一、元组（tuple）

什么是元组？元组是一种容器，可以同时存储多个数据，不可变，有序
不可变--不可以增删改
有序--可通过下标获取元素
注意：元组中的元素可以是任何类型的数据
（1）一旦创建，没有任何方法可以修改元组中的元素，只能使用del命令删除整个元组。
（2）Python内部实现对元组做了大量优化，访问和处理速度比列表快。
（3）调用函数时使用元组传递参数可以防止在函数中修改元组，使代码更安全。
（4）元组可用作字典的键，而列表则永远都不能当做字典键使用。
元组的创建

tuple1=(1,2,3,4,[1,2,3],'字符串')
tuple2=(100,)
tuple3=1,2,3,"123","字符串",[1,2,3] #若多个数据直接用逗号隔开，表示一个元组
print(tuple1,tuple2,tuple3)

元素获取
元组不支持增删改
列表获取元素的方式，元组都支持

tuple3=1,2,3,"123","字符串",[1,2,3]
print(tuple3[4])

获取部分元素：
可以通过相同的变量个数，来一一获取元组中的元素

x,y,z=1,2,3 #x,y,z指向新建的元组
print(x,y,z)
x,y,z=z,x,y #z,x,y创建了一个新的元组，x,y,z指向该元组
print(x,y,z)

在元组中使用*号
1、可以通过在变量前加获取部分元素，返回值是一个列表
2、可以通过在元组前面加，展开元组，获取里面的所有元素
适用于列表

tuple4='xiaoming',90,89,85,95,'male','13555899752'
name,*score,sex,tel=tuple4
print(name,score,sex,tel)
print(*tuple4)

元组的基本操作
+,*,len(),max(),min(),in,not in,迭代，tuple()

二、字典（dict）

字典是一个容器，可以存储多个数据，以键值对的形式存储
可变--可以增删改
无序--不能通过下标获取值
key--用来定位值的，要求只能是不可变的数据类型（数字、字符串、元组等）
value--存储的数据，可以是任何类型的数据
1、创建字典，获取元素

student={'name':'小明','age':30,'stuID':20180801,'sex':'boy'}
print(student['name'],student['age'])
print(student.get('name'),student.get('age'))

2、字典的增删改查
查询
1、通过Key获取(没有key会报错)
2、通过get获取
3、遍历字典：
（1）通过for-in语句拿到key，通过key获取对应的值(推荐使用)
（2）直接拿到值 for value in dict.value(不推荐使用，耗内存)
（3）同时拿到键值对for key,value in dict.items（不推荐使用，耗内存）

student={'name':'小明','age':30,'stuID':20180801,'sex':'boy'}
for x in student:
    print(x,end=' ')
print()
for x in student.values():
    print(x,end='  ')
print()
for k,v in student.items():
    print(k,v,end=',')
print()

增加：dict[key]=value(key不存在)
修改：dict[key]=value(key存在)
删除：删除键值对
　　　del dict[key] --通过key删除
　　　pop(key)--取出key对应的键值对

car={}
car['color']='red';car['wheel']=4;car['name']='benz'
print(car)
car["color"]='blue'
print(car)
del car["wheel"]
print(car)
car.pop('color')
print(car)

3、字典相关运算
判断：
（1）==和is，==判断字典的值是否相等，is判断字典的地址是否相等
（2）in和not in，判断key是否存在
4、字典相关方法
radiansdict.clear()--删除字典内所有元素
radiansdict.copy()--返回一个字典的浅复制
radiansdict.fromkeys(seq,value)--创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
radiansdict.get(key, default=None)--返回指定键的值，如果值不在字典中返回default值
radiansdict.items()--将键值对转成元组，作为序列的元素并返回
radiansdict.keys()--返回一个迭代器，可以使用 list() 来转换为列表
radiansdict.values()--返回一个迭代器，可以使用 list() 来转换为列表
radiansdict.setdefault(key, default=None)--和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default，若key存在就不会修改字典的值
radiansdict.update(dict2)--把字典dict2的键/值对更新到dict里（原始字典存在的key对应值进行修改）
pop(key[,default])--删除字典给定键 key 所对应的值，返回值为被删除的值，key值必须给出； 否则，返回default值
popitem()--随机返回并删除字典中的一对键和值(一般删除末尾对)

