一、元组

1、元组的概念

元组 tuple，是一个不可变序列一般情况下如果不希望数据改变的时候就用元组，其余情况都用列表 my_tuple = (1,2,3,4,5) print(my_tuple,type(my_tuple)) # (1, 2, 3, 4, 5) <class 'tuple'> my_tuple[3] = 8 # TypeError: 'tuple' object does not support item assignment 当元组中只有一个元素时，元素后面应该要加一个逗号，这样才能成为元组。 a_tuple = (1) print(a_tuple,type(a_tuple)) # 1 <class 'int'> a_tuple = (1,) print(a_tuple,type(a_tuple)) # (1,) <class 'tuple'>

2、元组的解包

元组的解包指将元组当中的每一个元素都赋值给一个变量。在对一个元祖解包的时候，变量的数量要和元组中元素的数量保持一致。如果变量的数量和元素的数量不一致，也可以在变量前面加上一个 星号*。这样会获取元组中剩余的元素，并以列表的形式返回。任何可迭代对象都支持解包，可迭代对象包括元组、列表、字典、集合、字符串、生成器等。 my_tuple = 1,2,3,4,5 print(my_tuple, type(my_tuple)) # (1, 2, 3, 4, 5) <class 'tuple'> a,b,*c = my_tuple print('a =',a) # a = 1 print('b =',b) # b = 2 print('c =',c) # c = [3, 4, 5] a,*b,c = my_tuple print('a =',a) # a = 1 print('b =',b) # b = [2, 3, 4] print('c =',c) # c = 5 *a,b,c = my_tuple print('a =',a) # a = [1, 2, 3] print('b =',b) # b = 4 print('c =',c) # c = 5 *a,*b,c = my_tuple # SyntaxError: two starred expressions in assignment print('a =',a) print('b =',b) print('c =',c) a,b,*c = 'hello python' print('a =',a) # a = h print('b =',b) # b = e print('c =',c) # c = ['l', 'l', 'o', ' ', 'p', 'y', 't', 'h', 'o', 'n'] a,b,*c = [1,2,3,4,5,6] print('a =',a) # a = 1 print('b =',b) # b = 2 print('c =',c) # c = [3, 4, 5, 6]

二、字典

1、字典的概念

字典 dict，映射（mapping）类型的数据结构。字典的作用其实和列表类似，是用来存储对象的容器。列表存储数据的性能非常好，但是查询数据的性能很差。而字典正好相反。在字典当中每一个元素都有唯一的一个名字，通过这个名字可以快速查询到指定的元素。这个唯一的名字我们一般称之为键 key，通过 key 我们可以查询到 value 值。所以字典我们也称之为 键值对(key-value)。每个字典当中可以有多个键值对，每一个键值对我们可以称之为一项（item）。字典中的键是不能重复的，如果重复后面的会替换前面的。

2、语法

语法: {key:value,key:value…} d = {'name':'钢铁侠','age':38,'sex':'男'} # 需要根据键来获取值 print(d['name'],d['age'],d['sex']) # 钢铁侠 38 男

3、字典的使用

3.1 创建字典

使用dict()函数来创建字典 d = dict(name='钢铁侠',age=35,sex='男') print(d,type(d)) # {'name': '钢铁侠', 'age': 35, 'sex': '男'} <class 'dict'> dict()函数也可以将一个包含有双值子序列转换为字典 双值序列：序列中有2个值。例如 [1,2]、(‘b’,‘a’)、‘ab’子序列：如果序列中的元素也是序列，那么我们就称这个元素为子序列。例如 [(1,2),(3,4)] d = dict([('name','钢铁侠'),('age',35)]) print(d,type(d)) # {'name': '钢铁侠', 'age': 35} <class 'dict'>

3.2 len()

len() 获取字典中键值对的个数 d = {'name':'钢铁侠','age':38,'sex':'男'} print(len(d)) # 3

3.3 in、not in

in 检查字典中是否包含指定的键，返回True / Falsenot in 检查字典中是否不包含指定的键 d = {'name':'钢铁侠','age':38,'sex':'男'} print('name' not in d) # False

