python学习笔记-day5

元组tuple

只读列表，不能修改
names = （）

字典dict(像对象）

{key1:value1,key2:value2}
info={
  "name"="lc"
  "age" = 21
}
info['age'] = 21 #对象通过key查询

dict特性

1. key-value结构
2. key必须为不可变的数据类型（字符串，数字，元组，不能是列表）
3. key必须唯一（hashtable）
4. 一个key对应的value可以存放任意数据类型，可修改，可以不唯一
5. 可嵌套，即value也可以是dict
6. 查询速度快，且不受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

1. 集合元素不可变，代表着不可以存一个list，dict在集合里，字符串，数字，元组等不可变类型可以存
2. 天生去重，在集合里没有办法存重复元素
3. 无序，不像列表一样通过索引来标记在列表中的位置，元素是无序的，集合中的元素没有先后之分，如{3，4，5}和{3，5，4}算作在同一个集合
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'

字符串->列表 list(a)