什么时候用容器类型的数据？ ---> 需要同时保存多个数据的时候        什么时候用列表？ ---> 保存的多个数据是同一类的数据（不需要区分）     什么时候用字典？ ---> 保存的多个数据是不同类的数据 (需要区分)

一、tuple

1.什么是元祖

使用()将多个元素括起来，多个元素之间用逗号隔开

a.

容器，可以同时存储多个数据,不可变的，有序的

不可变 ---> 不能增删改

有序 ---> 可以通过下标获取元素

b.

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

tuple1= (1,'yue',True, [1,2],lambda s:s*2)

print(tuple1)

注意

1.

如果元祖的元素只有一个的时候，必须在元素的后面加逗号

tuple2= (100,)

print(type(tuple2))

2.

多个数据直接用逗号隔开，表示的也是一个元祖

tuple2= 10,20,'abc'

print(tuple2,type(tuple2))

 2、元素的查

元祖的元素不支持增删改

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

遍历：和列表一样

tuple2= ('星期一','星期二','星期三','星期四')

print(tuple2[1])

print(tuple2[2:])

print(tuple2[::-1])

# 遍历

for item in tuple2:

    print(item)

index= 0

while index< len(tuple2):

    print(tuple2[index])

    index+= 1

补充：获取部分元素

可以通过相同的变量个数，来获取元祖中的元素

x, y= (10,20)

print(x, y)

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

x, y= 10,20

# 1.应用：交换两个数的值

a= 10

b= 20

# 错误写法

# a = b  # a = 20

# b = a  # b = 20

# 方法1：

# t = a  # t = 10

# a = b  # a = 20

# b = t  # b = 10

# 方法2：

a, b= b, a     # a,b = (b,a) = (20, 10)

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

tuple2= ('小明',90,89,67,100)

name,*score= tuple2

print(name, score)

tuple2= (90,89,67,100,'小明')

*score, name= tuple2

print(score, name)

tuple2= ['boy',15300022673,90,89,67,100,'小明']

sex, tel,*score, name= tuple2

print(sex, name, score)

"""

(了解)

可以通过在列表或者元祖前加*,来展开列表中的元素

"""

tuple3= (1,2,3,4)

print(*tuple3)

list1= ['abc',100,200]

print(*list1)

 3.元祖的运算

+, *, ==, is, in, not in ---> 和列表一样

print((1,2,3)+ ('a','b'))

print((1,2)* 3)

print((1,2,3)== (1,2,3))

print((1,2,3)is (1,2,3))

print(1 in (1,2,3))

print(1 not in (1,2,3))

4.len(), max(), min()

tuple3= 10,230,100,78,34

print(len(tuple3))

print(max(tuple3))

print(min(tuple3))

5.tuple()

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

print(tuple('abhdnc'))

print(tuple([1,23,90]))

print(tuple(range(5)))

print(tuple({'a': 100,'b': 200}))

6.sorted()

可以通过sorted()方法，对元祖进行排序，产生一个新的列表

tuple3= 10,230,100,78,34

new= sorted(tuple3)

print(new, tuple3)

二、dict

1.什么是字典（dict）

"""

字典是一个容器类的数据类型，可以用来存储多个数据(以键值对的形式存储)。可变的，无序的

{key1:value1, key2:value2...}

可变 ---> 可以增删改

无序 ---> 不能通过下标获取值

键(key): 用来定位值的。要求只能是不可变的数据类型(数字，字符串，元祖...)。是唯一的

值(value): 存储的数据。可以是任何类型的数据

"""

# person1 = ['yuting', 18, 90, 100, '1547262889']

person2= {'name': 'yuting','age': 18,'face': 90,'score': 100,'tel': '1547262889','name':'小花'}

dict1= {10: 893,'abc': 100, (1,23): 'abc'}

print(person2)

dict1= {}

print(dict1)

2、字典的增删改查

1.查(获取键值对的value)

"""

获取字典的值，必须通过key来获取

a.字典[key]  ---> 获取key对应的值

注意：key值必须是存在的，否则会报KeyError

"""

student= {'name': '小明','age': 30,'study_id': 'py001','sex': 'boy'}

print(student['name'])

print(student['sex'])

# print(student['score'])  # KeyError: 'score'

"""

b.字典.get(key)  ---> 通过key获取值

注意：key值不存在的时候不会报错，结果是None

"""

print(student.get('age'), student.get('study_id'))

print(student.get('score'))

"""

确定key一定存在就是使用[]语法，key可能不存在的时候使用get语法

"""

c.直接遍历字典（推荐使用）

通过for-in遍历字典拿到的是key值

"""

for xin student:

    print(x, student[x])

d.其他遍历方式(了解)

# 直接遍历拿到值

for valuein student.values():

    print(value)

# 直接拿到key和value

print(student.items())

for key, valuein student.items():

    print(key, value)

2.增(添加键值对)

"""

