1.pickle 序列化模块

import picklefrom collections import Iterator,Iterable##pickle 序列化模块"""序列化：    把不能直接存储的数据变得可存储反序列化：    把数据恢复成原本的数据格式

serialize 序列化unserialize  反序列化

"""#正常情况下不能够直接把容器类型数据直接存储到文件当中"""with open("ceshi.txt",mode='w',encoding='utf-8') as fp:    lst=[1,2,3,4]    fp.write(lst)"""#dumps  把任意对象序列化成一个byteslst=[1,2,3,4]res=pickle.dumps(lst)print(res)

#lasds  把任意bytes反序列化成原来的数据res=pickle.loads(res)print(res)

def func():    print("我是一个函数")#序列化函数res=pickle.dumps(func)print(res)#反序列化函数func=pickle.loads(res)func()

#序列化迭代器it=iter(range(10))print(isinstance(it,Iterator))res=pickle.dumps(it)print(res)res=pickle.loads(res)print(res)

#dumps 和loads 把数据存储在文件lst=[1,2,3,4]with open("ceshi.txt",mode='rb+') as fp:    res=pickle.dumps(lst)    fp.write(res)    #读取内容的时候，先把光标移到文件行首    fp.seek(0)    res2=fp.read()    print(res2)    lst=pickle.loads(res)    print(lst,type(lst))

#jump  把对象序列化后写入到file-like  object（即文件对象）def  func2():    print("我是func2")with open("ceshi02.txt",mode="wb")  as fp:    #参数1：要序列化的数据，参数2：对应的文件对象    pickle.dump(func2,fp)

#load  把file-like  object（即文件对象）中的内容拿出来反序列化成原来的数据with open("ceshi02.txt",mode="rb")  as fp:    func=pickle.load(fp)func()

#pickle 模块可以序列化所有的数据类型

2.json

import json,pickle####json"""json  可以序列化数据，可以转换成一个字符串json 格式的数据，可以让所有的编程语言都能够识别有数据类型的现在：bool  float int list tuple dict str None"""#第一组：dumps和loads 用来序列化或反序列化字符串"""ensure_ascii=True 是否显示中文，设置ensure_ascii=False  显示中文sort_keys=False 对字典的键进行ASCII排序"""dic={"name":"lizuqing","age":"58","sex":"man","family":["爸爸","妈妈","姐姐","妹妹"]}res=json.dumps(dic,ensure_ascii=False)print(res,type(res))

dic=json.loads(res)print(dic,type(dic))

#第二组：dump和load  用来对数据进行存储dic={"name":"lizuqing","age":"58","sex":"man","family":["爸爸","妈妈","姐姐","妹妹"]}with open("ceshi03.txt",mode="w",encoding="utf-8") as fp:    json.dump(dic,fp,ensure_ascii=False)  #{"name": "lizuqing", "age": "58", "sex": "man", "family": ["爸爸", "妈妈", "姐姐", "妹妹"]}

with open("ceshi03.txt",mode="r",encoding="utf-8") as fp:    dic=json.load(fp)print(dic,type(dic))

#json 和pickle 两个模块的区别#json 的用法特征"""json 可以连续dump，但是不能连续loadload只可以load一次，它是一次性把所有数据作为一个整体来进行转化"""

dic1={"a":1,"b":2}dic2={"c":3,"d":4}with open("ceshi04.txt",mode="w",encoding="utf-8") as fp:    json.dump(dic1,fp)    fp.write("\n")    json.dump(dic2,fp)    fp.write("\n")#error 只能load一次，是一次性把所有数据转化"""with open("ceshi04.txt",mode="r",encoding="utf-8") as fp:    res=json.load(fp)print(res)"""#解决方式with open("ceshi04.txt",mode="r",encoding="utf-8") as fp:    for line in fp:        # res1=fp.readline()        res=json.loads(line)        print(res)#pickle 的用法特征"""pickle 可以连续dump，也可以连续load"""dic1={"a":1,"b":2}dic2={"c":3,"d":4}with open("ceshi05.txt",mode="wb") as fp:    pickle.dump(dic1,fp)    pickle.dump(dic2,fp)

with open("ceshi05.txt",mode="rb") as fp:    dic1=pickle.load(fp)    dic2=pickle.load(fp)print(dic1)print(dic2)

with open("ceshi05.txt",mode="rb") as fp:   try:        while True:            dic=pickle.load(fp)            print(dic)          #异常错误处理   except:       passprint(333)

"""try ....except.... 把有问题的代码直接卸载try这个代码块中， 如果出现异常，直接走except  这个代码块，防止报错终止程序try:    print("wangwendashuaiguo")except:    passprint(333)"""# 总结:"""

