python初级6元组字典集合

1.元组简介

元组基本介绍

a=()
print(type(a))
<class 'tuple'>

元组类型
●元组表现形式tuple
●元组也可以通过索引取值
还要注意 print(a[2])而不能是print(a（2）) 这个细节

a=(65165,'蔡徐坤',55,'kd')
print(a[2])55

●元组是一个不可变序列(一般当我们希望数据不改变时，我们使用元组，其他情况下基本都用列表)所以元组不可用赋值

a=(65165,'蔡徐坤',55,'kd')
a[2]=6545
print(a[2])TypeError: 'tuple' object does not support item assignment#“tuple”对象不支持项分配

创建元组

●使用( )创建元素
●元组不是空元组至少有有个逗号( , ) 当元组不是空元组时括号可以省略

a=5,
print(a,type(a))(5,) <class 'tuple'>

a=5
print(a,type(a))5 <class 'int'>

a=()
print(a,type(a))() <class 'tuple'>

●即还有一个特殊的用法也可以不加括号

a=5,5,'das',525
print(a,type(a))(5, 5, 'das', 525) <class 'tuple'>

元组解包

●元组解包指将元组当中的每一个元素都赋值给一个变量

前面讲到

a=2
b=1
a,b=b,a
print(a,b)1 2

于是元组解包有

●当值有太多个，变量总不够时。（用*c ，当然 *s
也是可以的，关键是不要前面的a b重复 *ddf 也是可以。）

a,b,*dsaasde=1,5,'今天是个好日子',8
tup=a,b,*dsaasde
print('tup=',tup)tup= (1, 5, '今天是个好日子', 8)

a,b,*c=1,5,'新的一天',8
tup=a,b,*c
print('a=',a)
print('b=',b)
print('c=',c)
print('*c=',*c)a= 1
b= 5
c= ['新的一天', 8]
*c= 新的一天 8#在这里这个*好像有消除[ ] 的功能  很奇怪但是这里老师没有讲  这里先忽略吧

a,*b,c=1,5,'规划人生',8
tup=a,*b,c
print('a=',a)
print('b=',b)
print('c=',c)a= 1
b= [5, '规划人生']   #这就比较怪  但是不难看出应该是tup=a,*b,c  可以把多个传到一个列表 而print('*c=',*c) 打印是加* 就把[ ] 去掉了 这也算一种解包方法把 c= 8意思是就是可以这样
a,*b,c=1,5,'规划人生',8
tup=a,*b,c
print('a=',a)
print('b=',*b)
print('c=',c)a= 1
b= 5 规划人生  #去掉了[ ]
c= 8


*a,b,c=1,5,'规划人生',8
tup=*a,b,c
print('a=',*a)
print('b=',b)
print('c=',c)a= 1 5
b= 规划人生
c= 8

*a,b,c=1,5,'规划人生',8
tup=*a,b,c
print('a=',*a)
print('b=',*b)
print('c=',c)   #要是*c  就会报错TypeError: print() argument after * must be an iterable, not int  *后面的print（）参数必须是iterable（可迭代的），而不是int  a= 1 5
b= 规 划 人 生     # 规划人生 四个字符串之间多了三个空格
c= 8

●列表也是可以的字符串也是可以当然你标注两个星星是就会报错SyntaxError: two starred expressions in assignment

tup='是电动机'
a,*b,c=tup
tup=*a,b,c
print('a=',a)
print('c=',c)
print('b=',b)
a= 是
c= 机
b= ['电', '动']

tup=[5545,'sd',5,'d',2236]
a,*b,c=tup
tup=a,*b,c
print('a=',a)
print('c=',c)
print('b=',b)
a= 5545
c= 2236
b= ['sd', 5, 'd']

●可以看出这里的*有去[ ]的功能 *b（在变量前面加上星号）将获取到的元组的剩余的元素以列表的形式

2.字典简介

字典的基本介绍

d={}
print(d,type(d)){} <class 'dict'>

