一、元組類型

1、定義
t1 = ()
print(t1, type(t1))

# 參數為for可以循環的對象(可迭代對象)

t2 = tuple("123")
print(t2, type(t2))

t3 = tuple([1, 2, 3])
print(t3, type(t3))

t4 = tuple((7, 8, 9))
print(t4, type(t4))

# 思考:如何定義一個只有一個值的元組

# "Owen"
print(("Owen", ))
print(tuple(['Owen']))

?

2、常用操作

索引取值

t = (1, 2, 3, 2, 3, 2)

print(t[1])
print(t[-2])

切片
print(id(t))

nt = t[:-1:]
print(nt, id(nt))

長度（item元素個數）

print(len(t))

3、元組內置方法

print(t.count(2)) # 該數據集合可以存放相同數據

print(t.index(2, 2, 3))# 返回該值的索引

4、元組類型總結：存多個值，有序存儲、不可變

二、字典
1、定義
dict的key：可以為所為不可變類型：int float tuple str bool None， 一般就采用字符串
dict的value：可以為所以數據類型

注：key具有唯一性（重復會覆蓋舊值），value可以重復
dic = {1: None, None: None, 3.14: None,
True: None, 'abc': None, (1,): None,
None: 12345
}

print(dic)

# 方法1
d1 = {'name': 'Owen', 'age': 18}
print(d1)
# 方法2
d2 = dict({'name': 'Owen', 'age': 18})
print(d2)
# 方法3
d3 = dict(name='Egon', age=58)
print(d3)

2、常用操作

字典無序存儲數據，無索引與切片，用key來取值

2.1、增刪改查

# 增
dic = {}
dic['name'] = 'Mac' # 增：key不存在
print(dic)

# 改
dic['name'] = 'Big Mac' # 改：key已存在
print(dic)

# 查
print(dic['name'])

# 刪
del dic['name']
print(dic)

3、內置方法

3.1 get取值 *****

dic = {'a': 10, 'b': 20}

print(dic['c']) # KeyError

res = dic.get('c') # 擁有默認值，None，可以避免錯誤
print(res)

res = dic.get('d', 'key不存在') # 可以自定義默認值
print(res)

# 增：添加的參數是字典，與dic可以重復，若重復就是更新值，新key就是新增

dic.update({'a': 100, 'c': 300})
print(dic)

# 刪
dic.update({'a': 100, 'c': 300})
res = dic.pop('c') # 根據key刪除指定對象，并返回刪除的對象的value
print(res)

3.2 復制：(淺拷貝) # 淺copy：只做第一層copy，內部的成員地址還是原來的地址

newDic = dic.copy()
print(newDic)

d1 = {'list': [1, 2]}
d2 = d1.copy()

print(id(d1), id(d1['list']))

print(id(d2), id(d2['list']))

d1['list'].append('abc')
print(d2)

3.3 隨機刪除，返回值是(key, value)

print(dic)
print(dic.popitem())
print(dic.popitem())
print(dic)

3.4 如何定義一個空字典{}.fromkeys(）

# 第一個參數：keys：list|tuple|str，第二個參數：統一的默認value

d10 = {}.fromkeys(['a', 'b', 'c'], '')
print(d10) # {'a': '', 'b': '', 'c': ''}

3.5 字典的循環

dic = {'a': 10, 'b': 20, 'c': 30}
# 直接for循環(遍歷)字典得到的是key
for k in dic:
print(k, dic[k])

values = dic.values()
print(values, type(values)) # 只循環value

keys = dic.keys()
print(keys, type(keys)) # 存放key的集合

k_vs = dic.items()
print(k_vs, type(k_vs)) # 存放key-value的鍵值對關系

三、集合

1、定義與聲明

1.1 什么是set：

i) 單列數據集合：str，list，tuple，set 雙列：dict
ii) 無序存儲：無key無index，無法取值
iii) 可變數據類型，內部可以存放任意類型數據，但數據具有唯一性 *****

1.2 {}代表空字典，用set()來創建空集合

s1 = set()
print(s1, type(s1))
s2 = set('abc')
print(s2, type(s2))

2、內置方法與使用 - 集合間的運算 （& | ^ - > < ==）

p_set = {'a', 'b', 'c', 'egon'}
l_set = {'x', 'y', 'z', 'egon'}

# 交集 &
res = p_set & l_set
print(res)
res = p_set.intersection(l_set)
print(res) # {'egon'}

# 并集
res = p_set | l_set
print(res)
res = p_set.union(l_set)
print(res) # {'z', 'c', 'y', 'x', 'b', 'a', 'egon'}

# 差集
res = p_set - l_set
print(res) # {'a', 'b', 'c'}
res = l_set.difference(p_set)
print(res) # {'x', 'z', 'y'}

# 對稱差集
res = p_set ^ l_set
print(res)
res = p_set.symmetric_difference(l_set)
print(res) # {'y', 'a', 'b', 'x', 'z', 'c'}

print(p_set)
print(l_set)
# p_set.difference_update(l_set) # 將運算結果賦值給調用者
p_set = p_set - l_set
print(p_set) # {'c', 'a', 'b'}
print(l_set) # {'egon', 'z', 'y', 'x'}

# 添加刪除操作
s = set()
s.add('abc')
s.add('xyz')
print(s)
res = s.pop() # 隨機刪除一個ele元素
print(res)
if 'xyz' in s:
s.remove('xyz') # 有ele刪除，無ele拋異常

轉載于:https://www.cnblogs.com/yuanlianghong/p/10600257.html

總結

以上是生活随笔為你收集整理的元组、字典、集合的常用方法的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。