Python基础——元组、字典和集合

1.可变对象与不可变对象

• Python 中可变对象有：列表（list）、字典（dict）、集合（set）
• Python 中不可变对象有：数值类型（int和float）、字符串（str）、元组（tuple）
• 可变对象都保存了id（标识）、type（类型）、value（值）三个数据

2.元组（tuple）简介

• 元组是一个不可变序列（一般情况不希望数据改变时，使用元组；否则基本都使用列表）
• 元组使用（）创建元素，使用逗号来隔开元素；除空元组外，至少有一个逗号，且可省略括号。例如(‘Python’, [ ‘Toro’, 1], 1, 2, 3)，（3， ）
• 元组是一种序列，它支持序列的基本操作，包括索引、切片、序列加（+）、序列乘（*）、in、len()、max()、min()。元组不可修改，指的是元组中每个元素的指向永远不变。

a = ('Toro', 201607, ['Python', 71], 'alex')
print(a, type(a))
print(a[1:4])
for i in a:
    print(i) 
# 输出结果 ('Toro', 201607, ['Python', 71], 'alex') <class 'tuple'>
# 输出结果(201607, ['Python', 71], 'alex')
#输出结果  Toro
#         201607
#         ['Python', 71]
#         alex

a = ('Toro', 201607, ['Python', 71], 'alex')
print(a, type(a))
a[2][0] = a[2][0].upper()
print(a)
a[2].append('朱丽叶')
print(a)
# 输出结果 ('Toro', 201607, ['Python', 71], 'alex') <class 'tuple'>
# 输出结果 ('Toro', 201607, ['PYTHON', 71], 'alex')
# 输出结果 ('Toro', 201607, ['PYTHON', 71, '朱丽叶'], 'alex')

• 元组解包：将元组中的每一个以元素都赋值给一个变量

my_tuple = ('Toro', 201607, ['Python', 71], 'alex')
a, b, c, d = my_tuple
print('a = ', a)         # 输出结果 a =  Toro
print('b = ', b)         # 输出结果 b =  201607
print('c = ', c)         # 输出结果 c =  ['Python', 71]
print('d = ', d)         # 输出结果 d =  alex

3.字典

3.1字典的基本介绍

• 字典属于⼀种新的数据结构称为映射(mapping)
• 字典的作⽤和列表类似，都是⽤来存储对象的容器
• 列表存储数据的性能好，但是查询数据的性能差，字典正好与之相反
• 在字典中每⼀个元素都有唯⼀的名字，通过这个唯⼀的名字可以找到指定的元素
• 这个唯⼀的名字我们称之为key 通过key可以快速查询value 也可以称之为值
• 字典我们也称之为键值对(key-value)结构
• 每个字典中都可以有多个键值对，⽽每⼀个键值对我们称其为⼀项(item)
• 创建⼀个有数据的字典 语法 {key:value}
• 字典的值可以是任意对象 字典的键可以是任意的不可变对象(int str bool tuple…)
• 字典的键是不能重复的，如果出现重复的后⾯的会替换前⾯的

3.2字典的使用

• dict()函数来创建字典
• get(key[,default]) 根据键来获取字典的值。第⼆个参数可以指定⼀个默认值，当获取不到值的时候会返回默认值（None）
• update() 将其他字典的key-value添加到当前的字典当中
• del 删除字典中的key-value
• popitem() 删除字典最后的⼀个key-value 这个⽅法是有返回值的。删除之后它会将删除的key-value作为返回值返回
• pop(key[,default]) 根据key删除⾃定中的key-value,并返回value。第⼆个参数可以指定⼀个默认值，当获取不到值的时候会返回默认值

a = dict(name='Toro', age='18')
print(a, type(a))    # 输出结果{'name': 'Toro', 'age': '18'} <class 'dict'>
b = dict((['name', 'Toro'], ['age', '18']))
print(b, type(b))    # 输出结果{'name': 'Toro', 'age': '18'} <class 'dict'>
my_name = b.get('name', '该值不存在')
my_gender = b.get('gender', '该值不存在')
print(my_name)       # 输出结果Toro
print(my_gender)     # 输出结果None
b.update({'gender': 'male'})
print(b)             # 输出结果{'name': 'Toro', 'age': '18', 'gender': 'male'}
del b['gender']
print(b)             # 输出结果{'name': 'Toro', 'age': '18'}
d = b.popitem()
print(d)             # 输出结果('age', '18')
print(b)             # 输出结果{'name': 'Toro'}
e = b.pop('name', '该值不存在')
print(e)             # 输出结果Toro
print(b)             # 输出结果{}