●字典属于一种新的数据结构称为映射(mapping)
●字典的作用和列表类似，都是用来存储对象的容器
●列表存储数据的性能好，但是查询数据的性能差，字典正好与之相反
●在字典中每一个元素都有唯一的名字，通过这个唯一的名字可以找到指定的
元素
●这个唯一的名字我们称之为key 通过key可以快速查询value 也可以称之为值
●字典我们也称之为键值对(key-value)结构
●每个字典中都可以有多个键值对，用每一个键值对我们称其为一项(item)
●创建一个有数据的字典语法 {key:value,key:vlaue,key:vlaue}

●字典的值vlue可以是任意对象字典的键key可以是任意的不可变对象(int str bool
tuple…) 这点会放到面向对象着重
●字典的键是不能重复的，如果出现重复的后面的会替换前面的
●根据键来获取值
就如下面的print(d[‘name’])

d={'name':'葫芦小金刚','age':'9999岁','sex':'不男不女','name':'青瓜王者'}
print(d['name'])青瓜王者

3.字典的使用

创建字典

1● dict()函数来创建字典
向函数中传递了两个参数

d=dict(name='嘎嘎嘎',age=88888)
print(d){'name': '嘎嘎嘎', 'age': 88888}

2● 双值子序列

d=dict([('name','嘎嘎嘎'),('age',88888)])
print(d){'name': '嘎嘎嘎', 'age': 88888}

● 双值序列，序列中有两个值如[3,4 ] ‘hf’ (‘a’,5)
● 子序列,如果序列中的元素也是序列，那么我们就称这个元素为子序列[(3,4),(5,6)] 前者就是双值子序列

常规通用操作

● len()获取字典中键值对的个数
● in 检查字典中是否包含指定的键
● not in检查字典中是否不包含指定的键
返回值都是布尔值，且用在列表里则是检查列表里是否包含（不）指定的元素
● 根据键来获取字典当中的值
·● dict[key]
key 一般都要加引号（否则他会把key当作一个变量处理）除非前面已经如 n=key 直接用n就不用加引号 ●dict[‘key’]

d={'name':'葫芦小金刚','age':'9999岁','sex':'男'}
print(d['name'])葫芦小金刚
d={'name':'葫芦小金刚','age':'9999岁','sex':'男'}
n='name'
print(d[n])葫芦小金刚

当然如果这个key不存在再这样操作就会报错key error
我们可以用函数的方法解决那就是下面的方法

d={'name':'葫芦小金刚','age':'9999岁','sex':'男'}
print(d.get('n'))None

get(key[,default])
根据键来获取字典的值。第二个参数可以指定一个默认
值，当获取不到值的时候会返回默认值 default在这里就是默认值的意思

d={'name':'葫芦小金刚','age':'9999岁','sex':'男'}
print(d.get('n','没有这个键呀'))
没有这个键呀

● 修改字典
●● 修改字典的key-value

d={'name':'葫芦小金刚','age':'9999岁','sex':'男'}
d['name']='钢铁侠'
print(d){'name': '钢铁侠', 'age': '9999岁', 'sex': '男'}

●● 向字典中添加key-value值

d={'name':'葫芦小金刚','age':'9999岁','sex':'男'}
d['战斗力']=888888
print(d){'name': '葫芦小金刚', 'age': '9999岁', 'sex': '男', '战斗力': 888888}

● d.setdefault(key,[,default]) 可以向字典中添加 key-vlaue
如果key已存在字典当中，则返回key的值，不会对字典做任何操作
如果key不存在，则向字典中添加这个key，并设置vlaue

d={'name':'葫芦小金刚','age':'9999岁','sex':'男'}
d.setdefault('name','钢铁王子')
r=d.setdefault('name','钢铁王子')
print(r)
print(d)葫芦小金刚
{'name': '葫芦小金刚', 'age': '9999岁', 'sex': '男'}

d={'name':'葫芦小金刚','age':'9999岁','sex':'男'}
d.setdefault('name','钢铁王子')
r=d.setdefault('nme','钢铁王子')
print(r)
print(d)钢铁王子
{'name': '葫芦小金刚', 'age': '9999岁', 'sex': '男', 'nme': '钢铁王子'}

