元组
元组：
1、也是容器，也可以存放多个元素
2、元组特点：
类似列表不支持删除、添加、修改
元组支持下标和切片(下标方式同列表,切片的方式也同列表)
切片切的是什么类型的得到的值就是什么类型，如：切的是元组，得到的就是元组类型
3、声明元组：
tuple = ()
4、元组的内置函数：
不支持：添加、删除、修改
在元组中添加元素： 借助于list与tuple之间的转换完成
首先将元组转成列表，在列表状态进行添加删除，添加完成后，再转换成元组
s1 = ('q', 'w', 'r')
d1 = list(s1)
print(type(d1))
print(d1)
d1.append('qwe')
print(d1)
s1 = tuple(d1)
print(s1)
支 持：
查找 idenx() 如存在返回第一个的位置，不存在报错：ValueError: tuple.index(x): x not in tuple
个数 count() 查找元组中一个元素存在的次数
5、元组的排序：
sorted(tuple) 升序，可以进行排序，但是得到的值类型为列表
6、类型的转换
str --- int
list --- tuple
tuple = (1,3,4)
print(type(tuple))
#获取,下标和切片
tuple1 = (1, 3, 4, 9, 5, 2)
print(tuple1[2])
print(tuple1[:3])
print(tuple1[::-1]) #倒序输出
print(tuple1.index(2)) #输出第一个2的位置
print(tuple1.count(9)) #输出元组的和
w = (1, 4, 3, 2)
对元组的升序
e = sorted(w) #对元组进行升序，但是的到的是列表
print(e)
s = tuple(e) #将列表转换位元组
print(s)
降序
a = [2, 4, 6, 9]
print(sorted(a, reverse = True)) #对列表的降序输出
6、用元组类型实现：最大值、最小值、求和
max()
min()
sum()
t = (1, 2, 3, 4)
print(max(t)) #查找最大值
print(min(t)) #查找最小值
print(sum(t)) #求和
元组支持的符号：
+ #将两个元组合并
* #将元组输出多少遍
[] #切片
[:] #
in #判断是否在元组中,在返回True，不存在返回False
is #判断两个元组是否相同，相同返回True，不相同返回False
t1 = (1, 2, 3, 4)
t2 = (5, 6, 7, 8)
print(t1 + t2)
print(t1 * 2)
print(1 in t1)
print(t1 is t2)
集合
集合(set )
特点：无序（存放的顺序与打印的顺序是不一致的）、不重复（在集合中不能出现重复的元素）
底层原理：哈希表
哈希表： 无序、不重复
总结：可以用于保存一些不重复的元素
声明集合：
set1 = set() #这是定义了一个空的集合
print(type(set1))
#注意以下这个方法
set2 = {} #这是定义了一个空字典，空集合不能这样声明
print(type(set2))
set3 = {'tang', 'jian', 'feng'} #这就是声明一个有元素的集合
print(set3)
print(type(set3))
#列表的快速去重
list1 = ['1', '6', '6', '4', '4']
set4 = set(list1)
print(list(set(list1)))
是否支持下标和切片：
列表中那些内置函数与下标有关：
insert()
pop()
idenx()
del
集合里面的函数：
添加：
# add() 添加,单个元素的添加
set1 = {1, 2, 7, 4, 5} #集合中的整型默认会排序
print(set1)
set1.add(9) #再集合中添加一个元素
print(set1)
# update() 添加多个
set2 = {11, 43, 23}
set2.update(set1) #将一组可迭代的元素，类似与列表的extend
print(set2)
删除：
# discard() 指定元素删除，集合中没有该元素，则什么都不做
# remove() 删除指定元素，如果集合中没有该元素则抛异常
set1 = {1, 2, 3, 4, 7}
set1.remove(3) #删除集合中的元素3
print(set1)
# pop（） 随机删除（每次都会删除第一个），返回删除的元素
set2 = {'ww','rr','ff','gg'}
s = set2.pop()
print(s)
# clear（） 清空
set3 = {1, 3, 5, 6}
t = set3.clear()
print(t)
不支持修改和查询，如果非要修改可以修改类型为列表然后修改，
符号：
+ 不支持
* 不支持
[] 不支持
[:] 不支持
in 支持，存在返回True，不存在返回False
is 支持，相同返回True，不相同返会False
集合中特有的符号：
交集： &
并集： |
差集： -
set1 = {1, 3, 4}
print(len(set1))
set2 = {2, 3, 5}
#集合运算 交集（&）、并集（|）、差集（-） 对称差集（^）
# None(空值) 、 and(与) or(或) not(非)
t = set1 & set2 #查找交集，两个集合中的相同的元素
print(t)
s = set1.intersection(set2) #这样也可得到交集
print(s)
t1 = set1 | set2 #查找并集，两个元素合并到一起
print(t1)
#set1.intersection_update(set2) #这里是将得到的差集重新定义到set1中，定义新的set1
print(set1)
t2 = set1 - set2 #查找差集
print(t2)
t3 = set1 ^ set2 #对称差集，就是将两个集合中不一样的元素合并到一起
print(t3)
字典
字典
字典的使用场景
[key：value]
[key: value]
字典的特点：里面不是存放单独的元素，而是以键值对出现的key和volue（一个key绑定一个value）
1、键值对保存
2、键不能重复，值可以重复
3、没有下标，因为底层实现也是哈希表的方式
字典的声明：
空字典：
dict1 = dict()
print(type(dict1))
dict2 = {}
print(type(dict2))
有内容的字典：
dict3 = {'tang': 24, 'li': 20, 'wang': 20} #key不能重复value可以重复
print(dict3)
字典的获取：都是根据key得到value
dict[key] 有则返回key对应的value的值，没有则报错
内置方法： get()
dict.get('key') 返回的为key对应的value值，没有且没有设置默认值则返回None（空）
dict.get('key', 1) 这里是当没有找到指定的key时，就返回默认值1
dict4 = {'tang': 24, 'xu': 25, 'li': 25,'wang': 24 }
print(dict4['tang'])
print(dict4.get('tang'))
print(dict4.get('tan',18)) #这是当没有找到key时就返回默认值18
字典的增、删、改、查
增、改：
格式: dict['key'] = value #修改和添加的格式一样，
当字典里没有这个key就是添加，有这个key就是修改
dict5 = {}
dict5['tang'] = 18 #
print(dict5)
dict5['tang'] = 19
print(dict5)
删：
dict.pop('key') #根据key删除键值对，返回value
dict.popitm() #随机删除键值对（从后往前删除），并以元组的形式返回
dict.clear() #清除
del dict['key'] #根据key删除键值对，类似pop（）
del dict #清空内容并回收内存
dict6 = {'t': 12, 'x': 13, 'e': 14, 'r': 15}
print(dict6.pop('r')) #根据key删除键值对，并返回value
print(dict6.popitem()) #随机删除键值对
print(dict6)
#dict6.clear() #清除
#print(dict6)
del dict6['x'] #根据key删除键值对，类似pop（）
print(dict6)
del dict6
查：
不支持查找
取值：
dict.keys() #取出所有的key
dict.values() #取出所有的value
dict.itms() #取出所有值，每队键值对是一个元组
dict7 = {'a': 12, 's': 34, 'd': 45}
ks = dict7.keys() #取所有的key
print(list(ks))
vs = dict7.values() #取所有的value
print(list(vs))
ts = dict7.items() #取所有的键值对
print(list(ts))
print(list(ks),list(vs))
构建一个新的字典，通过iterable
dict8 = dict.fromkeys(['z','x','c'], 100)
print(dict8)
支持的符号：
in
is
dict8 = {'q': 12,'www': 13,'e':14}
for i in dict8:
print(i) #这是通过for循环遍历所有的key
for key,value in dict8.items():
print(key,value) #这就是遍历输出键值对
if 'www' in dict8: #通过www根字典中的每一个key进行比较，如果有相同的则返回True
print('能')
else:
print('不能')
转换：
list1 = [1, 3, 4, 5]
#dict2 = dict(list1) #不能转为字典
#print(dict2)
list2 = [('q', 100), ('s', 200), ('w',300)]
dict3 = dict(list2) #需要满足字典的格式才能转为字典，否则无法转换
print(dict3)
list3 = list(dict3) #字典转列表，只会保留key的值
print(list3)
总结：列表转字典需要满足条件，否则无法转换，字典转列表只会保留key的值
Processed:
0.010, SQL:
9
