Python学习-元组&字典&集合

1 元组

1.1 元组的创建

• Python的元组与列表类似，区别在于元组的元素不能修改.
• 元组用小括号创建，元素之间用逗号隔开。

# 普通创建
tup_one=(1,2,5,4)
tup_two='a','b','c','d'     # 不需要括号也可以
print(type(tup_one),tup_one)
print(type(tup_two),tup_two)
# 传递值方式,类似多变量同时赋值，变量个数与元素个数要一致
tup_one=1,2,5,4
a,b,c,d=tup_one
print('a=',a)
print('b=',b)
print('c=',c)
print('d=',d)
# 如果变量个数与元素个数不一致，则在变量前面加个*号使对应变量变成列表，注意只能在其中一个变量加*号，不能多个变量加
tup_one=1,2,5,4
a,b,*c=tup_one
print('a=',a)
print('b=',b)
print('c=',c)

执行结果：

<class 'tuple'> (1, 2, 5, 4)
<class 'tuple'> ('a', 'b', 'c', 'd')

a= 1
b= 2
c= 5
d= 4

a= 1
b= 2
c= [5, 4]

• 创建空元组

tup_none=()

• 元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用。

tup1=(66)
tup2=(66,)
print(type(tup1))	# 
print(type(tup2))

1.2 元组的访问

元组与字符串类似，下标索引从0开始，可以进行截取，组合，重复等。

tup2=(2,66,'haha',88,'hello')
print(tup2[2])		# haha
print(tup2[1:3])	# (66, 'haha')
tup3=(33,188)
print(tup2+tup3)	# (2, 66, 'haha', 88, 'hello', 33, 188)
print(tup3*3)		# (33, 188, 33, 188, 33, 188)

1.3 元组的修改和删除

• 元组中的元素值是不允许修改的，而所谓元组的不可变指的是元组所指向的内存中的内容不可变。

tup4=('p','y','t','h','o','n')
tup4[2]='m'		# 'tuple' object does not support item assignment
print(id(tup4))	# 内存地址：42259272
tup4=(1,2,3)
print(id(tup4))	# 内存地址变为：42941392

• 元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，语法：del tuple

1.4 元组的内置函数

• len(tuple)：计算元组的元素个数。
• max(tuple)：返回元组中元素最大值。
• min(tuple)：返回元组中元素最小值。
• tuple(iterable)：将可迭代系列转换为元组。

tup5=(1,2,6,4,5)
print(len(tup5))    # 计算元组的元素个数。
print(max(tup5))    # 返回元组中元素最大值。
print(min(tup5))    # 返回元组中元素最小值。
print(tuple('python'))  # 将可迭代系列转换为元组。

2 字典

2.1 字典的创建

• 字典是一种可变容器模型，可存储任意类型对象

