元组tuple
只读列表，不能修改
names = （）
字典dict(像对象）
{key1:value1,key2:value2}
info={
"name"="lc"
"age" = 21
}
info['age'] = 21 #对象通过key查询
dict特性
- key-value结构
- key必须为不可变的数据类型（字符串，数字，元组，不能是列表）
- key必须唯一（hashtable）
- 一个key对应的value可以存放任意数据类型，可修改，可以不唯一
- 可嵌套，即value也可以是dict
- 查询速度快，且不受dict大小影响
dict用法
创建：
#方法一：
info2 = {
"name":"lc:
"age":21
}
#方法二：key不加引号
info = dict(name = "lc,age = 21)
新增：
info["salary"] = 5000
检查式新增：
#向dict中新增一个key，value值，如果这个key不存在则新增，如果key已存在则返回已存在的key对应的value
info.setdefault("job","student")
修改：
#普通修改
info["name"] = "lyd"
#合并修改
info1 = {
"lc"=[21,20000]
"lyd"=[21,30000]
"wsq"=[21,20000]
}
info2 = {
"lc"=[22,30000]
"ghx" = [22,30000]
}
info1.update(info2) #把info2的每个k，v赋值给info1，相同key则覆盖
查：
#get
info1.get("lc") #返回value，即便key不存在也不会报错
#直取
info["lc"]#key不存在会报错
#判断是否在dict中有指定的key
"lc" in info #返回True Flase
#
dict.keys() #返回一个包含多有key的列表
dict.values() #返回一个包含所有value的列表
dict.items() #返回一个包含所有（键，值）元组的列表
删：
dict.pop("lc") #删除指定key
del dict["lc"] #删除指定key
dict.popitem() #以LIFO（栈）删除一对值
dict.clear() #清空dict
循环：
1. for k in dic.keys()
2. for k,v in dic.items()
3. for k in dic #推荐，效率更高
特殊方法：
formkeys:批量生成多个k,v的dict
n = ["lc","peiqi","lyd"]
d = dict.fromkeys(n,0)
{"lc":0,"peiqi":0,"lyd":0}
copy: 浅copy，同列表的copy一样
求长度：
len(info) #len()方法可同时用于列表，字符串
字典为何查询这么快？
因为dict是基于hashtable实现的，hashtable的原理导致查询速度就是O（1），
集合set
- 集合元素不可变，代表着不可以存一个list，dict在集合里，字符串，数字，元组等不可变类型可以存
- 天生去重，在集合里没有办法存重复元素
- 无序，不像列表一样通过索引来标记在列表中的位置，元素是无序的，集合中的元素没有先后之分，如{3，4，5}和{3，5，4}算作在同一个集合
- 关系测试（作用）：基于以上特性，我们可以用集合来：去重和关系运算
创建：
a = {} #不是集合！！ {}默认是字典dict
a = {3} #是集合
增：
a = {1,2,3,4,5}
a.add(9)
查：
3 in a 返回True False
改：
不能修改已存在的元素
删除：
a.pop() #随机删除一个值，并返回该值
a.remove(3) #删除3这个元素，若3不存在则会报错
a.discard（8）#删除8指定的值，若该值不存在，不会报错
copy同列表
关系测试
A = {'a','b','c','d'}
B = {'a','b','e','f'}
交集：
#方法一:符号&
A & B #返回一个新集合
#方法二：
A.intersection(B)
并集：
#方法一:符号|
A | B #返回一个新集合
#方法二：
A.union(B)
差集：
#方法一:符号 -
A - B #返回一个新集合
#方法二：
A.difference(B)
对称差集：相交的部分踢出去
#方法一:符号 ^
A ^ B #返回一个新集合
#方法二：
A.symmetric_difference(B)
子集，父集：返回True False
#方法一:
A.issubset(B) #是不是B的子集，
#方法二：
A.issuperset(B) #是不是B的父集
测试后修改：
A.difference(B)
{'c','d'}
A.difference_uodate(B)
A -> {c,d} #把A覆盖了
二进制
a = 0011 1100 -> 60
b = 0000 1101 -> 13
运算符：
&：按位与，都为1 则为1 (位相乘）
(a & b) = 12 -> 0000 1100
| :按位或，有一个为1，则为1（位相加）
(a | b) = 61 -> 0011 1101
^ :按位异或，相异时结果为1 （位相减）
(a ^ b) = 49 -> 0011 0001
~ :按位取反，对数据的每个二进制位取反 ~x = -(x+1)
(~a) = -61 -> 1100 0011
>>: 右移 运算数的各二进制位全部右移若干位 除2
a>>2 15
a>>1 30
<<: 左移 乘2
a<<2 60
ASCII码
ord('a') -> 97
chr(97) -> 'a'