# json 和 pickle 两个模块的区别:(1)json序列化之后的数据类型是str,所有编程语言都识别,   但是仅限于(int float bool)(str list tuple dict None)   json不能连续load,只能一次性拿出所有数据(2)pickle序列化之后的数据类型是bytes,   所有数据类型都可转化,但仅限于python之间的存储传输.   pickle可以连续load,多套数据放到同一个文件中

"""

3.random
import random
#random()获取随机0-1之间的小数（左闭右开） 0<=x<1
res=random.random()
print(res)

#randrange()随机获取指定范围内的整数（包含开始值，不包含结束值，间隔值）
# 0  1   2 不包含3
res=random.randrange(3)
print(res)
#1-4
res=random.randrange(1,5)
print(res)
#1  4  7
res=random.randrange(1,10,3)
print(res)

#randint()  随机获取指定范围内的整数（必须两个参数,了解）
res=random.randint(1,4)
print(res)
#randint 无论给1个还说3个都说错误的，只能给2个
#res=random.randint(1,10,3)

#unifrom()  获取指定范围内的随机小数（左闭右开） 1<=x<3
res=random.unifrom(1,3)
print(res)
res=random.unifrom(2,-1)   #-1<x<=2
print(res)

#return a+(b-a)*self.random()
"""
2+(-1-2)*0=2
2+(-1-2)*1=-1
"""

#choice  随机获取序列中的值（多选一0
lst=["苏泽惠","郭艺梦你","银燕","李倩"]
res=random.choice(lst)
print(res)
def mychioce():
 length=len(lst)
 res=random.randrange(0,length)
 return lst[res]
print(mychioce())

#sample() 随机获取序列中的值（多选多）[返回列表]
lst=["苏泽惠","郭艺梦你","银燕","李倩"]
res=random.sample(lst,2)
print(res)

#shuffle() 随机打乱 序列中的值（直接打乱原序列）
lst=["苏泽惠","郭艺梦你","银燕","李倩"]
random.shuffle(lst)
print(lst)

#随机验证码  4
def yanzhengma():
strvar=""
 
 print(ord("a"))  #97
 print(chr(97))  #a

for i in range(4):
  #a~z 97 ~ 122   获取小写字母
  res1=chr(random.randrange(97,123))
  #A~Z  65 ~ 90   获取大写字母
  res2=chr(random.randrange(65,91))
  #1 ~9  获取0-9 是个数字
  res3=random.randrange(1,10)
  #吧可能的字符放到列表中
  lst=[lst1,lst2,lst3]
  #拼接字符串
  strvar+=str(random.chioce(lst))
 return strvar
 
res=yanzhengma()
print(res)

5.os 模块 对系统进行操作
import os
# system 在python中执行命令
os.system("mspaint")
os.system("ipconfig")

#popen()  执行系统命令返回对象，通过read方法读出字符串，不会乱码
obj=os.popen("ipconfig")
print(obj.read())
#listdir()  获取指定文件夹中所有内容的名称列表
"""
. 代表的是当前路径
.. 代表的是上一级路径
"""
res=os.listdir(".")
print(res)

#getcwd()  获取当前文件所在的默认路径
res=os.getcwd()
print(res)   #获取当前路径
print(__file__)   #获取当前文件名完整路径

os.mkdir("ceshi100")   #创建目录（文件）
 os.rmdir("ceshi100")    #删除目录（文件）
 os.rename("ceshi100"，"ceshi200")   #对文件目录重命名（文件）

#copy(src,dst)   复制文件权限和内容
import shutil
shutil.copy("2.py","chishi333")

#chdir()  修改当前文件工作的默认路径
os.chdir(r"V:\homework\L004\day05")
os.mkdir("ceshi200")

#environ  获取或修改环境变量  (了解）
print(os.environ)

#name 获取系统标识  linux,mac --> posix    windows -->  nt
print(os.name)   #nt

6.os.pathimport os#os  Windows中的换行print(repr(os.linesep))#abspath  将相对路径转为绝对路径res=os.path.abspath(".")print(res)#basename  返回文件名     5颗星pathvar=r"E:\PycharmProjects\weekday_04\day06\os_module.py"res=os.path.basename(pathvar)print(res)#dirname  返回路径部分    5颗星pathvar=r"E:\PycharmProjects\weekday_04\day06\os_module.py"res=os.path.dirname(pathvar)print(pathvar)

print(os.getcwd())   #获取当前路径   5颗星print(__file__)        #获取完整文件路径      5颗星

#split() 将路径拆分成单独的文件部分和路径部分 组合成一个元组pathvar=r"E:\PycharmProjects\weekday_04\day06\os_module.py"res=os.path.split(pathvar)print(res)

#join()  将多个路径和文件组成新的路径 可以自动通过不同的系统加不同的斜杠  linux / windows\ 5颗星"""linux:  /home/wangwen/a.pywindows:   E:\PycharmProjects\weekday_04\day06

