---

1.什么是元祖

a.
是容器，可以存储多个数据，不可变，有序的
不可变：不能增删改
有序：可以通过下标获取

b.
元素，可以是任何类型的数据

注意：如果元祖的元素只有一个，则必须在后面加逗号表示一个元祖

tuple1 = (100,)
print(tuple1)

tuple1 = 10, 20, 'abc'   # 也是元祖(多个数据用逗号隔开表示的也是元祖)
print(tuple1)

2.元祖：不支持增删改，但可以查

列表获取元素的方式，元祖都支持
元祖[下标] 或 元祖[ : : ]

tuple2 = '星期一', '星期二', '星期三', '星期四'
print(tuple2[0])
print(tuple2[2:])
print(tuple2[ : : -1])

#### 3.遍历元祖
for item in tuple2:
    print(item)

index = 0
while index < len(tuple2):
    print(tuple2[index])
    index += 1

4.补充：获取部分元素：可以通过相同的变量个数，来一一获取元祖中的元素

x, y = (10, 20)
print(x, y)

x, y, z = 10, 20, 30
print(x, y, z)

应用：交换两个数的值

a = 10
b = 20
方法1：
t = a
a = b
b = t

方法2：
a, b = b, a
print(a, b)

5.可以通过在变量前加*来获取部分元素(适用列表)

tuple2 = ( 90, 80, 70, '小明')
name, *score = tuple2
print(name, score)

*score, name = tuple2
print(name, score)

6.可以在列表或元祖前加*，来展开列表中的元素

tuple3 = ( 90, 80, 70, '小明')
print(*tuple3)

list1 = ['abc', '100', '200']
print(*list1)

7.元祖运算

>, +, *, ==, is, in, not in

print((1, 2, 3) + ('z', 'c', 'b'))
print((1,2) * 2)
print((1,2,3) == (1, 2, 3))
print((1,2,3) is (1,2,3))
print((1,2) in (1,2,3))
print((1,2,3) not in (1,2,3))

8.元祖支持的函数方法

• len()
• max()
• min()

9.tuple()

所有的序列都可以转换成元祖，注意：字典只能将key值作为元祖元素

print(tuple('abcd'))

10.sorted()

排序后产生一个新的列表

tuple4 = (1,2,3,8,0,4)
tuple5 = sorted(tuple4)
print(tuple4)
print(tuple5)

11.需要存储多个数据时就用容器

什么时候用列表：保存同一类数据时用列表
什么时候用字典：需要区分数据意义时就要字典
什么时候用元祖: 保存同一类数据时用列表，并且不可变时

---

12.什么是字典

字典是一个容器类的数据类型，可以用来存储多个数据（键值对的形式存储数据）
{key1:value1, key2:value2, .....}
字典是可变的（可以增删改），无序的（不能用下标获取值）
key:用来定位值的。要求：唯一性，只能是不可变的数据类型（数字，字符串，元祖....）
值：存放数据，可以是任何类型的数据

student = {'name':'xiaoming', 'age':'18', 'math':80, 'english':90,'chinese':90}
print(student['name'])

13.查（获取value）

获取字典的值必须通过key来获取
每次只能获取单个值
a.
语法：字典[key] 获取key对应的值
key必须存在，否则报错
b.
字典.get(key) :获取key对应的值
key不存在时不会报错，返回一个none
注意：key一定存在时用字典[key]，当key可能存在可能不存在时用字典.get（）方法

student = {'name':'xiaoming', 'age':'18', 'math':80, 'english':90,'chinese':90}
print(student['math'])
print(student.get('math'))
print(student.get('kkkk')) # 返回None

14.直接遍历字典(拿到key推荐使用)

student = {'name':'xiaoming', 'age':'18', 'math':80, 'english':90,'chinese':90}
for x in student:
    print(x, student[x])

15.其他方式遍历（占cpu）

a.直接遍历获取值

for value in student.values():
    print(value)

b.直接遍历获取key-value

for key, value in student.items():
    print(key, value)

17.添加键值对

• 语法：dict[key] = value(key不存在)

car = {}
car['color'] = 'red'
print(car)

18.修改

• 语法：dict[key] = value(key存在)

car = {}
car['color'] = 'red'
car['color'] = 'black'
print(car)

19.删除键值对

• a.
  语法：del dict[key] 通过key删除键值对

• b.
  语法：dict.pop(key) 取出key对应的值，但相对来说就是删除键值对

student = {'name':'xiaoming', 'age':'18', 'math':80, 'english':90,'chinese':90}
del student['age']
print(student)

name = student.pop('name')
print(student, name)

20.字典相关运算

字典不支持+，* 运算
但只支持 == 运算，但字典长度要相同，字典是无序的
字典也支持 is，in，not in
注意：key in dict 或者 key not in dict

print({'a': 100, 'b':200} == {'b': 200, 'a': 100})
print({'a': 100, 'b':200} is {'b': 200, 'a': 100})
print('a' in {'a': 100, 'b':200})
print('a' not in {'a': 100, 'b':200})

21.字典相关函数和方法

• len(dict)
  获取键值对的个数

• dict.clear()
  清空字典所有的键值对

• dict.copy()
  复制一份所有的键值对，产生一个新的字典

dict1 = {1,5,8,9}
dict2 = dict1.copy()
print(dict2)

