Python基础及语法（九）

序列化和反序列化

按照某种规则，把内存的数据保存到文件中，文件是一个字节序列，所以把数据转换成字节序列保存在文件中，这个过程叫序列化，相反，把文件中的字节序列恢复到内存称为反序列化。

import pickle
a = 123
b = '123'
c = [1, 2, 3]
d = {'a': 1, 'b': '2', 3: (3,)}
with open('test', 'wb') as f:  # 序列化
    pickle.dump(a, f)
    pickle.dump(b, f)
    pickle.dump(c, f)
    pickle.dump(d, f)
with open('test', 'rb') as f:  # 反序列化
    for i in range(4):
        x = pickle.load(f)
        print(type(x), x)
# <class 'int'> 123
# <class 'str'> 123
# <class 'list'> [1, 2, 3]
# <class 'dict'> {'a': 1, 'b': '2', 3: (3,)}

 

import pickle


class AAA:
    tttt = 'ABC'

    def __init__(self):
        self.aaaa = 'abcd'


    def show(self):
        print('ABCD')


a = AAA()
a.show()  # ABCD
print(a.tttt, a.aaaa)  # ABC abcd
with open('test', 'wb') as f:
    pickle.dump(a, f)

在另一个终端

import pickle
class AAA:
    pass
with open('D:/python/test', 'rb') as f:
    b = pickle.load(f)
print(b.aaaa)  # abcd

b.show()，b.tttt均报错，所以只保存了__init__里的内容

import pickle


class AAA:
    tttt = 'ABC'

    def __init__(self):
        self.aaaa = 'abcd'


    def show(self):
        print('ABCD')


a = AAA()
a.show()  # ABCD
print(a.tttt, a.aaaa)  # ABC abcd
p = pickle.dumps(a)  # 序列化
with open('text', 'wb') as f:
    f.write(p)

在另一个终端

import pickle
with open('D:/python/test', 'rb') as f:
    b = f.read()
c = pickle.loads(b) # 反序列化5 print(c.aaaa) # abcd

这次把类名也保存了下来

pickle适合Python程序之间使用。跨平台，跨语言，跨写一下pickle不适用，需使用公共协议，如XML、Json、Protocol Buffer等

Json

Json(JavaScript Object Notation)是一种轻量级的数据交换格式，支持字符串，必须用双引号包起来，数值（正负整数，浮点数），对象（字典），数组（列表），true（True），false（False），null（None）

json模块

import json
obj = {'name': 'Tom', 'age': 18, 'class': ['Python', 'Linux']}
f = json.dumps(obj)  # json转码
g = json.loads(f)  # json解码
print(type(obj), obj)  # <class 'dict'> {'name': 'Tom', 'age': 18, 'class': ['Python', 'Linux']}
print(type(f), f)  # <class 'str'> {"name": "Tom", "age": 18, "class": ["Python", "Linux"]}
print(type(g), g)  # <class 'dict'> {'name': 'Tom', 'age': 18, 'class': ['Python', 'Linux']}
with open('test', 'w') as f:
    json.dump(obj, f)    # json转码
with open('test', 'r') as f:
    h = json.load(f)  # json解码
print(type(h), h)  # <class 'dict'> {'name': 'Tom', 'age': 18, 'class': ['Python', 'Linux']}

MessagePack

MessagePack是一个基于二进制的高效的对象序列类库，可用于跨语言通信，它像Json那样但比Json高效

msgpack模块

import msgpack
obj = {'name': 'Tom', 'age': 18, 'class': ['Python', 'Linux']}
f = msgpack.dumps(obj)  # MessagePack转码
g = msgpack.loads(f)  # MessagePack解码
print(type(obj), obj)  # <class 'dict'> {'name': 'Tom', 'age': 18, 'class': ['Python', 'Linux']}
print(type(f), f)  # <class 'bytes'> b'\x83\xa4name\xa3Tom\xa3age\x12\xa5class\x92\xa6Python\xa5Linux'
print(type(g), g)  # <class 'dict'> {'name': 'Tom', 'age': 18, 'class': ['Python', 'Linux']}
with open('test', 'wb') as f:
    msgpack.dump(obj, f)    # MessagePack转码
with open('test', 'rb') as f:
    h = msgpack.load(f)  # MessagePack解码