#绝对路径以 /  开头的是绝对路径  Linux以盘符开头的完整路径是绝对路径   windows

#相对路径.  当前路径..  上一级路径"""path1="wenkday_04"path2="day06"path3="os_module.py"res=os.path.join(path1,path2,path3)    #推荐print(res)res=path1+path2+path3print(res)

#splittext()  将路径分隔为后缀和其他部分pathvar=r"E:\PycharmProjects\weekday_04\day06\os_module.py"res=os.path.splitext(pathvar)print(res)

#getsize()  获取文件的大小   5颗星pathvar=r"E:\PycharmProjects\weekday_04\day06\os_module.py"res=os.path.getsize(pathvar)print(res)

#isdir()  检测路径是否是一个文件夹  5颗星pathvar=r"E:\PycharmProjects\weekday_04\day06"print(os.path.isdir(pathvar))

#isfile()  检测路径是否是一个文件   5颗星pathvar=r"E:\PycharmProjects\weekday_04\day06\os_module.py"print(os.path.isfile(pathvar))print("--------------------")#getmtime()   获取文件最后一次修改时间（返回时间戳）pathvar=r"E:\PycharmProjects\weekday_04\day06\pickle_module.py"res=os.path.getmtime(pathvar)print(res)import timestr_time=time.ctime(res)print(str_time)#getatime()  获取文件最后一次访问时间（返回时间戳）pathvar=r"E:\PycharmProjects\weekday_04\day06\pickle_module.py"res=os.path.getatime(pathvar)print(res)str_time=time.ctime(res)print(str_time)

#exists()   检测指定的路径是否存在     5颗星pathvar=r"E:\PycharmProjects\weekday_04\day06\pickle_module.py"res=os.path.exists(pathvar)print(res)#isabs()   检测一个路径是否是绝对路径   abspath         5颗星""" 别人传变量给你先判断是不是绝对路径，如果不是用abspath转换"""pathvar=r"E:\PycharmProjects\weekday_04\day06\pickle_module.py"res=os.path.isabs(pathvar)print(res)

strvar="."res=os.path.isabs(strvar)print(res)

7.计算文件夹所有的大小import ospath1=os.getcwd()# print(res1)pathvar=os.path.join(path1,"ceshi300")#E:\PycharmProjects\weekday_04\day06\ceshi300print(pathvar)

#part1  基本操作lst=os.listdir(pathvar)print(lst)#初始化变量   size=0size=0for i in lst:    # print(i)    #拼接成完整的绝对路径    pathnew=os.path.join(pathvar,i)    # print(pathnew)    # res=os.path.getsize(pathnew)    # print(res)    #判定它是不是文件，计算大小，getsize只能算文件的大小    if os.path.isfile(pathnew):        print(i, "是一个[文件]")        size+=os.path.getsize(pathnew)        # 判定它是不是文件夹    elif os.path.isdir(pathnew):        print(i,"是一个[文件夹]")print(size)   #1957+2620=4577

#part2  递归方法计算文件夹里面所有内容大小def getallsize(pathvar):    size=0    lst = os.listdir(pathvar)    for i in lst:        pathnew=os.path.join(pathvar,i)        if os.path.isfile(pathnew):            #统计文件大小            size += os.path.getsize(pathnew)   #4577        elif os.path.isdir(pathnew):            size+=getallsize(pathnew)  #7578            # pass

    return sizeres=getallsize(pathvar)print(res)8.zipfile 压缩模块

import zipfile#part1 压缩文件#创建压缩包zf=zipfile.ZipFile("ceshi01.zip","w",zipfile.ZIP_DEFLATED)#写入文件#wrte(路径，别名)# zf.write("1.py")# zf.write("2.py")zf.write(r"E:\PycharmProjects\weekday_04\day06\1.py","1111.py")zf.write(r"E:\PycharmProjects\weekday_04\day06\2.py","2222.py")#可以在写入文件的同时，创建一个文件夹zf.write(r"E:\PycharmProjects\weekday_04\day06\3.py","temp/3333.py")#关闭文件print(zf)zf.close()#part2 解压文件