● update() 将其他字典的key-value添加到当前的字典当中

d1={'d':4,'a':55,'g':99}
d2={'s':9,'p':65,'j':33}
d1.update(d2)
print(d2)
print(d1){'s': 9, 'p': 65, 'j': 33}
{'d': 4, 'a': 55, 'g': 99, 's': 9, 'p': 65, 'j': 33}

● 如果有重复的key，后面的会替换前面的

d1={'d':4,'a':55,'g':99}
d2={'s':9,'p':65,'j':33,'d':5}
d1.update(d2)
print(d2)
print(d1){'s': 9, 'p': 65, 'j': 33, 'd': 5}
{'d': 5, 'a': 55, 'g': 99, 's': 9, 'p': 65, 'j': 33}

● del 删除字典中的key-value（这里是没有下面的pop popitem 那样有返回值的）

d1={'d':4,'a':55,'g':99}
del d1['d']
del d1['a']
print(d1){'g': 99}

● popitem() 随机删除字典最后的一个key-value 这个方法是有返回值的（一般都会删除最后一个）。删除之后它会将删除的key-value作为返回值（删除之后会将删除后的元素以元组的形式返回 元组中第一个值是删除的key 第二个是删除的vule）返回

d1={'d':4,'a':55,'g':99}
d1.popitem()
print(d1)
r=d1.popitem()
print(r){'d': 4, 'a': 55}
('a', 55)

pop(key[,default]) 根据key删除指定中的value。第一个参数可以指定一个
默认值，当获取不到值的时候会返回默认值 （这里的default就是默认值）

d1={'d':4,'a':55,'g':99}
d1.pop('d','4')
r=d1.pop('d','4')
print(r)
print(d1)4
{'a': 55, 'g': 99}

而如果是输入没有的键，则会报错d1.pop(‘w’) 而如果是d1.pop(‘w’,‘4’) 则不会

d1={'d':4,'a':55,'g':99}
d1.pop('w')
r=d1.pop('w')
print(d1)Traceback (most recent call last):File "D:/LongProject/作业.py", line 21, in <module>d1.pop('w')
KeyError: 'w'

没有w这个键也就没法删除w键对应的值，所以返回了我设置的默认值4 为了方便看清楚，这里打印出返回的默认值

d1={'d':4,'a':55,'g':99}
d1.pop('w',4)
r=d1.pop('w',4)
print(r)
print(d1)4
{'d': 4, 'a': 55, 'g': 99}

浅复制copy( )

copy() 方法用来对字典进行潜复制
注意:潜复制只会复制字典本身，如果字典中还有个字典是不会进行复制的

d1={'d':4,'a':55,'g':99}
d2=d1
d1['d']=6
print('d1=',d1)
print('d2=',d2)d1= {'d': 6, 'a': 55, 'g': 99}
d2= {'d': 6, 'a': 55, 'g': 99}

d1={'d':4,'a':55,'g':99}
d2=d1
d2['d']=6
print('d1=',d1)
print('d2=',d2)d1= {'d': 6, 'a': 55, 'g': 99}
d2= {'d': 6, 'a': 55, 'g': 99}

以上这种情况不算复制（可以看是一个改了值，另一个也跟着改）因为d1和d2指向的是同一个对象
而下面的方式才是复制

d1={'d':4,'a':55,'g':99}
d2=d1.copy()
d1['d']=6
print('d1=',d1)
print('d2=',d2)d1= {'d': 6, 'a': 55, 'g': 99}
d2= {'d': 4, 'a': 55, 'g': 99}

d1={'d':4,'a':55,'g':99}
d2=d1.copy()
d2['d']=6
print('d1=',d1)
print('d2=',d2)d1= {'d': 4, 'a': 55, 'g': 99}
d2= {'d': 6, 'a': 55, 'g': 99}

d1={'d':4,'a':55,'g':99}
d2=d1.copy()
d2['d']=666
print('d1=',d1,id(d1))
print('d2=',d2,id(d2))d1= {'d': 4, 'a': 55, 'g': 99} 33880768
d2= {'d': 666, 'a': 55, 'g': 99} 33880832

