Python入门——序列——元组、字典

接下来我们继续学习python序列中的元组和字典

元组tuple

• 列表属于可变序列，可以任意修改列表中的元素。

• 元组属于不可变序列，不能修改元组中的元素。

  因此，元组没有增加元素、修改元素、删除元素相关的方法。

因此，我们只需学元组的创建和删除，元素的访问和计数即可。元组支持如下操作：

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

元组的创建

1.通过（）创建元组。# 小括号可以省略

注意：如果元组只有一个元素，则必须后面加逗号，这是因为解释器会把（1）解释为整数1，（1，）解释为元组

2.通过tuple（）创建元组

基本格式：tuple（可迭代的对象）

总结：

一、tuple（）可以接收列表、字符串、其他序列类型、迭代器等生成元组

二、list（）可以接收元组、字符串、其他序列类型、迭代器等生成列表

元组的元素访问和计数

1.元组的元素不能修改

a = (20, 10, 30, 9, 8)

a[3] = 33

这个修改元组大的操作就会报错，因为元组元素不可修改

2.元组的元素访问

包括index（）、count（）、切片等操作，和列表一摸一样

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

3.元组排序

列表中关于排序的方法 list.sorted（）是修改原列表对象，元组没有该方法。如果要对元组排序，智能使用内置函数sorted（tupleObj），并生成新的列表对象

a = (20,10,30,9,8)
b = sorted(a)  #b是新对象，内容是：[8, 9, 10, 20, 30]

最后我们再通过tuple（）操作给它还原为元组

ZIP（）

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

• 如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同

a = [10,20,30]
b = [40,50,60]
c = [70,80,90,100]
d = zip(a,b,c)
print(d)  #zip object
e = list(d) #列表：[(10, 40, 70), (20, 50, 80), (30, 60, 90)]
print(e)

元组的生成器推导式

1. 从形式上看，生成器推导式与列表推导式类似，只是生成器推导式使用小括号。
2. 列表推导式直接生成列表对象，生成器推导式生成的不是列表也不是元组，而是一个生成器对象。
3. 我们可以通过生成器对象，转化成列表或者元组。也可以使用生成器对象的__next__()方法进行遍历，或者直接作为迭代器对象来使用。不管什么方式使用，元素访问结束后，如果需要重新访问其中的元素，必须重新创建该生成器对象。

元组总结

1. 元组的核心特点是：不可变序列。
2. 元组的访问和处理速度比列表快。
3. 与整数和字符串一样，元组可以作为字典的键，列表则永远不能作为字典的键使用

字典

字典是“键值对”的无序可变序列，字典中的每个元素都是一个“键值对”，包含：“键对象”和“值对象”。可以通过“键对象”实现快速获取、删除、更新对应的“值对象”。

一个典型的字典的定义方式：

a = {'name':'yushu', 'age':18, 'job':'programmer'}

列表中我们通过“下标数字”找到对应的对象。字典中通过“键对象”找到对应的“值对象”。

1. “键”是任意的不可变数据，比如：整数、浮点数、字符串、元组。
2. 但是：列表、字典、集合这些可变对象，不能作为“键”。
3. 并且“键”不可重复。
4. “值”可以是任意的数据，并且可重复。

字典的创建

1.通过{}、dict()来创建字典对象。

2.通过zip()创建字典对象

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

字典元素的访问

为了测试各种访问方法，我们这里设定一个字典对象：

a = {'name':'yushu','age':18,'job':'programmer'}

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

   a = {'name':'yushu','age':18,'job':'programmer'}

   b = a['name']

   print(b)  # yushu

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

   a = {'name':'yushu','age':18,'job':'programmer'}

   b = a.get('name')

   c = a.get('gender','不存在')

   print(b)  # yushu

   print(c)  # 不存在

3. items()列出所有的键值对

   a = {'name':'yushu','age':18,'job':'programmer'}

   b = a.items()

   print(b)   # dict_items([('name', 'yushu'), ('age', 18), ('job', 'programmer')])

4. keys()列出所有的键，values()列出所有的值

   a = {'name':'yushu','age':18,'job':'programmer'}

   k = a.keys()

   v = a.values()

   print(k)   #  dict_keys(['name', 'age', 'job'])

   print(v)   #dict_values(['yushu', 18, 'programmer'])

5. len() 键值对的个数

   a = {'name':'yushu','age':18,'job':'programmer'}

   num = len(a)

   print(num)   # 3

6. 检测一个“键”是否在字典中

   a = {'name':'yushu','age':18,'job':'programmer'}

   print("name" in a)   # True

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

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

   a = {'name':'yushu','age':18,'job':'programmer'}

   a['address']='hubei'

   a['age']=16

   print(a)

   # {'name': 'yushu', 'age': 16, 'job': 'programmer', 'address': 'hubei'}

8. 使用update()将新字典中所有键值对全部添加到旧字典对象上。如果key有重复，则直接覆盖

   a = {'name':'yushu','age':18,'job':'programmer'}

   b = {'name':'why','money':1000,'gender':'男的'}

   a.update(b)

   print(a)

   # {'name': 'why', 'age': 18, 'job': 'programmer', 'money': 1000, 'gender': '男的'}

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

   a = {'name':'yushu','age':18,'job':'programmer'}

   del(a['name'])

   print(a)   # {'age': 18, 'job': 'programmer'}

   age = a.pop('age')

   print(age)   # 18

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

    a = {'name':'yushu','age':18,'job':'programmer'}

    r1 = a.popitem( )

    r2 = a.popitem( )

    r3 = a.popitem( )

    print(a)   # { }

    今天的介绍就到此结束了，后面我会更新一篇序列的总结篇，感兴趣的小伙伴可以留意一下！