3.4 获取字典中的值

3.4.1 根据键获取字典中的值

语法：d[key] d = {'name':'钢铁侠','age':38,'sex':'男'} print(d['age']) # 38

3.4.2 用get方法获取字典中的值

语法：字典名.get(key,[default])如果字典当中没有这个Key值，会返回一个None；也可以指定一个默认值来作为第二个参数，这样获取不到Key值的时候就返回默认值。 d = {'name':'钢铁侠','age':38,'sex':'男'} print(d.get('age')) # 38 print(d.get('job')) # None print(d.get('birthday','这个key值不存在')) # 这个key值不存在

3.5 修改字典

3.5.1 d[key] = value

修改字典中的key-value d = {'name':'钢铁侠','age':38,'sex':'男'} d['name'] = '葫芦娃' print(d) # {'name': '葫芦娃', 'age': 38, 'sex': '男'} 向字典中添加key-value d = {'name':'钢铁侠','age':38,'sex':'男'} d['phone'] = '12345678' print(d) # {'name': '钢铁侠', 'age': 38, 'sex': '男', 'phone': '12345678'}

3.5.2 setdefault(key,[default])

向字典中添加 key-value如果这个key已经存在于字典当中，则返回key值，不会对字典有任何的影响；如果Key不存在，则向字典中添加这个key，并设置value。 d = {'name':'钢铁侠','age':38,'sex':'男'} result = d.setdefault('name','葫芦娃') print(result) # 钢铁侠 print(d) # {'name': '钢铁侠', 'age': 38, 'sex': '男'} d = {'name':'钢铁侠','age':38,'sex':'男'} result = d.setdefault('hello','葫芦娃') print(result) # 葫芦娃 print(d) # {'name': '钢铁侠', 'age': 38, 'sex': '男', 'hello': '葫芦娃'}

3.5.3 update( )

将其他字典当中的key-value添加到当前字典当中 d1 = {'a':1,'b':2,'c':3} d2 = {'d':4,'e':5,'f':6} d1.update(d2) print(d1) # {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6} print(d2) # {'d': 4, 'e': 5, 'f': 6}

3.6 删除

3.6.1 del

删除字典中的一对key-value d1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6} del d1['a'] del d1['b'] print(d1) # {'c': 3, 'd': 4, 'e': 5, 'f': 6}

3.6.2 popitem( )

随机删除一个键值对，一般都会删除最后一个它会将删除之后的键值对作为返回值返回。返回的是一个元组， 元组中有2个元素：第一个元素是删除的key，第二个元素是删除的value。 d1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6} result = d1.popitem() print(result) # ('f', 6) print(d1) # {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}

3.6.3 pop(key,[default])

根据key来删除 key-value d1 = {'c': 3, 'd': 4, 'e': 5} result = d1.pop('b','这个key值不存在') print(result) # 这个key值不存在 print(d1) # {'c': 3, 'd': 4, 'e': 5} result = d1.pop('c') print(result) # 3 print(d1) # {'d': 4, 'e': 5}

3.6.4 clear( )

清空字典 d1 = {'c': 3, 'd': 4, 'e': 5} d1.clear() print(d1) # {}

3.7 copy( )