即复制以后的对象和原对象应该是独立的他们两个id是不相同的

d1={'d':{'name':'葫芦小金刚','age':10000},'a':55,'g':99}
d2=d1.copy()
d2['d']['name']='黑猫警长'
print('d1=',d1,id(d1))
print('d2=',d2,id(d2))d1= {'d': {'name': '黑猫警长', 'age': 10000}, 'a': 55, 'g': 99} 34405120
d2= {'d': {'name': '黑猫警长', 'age': 10000}, 'a': 55, 'g': 99} 34405312

d1={'d':{'name':'葫芦小金刚','age':10000},'a':55,'g':99}
d2=d1.copy()
d1['d']['name']='黑猫警长'
print('d1=',d1,id(d1))
print('d2=',d2,id(d2))d1= {'d': {'name': '黑猫警长', 'age': 10000}, 'a': 55, 'g': 99} 34536192
d2= {'d': {'name': '黑猫警长', 'age': 10000}, 'a': 55, 'g': 99} 34535040

●由上我们说修改一个值不会影响另外一个值,这叫copy,而上面的修改一个字典内字典的值，另一个复制或者被复制对象就也跟着改变，这就叫浅复制。当然你修改’a’: 55, ‘g’: 99
他们的值另一个复制的或者是被复制的不会受影响
●注意:潜复制只会复制字典本身，如果字典中还有个字典是不会进行复制的
●这个值也可以是一个可变对象，这个可变对象也不会被复制**（这里说的复制：即复制后修改复制对象或者被修改对象，另一方不会受影响）**

遍历字典

建议此处结合以往的python初级5列表 6. 遍历列表来看看
我们主要可以通过3种方式对字典进行遍历

keys()

该方法返回字典所有的key

d1={'d':{'name':'葫芦小金刚','age':10000},'a':55,'g':99}
print(d1.keys())dict_keys(['d', 'a', 'g'])   可看出字典里的字典key无法返回

返回字典里的key

d={'d':4,'a':55,'g':99}
for k in d.keys():print(k)d
a
g

返回字典里的vlue

d={'d':4,'a':55,'g':99}
for k in d.keys():print(d[k])
4
55
99

values()

该方法返回一个序列，序列中保存有字典的值

d={'d':4,'a':55,'g':99}
for k in d.values():print(k)4
55
99
即之前的keys（）方法囊括了这个方法 因为他有返回字典里的key和value功能

然后还有一种老师未讲到

d={'d':4,'a':55,'g':99}
for i in d:print(i)
d
a
g

d={'d':4,'a':55,'g':99}
for i in d:print(d[i])
4
55
99

items()

该方法会返回字典中所有的项它返回一个序列，序列中包含有双值
子序列双值分别是字典中的key和value

d={'d':4,'a':55,'g':99}
print(d.items())dict_items([('d', 4), ('a', 55), ('g', 99)])

那么咱们该如何遍历呢，咱们可以这么给他弄 a,b两个变量

d={'d':4,'a':55,'g':99}
for a,b in d.items():print(a ,' : ',b)
d : 4
a : 55
g : 99

如果只弄一个变量那么

d={'d':4,'a':55,'g':99}
for i in d.items():print(i)('d', 4)('a', 55)('g', 99)

4. 集合

4.1 集合简介

●集合表现形式set 集合和列表非常相似
●不同点
----集合只能存储不可变对象
----集合中存储的对象是无序的（而集合是有序的）
无序

d={3,6,87,88,6}
print(d,type(d)){88, 3, 6, 87} <class 'set'>

----集合不能出现重复元素

重复的元素给你去除了

d={3,6,87,88,6,6,6,6,6,6}
print(d,type(d)){88, 3, 6, 87} <class 'set'>

●使用{}来创建集合

d={'d','a','g'}
print(d,type(d)){'g', 'd', 'a'} <class 'set'>

d={}
print(d,type(d)){} <class 'dict'>  这样它的类型就是字典

set()函数

●可以通过set()来将序列和字典转换成集合