• dict.fromkeys(序列，值)
  将序列中的每个元素作为key，后面的值作为value

dict3 = dict.fromkeys('xyz', 100)
print(dict3)  #{'x': 100, 'y': 100, 'z': 100}

• dict.get(key) # key不存在时返回none
• dict.get(key, 默认值) # key不存在时取默认值

student = {}
print(student.get('name'))
print(student.get('name', '无名'))

• dict.values()
  直接获取所有的value序列

• dict.keys()
  直接获取所有key的序列

• dict.items()
  将键值对转换成元祖，作为一个序列的元素
  注意：返回的都不是列表，是其他类型的序列

• dict.setdefault(key)

• dict.setdefault(key, 值)
  key存在时对字典没有任何效果，key不存在时会添加一个新的键值对（key为空时默认为none）

student = {}
student.setdefault('aa', 100)
print(student)

student.setdefault('aa')
print(student)

• dict1.update(dict2)
  使用2中的键值对去更新字典2(已经存在的key就更新，不存在的就添加)

dict1 = {'a': 1, 'b': 2}
dict2 = {'a': 100, 'c': 500}

dict1.update(dict2)
print(dict1)
print(dict2)

---

22.什么是集合（set）

集合也是容器，集合是可变的，无序的
可变：能增删改
无序：不能通过下标获取元素
形式：{元素1，元素2....}
元素：必须是不可变的数据，并且元素具有唯一性，则集合自带去重的功能

set1 = {1, 'asd', 45, (10, 200)}
print(set1)

注意：set2 = {}表示字典，而不是集合

23.集合的查（获取）

• a.
  集合不能单独获取一个元素，不能切片，只能通过for-in来遍历

set1 = {1, 'asd', 45, (10, 200)}
for x in set1:
    print(x)

24.增加元素

• a.
  set.add(元素) ：集合中添加一个元素
  set1 = {1, 'asd', 45, (10, 200)}
  set1.add(5)
  print(set1)

• b.
  set1.update(set2) :将集合2中的元素添加到集合1中,相当于数学求并集

set2 = {'zzz', 'aaa'}
set1.update(set2)
print(set1)

set2.update('789')
print(set2)  #{'aaa', 'zzz', '9', '7', '8'}

set2.update(['abc', 'uuu'])
print(set2)         # 列表元素必须是不可变的

set2.update({'name': 520})
print(set2)         # 字典只能把key添加到集合中

25.删除

集合就一种删除方法
语法：集合.remove(元素)

注意：集合不能改

26.集合相关运算

包含，交集，并集，补集，差集

27.包含

运算符： >= 和 =<
集合1 >= 集合2 : 判断集合1是否包含集合2
集合1 <= 集合2 : 判断集合2是否包含集合1

set1 = {1, 2, 3, 4, 5}
set2 = {1, 2, 3,}
print(set1 >= set2)
print(set2 <= set1)

28.交集

求两个集合公共部分
运算符：&

set1 = {1, 2, 3, 4, 5}
set2 = {1, 2, 3,}
print(set1 & set2)   #{1, 2, 3}

29.并集

求两个集合的和
运算符：|

set1 = {1, 2, 8, 4, 10}
set2 = {1, 20, 9,}
print(set1 | set2)   # {1, 2, 4, 20, 8, 9, 10}

30.差集

运算符: -
集合1 - 集合2 ：求集合1中除了集合2以外的部分

set1 = {1, 2, 8, 4, 10}
set2 = {1, 20, 9,}
print(set1 - set2)   # {8, 2, 10, 4}

31.补集

运算符： ^
求两个集合除了公共部分以外的部分

set1 = {1, 2, 8, 4, 10}
set2 = {1, 20, 9,}
print(set1 ^ set2)   # {2, 4, 8, 9, 10, 20}

---

1.整型

语法：int()
浮点数、布尔、部分字符串
去掉引号后就本身就是整数，才能转换成整型

print(int('+4'), int('-5'))

2.浮点数

语法：float()
整数、布尔、部分字符串
去掉引号本身就是一个数字的字符串才能转换成浮点数

print(float('23.5'),float(+25), float(-5))

3.bool

语法：bool()
所有的数据都能转换成bool类型
所有容器为空时转换都是False，整数0才能转换成False

print(bool(-5))
print(bool(None))

简化条件语句
num = 11
if num:
    print('不为0')

4.字符串

语法：str()
所的数据都可以转换成字符串,也就是在数据外面加引号

print(str([1, 2, 5]),str({'name': 555, 'age': 18}))

5.列表

语法：list()
序列才能转换成列表
将序列元素作为列表的元素
字典转化成列表只是将字典的key做作为列表的元素

print(list({'a':10, 'b':20}))
print(list({'a':10, 'b':20}.items()))
# [('a', 10), ('b', 20)]

6.元祖

tuple()
将序列转换成元祖

print(tuple({'a':10, 'b':20}))  #('a', 'b')
print(tuple({'a':10, 'b':20}.items()))  #(('a', 10), ('b', 20))

7.字典

语法：dict()
只有序列才能转换成字典，要求序列的每个元素有且只有两个元素

print(dict([('name', 'xiaoming'), ('age', 20)]))

8.集合set

语法：set()
序列可以转换成集合，有去重的功能
字典转换成集合，也只能将key作为集合的元素

print(set({'naem' : 'xiaoming', 'age': 18}))