数据类型（dict,set）和文件操作
dict 类'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values'
dic = {"k1":"v1",}
字典的key都能是什么
数字，字符串，布尔值，元组都可以（原值都是不可变的） 列表 字典 集合不可以（属于可变的） #布尔值里的True=1，False=0，，不能同时写，一样的
dict 的查找速度很快，可以认为查找时一次就能找到，查找时会做成一个哈希表，有哈希索引，经过哈希计算之后key值会变成一个内存地址，查找时直接找内存地址
功能
clear 清空
copy(和列表一样)
pop("key","默认值") 删掉key值对应的值，并取出来，，，key不存在时报错，加了默认值，就不会报错，打印默认值
popitem() 随机删掉键值对 操作完位为元组类型
setdefalut("key","value") 设置：只添加不修改，有key时，不改变
update({"key":"value"}) 更新 不存在加进去，存在时更新
重点 类.fromkeys() dict.fromkeys() 生成一个字典
val = dict.fromkeys(["k1","k2","k3"],value)
value 是一个可变数据类型时，对val做操作后，所有的key对应的value都变化
是一个不可变类型时，更改其中一个时不会全部改变，只改变其中一个
dict 类'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values' clear 清空 d = {"k1":"v1","k2":"v2","k3":"v3"} d.clear() print(d) #copy 浅拷贝 只拷贝最外层，指向同一块内存 ****单个字典时，在只有数字，字符串的时候，深浅拷贝一样**** d1 = {"k1":"v1","k2":"v2","k3":"v3"} d2 = d1.copy() #这里是重新创建了一个字典，但是字典内的元素指向同一个内存 print(d2) d1["k1"] = 666 print(d1) print(d2) import copy 深拷贝# 所有层都拷贝，最后一层补不拷贝，改变后不一样 ****单个字典时，在只有数字，字符串的时候，深浅拷贝一样**** import copy d1 = {"k1":"v1","k2":"v2","k3":"v3"} d2 = copy.deepcopy(d1) #这里是重新创建了一个字典， print(d2) d1["k1"] = 666 print(d1) print(d2) *****嵌套时才有区别***** 浅拷贝 d1 = {"k1":[11,22,33],"k2":"v2","k3":"v3"} d2 = d1.copy() #这里是重新创建了一个字典，但是字典内的元素指向同一个内存 print(d2) d1["k1"].append(666) #因为指向同一个内存，所以d1改变d2也会改变 print(d1) print(d2) # 深拷贝 import copy d1 = {"k1":[11,22,33],"k2":"v2","k3":"v3"} d2 = copy.deepcopy(d1) #这里是重新创建了一个字典，d1 d2 指向不同的内存 print(d2) d1["k1"] = 666 #因为指向不同的内存，所以d2不会改变 print(d1) print(d2) 重点 类.fromkeys() dict.fromkeys() 生成一个字典 value 是一个可变数据类型时，对val做操作后，所有的key对应的value都变化 是一个不可变类型时，更改其中一个时不会全部改变，只改变其中一个 val = dict.fromkeys(["k1","k2","k3"],6666) print(val) val["k1"] = "aaa" print(val) val = dict.fromkeys(["k1","k2","k3"],[11,22,33]) print(val) val["k1"].append("qqqq") print(val) get() 取到key，没有时返回None d = {"k1":"v1","k2":"v2","k3":"v3"} print(d.get("k2")) keys() 取到所有key 常和for循环一起用 d = {"k1":"v1","k2":"v2","k3":"v3"} for v in d.keys(): print(v) values() 取到所有value 常和for循环一起用 d = {"k1":"v1","k2":"v2","k3":"v3"} for v in d.values(): print(v) items() 取到所有键值对 常和for循环一起用 d = {"k1":"v1","k2":"v2","k3":"v3"} for v in d.items(): print(v) pop("key","默认值") 删掉key值对应的值，并取出来，，，key不存在时报错，加了默认值，就不会报错，打印默认值 d = {"k1":"v1","k2":"v2","k3":"v3"} v = d.pop("k2") print(v) print(d) d = {"k1":"v1","k2":"v2","k3":"v3"} v = d.pop("k12",888) print(v) print(d) popitem() 随机删掉键值对 操作完为元组类型 d = {"k1":"v1","k2":"v2","k3":"v3"} v1,v2 = d.popitem() print(v1,v2) print(d) setdefalut("key","value") 设置：只添加不修改，有key时，不改变 d = {"k1":"v1","k2":"v2","k3":"v3"} d.setdefault("k5","v5") print(d) d = {"k1":"v1","k2":"v2","k3":"v3"} d.setdefault("k2","v5") print(d) update({"key":"value"}) 更新 不存在加进去，存在时更新 d = {"k1":"v1","k2":"v2","k3":"v3"} d.update({"k2":"v5"}) print(d) d = {"k1":"v1","k2":"v2","k3":"v3"} d.update({"k5":"v5"}) print(d)
数据类型基本形式
v1 = [] #v1 = list() v2 = () #v2 = tuple() v3 = {} #v3 = dict() 默认字典 v4 = set() #集合
集合
set 类 di = {"k1","k2"} 集合 是无序的 所有的元素都是唯一的 可以for，可以取长度，不可以索引
集合是可变的 要求集合里的元素是不可变的，
add() 添加，如果存在不添加
copy()
差集（后面的元素一般是可迭代对象）
v.difference(n) v中存在n中不存在的数据，并取出
v.difference_update(n) 找到v中存在n中不存在的数据，并更新v中的值，
对称差集
v.symmetric_difference(n) 去掉v,n中相同的元素，并取出
v.symmetric_difference——update(n) 去掉v,n中相同的元素，并更新v中的值
交集
intersection()
intersection_update()
并集
union()
isdisjoint() 有交集False，没有True
v.issubset(n) 判断v是否是n的子集
v.issuperset() 判断v是否是n的父集
删除集合元素
pop() 随机删除
remove() 没有时报错
discard() 没有时不报错
update() 更新 不用接收
集合 set 类 s = {"a1","a2"} 集合 是无序的 并且没有重复元素，所有的元素都是唯一的 可以for，可以取长度，不可以索引 集合是可变的 要求集合里的元素是不可变的， add() 添加，如果存在不添加 s = {"a1","a2"} s.add("a3") print(s) #copy 浅拷贝 只拷贝最外层，指向同一块内存 ****单个集合时，在只有数字，字符串的时候，深浅拷贝一样**** s = {"a1","a2"} s1 = s.copy() #重新创建了一个集合， print(s1) s.add("a3") #所以s改变，s1不改变 print(s) print(s1) import copy 深拷贝# 所有层都拷贝，最后一层补不拷贝，改变后不一样 ****单个集合时，在只有数字，字符串的时候，深浅拷贝一样**** import copy s = {"a1","a2"} s1 = copy.deepcopy(s) #重新创建了一个集合， print(s1) s.add("a3") #所以s改变，s1不改变 print(s) print(s1) *****嵌套时才有区别***** #copy 浅拷贝 只拷贝最外层，指向同一块内存 重新创建了一个集合，但是集合中的元素指向一个内存,,所以会都改变 import copy 深拷贝 出最后一层全部拷贝， 拷贝后指向两个内存，所以不会一起改变 clear()清空 s = {"a1","a2"} s.clear() print(s) 删除集合元素 pop() 随机删除 v = {"11", "22", "33", "44", "55"} v.pop() print(v) remove() 在集合中删除指定值 没有时报错 v = {"11", "22", "33", "44", "55"} v.remove("22") print(v) v = {"11", "22", "33", "44", "55"} v.remove("77") print(v) discard() 在集合中删除指定值 没有时不报错 v = {"11", "22", "33", "44", "55"} v.discard("22") print(v) v = {"11", "22", "33", "44", "55"} v.discard("77") print(v) update() 更新 不用接收 v = {"11", "22", "33", "44", "55"} n = {"aaa","sss"} v.update(n) print(v) 差集（后面的元素一般是可迭代对象） v.difference(n) v中存在n中不存在的数据，并取出 v = {"11","22","33","44","55"} n = {"44","55","66","77","88"} a = v.difference(n) print(a) v.difference_update(n) 找到v中存在n中不存在的数据，并更新v中的值， v = {"11","22","33","44","55"} n = {"44","55","66","77","88"} v.difference_update(n) print(v) 对称差集 v.symmetric_difference(n) 去掉v,n中相同的元素，并取出 v = {"11","22","33","44","55"} n = {"44","55","66","77","88"} a = v.symmetric_difference(n) print(a) v.symmetric_difference_update(n) 去掉v,n中相同的元素，并更新v中的值 v = {"11","22","33","44","55"} n = {"44","55","66","77","88"} v.symmetric_difference_update(n) print(v) 交集 intersection() 找到v,n中相同的元素，并取出 v = {"11","22","33","44","55"} n = {"44","55","66","77","88"} a = v.intersection(n) print(a) intersection_update() 找到v,n中相同的元素，并更新v中的值 v = {"11","22","33","44","55"} n = {"44","55","66","77","88"} v.intersection_update(n) print(v) isdisjoint() 判断是否无交集 有交集False，没有True v = {"11","22","33","44","55"} n = {"44","55","66","77","88"} a = v.isdisjoint(n) print(a) union() #并集 v = {"11","22","33","44","55"} n = {"44","55","66","77","88"} a = v.union(n) print(a) v.issubset(n) 判断v是否是n的子集 v = {"44","55"} n = {"44","55","66","77","88"} a = v.issubset(n) print(a) v.issuperset(n) 判断v是否是n的父集 v = {"44","55","66","77","88"} n = {"44","55"} a = v.issuperset(n) print(a) 去重 相当于变成集合类型的数 li = ["44","55","66","77","88","44","44"] v = set(li) print(v)
文件操作 操作文件三要素：(#打开文件后，一定要关闭)
1 路径 ：E:\\python\老师讲解笔记和程序\day6\s7day6.txt
2 编码 ：utf-8
3 模式 ：只读 只写 读写 r rb w wb a ab r+ w+ r+b w+b a+b r+能读能写（最常用，最强大）w+写读（先清空再写）w+比a+功能更强大
1 只读 读取utf-8编码数据，转换成Unicode编码的数据 文件在硬盘上时，一定是某种编码，utf-8或gbk等等
a---mode = "r" 模式 转换
open(文件路径，encoding= "utf-8",mode=“r”)
b---mode ="rb" 不做转换 读取的时候 rb模式的表现形式 bytes
open(文件路径，mode=“rb”) 不常用
********#绝对路径E:\\python\老师讲解笔记和程序\day6\s7day6.txt
**********#相对路径 直接写文件名
# a-- 读取在硬盘里的utf-8编码数据，读到内存后转换成Unicode编码的数据，在内存里的表现形式为字符串 obj = open("D:\\abc.txt",encoding="utf-8",mode="r") content = obj.read() #字符串类型 obj.close() print(content) # b-- 不设置编码转换的时候，表现形式为bytes类型 obj = open("D:\\abc.txt",mode="rb") content = obj.read() #bytes类型 obj.close() print(content) obj = open("user.txt",encoding="utf-8",mode="r") content = obj.read() #字符串类型 obj.close() print(content)
2 只写 不存在时创建，存在时先清空然后覆盖内容
#a---- open(文件路径，encoding= "utf-8",mode="w") obj = open("美女.txt",encoding="utf-8",mode="w") obj.write("海角-嘉敏") obj.close() #b---- open(文件路径，mode=“wb”) 不常用 obj = open("美女.txt",mode="wb") obj.write("海角-嘉敏00000".encode("utf-8")) obj.close() #写完之后不能读 obj = open("美女.txt",mode="w") content = obj.read() obj.close() print(content)
3 只追加 a ******a+只能在最后写******
obj = open("美女.txt",encoding="utf-8",mode="a") obj.write("小红") obj.close() obj = open("美女.txt",mode="ab") obj.write("000".encode("utf-8")) obj.close() #r+ 读写 默认在最后写 obj = open("美女.txt",encoding="utf-8",mode="r+") data = obj.read()#读 obj.write("gggg")#写，单独写的时候，会从头开始写，有内容的话会覆盖 obj.close() print(data) obj = open("美女.txt",encoding="utf-8",mode="r+") obj.write('666')#写，单独写的时候，会从头开始写，有内容的话会覆盖 obj.close() obj = open("美女.txt",encoding="utf-8",mode="r+") data = obj.read(4) obj.write('666') #依旧写到最后位置 obj.close() print(data) obj = open("美女.txt",encoding="utf-8",mode="r+") data = obj.read(2) obj.seek(1) #seek是字节，汉字三个字节一位，标明了要写入的位置 obj.write("0") #单独写的时候，会从头开始写，有内容的话会覆盖 obj.close() #指定写的时候，有内容的话会覆盖，（只是看不到，） print(data)
1 语法： 2 file object = open(file_name [, access_mode][, buffering]) 3 各个参数的细节如下： 4 5 file_name：file_name变量是一个包含了你要访问的文件名称的字符串值。 6 access_mode：access_mode决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。 7 buffering:如果buffering的值被设为0，就不会有寄存。如果buffering的值取1，访问文件时会寄存行。如果将buffering的值设为大于1的整数，表明了这就是的寄存区的缓冲大小。如果取负值，寄存区的缓冲大小则为系统默认。
文件操作功能：
#read(读到第几个字符（r）\字节(rb)) 默认读取所有文件 obj = open("美女.txt",encoding="utf-8",mode="r+") data = obj.read(2) print(data) obj = open("美女.txt",mode="r+b") data = obj.read(2) print(data) #write("字节（wb）或字符串(w)")#不存在时创建，存在时先清空然后覆盖内容 obj = open("美女.txt",encoding="utf-8",mode="w+") obj.write("2") obj.close() #seek(n) 指定位置写并覆盖 指定指针位置 不管是r还是rb n永远都是字节 obj = open("美女.txt",encoding="utf-8",mode="r+") obj.seek(1) #seek是字节，汉字三个字节一位，标明了要写入的位置 data = obj.read(2) obj.close() print(data) #**tell() 读取当前指针在哪 obj = open("美女.txt",encoding="utf-8",mode="r+") # obj.tell() # obj.close() num = int(input("请输入要读取的字符："))#因为编码不同，当文件里是汉字时，写入数字和字母会出现错误，因为字母，数字和汉字所占的位数不同导致的 data = obj.read(num) obj.seek(obj.tell()) obj.write("34") flush() #将内存中的内容强制刷到硬盘 obj = open("aaa",encoding="utf-8",mode="w") while True: data = input(">>>") obj.write(data) #因为无法执行close，所以写的只能写到内存中 obj.flush() #强刷会把内容强制刷到硬盘里，就能读到东西了 obj.close() obj = open("aaa",encoding="utf-8",mode="r"+) val = obj.read() print(val) readline() #只读一行 obj = open("美女.txt",encoding="utf-8",mode="r+") data = obj.readline() print(data) #读一次之后，指针在第2个位置，再次去读就会从下一个位置开始读 data = obj.readline() print(data) readlines() #按行读到所有东西 xreadlines() #py3里没有这个功能了 #重点： #for line in obj : #把每一行都打印出来 等价于py2里的 #xreadlines() obj = open("美女.txt",encoding="utf-8",mode="r+") for line in obj: print(line) obj.close() #手动关毕 #打开文件后，一定要关闭 obj = open(文件路径,mode=rb) xxxx obj.close() #自动关闭 with open(文件路径,mode= "rb") as obj: xxx #代码执行完毕后，自动关闭文件 truncate() #截取文件内容，根据指针位置，只保留之前的数据 obj = open("美女.txt",encoding="utf-8",mode="r+") obj.seek(3) obj.truncate() obj.close() writeable() #是否可写 #以r 模式打开的时候不可写 readable() #是否可读 #以w 模式打开的时候不可读 fileno() #文件描述符，就是一个数字
浙公网安备 33010602011771号