一，元组(tuple)

元组是不可变的列表，列表中除了课表操作外，其他的操作都适用于元组

1.元组的声明(元组名=(1,2,'a'))

a.使用()将元素包含起来，多个元素之间用逗号隔开.比如：(1,2,'a')
b.元素的类型可以使任何类型

2.元组的操作

注意：改，增，删相关操作不能作用于元组，只有查询可以。

查：
(1).通过多个变量分别获取元组中的各个元素(变量个数和元素个数相同)
代码实现：

colors = ('red','green','bule','yellow')
names = ('name1','name2','name3')

输出结果：

name1 name2 name3

(2).*的使用
*midel表示获取first和last取完后剩下的值。如果没有*，则获取所有元素中间的那个; 如果*在两端的时候，加*一边截取的是剩下的部分，生成一个列表
代码实现：

first, *midel, last = names
print(first,*midel,last)
*name,name1 = names
print(name,name1)

输出结果：

name1 name2 name3
['name1', 'name2'] name3

(3)获取指定元素
代码实现：

print(colors[1])
# 获取多个元素(切片)
print(colors[0:4:3])
# 遍历取值
for i in colors:
    print(i)
print('--------------')
#in,not in
print('red' in colors)

输出结果：

green
('red', 'yellow')
red
green
bule
yellow
True

二，字典：(dict)

字典也是一种容器类型的数据类型(序列)，存的数据时以键值对的形式出现的。字典中的元素全部都是键值对。字典是可变的(能够增删改)，但是是无序的(不能索引)

键：值(key:value).键值中的key是形式，值才是真正要存的内容

• 键:理论上可以是任何不可变的数据类型，但是实际开发的时候一般使用字符串作为key.(不可变的数据类型都可以作为key,包括数字和字典；但是可变的数据类型不能使用(列表))
• 值：可以使任意数据类型

1.声明一个字典

(1).直接创建：

变量名 = {'元素1'，'元素2'}

注意：dict = {}是空字典，而不是空集合
(2).将其他数据类型转换成字典
当字典中有两个元组，并且元组中都只有两个元素的时候可以转换成字典
代码实现：

dict3 = {(1, 2), (2, 3)}
print(dict3)

输出结果：

{(1, 2), (2, 3)}

2.字典的增删改查

(1).查取元素：获取字典中的元素的值
a.字典获取元素的值是通过key来获取的;字典[key]。（存在‘越界’）
b.字典.get(key)

注意：如果Key确定存在，使用字典[key]；若不确定key是否存在，使用get()

代码实现：

person = {'name': '路飞', 'age': 17, 'face': 90}
print(person['name'])
#print(person['aaa']) 报错;‘越界’
print(person.get('name'))
print(person.get('aaa'))
# 当使用get()来获取时，如果字典中不存在get的key，输出为None

输出结果：

路飞
路飞
None

(2)增加元素，修改元素：通过key获取字典元素，然后赋值。当想要增加的key本身就存在的时候，就是修改这个key的值；如果不存在的话就是增加的键值对
增加元素：字典[key]=value
修改元素：字典[待修改value的key]=新value
代码实现：

# 增加
person['height'] = 1.8
print(person)
print('1------------------------------------')
# 修改
person['age'] = 18
print(person)

输出结果：

{'name': '路飞', 'age': 17, 'face': 90, 'height': 1.8}
1------------------------------------
{'name': '路飞', 'age': 18, 'face': 90, 'height': 1.8}

(3).删除：
a.del 字典[key]

注意：删除的是键值对，而不是只删除key.key-value总是同时存在

b.字典.pop(key)
代码实现：

del person['face']
print(person)
# del person['aaa'] ,因为del是先查找，再删除，所以在删除不存在的键值对时会报错
AGE = person.pop('age')
# 会返回被删除的键值对应的值
print(AGE)
print(person)

输出结果：

{'name': '路飞', 'age': 18, 'height': 1.8}
18
{'name': '路飞', 'height': 1.8}

3.相关的数组属性

• 字典.keys():获取字典所有的key,返回值是dict_keys,但是可以把他当做列表使用
• 字典.value():获取字典所有的值。
• 字典.items:将字典中所有的键值对转换成一个一个的元组，key作为元祖的第一个元素，value作为元组的第二个元素
  代码实现：

stu_dict = {'name': 'chen', 'stu_id': 'py1805', 'score': {'eng_score': 80, 'math_score': 85}}
keys = stu_dict.keys()
print(keys, type(keys))
print('2-------------------------------------')
# 遍历获取每个key
for key in keys:
    print(key)
print('3-------------------------------------')
print(stu_dict.values())
print('4-------------------------------------')
print(stu_dict.items())
print('5-------------------------------------')

输出结果：