print(type(h), h)  # <class 'dict'> {'name': 'Tom', 'age': 18, 'class': ['Python', 'Linux']}

 面向对象

语言分类

面向机器（汇编语言）：抽象成机器指令，机器容易理解

面向过程（C语言）：按步骤，一步步进行

面向对象（C++，Java，Python）：随着计算机需要解决的问题规模扩大，面向过程不太适合了，而开发出的高级汇编语言，将万事万物抽象为各种对象

类class

类是抽象的概念，是万事万物的抽象，是一类事物共同特征的集合

对象instance，object

对象是类的具象，是一个实体，对于我们每个人这个个体，都是抽象概念人类的不同的实体

属性

对对象状态的抽象，用数据结构来描述

操作

对对象状态的抽象，用操作名和实现操作的方法来描述

面向对象的3要素

封装：将数据和操作组装在一起，对外只暴露部分接口。

继承：多复用，不用重复写代码，多继承少修改，使用继承来改变和体现个性

多态：面向对象编程最灵活的地方，动态绑定

封装

定义类就是封装，将类属性和操作组织在里面

class ClassName:  # 命名通常使用大驼峰的命名方式
    """a class"""
    a = 'abc'  # 定义类属性

    def show(self):  # 定义类方法
        return self.__class__.__name__


print(ClassName)
print(ClassName.__name__)  # 类名
print(ClassName.__doc__)  # 类文档
print(ClassName.__dict__)  # 类字典
print(ClassName.show)  # 类属性

类及类属性

类对象：类也是对象，类定义后生成一个对象

类属性：类定义中的变量和类的方法都是类的属性，__name__，__doc__等是类的特殊属性

类变量：属性也是标识符，均为变量

实例化

class ClassName:
    """a class"""
    a = 'abc'

    def show(self):
        return self.__class__.__name__


a = ClassName()  # 实例化
b = ClassName()  # 实例化
print(a.show)
print(b.show)

__init__方法

类实例化后要初始化，会调用__init__(self)方法，可以不定义，如果没有定义会隐式调用其父类的

class Test:
    def __init__(self):
        print('init')


print(Test)  # 不调用
Test()  # 调用
a = Test()  # 调用

初始化可以传入多个参数

class Test:
    def __init__(self, a, b):
        self.a = a
        self.b = b

    def show(self):
        print(self.a, self.b)


c = Test(123, 'abc')
print(c.a, c.b)  # 123 abc
c.show()  # 123 abc

注意__init__只能return None

实例对象instance

实例化后获得一个该类的实例，就是实例对象

方法绑定

实例化后，调用方法，实例对象会绑定到方法上，指向当前调用该方法的实例本身

slef

class Test:
    def __init__(self):
        print('init is {}'.format(id(self)))

    def show(self):
        print('show is {}'.format(id(self)))


a = Test()
print('a is {}'.format(id(a)))
a.show()
# id相等

类变量和实例变量

class Test:
    a = 3  # 类变量

    def show(self):
        print(self.a)


a = Test()
a.show()  # 3
b = Test()
b.a = 5  # 实例变量
b.show()  # 5

属性本质

class Test:
    a = 3  # 类变量

    def __init__(self, name):
        self.name = name


print('类')
print(Test.__class__, type(Test), Test.__class__ is type(Test))  # <class 'type'> <class 'type'> True
print(Test.__dict__)  # 类字典
b = Test('b')
print('实例')
print(b.__class__, type(b), b.__class__ is type(b))  # <class '__main__.Test'> <class '__main__.Test'> True
print(b.__class__.__name__, type(b).__name__)  # Test Test
print(b.__class__.__dict__)  # 类字典
print(b.__dict__)  # {'name': 'b'}
# 可以看出实例的__class__就是类

类方法和静态方法

定义的__init__等方法，这些方法本身都是类的属性，第一个参数必须是self，而self必须指向一个对象，也就是实例化后由实例调用这个方法

普通函数

class Test:

    def show():
        print('普通函数')


a = Test
a.show()  # 普通函数
Test.show()  # 普通函数
# 能运行，但不建议这样用

类方法

class Test:
    @classmethod
    def show(cls):
        print('类方法')


a = Test
a.show()  # 类方法
Test.show()  # 类方法

静态方法

class Test:
    @staticmethod
    def show():
        print('静态方法')


a = Test
a.show()  # 静态方法
Test.show()  # 静态方法