zf=zipfile.ZipFile("ceshi01.zip","r")"""extratall  解压所有extrat  解压单个文件"""#解压所有文件到某个路径下，./代表当前路径下的某个文件夹sdfzf.extractall("./ceshi01")#extrat  解压单个文件zf.extract("1111.py","./ceshi002")zf.close()

#part3 追加文件   with语法自动关闭zip压缩包操作with zipfile.ZipFile("ceshi01.zip","a",zipfile.ZIP_DEFLATED) as zf:    zf.write("ceshi05.txt")

#part4 查看压缩包内容with zipfile.ZipFile("ceshi01.zip","r",zipfile.ZIP_DEFLATED) as zf:    lst=zf.namelist()print(lst)

9.面向对象"""用几大特征表达一类事物称为一个类，类更像是一张图纸，表达的是一个抽象概念对象是类的具体实现，更像是由这图纸产出的具体物品，类只有一个，但对象可以有多个"""#（1）类的定义class MyClass:    pass#推荐写法class MyClass():    passclass MyClass(object):    pass#（2）类的实例化class car():    color="蓝色"#类的实例化，产生的是对象obj=car()print(obj)#（3）类的基本结构"""类中只有两样东西：    （1）成员属性    （2）成员方法"""class MyCar():    #成员属性    color="红色"    #成员方法    def func(self):        pass

#例外不标准写法，不推荐使用"""类中的逻辑在定义类的时候，直接执行，这个写法语法上不报错，但是严禁 禁止使用"""class MyCar():    if 5==5:        print(123)#（4）类的命名"""推荐使用驼峰命名方法：    每个单词首字母大写：    myclass  =>  MyClass    mycar  =>  MyCar"""

10.封装#封装：对类中成员属性和方法的保护，控制外界对内部成员的访问，修改，删除等操作class MyCar():    #公有成员属性    pinpai="布加迪威航"    #私有成员属性    __oil="2.5L"    def run(self):        #self.pinpai   <======>  obj.pinpai        print("我的小车会跑",self.pinpai)    #私有方法    def __oil_info(self):        print("油耗信息是保密的")

"""绑定方法：    （1）绑定到对象：系统会默认吧对象当成参数进行传递，让self形参进行接收。（对象.方法）    （2）绑定到类：系统会默认把类当成参数进行传递，让形参进行接收（对象.方法，类.方法  通过装饰器修饰）"""#实例化对象  或者类的实例化，都可以，都是产生对象的意思obj=MyCar()#（1）实例化的对象访问公有成员属性和方法print(obj.pinpai)#obj.run()，系统自动把obj这个对象当成参数传递给run()方法中self这个参数进行接收obj.run()# obj.__oil()    不允许调用#（1）实例化的对象添加公有成员属性和方法# __dict__  可以获取对象或者类的内部成员print(obj.__dict__)    #d打印obj的成员obj.color="黄色"print(obj.color)print(obj.__dict__)

#动态添加成员方法# （1）添加无参方法def fang_xiang_pan():    print("我说是制造方向盘的方法！")

#让类外的函数赋值给obj对象的成员方法  fang_xiang_panobj.fang_xiang_pan=fang_xiang_panobj.fang_xiang_pan()print(obj.__dict__)

# （2）添加有参方法def func(self,something):    print(self.pinpai,something)

#将右侧的值赋值给左侧的成员属性funcobj.func=func#需要手动把对象传进去，不如使用绑定方法obj.func(obj,"有参方法")

#使用绑定方法自动把obj当成参数传递  依靠 MethodType#将创建的绑定方法，赋值给成员属性func2，意味着下次调用不需要手动传递该对象，系统会自动帮你传递；import types#MethodType（函数，要绑定的对象上）obj.func2=types.MethodType(func,obj)obj.func2("有参方法")

# （3）添加lambda 表达式obj.dahuangfneg=lambda :print("请叫我大黄蜂")obj.dahuangfneg()obj.qingtianzhu=lambda n :print(n)obj.qingtianzhu("擎天柱")

#继承：一个类除了自身所拥有的属性方法之外，还获取了另外一个类的成员属性和方法#多态：不同的子类对象，调用相同的父类方法，产生不同的执行结果

11.类的相关操作class Plane():    #公有成员属性    captain="lizhuqing"    # 私有成员属性    __air_sister=20    #普通公有方法    def fly():        print("灰机会飞！",Plane.__air_sister)    #灰机会飞！  20    # 普通私有方法    def __fly2():        print("空姐数量是保密的！")obj=Plane()#对象无法调用无参的普通方法，必须要加self# obj.fly()  error