student={'name':'小明','age':30,'stuID':20180801,'sex':'boye'}
student_copy=student.copy()
print(student_copy)
student.clear()
print(student)
temp=student.fromkeys([1,2,3],'小明')
print(temp)
a=student_copy.get('name')
b=student_copy.get('weight',70)
print(a,b)
stu_items=student_copy.items()
stu_keys=student_copy.keys()
stu_values=student_copy.values()
print(stu_items,stu_keys,stu_values)
print(type(stu_items),type(stu_keys),type(stu_values))
student_copy.setdefault('addr','成都市科华北路')
print(student_copy)
tempdict={'addr':"成都市科华北路168号","score":[90,93,96]}
student_copy.update(tempdict)
print(student_copy)

三、集合（set）

什么是集合？集合是一种容器，可以同时存储多个数据，可变，无序，唯一
可变--可以增删改查(集合可变，集合中的元素不可变)
无序--不能使用下标获取元素
唯一--自动排除重复的元素
集合的元素只能是不可变的数据
1、创建集合

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

2、集合的增删改查
获取元素：集合不能单独获取一个元素，也不能切片，只能通过for-in遍历
增加元素：
　　　　（1）add--在集合中添加一个元素
　　　　（2）update--将序列中的元素添加到集合1
删除元素：
　　　　（1）remove--若集合中没有该元素，会报错
　　　　（2）discard--若集合中没有该元素，不会报错
修改元素：集合中的元素不可修改

set1={10,20,'abc',(10,20,30)}
for x in set1:
    print( x , end=',')
set1.add((1,2,3))
print(set1)
set1.update({'abc','bcd'})
set1.update({'name':'xiaoming','age':20}) #添加key
print(set1)
set1.discard(20)
set1.remove(10)
print(set1)

3、集合相关的数学运算
1、包含关系：<=,>= 返回值为布尔类型
2、交集：set1 & set2
3、并集：set1 | set2
4、差集：set1 - set2
5、补集：set1 ^ set2

set1={1,2,3,4}
set2={1,2,3,4,5}
print(set2>=set1)
set1={1,3,5,7,9,11,13}
set2={1,2,3,4,5,6,7,8,9}
print(set1&set2,set1|set2,set1-set2,set1 ^ set2)

4、集合相关方法

set1={8,9,10,11,12,13}
set2={5,6,7,8,9,10}
set3={1,3,5,7,9,10,11,12,13,15}
set4={2,4,6,8,10,12}
#还有issuperset(), issubset函数判断子集和父集
a=set3.difference(set2,set1) #返回差集
temp=set3.copy() 
temp.difference_update(set2,set1)#用差集更新原来的集合
b=set1.intersection(set2,set4) #交集
c=set1.isdisjoint(set2) #是否包含相同的元素
d=set1.symmetric_difference(set2) #补集
e=set1.union(set2) #并集
print(a,temp,b,c,d,e)

四、类型转换

1、整型
int(x [,base])--可以转换的包括String类型和其他数字类型，但是会丢失精度
2、浮点数
float(x)--可以转换String和其他数字类型，不足的位数用0补齐
3、布尔型
bool（）--所有数据可以转成布尔类型
为空为零的值转换成布尔类型为False，其余的为True
作用：多用于条件判断语句
4、字符串
str( )--所有数据类型都可以转成字符串
5、列表
list()--将序列转变成一个列表，参数可为字符串、元组、字典、列表，为字典时，返回字典的key组成的列表
6、元组
tuple()--参数可以是元组、列表或者字典;参数是字典时，返回字典的key组成的元组
7、字典
dict()--序列的每个元素都包含两个元素的才能转换成字典

#整型
print(int('123'),int('0b101010',2),int('0o77',8),int('0x11',16))
#浮点型
print(float(123),float("123"),float('123.123'))
#布尔型
print(bool(''),bool([]),bool(0),bool({}),bool(None),bool(()))
num=100
if num % 2:print("是奇数") #将条件语句的结果转换成bool类型
else:print("是偶数")
#字符串
print(str(123),str([1,2]),str((1,2)),str({'1':1,'2':2}))
#列表
print(list('123'),list((1,2,3)),list(range(1,6)),list({'name':'xiaoming','age':20}))
#元组
print(tuple('123'),tuple([1,2,3]),tuple(range(1,6)),tuple({'name':'xiaoming','age':20}))
#字典
A=((1,2),(2,4),(3,6))
B=[[1,2],[2,3],[3,4]]
print(dict(A),dict(B))