tuple
什么是元祖（tuple）
Python提供的容器型数据类型，不可变，并且有序
不可变 - 不支持增删改，只支持查
有序 - 可以通过下标获取元素（每个元素对应一个确定的下标）字面量和元素
（元素1，元素2，...）
可以是任意数据类型，并且类型可以不一样，同样的元素可以有多个
point = (20,20)
print(point,type(point))
注意：
1.空的元祖
tuple2 = ()
print(type(tuple2))
2.只有一个元素的元祖-- 在元素后面加一个逗号！！
tuple2 = (100,)
print(tuple2,type(tuple2))
3.直接将多个元素用逗号隔开，不加小括号，表示的也是一个元祖
tuple3 = 12,25,25,25,36,4
print(tuple3,type(tuple3))
- 元祖获取元素和列表是一样的
tuple4 = ('南充','广安','达州','广元')
print(tuple4[1],tuple4[2])
获取部分
print(tuple4[0:3])
print(tuple4[::])
直接遍历
for city in tuple4:
print(city)
通过下标遍历
for index in range(len(tuple4)):
print(tuple4[index])
index = 0
while index < len(tuple4):
print(tuple4[index])
index+=1
补充：特殊的获取方式
- 变量1，变量2... = 元祖 -- >用前面的变量依次获取元祖中元素的值 要求前面变量的个数和元祖的个数一致
point = (100,200)
x,y = point # x, y = 100,200
print(y,x)
- 变量1，变量2 = 元祖 -- 通过带 的变量获取元祖中剩余的部分
注意：这个结构中带的变量只有一个，不带的变量可以有多个
name,*scores= ('小明',25,52,32,52)
print(name,*scores)
*scores,num = ('小明',25,52,32,52)
print(*scores,num)
*info,num1,num2 = ('小明',25,52,32,52)
print(*info,num1,num2)
补充：*的用法
nums = (1,2,3,4,56,7)
nums2 = [1,2,3,4,5]
print(*nums,*nums2)
4.相关运算（和列表一样）*，+，in/not in len(),max(),min(),sum(),tuple()
tuple1 = (10,25,2)
tuple2 = (22,'dfsf',52)
print(tuple1 + tuple2,tuple1*2)
print('abc' in tuple1)
print('abc' not in tuple1)
5.排序
sorted(序列) - 对序列中的元素排序，产生一个新的序列
注意：列表.sort() -- 修改原列表中的顺序 sorted(列表) - 产生一个新的列表
tuple1 = (1,25,2,)
print(sorted(tuple1))
new_strs = sorted('sfadsfdsfadfadsf')
print(new_strs)
num = ''.join(new_strs)
print(num)
joio的使用
字符串.join(序列) - 将序列中的元素取出，用指定的字符串链接在一起。要求序列中的元素是字符串
new_strs = ''.join(['s','sd','sd'])
print(new_strs)
dict
- 什么是字典（dict）
Python提供的容器型数据类型，可变并且无序
可变 - 支持元素的增删改
无序 - 不支持下标的操作
2.字面量和元素
用大括号括起来，里面有多个键值对，每个键值对用逗号隔开，键值对就事字典的元素
键值对: 键/dey：值/value（键值对）- 键值对必须成对出现；脱离字典是没有意义的。
{ key1:value1,key2:value2,key3:value3...}
键 - 必须是不可变的，而且是唯一的。实际一般将字符串作为键
值 - 可以是任何数据类型
注意：字典存储数据 实质是通过值来存的，key是值对应的标签和获取值的方式。
dict1 = {} # 空字典
dict1 = {'a':12,'b':25,(1,2):'afd'} # key是唯一的
print(dict1)
3.什么时候使用字典：多个没有相同意义的数据（需要区分），就使用字典。例如：保存一个人的不同信息；
什么时候使用列表：存储的多个数据是相同的数据，（相同意义的数据），不需要对不同的数据进行区分；例如：保存一个班的学生的成绩
person = {'name':'xiaoming','age':18,'sex':'girl','height':165,'weight':56,'score':90}
练习 ； 声明一个变量 保存一个班的学生信息（四个学生），每个学生需要保存姓名、电话和年龄
students = [{'name':'小明','tel':564346,'age':30},{'name':'张三','tel':56421516,'age':15},
{'name':'李四','tel':564343545,'age':15},
{'name':'王五','tel':152156,'age':30}]
字典元素的增删改查
- 查（获取值）
注意：字典中的键值对单独拎出来你没有任何意义
a. 字典[key] - 获取字典中key对应的值
注意： 当key不存在的时候，会报出keyError
car = {'color':'黄色','type':'跑车','price':500000}
print(car['color'])
b. 字典.get(key) - 获取字典中key对应的值
注 意： 当key不存在的时候，不会报错，并会取到一个默认值：none
字典.get(key,值1) - 当key不存在的时候，不会报错 ，并且取到对应的值1
print(car.get('type'))
print(car.get('speed'))
print(car.get('color','红色'))
print(car.get('speed',0))
c. 遍历字典
注意：直接通过for- in 遍历字典取到的是key
dict1 = {'a':100,'b':300,'c':23}
遍历字典取到的是key
for key in dict1:
# key
print(key,end='')
# value
print(dict1[key])
遍历字典的values(),获取所有值
for value in dict1.values():
print(value)
遍历字典的item(),直接获取key和value(不建议使用)
for key,vlue in dict1.items():
print(key,value)
- 增,改
a.
字典[key] = 值 - 当key不存在就是添加键值对，当key存时，就是修改key对应的值
movie = {'name':'喜洋洋','type':'卡通','time':120}
添加
movie['score'] = 9.9
print(movie)
修改
movie['name'] = '喜洋洋与灰太狼'
print(movie)
- 删(删除键值对)
a. del 字典[key] - 删除字典中指定的key对应的键值对
b. 字典.pop(key) - 取出字典中key对应的值
name = movie.pop('name')
print(movie,name)
练习：用一个字典保存一个学生的信息：{'name':'张三'，'age':18,'score':85}
输入修改的信息，例如：请输入修改信息的：name - > 修改名字 abc -> 没有该信息
dict1= {'name':'张三','age':18,'score':85}
num = input('请输入修改信息：')
for key in dict1:
if num == 'name':
name1 = input('请输入修改姓名：')
dict1['name'] = name1
print(dict1)
break
elif num == 'age':
age2 = int(input('请输入年龄：'))
dict1['age'] = age2
print(dict1)
break
elif num == 'score':
score2 = int(input('请输入成绩：'))
dict1['score'] = score2
print(dict1)
break
else:
print(input('没有该信息'))
相关运算
1.比较运算
== ，!=
注意：判断两个字典是否相等，只看键值对是否一样，不管键值对的顺序
字典不支持 > < 符号
print({'a':1,'b':2} == {'b':2,'a':1}) # 相等 字典是无序的 为True
- in /not in
key in 字典 判断字典中指定的key是否存在
key not in 字典 判断字典中指定的key是否不存在
dict1 = {'a':1,'b':2}
print('a' in dict1)
print(1 in dict1) # False
- len(),max(),min()
dict（数据） - 要求是序列，并且序列的元素都是有两个元素的子序列
获取字典中键值对的个数
print(len(dict1))
print(max(dict1)) # 判断所有key的最大值
print(min(dict1)) # 字典中key的最小值
将列表作转为字典
print(dict([(1,2),[52,'sdd'],('sdf','s')]))
字典转别的序列 都是将字典中的key取出，作为序列的元素
dict1 = {'a':1,'b':2}
print(list(dict1))
相关方法：
字典.clear() - 清空字典
注意：清空容器推荐使用clear 操作，而不是重新赋一个空的容器
dict1 = {'a':1,'b':2}
直接赋值，修改其中一个的元素，会影响另外一个
dict2 = dict1
dict1.clear()
print(dict1)
- 字典.copy（） - 复制字典中的元素，产生一个新的字典
dict1 = {'a':1,'b':2}
拷贝赋值，会产生新的地址，赋值后相互不影响
dict2 = dict1.copy()
dict2.clear()
print(dict1)
print(id(dict1),id(dict2))
- 字典.fromkeys(seq,value) -- 以序列中所有的元素作为key，指定的值作为value创建一个新的字典
new_dict = dict.fromkeys('adv',100)
print(new_dict)
字典.keys() -将字典所有的key取出产生一个新的序列
字典.values() - 将字典所有的values取出产生一个新的序列
字典.items() - 将字典所有的key 和 values取出产生一元祖取出产生一个新的序列
- 字典.setdefault(key,value = none)
字典.setdefault(key) - 当key存在的时候，添加键值对key:None
字典.setdefault(key,value) - 当key不存在的时候，添加键值对key:value
注意：这个操作当key存在的时候，不会修改
dict1 = {'name':'xiaoming','color':'black','height':158}
dict1.setdefault('name2')
print(dict1)
字典1.update(字典2) - 使用字典2中的键值对去更新字典1，
如果字典2中的key在字典1中本来就存在就是修改，不存在添加
dict1 = {'name':'xiaoming','color':'black','height':158}
dict1.update({'height':120,'age':78})
print(dict1)
集合
- 什么是集合（set）
可变的
无序的；元素是唯一的并且不可变
2.字面量
{元素1，元素2...}
set1 = {1,0,2,2,2,52} #
print(set1) # {0, 1, 2, 52} 元素是唯一的 可以去重
空集合
set2 = set()
print(set2)
- 增删改查
set1 = {1,0,2,52}
- 查
集合不能单独的获取单个元素，只能一个一个的遍历
for itme in set1:
print(itme)
增
a.集合.add(元素) - 在集合中添加指定元素
b.集合.update(序列) - 将序列中的元素添加到集合中
set1 = {1,0,2,52}
set1.add('ssf')
print(set1)
set1.update({'aa':10,'sd':22})
print(set1)
删
集合.remove(元素) --- 删除集合中指定的元素
set1 = {1,0,2,52}
set1.remove(2)
print(set1)
4.数学集合运算
交集（&）：获取两个集合公共的元素产生一个新的集合
并集（|）：将两个集合中的元素合并在一起产生一个新的集合
差集（-）：集合1-集合2：去掉集合1中包含集合2的部分，剩下的产生一个新的集合
补集（^）：将两个集合合并在一起起去掉公共部分，剩下的部分产生一个新的集合
子集的判断：集合1>集合2, - > 判断集合1是否包含集合2 集合1<集合2 -- > 判断集合1是否包含集合2