• 字典的每个键值(key -> value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中：
  dictionary={key1:value1,key2:value2,…}

• 键必须是唯一的，但值则不必。

• 字典的键和值是一种映射关系，通过唯一的键找对应的值。

• 不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住。

• 值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

#	创建字典
dict_one={'a':1,'b':'hello','c':3,0:4}
print(type(dict_one),dict_one)
#   使用dict()函数来创建字典
dict1=dict(country='China',city='shenzhen')     # 向函数传递两个参数
print(dict1)
#   如果序列中的元素也是序列，那么我们称这个元素为子序列
dict11=dict([('name','Jury'),('age',18)])       # 将双值子序列转化为字典
print(dict11)

执行结果：

<class 'dict'> {'a': 1, 'b': 'hello', 'c': 3, 0: 4}
{'country': 'China', 'city': 'shenzhen'}
{'name': 'Jury', 'age': 18}

2.1 字典的访问和修改

• 可以通过字典的键来访问字典的值，只需将相应的键放到方括号当中

dict1={'a':1,'b':2,'c':3,'0':4}
print(dict_one['b'])    #   注意不要少了单引号，因为键的类型是字符串
print(dict_one['c'])

运行结果为：2 和 3

• 修改字典的内容

dict2={'a':1,'b':2,'c':3,'d':4}
dict2['b']='haha'	# 更新键'b'的值
print(dict2)	# {'a': 1, 'b': 'haha', 'c': 3, 'd': 4}
dict2['e']='new'	# 添加新的键值对
print(dict2)		# {'a': 1, 'b': 'haha', 'c': 3, 'd': 4, 'e': 'new'}

• 嵌套字典的访问

dict22={'a':{'name':'赵四','age':21},'b':2,'c':3}
print(dict22['a']['age'])

2.3 字典的删除操作

• 字典能删除单一的元素，也可以清空整个字典

dict3={'name':'张三','age':22,'sex':'男','city':'深圳'}
del dict3['city']       # 删除键 'city'
print(dict3)			# {'name': '张三', 'age': 22, 'sex': '男'}
dict3.clear()           # 清空字典
print(dict3)			# {}
del dict3               # 删除字典

2.4 字典内置的函数和方法

函数	描述
len(dict)	计算字典元素个数，即键的总数。
str(dict)	输出字典，以可打印的字符串表示。
type(variable)	返回输入的变量类型，如果变量是字典就返回字典类型。

方法	描述
dict.clear()	删除字典内所有键和元素
dict.copy()	返回一个字典的浅复制，
dict.keys()	返回一个迭代器(即字典的键)，可以使用 list() 来转换为列表
dict.values()	返回一个迭代器(即字典的值)，可以使用 list() 来转换为列表
dict.fromkeys(seq[,value])	创建一个新字典，以序列seq中元素做字典的键，value(可选项)为字典所有键对应的初始值(value值只能有一个)
dict.get(key,default=None)	返回指定键的值，如果值不在字典中返回default值
dict.setdefault(key,default=None)	和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
key in dict	如果键在字典dict里返回true，否则返回false
dict.items	以列表形式返回可遍历的(键, 值) 元组数组
dict.update(dict1)	把字典dict1的键/值对更新到dict里
dict.pop(key[,default])	删除字典给定键 key 所对应的值，并返回为被删除的值。key值必须给出。 否则，返回default值。
dict.popitem()	删除字典中的最后一对键和值，并返回一个键值对(key,value)形式，按照 LIFO（Last In First Out 后进先出法） 顺序规则，即最末尾的键值对。

dict3={'name':'张三','age':22,'sex':'男','city':'深圳'}
dict4=dict3.copy()      #   返回一个字典的浅复制
print(dict4)
d={'a':{'name':'钢铁侠','age':35},'b':2,'c':3}
d1=d.copy()
d1['a']['name']='美国队长'
print(d,id(d))
print(d1,id(d))
print(list(dict3.keys()))   # 返回一个迭代器(即字典的键)，可以使用 list() 来转换为列表
print(list(dict3.values())) # 返回一个迭代器(即字典的值)，可以使用 list() 来转换为列表
dict5={}
dict5=dict5.fromkeys(['a','b','c'],10)  # 创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值（value值只能有一个）
print(dict5)
print(dict5.get('c'))
print(dict5.get('d',20))   # 返回指定键的值，如果值不在字典中返回default值
dict5.setdefault('e',30)    # 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
print(dict5)
print('e' in dict5)     # 如果键在字典dict里返回true，否则返回false
print(dict5.items())    # 以列表形式返回可遍历的(键, 值) 元组数组
dict6={'old':'aa'}
dict6.update(dict5)
print(dict6)
print(dict6.pop('old'))     # 删除字典给定键 key 所对应的值，并返回为被删除的值
print(dict6)
print(dict6.popitem())      # 删除字典中的最后一对键和值，并返回一个键值对(key,value)形式，按照 LIFO（Last In First Out 后进先出法） 顺序规则，即最末尾的键值对。
print(dict6)

运行结果：

{'name': '张三', 'age': 22, 'sex': '男', 'city': '深圳'}
['name', 'age', 'sex', 'city']
['张三', 22, '男', '深圳']
{'a': 10, 'b': 10, 'c': 10}
10
20
{'a': 10, 'b': 10, 'c': 10, 'e': 30}
True
dict_items([('a', 10), ('b', 10), ('c', 10), ('e', 30)])
{'old': 'aa', 'a': 10, 'b': 10, 'c': 10, 'e': 30}
aa
{'a': 10, 'b': 10, 'c': 10, 'e': 30}
('e', 30)
{'a': 10, 'b': 10, 'c': 10}

2.5 字典的遍历

• 可以通过dict.keys()、dict.values()、dict.items()方法来遍历字典

d={'name':'张三','age':22,'sex':'男','city':'深圳'}
for i in d.keys():
    print(i)
for j in d.values():
    print(j)
for i,j in d.items():
    print(i,j)

运行结果：

name
age
sex
city
张三
22
男
深圳
name 张三
age 22
sex 男
city 深圳

3 集合

3.1 集合的创建

• 集合（set）是一个无序的不重复元素序列。
• 可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典
• 由于集合是无序的，如果想要通过索引访问集合的元素，可以先将集合转换为其他有序的数据类型，然后再进行索引访问，如list(set)

set1={'a','c','a','c'}
print(set1)
set2=set('python')
print(set2)

运行结果：

{'c', 'a'}
{'t', 'n', 'h', 'o', 'p', 'y'}

• 集合推导式（set comprehension），类似列表推导式，之前列表的学习内容遗漏了。

a={i for i in 'abcdrbcad' if i not in 'abc'}
print(a)	# {'r', 'd'}

3.2 集合内置的函数&方法

• 集合的函数与列表的类似，如len()、max()、min()等
• 集合的方法

方法	描述
set.add()	为集合添加元素，如果元素已存在则不进行任何操作
set.clear()	移除集合中的所有元素
set.copy()	拷贝一个集合
set1.difference(set2)	返回两个集合的差集
set1.difference_update(set2)	移除集合中的元素，该元素在指定的集合也存在。
set1.intersection(set2,set3,…)	返回集合的交集，集合可以是多个，用逗号隔开
set1.intersection_update(set2,set3,…)	返回集合的交集，该元素在指定的集合也存在，集合可以是多个，用逗号隔开
set1.symmetric_difference(set2)	返回两个集合中不重复的元素集合。
set1.symmetric_difference_update(set2)	移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
set1.isdisjoint(set2)	判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
set1.issubset(set2)	判断指定集合是否为该方法参数集合的子集。
set1.issuperset(set2)	判断该方法的参数集合是否为指定集合的子集
set.pop()	随机移除元素,并返回删除的元素
set.remove(value)	移除指定元素,元素不存在则会报错
set.discard(value)	删除集合中指定的元素,即使元素不存在也不会报错
set1.union(set2)	返回两个集合的并集
set1.update(set2)	给集合添加元素

ps:上面提及的方法可以自行尝试，由于篇幅问题，这里不做展示。