copy( )用于对字典进行一个浅复制。浅复制只会复制字典的本身，如果字典中还有字典，是不会被复制的。复制以后的对象，和原对象是独立的。修改一个不会影响另一个。 d = {'a':{'name':'黑猫警长','age':18},'b':2,'c':3} d1 = d print('d =',d,id(d)) # d = {'a': {'name': '黑猫警长', 'age': 18}, 'b': 2, 'c': 3} 3039239036648 print('d1 =',d1,id(d1)) # d1 = {'a': {'name': '黑猫警长', 'age': 18}, 'b': 2, 'c': 3} 3039239036648 d1['b'] = 20 print('d =',d,id(d)) # d = {'a': {'name': '黑猫警长', 'age': 18}, 'b': 20, 'c': 3} 3039239036648 print('d1 =',d1,id(d1)) # d1 = {'a': {'name': '黑猫警长', 'age': 18}, 'b': 20, 'c': 3} 3039239036648 d1['a']['name'] = '皮卡丘' print('d =',d,id(d)) # d = {'a': {'name': '皮卡丘', 'age': 18}, 'b': 20, 'c': 3} 3039239036648 print('d1 =',d1,id(d1)) # d1 = {'a': {'name': '皮卡丘', 'age': 18}, 'b': 20, 'c': 3} 3039239036648 d = {'a':{'name':'黑猫警长','age':18},'b':2,'c':3} d2 = d.copy() print('d =',d,id(d)) # d = {'a': {'name': '黑猫警长', 'age': 18}, 'b': 2, 'c': 3} 2039041318632 print('d2 =',d2,id(d2)) # d2 = {'a': {'name': '黑猫警长', 'age': 18}, 'b': 2, 'c': 3} 2039041347728 d2['b'] = 20 print('d =',d,id(d)) # d = {'a': {'name': '黑猫警长', 'age': 18}, 'b': 2, 'c': 3} 2039041318632 print('d2 =',d2,id(d2)) # d2 = {'a': {'name': '黑猫警长', 'age': 18}, 'b': 20, 'c': 3} 2039041347728 d2['a']['name'] = '皮卡丘' print('d =',d,id(d)) # d = {'a': {'name': '皮卡丘', 'age': 18}, 'b': 2, 'c': 3} 2039041318632 print('d2 =',d2,id(d2)) # d2 = {'a': {'name': '皮卡丘', 'age': 18}, 'b': 20, 'c': 3} 2039041347728 # 修改d2中‘a’对应的字典，d中的字典也变了，说明字典{'name': '皮卡丘', 'age': 18}没有被复制。

4、遍历字典

4.1 keys( )

该方法返回的是一个序列，保存的是字典中所有的键。 d = {'name':'钢铁侠','age':38,'sex':'男'} print(d.keys()) # dict_keys(['name', 'age', 'sex']) list_keys = [] for k in d.keys(): list_keys.append(k) print(list_keys) # ['name', 'age', 'sex']

4.2 values( )

该方法返回的是一个序列，保存的是字典中所有的值。 d = {'name':'钢铁侠','age':38,'sex':'男'} print(d.values()) # dict_values(['钢铁侠', 38, '男']) list_values = [] for k in d.values(): list_values.append(k) print(list_values) # ['钢铁侠', 38, '男']

4.3 items( )

该方法返回的是一个序列，保存的是字典中所有的项。这个序列当中包含有双值子序列，双值就是字典中的key-value。 d = {'name':'钢铁侠','age':38,'sex':'男'} print(d.items()) for k,v in d.items(): print(k,'=',v) # 运行结果： # dict_items([('name', '钢铁侠'), ('age', 38), ('sex', '男')]) # name = 钢铁侠 # age = 38 # sex = 男

三、集合

1、集合的概念

集合 set 和列表非常相似，但也有不同点：

1 集合中只能存储不可变对象2 集合中存储的对象是无序的3 集合中不能出现重复的元素 # 集合中只能存储不可变对象 s = {[1,2,3],[4,5,6]} # TypeError: unhashable type: 'list' print(s,type(s)) # 集合中存储的对象是无序的 s = {'a','b',1,2,3} print(s[0]) # TypeError: 'set' object does not support indexing # 集合中不能出现重复的元素 s = {2,3,1,4,2,2,3,1} print(s,type(s)) # {1, 2, 3, 4} <class 'set'> s = {} print(s,type(s)) # {} <class 'dict'> s = {1,2,3} print(s,type(s)) # {1, 2, 3} <class 'set'> # set() 可以将序列和字典转换为集合 s = set() print(s,type(s)) # set() <class 'set'> s = set([4,2,1,5,3,1,2,3,5,5]) print(s,type(s)) # {1, 2, 3, 4, 5} <class 'set'> s = set('hello') print(s,type(s)) # {'h', 'o', 'e', 'l'} <class 'set'> # 使用set()函数将字典转换为集合的时候，只会包含字典中的键 s = set({'a':1,'b':2,'c':3}) print(s,type(s)) # {'a', 'c', 'b'} <class 'set'> s = {'a','b',1,2,3} print(s,type(s)) # {1, 2, 3, 'b', 'a'} <class 'set'> a = list(s) print(a,type(a)) # [1, 2, 3, 'b', 'a'] <class 'list'>