d=set(1,2,5)
print(d,type(d))Traceback (most recent call last):File "D:/LongProject/作业.py", line 35, in <module>d=set(1,2,5)Traceback (most recent call last):File "D:/LongProject/作业.py", line 35, in <module>d=set(1,2,5)
TypeError: set expected at most 1 argument, got 3   （报错了）

然后加上中括号试试

d=set([1,2,5])
print(d,type(d)){1, 2, 5} <class 'set'>

然后试试字典
可看出用set（）函数将字典转化为集合时只会保留key

d=set({'name':'葫芦小金刚','age':10000})
print(d,type(d)){'name', 'age'} <class 'set'>

如果是字典想转化为列表直接在前面加上list
当然还是只保留key

d=list({'name':'葫芦小金刚','age':10000})
print(d,type(d))['name', 'age'] <class 'list'>

set() 的无序性

s={'a','s','d',1,2,5}
print(s,type(s))                 将其多次运行后的处集合s内元素的顺序都不相同

集合也不适用于索引但是可以转换类型然后索引

s={'a','s','d',1,2,5}
print(s[0])TypeError: 'set' object is not subscriptable

s={'a','s','d',1,2,5}
print(list(s)[0])a                    然而多次运行后仍有结果可能出现d或者其他 这说明集合具有无序性
后来我尝试多种方法
s={'a','s','d',1,2,5}
s=list(s)
print(s[0])   1 <class 'list'>                 这个s[0] 还是会一直变

集合的使用

●使用in和not in 来检查集合中的元素返回布尔值
●len() 使用len()来获取集合中元素的数量 print(len())
●add()像集合中添加元素

s={'a','s','d',1,2,5}
s.add(21)
s=print(s){1, 2, 5, 'a', 'd', 's', 21}

s={'a','s','d',1,2,5}
r=s.add(21)
print(r)
print(s)None
{1, 2, 5, 'd', 's', 21, 'a'}

●update()将一个集合中的元素添加到另一个集合（s中 s就是被添加者）当中当然下面还有将元组列表字典的中的元素添加到另一个集合当中

集合元素添加到集合中

s={4,55,'g'}
s1=set('python')
s.update(s1)
print(s){'p', 'y', 4, 'h', 'o', 'g', 't', 'n', 55}

s={4,55,'g'}
s1={'python'}
s.update(s1)
print(s){'g', 'python', 4, 55}

列表元素添加到集合中

s={4,55,'g'}
s1=['python']
s.update(s1)
print(s){'g', 'python', 4, 55}

元组元素添加到集合中

s={4,55,'g'}
s1=('python')
s.update(s1)
print(s){'p', 4, 'o', 't', 'n', 'h', 55, 'y', 'g'}

这里并无强调update（）操作有没有返回值说明默认应该是没有的
可从下看出update（）确实没有返回值

s={4,55,'g'}
s1=('python')
r=s.update(s1)
print(r)
print(s)None
{4, 'p', 'y', 't', 'g', 'o', 'h', 'n', 55}

pop 有返回值

s={4,55,‘g’}
r=s.pop()
print®
print(s) 这样操作还是删除的
●pop()随机删除集合中的一个元素一般是删除最后一个元素

s={4,55,'g'}
r=s.pop()
print(r)
print(s)g
{4, 55}    多次运行后还是有可能出现4  无序  这样更能看出pop()这个方法是有返回值的

●remove() 删除集合中指定的元素

s={4,55,'g'}
r=s.remove(4)
print(r)
print(s)None
{'g', 55}        remove()也是没有返回值

●clear() 清空集合

s={4,55,'g'}
r=s.clear()
print(r)
print(s)None
set()       也是没有返回值

●& 交集运算（＆号表示and的符号 ampersand 读安per散的读and）
●| 并集运算
●- 差集运算（前减后，减去两个集合的交集的新集合）
●^ 亦或集（并集）
●<= 检查一个集合是否是另一个集合的子集
●< 检查一个集合是否是另一个集合的真子集
●>=检查一个集合是否是另一个集合的超集
●>检查一个集合是否是另一个集合的真超集

课堂复习环节