python基础知识笔记Day8-3.3

学习内容：元组完结+字典

学习时间：9：00-10:00

学习产出：CSDN 技术博客 1 篇

---

元组tuple

和列表相比，元组是不可变序列，不能修改元组中的元素。因此只需要学习元组的创建和删除，元组中元素的访问和计数。

元组支持：
1. 索引访问
2. 切片操作
3. 连接操作
4. 成员关系操作
5. 比较运算操作
6. 计数：元组长度 len()、最大值 max()、最小值 min()、求和 sum()等。

元组的创建

1.用()直接创建
a = (10,20,30)或者a = 10,20,30
如果元组只有一个元素，后面必须加逗号
a = (10,) 或者a = 10,
2.通过tuple()创建
tuple(可迭代的对象)
例：
例如：
b = tuple() #创建一个空元组对象
b = tuple(“abc”)
b = tuple(range(3))
b = tuple([2,3,4])
总结：
tuple()可以接收列表、字符串、其他序列类型、迭代器等生成元组。
list()可以接收元组、字符串、其他序列类型、迭代器等生成列表

元组的元素访问和计数

1.元组的元素不能修改
2.元组的元素访问方式和列表一样
例：a[1]是访问索引为1的元组对象

>>> a = (20,10,30,9,8)
>>> a[1]
10
>>> a[1:3]
(10, 30)
>>> a[:4]
(20, 10, 30, 9)

3.排序元组只能使用内置函数sorted(tupleObj)，并生成新的列表对象

>>> a = (20,10,30,9,8)
>>> sorted(a)
[8, 9, 10, 20, 30]

4.zip(列表1，列表2，…)将多个列表对应位置的元素组合成为元组，并返回这个zip对象

>>> a = [10,20,30]
>>> b = [40,50,60]
>>> c = [70,80,90]
>>> d = zip(a,b,c)
>>> list(d)
[(10, 40, 70), (20, 50, 80), (30, 60, 90)]

生成器推导式创建元组

从形式上看，生成器推导式与列表推导式类似，只是生成器推导式使用小括号。列表推
导式直接生成列表对象，生成器推导式生成的不是列表也不是元组，而是一个生成器对象。

>>> s = (x*2 for x in range(5))
>>> s
<generator object <genexpr> at 0x0000000002BDEB48>
>>> tuple(s)
(0, 2, 4, 6, 8)
>>> list(s) #只能访问一次元素。第二次就为空了。需要再生成一次
[]
>>> s
<generator object <genexpr> at 0x0000000002BDEB48>
>>> tuple(s)
()
>>> s = (x*2 for x in range(5))
>>> s.__next__()
0
>>> s.__next__()
2
>>> s.__next__()
4

元组总结：
1.不可变序列
2.访问和处理速度比列表快
3.与整数和字符串一样，元组可以作为字典的键，但列表不可以（因为键不能是可变数据）

字典

字典是“键值对”的无序可变序列，字典中的每个元素都是一个“键值对”，包含：“键对象”和“值对象”。可以通过“键对象”实现快速获取、删除、更新对应的“值对象”。
字典中通过“键对象”找到对应的“值对象”。“键”是任意的不可变数据，比如：整数、浮点数、字符串、元组。但是：列表、字典、集合这些可变对象，不能作为“键”。并且“键”不可重复。 “值”可以是任意的数据，并且可重复。

创建字典方法

1.通过{}、dict()创建字典

a = {'name':'gaoqi','age':18,'job':'programmer'}
b = dict(name='gaoqi',age=18,job='programmer')
print(a)
{'name': 'gaoqi', 'age': 18, 'job': 'programmer'}

a = dict([("name","gaoqi"),("age",18)]) #dict()括号里面可以是列表
c = {} #空的字典对象
d = dict() #空的字典对象
print(a)
print(b)
{'name': 'gaoqi', 'age': 18}
{'name': 'gaoqi', 'age': 18, 'job': 'programmer'}

2.通过zip()创建

k = ['name','age','job']
v = ['gaoqi','18','techer']
d = dict(zip(k,v))
print(d)
{'name': 'gaoqi', 'age': '18', 'job': 'techer'}

3.通过 fromkeys 创建值为空的字典

a = dict.fromkeys(['name','age','job'])
print(a)
{'name': None, 'age': None, 'job': None}

字典元素访问