3.3copy()

• copy() ⽅法⽤来对字典进⾏潜拷贝
  注意:潜复制只会拷贝字典本身，如果字典中还有个字典是不会进⾏拷贝的

import copy

a = {'name': {'Toro': 'c'}, 'age': '18', 'gender': 'male'}  # 原始对象

b = a   # 赋值，传对象的引用
c = copy.copy(a)   # 对象拷贝，浅拷贝
d = copy.deepcopy(a)   # 对象拷贝，深拷贝
a.update({'增加': 'hhh'})    # 修改对象a
a['name']['Toro'] = 'hahha'

print('a = ', a)  # 输出结果a =  {'name': {'Toro': 'hahha'}, 'age': '18', 'gender': 'male', '增加': 'hhh'}
print('b = ', b)  # 输出结果b =  {'name': {'Toro': 'hahha'}, 'age': '18', 'gender': 'male', '增加': 'hhh'}
print('c = ', c)  # 输出结果c =  {'name': {'Toro': 'hahha'}, 'age': '18', 'gender': 'male'}
print('d = ', d)  # 输出结果d =  {'name': {'Toro': 'c'}, 'age': '18', 'gender': 'male'}

3.4遍历字典

• keys() 该⽅法返回字典所有的key
• values() 该⽅法返回⼀个序列 序列中保存有字典的值
• items() 该⽅法会返回字典中所有的项它返回⼀个序列，序列中包含有双值⼦序列双值分别是字典中的key和value

a = {'name': {'Toro': 'c'}, 'age': '18', 'gender': 'male'}

print(a.keys())   # 输出结果 dict_keys(['name', 'age', 'gender'])
for i in a.keys():
    print(i)   # 输出结果 name  age  gender
for v in a.values():
    print(v)   # 输出结果 {'Toro': 'c'}    18    male
for t in a.items():
    print(t)   # 输出结果 ('name', {'Toro': 'c'})    ('age', '18')   ('gender', 'male')

4.集合

4.1集合简介

• 集合表现形式set集合和列表⾮常相似
• 不同点
  集合只能存储不可变对象
  集合中存储的对象是⽆序的
  集合不能出现重复元素
• 使⽤{}来创建集合

4.2集合的方法（可以参考列表的方法）

• len()使⽤len()来获取集合中元素的数量
• add()像集合中添加元素
• update()将⼀个集合中的元素添加到另⼀个集合当中
• pop()随机删除集合中的⼀个元素⼀般是删除最后⼀个元素
• remove()删除集合中指定的元素
• clear() 清空集合

4.3集合的运算

• 交集运算（ &）
• 并集运算（ | ）
• 差集运算（ -）
• 亦或集（^）
• 检查⼀个集合是否是另⼀个集合的⼦集（ <=）
• 检查⼀个集合是否是另⼀个集合的真⼦集（ <）
• 检查⼀个集合是否是另⼀个集合的超集（ >=）
• 检查⼀个集合是否是另⼀个集合的真超集（ >）

set_1 = {1, 2, 3, 4, 5}
set_2 = {1, 2, 3}
set_3 = {1, 2, 3}
set_4 = {1, 3, 5, 7, 9}

print(set_1 & set_2)   # 输出结果{1, 2, 3}
print(set_1 | set_2)   # 输出结果{1, 2, 3, 4, 5}
print(set_1 - set_2)   # 输出结果{4, 5}
print(set_2 - set_1)   # 输出结果set()
print(set_1 ^ set_2)   # 输出结果{4, 5}
print(set_1 ^ set_4)   # 输出结果{2, 4, 7, 9}
print(set_1 <= set_4)   # 输出结果False
print(set_1 <= set_2)   # 输出结果False
print(set_2 <= set_3)   # 输出结果True
print(set_2 < set_3)   # 输出结果False