dict_keys(['name', 'stu_id', 'score']) <class 'dict_keys'>
2-------------------------------------
name
stu_id
score
3-------------------------------------
dict_values(['chen', 'py1805', {'eng_score': 80, 'math_score': 85}])
4-------------------------------------
dict_items([('name', 'chen'), ('stu_id', 'py1805'), ('score', {'eng_score': 80, 'math_score': 85})])
5-------------------------------------

4.遍历字典

a.直接遍历字典时取到的是key(推荐使用)
b.直接获取key和value(不推荐)转换时执行步骤过多，消耗大

for key in stu_dict:
    print(key, stu_dict[key])
print('6------------------------------------')
for key, value in stu_dict.items():
    print(key, value)
print('7------------------------------------')

输出结果：

score {'eng_score': 80, 'math_score': 85}
6------------------------------------
name chen
stu_id py1805
score {'eng_score': 80, 'math_score': 85}
7------------------------------------

6.其他操作

(1).字典.formkeys(),删除字典中的所有键值对，然后将新的键值对存入
(2).key in 字典：判断字典中是否存在指定的Key
(3).字典1.update(字典2)：使用字典2的键值对取跟新字典1中的键值对.如果字典2中对应的key在字典1中不存在，就添加，否则就更新
代码实现：

dict4 = {'a': 1, 'b': 2}
new_dict4 = dict4.fromkeys('abc', '100')
print(new_dict4)
print('8--------------------------------------')
dog_dict = {'color': 'white', 'age': 3, 'type': '土狗'}
print('color' in dog_dict)
print('9--------------------------------------')
dict5 = {'a': 1, 'b': 2}
dict6 = {'a': 2, 'c': 3}
dict5.update(dict6)
print(dict5)

输出结果:

{'a': '100', 'b': '100', 'c': '100'}
8--------------------------------------
True
9--------------------------------------
{'a': 2, 'b': 2, 'c': 3}

三，集合(set)

集合也是一种数据类型(序列)；数据放在{}中，多个之间只用逗号隔开：{1,2,'a'}

集合是无序的，所以不能通过索引来取值；可变(可以增删改)，元素不能重复

1.声明集合

a.声明集合变量，然后赋值。

集合名={元素1，元素2}

空集合表示：set0 = set()
b.将其他数据类型转换成集合(转换时会自动将重复元素整合为一个)
代码实现：

# 空集合
set0 = set()
print(type(set0))
set1 = {1, 2, 3}
print(set1, type(set1))
print('1------------------------')
set2 = set('abc12343ah')
# 将其他数据转换成集合，自带一个去重复功能
print(set2)
print('2-------------------------')
set3 = set([1, 2, 3, 3, 5, 6])
print(set3)
print(list(set3))
print('3-------------------------')

输出结果：

<class 'set'>
{1, 2, 3} <class 'set'>
1------------------------
{'c', '1', 'h', '4', 'a', '2', '3', 'b'}
2-------------------------
{1, 2, 3, 5, 6}
[1, 2, 3, 5, 6]
3-------------------------

2.增删改查

(1).查取元素：遍历

注意：集合只能通过遍历来取值

代码实现：

for i in set1:
    print(i)

输出结果：

1
2
3

(2).增加元素
a.集合.add(待添加元素)：在指定集合中添加指定元素
b.集合1.update(集合2)：将集合2中的元素添加到集合1中(自动整合重复)
代码实现：

set1.add(100)
print(set1)
set1.update(set2)
print(set1)

输出结果：

{1, 2, 3, 100}
{1, 2, 3, 100, 'c', '1', 'h', '4', 'a', '2', '3', 'b'}

(3).删除元素
a.del:只能删除整个集合
b.集合.remove('待删除元素')：在指定的集合中删除指定的元素
c.pop():随机删除
代码实现：

set1.remove(100)
print(set1)
set1.pop()
print(set1)

输出结果：

{1, 2, 3, 'c', '1', 'h', '4', 'a', '2', '3', 'b'}
{2, 3, 'c', '1', 'h', '4', 'a', '2', '3', 'b'}

3.集合可以进行数学中集合相关的操作：判断是否包含，求交集，并集，补集

(1)包含：

• 集合1 >= 集合2 ：--判断集合1中是否包含集合2,判断依据，是否其中一* * 个是另一个的为真子集。
• 集合1 <= 集合2 ：--判断集合2中是否包含集合1,判断依据，是否其中一个是另一个的为真子集。
  代码实现：

set4 = {1, 2, 3, 4, 5, 7}
set5 = {1, 2, 3, 4, 'a', 5}
print(set4 >= set5, set4 <= set5)

输出结果：

False False

(2).求并集：|求交集：&求差集：-求补集：^转空集：集合.clear()
代码实现：

print(set4 | set5)
print(set4 & set5)
print(set5 - set4)
print(set4 ^ set5)
print(set4.clear(), type(set4))

输出结果：

{1, 2, 3, 4, 5, 7, 'a'}
{1, 2, 3, 4, 5}
{'a'}
{'a', 7}
None <class 'set'>