1.通过键获得值，若键不存在，则抛出异常。

>>> a = {'name':'gaoqi','age':18,'job':'programmer'}
>>> a['name']
'gaoqi'
>>> a['age']
18
>>> a['sex']
Traceback (most recent call last):
File "<pyshell#374>", line 1, in <module>
a['sex']
KeyError: 'sex'

2.通过get()方法获得“值”。推荐使用。优点是：指定键不存在，返回None；也可以设定指定键不存在时默认返回的对象。推荐使用get()获取”值对象“。

>>> a = {'name':'gaoqi','age':18,'job':'programmer'}
>>> a.get('name')
'gaoqi'
>>> a.get('sex')
>>> a.get('sex','一个男人')
'一个男人'

3.列出所有的键值对

>>> a = {'name':'gaoqi','age':18,'job':'programmer'}
>>> a.items()
dict_items([('name', 'gaoqi'), ('age', 18), ('job', 'programmer')])

4.列出所有的键，列出所有的值

>>> a = {'name':'gaoqi','age':18,'job':'programmer'}
>>> a.keys()
dict_keys(['name', 'age', 'job'])
>>> a.values()
dict_values(['gaoqi', 18, 'programmer'])

5.len()键值对的个数
6.检测一个“键”是否在字典中

>>> a = {"name":"gaoqi","age":18}
>>> "name" in a
True

字典元素添加、修改、删除

1.直接增加：给字典新增“键值对”。如果“键”已经存在，则覆盖旧的键值对；如果“键”不存在，则新增“键值对”。

>>>a = {'name':'gaoqi','age':18,'job':'programmer'}
>>> a['address']='西三旗 1 号院'
>>> a['age']=16
>>> a
{'name': 'gaoqi', 'age': 16, 'job': 'programmer', 'address': '西三旗 1 号院'}

2.使用update()将新字典中所有键值对全部添加到旧字典对象上，如果”键“有重复，则直接覆盖旧的键值对，如果“键”不存在，则新增“键值对”。

>>>a = {'name':'gaoqi','age':18,'job':'programmer'}
>>> a['address']='西三旗 1 号院'
>>> a['age']=16
>>> a
{'name': 'gaoqi', 'age': 16, 'job': 'programmer', 'address': '西三旗 1 号院'}

3.字典中元素的删除，可以使用del()方法；或者clear()删除所有键值对；pop()删除指定键值对，并返回对应的值对象；

>>> a = {'name':'gaoqi','age':18,'job':'programmer'}
>>> del(a['name'])
>>> a
{'age': 18, 'job': 'programmer'}
>>> b = a.pop('age')
>>> b
18

4.popitem()：随机删除和返回该键值对。字典是“无序可变序列”，没有第一个元素和最后一个元素的概念。若想一个接一个地移除并处理项，这个方法就非常有效（因为不用首先获取键的列表

>>> a = {'name':'gaoqi','age':18,'job':'programmer'}
>>> a.popitem()
('job', 'programmer')
>>> a
{'name': 'gaoqi', 'age': 18}
>>> a.popitem()
('age', 18)
>>> a
{'name': 'gaoqi'}

集合

集合是无序可变，元素不能重复。集合底层是字典实现，集合的所有元素都是字典中的“键对象”，因此是不能重复的且唯一的。
1.**使用{}**创建集合对象，并使用 **add()**方法添加元素

>>> a = {3,5,7}
>>> a
{3, 5, 7}
>>> a.add(9)
>>> a
{9, 3, 5, 7}

2.使用 set()，将列表、元组等可迭代对象转成集合。如果原来数据存在重复数据，则只保
留一个。

>>> a = ['a','b','c','b']
>>> b = set(a)
>>> b
{'b', 'a', 'c'}

3.**remove()**删除指定元素；**clear()**清空整个集合

>>> a = {10,20,30,40,50}
>>> a.remove(20)
>>> a
{10, 50, 30}

集合的操作：

>>> a = {1,3,'sxt'}
>>> b = {'he','it','sxt'}
>>> a|b #并集
{1, 3, 'sxt', 'he', 'it'}
>>> a&b #交集
{'sxt'}
>>> a-b #差集
{1, 3}
>>> a.union(b) #并集
{1, 3, 'sxt', 'he', 'it'}
>>> a.intersection(b) #交集
{'sxt'}
>>> a.difference(b) #差集
{1, 3}