字典[key] = 值（key不存在）

"""

car= {}

car['color']= 'yellow'

print(car)

car['price']= 300000

print(car)

3.修改（修改值）

"""

字典[key] = 新值 (key存在)

"""

car['color']= 'red'

print(car)

4.删 (删除键值对)

a.

del 字典[key]  ---> 通过key删除键值对

student= {'name': '小明','age': 30,'study_id': 'py001','sex': 'boy'}

del student['age']

print(student)

b.

字典.pop(key)  ---> 取出key对应的值(实质还是删除key对应的键值对)

name= student.pop('name')

print(student, name)

3.字典相关运算

==: 判断两个字典的值是否相等

is: 判断两个字典的地址是否相等

in 和 not in: key in 字典 / key not in 字典 ---> 判断key是否存在

"""

dic1= {'a': 1,'b': 2}

aa= dic1

print(dic1is aa)

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

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

print('abc' in {'abc': 100,'a': 200})# True

print('abc' in {'100': 'abc','a': 200})# False

4.字典相关的函数和方法

1.

len(字典) --> 获取键值对的个数

dict1= {'a': 1,'b': 2,'c': 3,'d': 4}

print(len(dict1))

2.

字典.clear() --> 清空字典

dict1.clear()

print(dict1)

3.

字典.copy()  --> 将字典中的键值对复制一份产生一个新的字典

dict1= {'a': 1,'b': 2,'c': 3,'d': 4}

dict2= dict1.copy()

print(dict2, dict1is dict2)

4.

dict.fromkeys(序列, 值) --> 创建一个字典，将序列中的每个元素作为key，值作为value

dict3= dict.fromkeys('xyz',100)

print(dict3)

dict3= dict.fromkeys(['aa','bb','cc'], (1,2))

print(dict3)

5.

字典.get(key)  --> key不存在取None

字典.get(key,默认值) --> key不存在取默认值

student= {}

print(student.get('name'))

print(student.get('name','无名'))

6.

字典.values()  --> 返回所有值对应的序列

字典.keys() --> 返回所有键对应的序列

字典.items() --> 将键值对转换成元祖，作为一个序列的元素

注意：返回的都不是列表，是其他类型的序列

dict1= {'a': 1,'b': 2,'c': 3,'d': 4}

items= list(dict1.items())

print(items,type(items))

print(dict1.items(),type(dict1.items()))

7.

字典.setdefault(key)  --> 添加键值对，键是key，值是None

字典.setdefault(key,value)  --> 添加键值对，键是key，值是value

注意：key存在的时候，对字典不会有任何操作(不会修改key对应的值)

dict1= {'a': 1,'b': 2,'c': 3,'d': 4}

dict1.setdefault('aa')

print(dict1)

8.

字典1.update(字典2) --> 使用字典2中键值对去更新字典1。(已经存在的key就更新，不存在就添加)

"""

dict1= {'a': 1,'b': 2}

dict2= {'b': 200,'c': 100}

dict1.update(dict2)

print(dict1)

三、set

1.什么是集合(set)

容器，可以同时存储多个数据,可变的，无序的,元素是唯一的

可变 --> 增删改

无序 --> 不能通过下标获取元素

唯一 --> 自带去重的功能

{元素1, 元素2...}

元素：只能是不可变的数据

"""

set1= {10,20,'abc', (10,200),10}

print(set1)# {(10, 200), 10, 20, 'abc'}

# set2 = {}  # 这个是空的字典

2.集合的增删改查

a.

查(获取元素)

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

for x in set1:

    print(x)

b.

增(添加元素)

集合.add(元素) --> 在集合中添加一个元素

set1= {1,2,3}

set1.add(4)

print(set1)

集合1.update(序列)  --> 将序列中的元素添加到集合1中

set1.update({'a','b'})

print(set1)

set1.update('0987')

print(set1)

set1.update(['abc','aaa'])

print(set1)

set1.update({'name': 1,'age': 18})# 字典只添加key

print(set1)

3.删(删除元素)

集合.remove(元素) --> 删除指定的元素

set1.remove(1)

print(set1)

 4.改(集合不能改)

2、集合相关的运算

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

1.包含

集合1 >= 集合2 ---> 判断集合1之中是否包含集合2

集合2 <= 集合2 ---> 判断集合2之中是否包含集合1

set1= {1,2,3,4,5,10}

set2= {3,4,1}

print(set1>= set2)

2.交集 -> &

& --> 求两个集合公共的部分

set1= {1,2,3,4,5}

set2= {1,2,3,10,20}

print(set1& set2)

3.求并集

| --> 求两个集合的和

print(set1| set2)

4.求差集

集合1-集合2 --> 求集合1中除了集合2以外的部分

print(set1- set2)

5.求补集

^ --> 求两个集合除了公共部分以外的部分

print(set1^ set2)