1.pickle 序列化模块
import pickle
from 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 把任意对象序列化成一个bytes
lst=[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，但是不能连续load
load只可以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(" ")
json.dump(dic2,fp)
fp.write(" ")
#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:
pass
print(333)
"""
try ....except....
把有问题的代码直接卸载try这个代码块中，
如果出现异常，直接走except 这个代码块，防止报错终止程序
try:
print("wangwendashuaiguo")
except:
pass
print(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:homeworkL004day05")
os.mkdir("ceshi200")
#environ 获取或修改环境变量 (了解）
print(os.environ)
#name 获取系统标识 linux,mac --> posix windows --> nt
print(os.name) #nt
6.os.path
import os
#os Windows中的换行
print(repr(os.linesep))
#abspath 将相对路径转为绝对路径
res=os.path.abspath(".")
print(res)
#basename 返回文件名 5颗星
pathvar=r"E:PycharmProjectsweekday_04day06os_module.py"
res=os.path.basename(pathvar)
print(res)
#dirname 返回路径部分 5颗星
pathvar=r"E:PycharmProjectsweekday_04day06os_module.py"
res=os.path.dirname(pathvar)
print(pathvar)
print(os.getcwd()) #获取当前路径 5颗星
print(__file__) #获取完整文件路径 5颗星
#split() 将路径拆分成单独的文件部分和路径部分 组合成一个元组
pathvar=r"E:PycharmProjectsweekday_04day06os_module.py"
res=os.path.split(pathvar)
print(res)
#join() 将多个路径和文件组成新的路径 可以自动通过不同的系统加不同的斜杠 linux / windows 5颗星
"""
linux: /home/wangwen/a.py
windows: E:PycharmProjectsweekday_04day06
#绝对路径
以 / 开头的是绝对路径 Linux
以盘符开头的完整路径是绝对路径 windows
#相对路径
. 当前路径
.. 上一级路径
"""
path1="wenkday_04"
path2="day06"
path3="os_module.py"
res=os.path.join(path1,path2,path3) #推荐
print(res)
res=path1+path2+path3
print(res)
#splittext() 将路径分隔为后缀和其他部分
pathvar=r"E:PycharmProjectsweekday_04day06os_module.py"
res=os.path.splitext(pathvar)
print(res)
#getsize() 获取文件的大小 5颗星
pathvar=r"E:PycharmProjectsweekday_04day06os_module.py"
res=os.path.getsize(pathvar)
print(res)
#isdir() 检测路径是否是一个文件夹 5颗星
pathvar=r"E:PycharmProjectsweekday_04day06"
print(os.path.isdir(pathvar))
#isfile() 检测路径是否是一个文件 5颗星
pathvar=r"E:PycharmProjectsweekday_04day06os_module.py"
print(os.path.isfile(pathvar))
print("--------------------")
#getmtime() 获取文件最后一次修改时间（返回时间戳）
pathvar=r"E:PycharmProjectsweekday_04day06pickle_module.py"
res=os.path.getmtime(pathvar)
print(res)
import time
str_time=time.ctime(res)
print(str_time)
#getatime() 获取文件最后一次访问时间（返回时间戳）
pathvar=r"E:PycharmProjectsweekday_04day06pickle_module.py"
res=os.path.getatime(pathvar)
print(res)
str_time=time.ctime(res)
print(str_time)
#exists() 检测指定的路径是否存在 5颗星
pathvar=r"E:PycharmProjectsweekday_04day06pickle_module.py"
res=os.path.exists(pathvar)
print(res)
#isabs() 检测一个路径是否是绝对路径 abspath 5颗星
"""
别人传变量给你先判断是不是绝对路径，如果不是用abspath转换
"""
pathvar=r"E:PycharmProjectsweekday_04day06pickle_module.py"
res=os.path.isabs(pathvar)
print(res)
strvar="."
res=os.path.isabs(strvar)
print(res)
7.计算文件夹所有的大小
import os
path1=os.getcwd()
# print(res1)
pathvar=os.path.join(path1,"ceshi300")
#E:PycharmProjectsweekday_04day06ceshi300
print(pathvar)
#part1 基本操作
lst=os.listdir(pathvar)
print(lst)
#初始化变量 size=0
size=0
for 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 size
res=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:PycharmProjectsweekday_04day061.py","1111.py")
zf.write(r"E:PycharmProjectsweekday_04day062.py","2222.py")
#可以在写入文件的同时，创建一个文件夹
zf.write(r"E:PycharmProjectsweekday_04day063.py","temp/3333.py")
#关闭文件
print(zf)
zf.close()
#part2 解压文件
zf=zipfile.ZipFile("ceshi01.zip","r")
"""
extratall 解压所有
extrat 解压单个文件
"""
#解压所有文件到某个路径下，./代表当前路径下的某个文件夹sdf
zf.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():
pass
class 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_pan
obj.fang_xiang_pan=fang_xiang_pan
obj.fang_xiang_pan()
print(obj.__dict__)
# （2）添加有参方法
def func(self,something):
print(self.pinpai,something)
#将右侧的值赋值给左侧的成员属性func
obj.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) error
Plane.fly()
#查看类Plane的所有成员
print(Plane.__dict__)
#（2）定义的类添加公有成员属性和方法
Plane.engine="烧汽油的"
print(Plane.__dict__) #多了obj方法
print(obj.__dict__) #为空
#添加方法
#（1）无参方法
def bianxing():
print("我的飞机变成小鸟")
Plane.bianxing=bianxing
Plane.bianxing()
#（2）有参方法
def setname(name):
print("我的飞机名字：",name)
Plane.setname=setname
Plane.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元" #动态为该对象付成员属性，price
print(obj.price)
del obj.price
print(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))
#实例化对象1
child1=Children("王铁成","黑色")
child1.cry()
child1.child_info()
#实例化对象2
child2=Children("廖雪峰","黄色")
child2.eat()
child2.child_info()
#实例化对象3
child3=Children("王宝强","绿色")
child3.sleep()
child3.child_info()