字典 dict
数据类型划分：可变数据类型，不可变数据类型
不可变数据类型： 元组，bool值，int，str 可哈希
可变数据类型： list，dict，set 不可哈希
dict key ：必须是不可变数据类型，可哈希，
value：任意数据类型。
dict 优点：二分查找法去查询
存储大量的关系型数据
特点：无序的
字典 dict的操作
增
dic={'age': 18, 'name': 'jin', 'sex': 'male'}
#直接改变
dic['height'] = 180 # 原来没有的键值对，无序添加
dic['age'] = 32 #原来有键，值直接覆盖改变
# setdefault()
dic.setdefault('height',180)# 没有才能添加成功
dic.setdefault('name','john')#有则不改变任何
dic.setdefault('hobbie') # 'hobbie': None
删
# pop() #删除存在的键值对 dic.pop('age')# 成功 print(dic.pop('age')) # 18 会返回删除的值 #删除不存在的，设置返回值提醒不存在 dic.pop('height') #没有的键，删除会报错 dic.pop('height',None)# 加上None 不会报错，返回none print(dic.pop('height','没有此件')) # 可设置返回值 #用于大量数据时删除不知道是否存在的值 dic.pop('name',None) # 成功 {'age': 18, 'sex': 'male'} # popitem() print(dic.popitem()) # 随机删除 有返回值 返回 存在元组里面的 删除的键值。 # del del dic #删除字典 del dic['name'] #删除键值对 #clear() dic.clear() # 清空
改
#直接赋值 dic['age'] = 32 #原来有键，值直接覆盖改变 #update dic2 = {'sex':'female','weight':75} dic2.update(dic) # 改变dic2 把后面的覆盖和添加到前面
查
在循环一个列表时，最好不要删除列表中的元素，这样会使索引发生改变，从而报错。
# print(dic.keys(),type(dic.keys())) #dict_keys(['age', 'sex', 'name']) <class 'dict_keys'> print(dic.values(),type(dic.values())) #dict_keys(['age', 'sex', 'name']) <class 'dict_keys'> print(dic.items(),type(dic.items())) #dict_items([('age', 18), ('name', 'jin'), ('sex', 'male')]) <class 'dict_items'> #循环去查 for i in dic: # 仅返回键 同dic.keys()一样 for i in dic.keys(): #返回键 for i in dic.values():# 返回值 print(i) #Python：找一一对应的最小单位 for i in dic.items(): print(i) # ('age', 18)('name', 'jin')('sex', 'male') for k,v in dic.items() : print(k,v) # name jin sex male age 18 #直接赋值去查 v1 = dic['name'] print(v1) v2 = dic['name1'] # 报错 print(v2)
# get()
print(dic.get('name1',"默认返回值") # 返回设定的返回值,默认返回none，防止报错
formkeys() 已知键，添加值。（可覆盖）
dic = dict.fromkeys([1,2,3],'春哥') print(dic) #{1: '春哥', 2: '春哥', 3: '春哥'} dic = dict.fromkeys([1,2,3],[]) print(dic) # {1: [], 2: [], 3: []} dic[1].append('袁姐') print(dic) # {1: ['袁姐'], 2: ['袁姐'], 3: ['袁姐']} dic[2].extend('二哥') print(dic) # {1: ['袁姐', '二', '哥'], 2: ['袁姐', '二', '哥'], 3: ['袁姐', '二', '哥']}
编码
1，各个编码之间的二进制，是不能互相识别的，会产生乱码。
2，文件的储存，传输，不能是unicode（只能是utf-8 utf-16 gbk,gb2312,asciid等）
ascii A : 00000010 8位 一个字节 unicode A : 00000000 00000001 00000010 00000100 32位 四个字节 中：00000000 00000001 00000010 00000110 32位 四个字节 utf-8 A : 00100000 8位 一个字节 中: 00000001 00000010 00000110 24位 三个字节 gbk A : 00000110 8位 一个字节 中 : 00000010 00000110 16位 两个字节
py3: str 在内存中是用unicode编码。 bytes类型 对于英文： str ：表现形式：s = 'alex' 编码方式： 010101010 unicode bytes ：表现形式：s = b'alex' 编码方式： 000101010 utf-8 gbk。。。。 对于中文： str ：表现形式：s = '中国' 编码方式： 010101010 unicode bytes ：表现形式：s = b'xe91e91e01e21e31e32' 编码方式： 000101010 utf-8 gbk。。。。
s1 = 'alex' # encode 编码，如何将str --> bytes, () s11 = s1.encode('utf-8') s11 = s1.encode('gbk') print(s11) s2 = '中国' s22 = s2.encode('utf-8') s22 = s2.encode('gbk') print(s22)
中文一定要用什么编码就用什么解码，英文则不必。
# str --->byte encode 编码 s = '二哥' b = s.encode('utf-8') print(b) #byte --->str decode 解码 s1 = b.decode('utf-8') print(s1)
集合
集合是无序的，不重复的数据集合，它里面的元素是可哈希的(不可变类型)，但是集合本身是不可哈希（所以集合做不了字典的键）的。以下是集合最重要的两点：
去重，把一个列表变成集合，就自动去重了。
关系测试，测试两组数据之前的交集、差集、并集等关系。
集合的创建
set1 = set({1,2,'barry'})
set2 = {1,2,'barry'}
print(set1,set2) # {1, 2, 'barry'} {1, 2, 'barry'}
集合的操作
set1 = {'alex','wusir','ritian','egon','barry'}
set1.add('景女神')
print(set1)
#update：迭代着增加
set1.update('A')
print(set1)
set1.update('老师')
print(set1)
set1.update([1,2,3])
print(set1)
set1 = {'alex','wusir','ritian','egon','barry'}
set1.remove('alex') # 删除一个元素
print(set1)
set1.pop() # 随机删除一个元素
print(set1)
set1.clear() # 清空集合
print(set1)
del set1 # 删除集合
print(set1)
for i in set1: print(i)
集合的其他操作
交集。（& 或者 intersection）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 & set2) # {4, 5}
print(set1.intersection(set2)) # {4, 5}
并集。（| 或者 union）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 | set2) # {1, 2, 3, 4, 5, 6, 7}
print(set2.union(set1)) # {1, 2, 3, 4, 5, 6, 7}
差集。（- 或者 difference）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 - set2) # {1, 2, 3}
print(set1.difference(set2)) # {1, 2, 3}
反交集。 （^ 或者 symmetric_difference）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 ^ set2) # {1, 2, 3, 6, 7, 8}
print(set1.symmetric_difference(set2)) # {1, 2, 3, 6, 7, 8}
子集与超集
set1 = {1,2,3}
set2 = {1,2,3,4,5,6}
print(set1 < set2)
print(set1.issubset(set2)) # 这两个相同，都是说明set1是set2子集。
print(set2 > set1)
print(set2.issuperset(set1)) # 这两个相同，都是说明set2是set1超集。
frozenset不可变集合，让集合变成不可变类型。
s = frozenset('barry') print(s,type(s)) # frozenset({'a', 'y', 'b', 'r'}) <class 'frozenset'>
for i in s:
print(i)
# y
# r
# a
# b
深浅copy
1 赋值运算 对于赋值运算来说，l1与l2指向的是同一个内存地址，所以他们是完全一样的。
l1 = [1,2,3,['barry','alex']] l2 = l1 l1[0] = 111 print(l1) # [111, 2, 3, ['barry', 'alex']] print(l2) # [111, 2, 3, ['barry', 'alex']] l1[3][0] = 'wusir' print(l1) # [111, 2, 3, ['wusir', 'alex']] print(l2) # [111, 2, 3, ['wusir', 'alex']] 复制代码
2 浅拷贝copy
l1 = [1,2,3,['barry','alex']] l2 = l1.copy() print(l1,id(l1)) # [1, 2, 3, ['barry', 'alex']] 2380296895816 print(l2,id(l2)) # [1, 2, 3, ['barry', 'alex']] 2380296895048 l1[1] = 222 print(l1,id(l1)) # [1, 222, 3, ['barry', 'alex']] 2593038941128 print(l2,id(l2)) # [1, 2, 3, ['barry', 'alex']] 2593038941896 l1[3][0] = 'wusir' print(l1,id(l1[3])) # [1, 2, 3, ['wusir', 'alex']] 1732315659016 print(l2,id(l2[3])) # [1, 2, 3, ['wusir', 'alex']] 1732315659016
对于浅copy来说，第一层创建的是新的内存地址，而从第二层开始，指向的都是同一个内存地址，所以，对于第二层以及更深的层数来说，保持一致性。
3 深拷贝deepcopy
import copy l1 = [1,2,3,['barry','alex']] l2 = copy.deepcopy(l1) print(l1,id(l1)) # [1, 2, 3, ['barry', 'alex']] 2915377167816 print(l2,id(l2)) # [1, 2, 3, ['barry', 'alex']] 2915377167048 l1[1] = 222 print(l1,id(l1)) # [1, 222, 3, ['barry', 'alex']] 2915377167816 print(l2,id(l2)) # [1, 2, 3, ['barry', 'alex']] 2915377167048 l1[3][0] = 'wusir' print(l1,id(l1[3])) # [1, 222, 3, ['wusir', 'alex']] 2915377167240 print(l2,id(l2[3])) # [1, 2, 3, ['barry', 'alex']] 2915377167304
对于深copy来说，两个是完全独立的，改变任意一个的任何元素（无论多少层），另一个绝对不改变
4 文件操作
文件名.txt
1,文件路径：d:文件名.txt
2,编码方式：utf-8 gbk 。。。。
3，操作方式：只读，只写，追加，读写，写读.....
以什么编码方式储存的文件，就以什么编码打开进行操作。
r rb f = open('文件名',mode='r',encoding='utf-8') content = f.read() print(content,type(content)) f.close() f = open('文件名',mode='rb',) content = f.read() print(content) f.close() r+ 读写 r+b 读写（以bytes类型） f = open('log',mode='r+',encoding='utf-8') print(f.read()) f.write('大猛，小孟') f.close() f = open('log',mode='r+b') print(f.read()) f.write('大猛，小孟'.encode('utf-8')) f.close()
f = open('log',mode='a',encoding='utf-8') f.write('佳琪') f.close() f = open('log',mode='ab') f.write('佳琪'.encode('utf-8')) f.close()
w #对于w:没有此文件就会创建文件 wb # 先将源文件的内容全部清除，在写。 先将源文件的内容全部清除，在写。 f = open('log',mode='w',encoding='utf-8') f.write('附近看到类似纠纷') f.close() f = open('log',mode='wb') f.write('附近看到类似纠纷'.encode('utf-8')) f.close() w+ f = open('log',mode='w+',encoding='utf-8') f.write('aaa') f.seek(0) print(f.read()) f.close() w+b .......
f = open('log',mode='r+',encoding='utf-8') content = f.read(3) # 读出来的都是字符 f.seek(3) # 是按照字节定光标的位置 f.tell() #告诉你光标的位置 print(f.tell()) f.readable() # 是否可读 f.truncate(4)# 再源文件上截取打印 line = f.readline() # 一行一行的读 line = f.readlines() # 每一行当成列表中的一个元素，添加到list中 for line in f: print(line)
# f = open('log',mode='a+',encoding='utf-8') # f.write('佳琪') # count = f.tell() # f.seek(count-9) # print(f.read(2)) # f.close()