元祖
a.是一种容器，可以同时存储多个数据，不可变的，有序的
不可变 --> 不能增删改
有序 --> 可以通过下标获取元素
b.里面的元素，可以是任何类型的数据
注意：
1.如果元祖的元素只有一个的时候，必须在后面加逗号
tuple1 = (100,)
print(type(tuple1))
#<class 'tuple'>
2.多个数据直接用逗号隔开，表示的也是一个元祖
tuple1 = 10,20,'abc'
print(tuple1,type(tuple1))
#(10, 20, 'abc') <class 'tuple'>
元素的查
元祖的元素不支持增加删改
列表获取元素的方式，元祖都支持：元祖[下标]，下标[:]
tuple1 = '星期一','星期二','星期三','星期四'
print(tuple1[1]) #星期二
print(tuple1[2:])#('星期三', '星期四')
print(tuple1[::-1])#('星期四', '星期三', '星期二', '星期一')
也是可以遍历 和列表一样
获取部分元素
x,y = (10,20)
print(x,y)
#10 20
a = 10
b = 20
a,b = b,a
print(a,b)
#20 10
可以通过在变量前加*来获取部分元素
tuple2 = ('叶玉',30,80,90)
name,*score = tuple2
print(name,score)
#叶玉 [30, 80, 90]
tuple2 = ('叶玉',30,80,90,'girl')
name,*score,sex = tuple2
print(name,sex,score)
#叶玉 girl [30, 80, 90]
可以通过在列表或者元素前加*，来展开列表中的元素
tuple3 = (1,2,3,4,5,6)
print(*tuple3)
#1 2 3 4 5 6
元祖的运算
+，*，==，is，in, not in, --> 和列表一样
len() 列表,max() 最大,min()最小
所有序列都可以转换为元祖，注意，字典只能将key值作为元祖元素
tuple() -->转换数据
7.sorted()由大到小排序
可以通过sorted()方法，对元祖进行排序，产生一个新的列表
tuple4 = 10,40,60,40
new = sorted(tuple4)
print(new,tuple4)
#[10, 40, 40, 60] (10, 40, 60, 40)
字典
字典是一个容器类的数据类型，可以用来储存多个数据(以键值对的形式储存)。可变的，无序的
可变 -->可以增删改
无序 -->不能通过下标获取值
{'叶玉':90,'小叶子':99.....}
键(key):用来定位值的。要求只能是不可变的数据类型(数字，字符串，元祖...)是唯一的
值(value):储存的数据。可以是任何类型的数据
查
获取字典的值，必须通过key来获取
a.字典[key] --> 获取key对应的值**确定key值在就用这个方法
注意：key值必须是存在的，否则会报keyError
student = {'name':'叶玉','sex':'女','age':18,'face':80,'score':100,'tel':'保密'}
print(student['name'])
#叶玉
b.字典.get(key) --> 通过key获取值**不确定key值在不在就用这个方法
注意：key值不存在的时候不会报错，结果是None
student = {'name':'叶玉','sex':'女','age':18,'face':80,'score':100,'tel':'保密'}
print(student.get('sex'))
#女
遍历字典
通过for-in 遍历字典拿到的是key值*建议使用
student = {'name':'叶玉','sex':'女','age':18,'face':80,'score':100,'tel':'保密'}
for x in student:
print(x,end=' ')
#name sex age face score tel
!!通过for-in 遍历字典拿到的是key值和value值*建议使用
student = {'name':'叶玉','sex':'女','age':18,'face':80,'score':100,'tel':'保密'}
for x in student:
print(x,student[x])
#name 叶玉
#sex 女
#age 18
#face 80
#score 100
#tel 保密
b.遍历拿到value值
直接遍历拿到值
student = {'name':'叶玉','sex':'女','age':18,'face':80,'score':100,'tel':'保密'}
for x in student.values():
print(x,end=' ')
#叶玉 女 18 80 100 保密
直接遍历拿到key和value
student = {'name':'叶玉','sex':'女','age':18,'face':80,'score':100,'tel':'保密'}
for x,y in student.items():
print(x,y,end=' ')
#name 叶玉 sex 女 age 18 face 80 score 100 tel 保密
增（增加键值对）
字典[key] = 值(key不存在)
car = {}
car['color'] = 'yellow'
print(car)
#{'color': 'yellow'}
改（改值）
字典[key] = 新值(key存在)
car = {'color': 'yellow'}
car['color'] = 'red'
print(car)
#{'color': 'red'}
删（删键值对）
del 字典[key] -->通过key删除键值对
student = {'name':'叶玉','sex':'女','age':18,'face':80,'score':100,'tel':'保密'}
del student['sex']
print(student)
#{'name': '叶玉', 'age': 18, 'face': 80, 'score': 100, 'tel': '保密'}
pop(key) -->取出key对应的值(实质还是删除key对应的键值对)
student = {'name':'叶玉','sex':'女','age':18,'face':80,'score':100,'tel':'保密'}
a = student.pop('age')
print(student)
#{'name': '叶玉', 'sex': '女', 'face': 80, 'score': 100, 'tel': '保密'}
print(a)
#18
字典相关的运算
字典不支持运算操作 比如+ ，*...
比较运算
print({'a':1,'b':2} == {'a':1,'b':2}) #True
print({'a':1,'b':3} == {'a':1,'b':2}) #False
is --> 判断地址是否一样
print({'a':1,'b':2} is {'a':1,'b':2})
#False
in 和 not in key in 字典 / key not in字典 -->判断在不在
print('abc' in {'abc':100,'a':'200'})
#True
len() -->获取键值对的个数
dict1 = {'a':1,'b':2,'c':3}
print(len(dict1))
#3
字典.clear() -->清空字典
dict1 = {'a':1,'b':2,'c':3}
dict1.clear()
print(dict1)
#{}
copy()--->拷贝
dict1 = {'a':1,'b':2,'c':3}
dict2 = dict1.copy() # 拷贝的内容新生成个地址
print(dict2,dict1 is dict2)
#{'a': 1, 'b': 2, 'c': 3} False （内容一样地址不一样）
dict.fromkeys(序列，值) -->将序列中每个元素的作为key,值作为value
dict3 = dict.fromkeys('xyz',100)
print(dict3)
#{'x': 100, 'y': 100, 'z': 100}
dict3 = dict.fromkeys(['a','b','c'],(10,20,30))
print(dict3)
#{'a': (10, 20, 30), 'b': (10, 20, 30), 'c': (10, 20, 30)}
字典.get(key) -->key不存在取None
字典.get(key,默认值) -->key不存在取默认值
student = {}
print(student.get('name')) #None
print(student.get('name','小叶子')) #小叶子
字典的转换
字典.values() --> 返回所有值对应的序列
a = {'a':1,'b':2,'c':3}
b = a.values()
print(b)
#dict_values([1, 2, 3])
字典.keys() --> 返回所有键对应的序列
a = {'a':1,'b':2,'c':3}
b = a.keys()
print(b)
#dict_keys(['a', 'b', 'c'])
字典.items() -->将键值对转换为元祖，作为一个序列的元素
dict1 = {'a':1,'b':2,'c':3}
items1 = dict1.items()
print(items1)
#dict_items([('a', 1), ('b', 2), ('c', 3)])
list(字典.items()) -->字典转换为列表
dict1 = {'a':1,'b':2,'c':3}
items1 = list(dict1.items())
print(items1)
#[('a', 1), ('b', 2), ('c', 3)]
集合(set)
容器，可以同时储存多个数据，可变的，无序的
可变 -->增删改
无序 -->不能通过下标获取元素
唯一 -->自带去重的功能
{元素1，元素2....}
元素：只能是不可变的数据
集合的增删改查
查(获取元素)
集合不能单独的获取一个元素，也不能切片，只能通过for-in来遍历
set1 = {10,20,'abc',(10,200)}
for x in set1:
print(x)
#
(10, 200)
10
20
abc
增
集合.add(元素) --> 在集合中添加一个元素
set1 = {1,2,3}
set1.add(4)
print(set1)
#{1,2,3,4}
集合1.update(序列) --> 将序列中的元素添加到集合1中
set1 = {1,2,3}
set1.update({'a','b'})
print(set1)
{1,2,3,4,'a','b'}
删(删除元素)
集合.remove(元素) -->删除指定的元素
set1 = {4,1,2,3}
set1.remove(1)
print(set1)
#{2, 3, 4}
改
集合不能改
集合相关的运算
集合相关的运算：是否包含 ，交集、并集、差集、补集
包含 --> >= <=
集合1 >= 集合2 -->判断集合1是否包含集合2
集合2 >= 集合1 -->判断集合2是否包含集合1
set1 = {1,2,3,4,5}
set2 = {2,3,4}
print(set1 >= set2)
#True
交集 --> &
求两个集合公共的部分
set1 = {1,2,3,4,5}
set2 = {2,3,4,6,7,8,9}
print(set1&set2)
#{2, 3, 4}
并集 --> |
求两个集合的和
set1 = {1,2,3,4,5}
set2 = {2,3,4,6,7,8,9}
print(set1|set2)
#{1, 2, 3, 4, 5, 6, 7, 8, 9}
差集 --> -
求集合1中除了集合2以外的部分
set1 = {1,2,3,4,5}
set2 = {2,3,4,6,7,8,9}
print(set1-set2)
#{1, 5}
补集 --> ^
求两个集合除公共部分以外的部分
set1 = {1,2,3,4,5}
set2 = {2,3,4,6,7,8,9}
print(set1^set2)
#{1, 5, 6, 7, 8, 9}
类型的转换
1.整型 --> int()
浮点数、布尔、部分字符串可以转换成整数
只有去掉引号后本身就是一个整数的字符串才能转换成整型
print(int('34')) #34
print(int('+34')) #34
print(int('-34')) #-34
浮点数 -->float()
整数，布尔，部分字符串可以转换成浮点数
去掉引号本身就是个数字，才可以转换成浮点数
print(float(100)) #100.0
print(float(True))#1.0
print('34.90')#34.90
print(float('100'))#100.0
布尔 --> bool()
所有字符都可以转换成布尔
只有为空为0的时候才可以转换为False，其他都是True
print(bool('abcd'))#True
print(bool('False'))#True
print(bool(''))#False
print(bool([1,2]))#True
print(bool([])) #False