访问控制

class Test:
    def __init__(self, a):
        self.a = a

    def show(self, i=10):
        if 0 < i < 50:
            self.a += i


b = Test(30)
print(b.a)  # 30
b.show(20)
print(b.a)  # 50
b.show(200)
print(b.a)  # 50

私有属性

开头使用两个下划线的属性名就是私有属性，不能被直接访问

class Test:
    def __init__(self, a):
        self.__a = a

    def show(self, i=10):
        if 0 < i < 50:
            self.__a += i
        return self.__a


b = Test(30)
print(b.show(20))  # 50
print(b.show(30))  # 80
print(b.show(50))  # 80
print(b.__dict__)  # {'_Test__a': 80}
print(b._Test__a)  # 80，私有属性通常不直接从外部访问，若要访问可以用这钟方式访问

 保护成员

开头使用一个下划线的属性名就是保护成员，能被直接访问，通常约定不直接访问

class Test:
    def __init__(self, a):
        self._a = a

    def show(self, i=10):
        if 0 < i < 50:
            self._a += i
        return self._a


b = Test(30)
print(b._a)  # 30
print(b.show(20))  # 50
print(b._a)  # 50

补丁

可以使用打补丁的方法修改类

# test1.py
from test2 import Test
from test3 import show


print(Test().show())  # test2
Test.show = show  # 打补丁
print(Test().show())  # test3

# test2.py
class Test:
    def show(self):
        return 'test2'

# test3.py
def show(self):
    return 'test3'

属性装饰器

# 使用属性装饰器前
class Test:
    def __init__(self, a):
        self.__a = a

    def show(self):
        return self.__a

    def set(self, i):
        self.__a = i


b = Test(30)
print(b.show())  # 30
b.set(20)
print(b.show())  # 20

# 使用属性装饰器后
class Test:
    def __init__(self, a):
        self.__a = a

    @property
    def show(self):
        return self.__a

    @show.setter
    def show(self, i):
        self.__a = i


b = Test(30)
print(b.show)  # 30
b.show = 20
print(b.show)  # 20

对象的销毁

调用__del__方法，编译结束的时候自动调用该方法

# 使用属性装饰器后
class Test:
    def __init__(self, a):
        self.__a = a

    def show(self):
        return self.__a

    def __del__(self):
        print('end')


a = Test('HI')
print(a.show())  # HI
# end

方法重载

Python没有重载，Python语法本身实现了重载

类的继承

基本概念

类的三要素：封装，继承，多态

# 没有继承
class TestOne:
    def show(self):
        print('{} show'.format(self.__class__.__name__))


class TestTwo:
    def show(self):
        print('{} show'.format(self.__class__.__name__))


test1 = TestOne()
test1.show()  # TestOne show
test2 = TestTwo()
test2.show()  # TestTwo show

# 有继承
class TestOne:
    """1"""
    def show(self):
        print('{} show'.format(self.__class__.__name__))


class TestTwo:
    """2"""
    def dict(self):
        print(self.__class__.__dict__)


class TestThree(TestOne, TestTwo):
    """3"""
    pass


test1 = TestOne()
test1.show()  # TestOne show
test2 = TestTwo()
test2.dict()  # TestTwo的字典
test3 = TestThree()
test3.show()  # TestThree show
test3.dict()  # TestThree的字典
print(TestThree.__mro__)  # 显示方法查找顺序，基类的元组
print(TestThree.mro())  # 同上
print(TestThree.__base__)  # 返回基类元组的第一项
print(TestThree.__bases__)  # 返回基类元组

方法的覆盖重写

class TestOne:
    """1"""
    def show(self):
        print('{} show'.format(self.__class__.__name__))


class TestTwo(TestOne):
    """2"""
    def show(self):
        print('覆盖了')


test1 = TestOne()
test1.show()  # TestOne show
test2 = TestTwo()
test2.show()  # 覆盖了

单继承

定义类的时候继承项只有一个基类的是为单继承

多继承

一个类继承自多个类就是多继承

多继承的弊端：多个父类有相同的方法名的时候不清楚继承哪个

解决方法：Python使用C3算法解决，在类被创建出来的时候就建立了MRO列表

其它解决方法：装饰器，Mixin

多态

在面向对象中，父类，子类，联系在一起，如果通过一套方法，就可以实现不同表现，就是多态