python学习之路day06（模块+面向对象）

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()