2、集合的使用

2.1 in 和 not in

s = {'a','b',1,2,3} print('a' in s) # True print('a' not in s) # False

2.2 len( )

获取集合的长度（即集合内元素的个数） s = {'a','b',1,2,3} print(len(s)) # 5

2.3 add( )

向集合中添加元素 s = {'a','b',1,2,3} s.add(4) print(s) # {1, 2, 3, 4, 'a', 'b'}

2.4 update( )

将一个集合中的元素添加到另一个集合中 s = {'a','b',1,2,3} s2 = set('hello') s.update(s2) print(s) # {'b', 2, 3, 1, 'h', 'o', 'e', 'l', 'a'} print(s2) # {'l', 'h', 'o', 'e'}

2.5 pop( )

删除集合中的一个元素 s = {'a','b',1,2,3} r = s.pop() print(s) # {1, 2, 3, 'a'} print(r) # b

2.6 remove( )

删除集合中指定的元素 s = {'a','b',1,2,3} s.remove('a') print(s) # {1, 2, 3, 'b'}

2.7 clear( )

清空集合中的元素 s = {'a','b',1,2,3} s.clear() print(s) # set()

3、集合的运算

3.1 交集运算 &

s1 = {1,2,3,4,5} s2 = {3,4,5,6,7} r = s1 & s2 print(r) # {3, 4, 5}

3.2 并集运算 |

s1 = {1,2,3,4,5} s2 = {3,4,5,6,7} r = s1 | s2 print(r) # {1, 2, 3, 4, 5, 6, 7}

3.3 差集运算 -

s1 = {1,2,3,4,5} s2 = {3,4,5,6,7} r1 = s1 - s2 print(r1) # {1, 2} r2 = s2 - s1 print(r2) # {6, 7}

3.4 异或集运算 ^

集合里面不相交的部分 s1 = {1,2,3,4,5} s2 = {3,4,5,6,7} r = s1 ^ s2 print(r) # {1, 2, 6, 7}

3.5 比较运算

返回的是布尔类型<= 检查一个集合是否是另一个集合的子集< 检查一个集合是否是另一个集合的真子集>= 检查一个集合是否是另一个集合的超集> 检查一个集合是否是另一个集合的真超集 a = {1,2,3} b = {1,2,3,4,5} c = {1,2,3} r1 = a <= b print(r1) # True r2 = a < b print(r2) # True r3 = a < c print(r3) # False

四、可变对象

每个对象都保存了三个数据： 1.id(标识)2.type(类型)3.value(值) a = [1,2,3] 列表就是一个可变对象a[0] = 10 (改的是对象里面的value) 这个操作是在通过变量去修改对象里面的值这个操作不会改变变量所指向的对象 a = [4,5,6] (改的是变量) 这个操作是在给变量重新赋值这个操作会让变量指向新的对象 a = [1,2,3] print('修改前',a,id(a)) # 修改前 [1, 2, 3] 2537002821000 a[0] = 10 print('修改后',a,id(a)) # 修改后 [10, 2, 3] 2537002821000 a = [1,2,3] print('修改前',a,id(a)) # 修改前 [1, 2, 3] 1669417788296 a = [4,5,6] print('修改后',a,id(a)) # 修改后 [4, 5, 6] 1669417788808 a = [1,2,3] b = a b[0] = 10 print('a',a,id(a)) # a [10, 2, 3] 2114062766984 print('b',b,id(b)) # b [10, 2, 3] 2114062766984 a = [1,2,3] b = a b = [7,8,9] print('a',a,id(a)) # a [1, 2, 3] 1662926902152 print('b',b,id(b)) # b [7, 8, 9] 1662926901640