#（1）定义的类访问公有成员属性和方法print(Plane.captain)#无论是对象还是类，都无法在类外调用类中的私有成员# print(Plane.__air_sister)    errorPlane.fly()#查看类Plane的所有成员print(Plane.__dict__)#（2）定义的类添加公有成员属性和方法Plane.engine="烧汽油的"print(Plane.__dict__)    #多了obj方法print(obj.__dict__)    #为空

#添加方法#（1）无参方法def bianxing():    print("我的飞机变成小鸟")Plane.bianxing=bianxingPlane.bianxing()

#（2）有参方法def setname(name):    print("我的飞机名字：",name)Plane.setname=setnamePlane.setname("大黄蜂")Plane.setname("擎天柱")

#（3）lambda表达式Plane.lunzi=lambda :print("我是制造飞机轮胎的方法")

"""（很重要）调用类中成员的时候，要么使用对象，要么使用类调用，不能直接写对象可以使用类中的相关公有成员，但是没有归属权，类中的成员都归当前这个类所有，但是不能使用对象中的相关成员

对象中如果有这个成员，用对象自己的如果没有,用类中的成员."""

#（3）定义的类删除公有成员属性和方法

 12.#类的删除

class MyCar():    price="100元"    __oil="百公里1升"    #普通方法    def bianxing_cat1():        print("车会变形猫",MyCar.price)    #绑定到对象方法    def bianxing_cat2(self):        print("车会变形猫",self.price)    #普通私有方法    def __oil_info1():        print("油耗信息保密1。")

    # 私有绑定方法    def __oil_info2(self):        print("油耗信息保密2。")    #定义公有绑定方法    def pub_func(self):        print(self.__oil)        self.__oil_info2()    #定义公有普通方法    def pub_func2():        print(MyCar.__oil)        MyCar.__oil_info1()#实例化对象obj=MyCar()print(obj.__dict__)print(MyCar.__dict__)

#(1) 实例化的对象删除公有成员属性和方法obj.price="2元"   #动态为该对象付成员属性，priceprint(obj.price)del obj.priceprint(obj.price)#func这个成员是一个静态方法，无论是类还是对象，都能当成普通方法调用"""在类外动态添加成员方法，返回 的是静态方法。"""obj.func=lambda n : print("我是func函数！",n)obj.func(123)# del obj.func    删除方法# obj.func(123)   删除之后无法调用

#(2) 定义的类删除公有成员属性和方法# del MyCar.price   删除后无法调用print(MyCar.price)    #对象无法调用# print(obj.price)    #类无法调用

del MyCar.bianxing_cat1# MyCar.bianxing_cat1()    删除后无法调用

#(3) 可否在内外调用私有属性   不可以"""改名策略：    _类名+私有成员名：比如    __oil==>_MyCar__oil    __oil_info1==>_MyCar__oil_info1"""#对象的调用print(obj._MyCar__oil)obj._MyCar__oil_info2()#类的调用print(MyCar._MyCar__oil)MyCar._MyCar__oil_info1()#（4)通过公有方法调用私有成员obj.pub_func()MyCar.pub_func2()

13.构造方法  __init__#__init__  魔术方法（构造方法）"""触发时机：实例化对象，初始化的时候触发功能：为对象添加成员参数：参数不固定，至少一个self参数返回值：无"""

#（1）  基本语法class MyClass():    def __init__(self):        self.name="anyixuan"# 实例化对象obj=MyClass()print(obj.name)

#（2） 多个参数的  __init__class MyClass():    def __init__(self,name):        #self.name(成员属性name)  =  name(参数name)        self.name=name

#实例化对象的同时，在括号中加上对应的参数，self是系统自己传递的，name需要手动传递，  “hegeg”会被name形参接收走obj=MyClass("hugege")print(obj.name)

#（3）  综合实力：类可以有一个，对象可以有多个  不同对象直接彼此数据隔离class Children():    def __init__(self,name,skin):        self.name=name        self.skin=skin    def cry(self):        print("小孩一生下就哭")

    def eat(self):        print("小孩饿了就喝奶奶")

    def sleep(self):        print("小孩一天23小时睡觉，还有一小时上厕所")

    def child_info(self):        print("该对象姓名：{}，肤色是：{}！".format(self.name,self.skin))

#实例化对象1child1=Children("王铁成","黑色")child1.cry()child1.child_info()

#实例化对象2child2=Children("廖雪峰","黄色")child2.eat()child2.child_info()

#实例化对象3child3=Children("王宝强","绿色")child3.sleep()child3.child_info()