python学习笔记-Day8 上（pickle补充、字段、面向对象成员、成员修饰符、特殊方法）

# pickle load
# 现在有两个python程序，调用关系如下

# s1.py
class foo:
   ….
Obj = foo(x,y)
Pickle.dump(obj, open(‘db’,’wb’))
S2.py

# s2.py
from s1 import foo

pickle.load(db)

# s2.py 反序列化加载包含对象，一定要先导入对象对应的类，否则Pickle load将会报错

# 因为python本身具有多态性，
# 所以这里使用python语法介绍java多态表现形式

class int:
    pass

class float(int): # 继承了int类
    pass

class str(int): # 继承了int类
    pass

# 我创建了三个类，这时我定义一个函数
def func(int arg):  # java必须指定传入参数的类型
    print(arg)

# 这时多态表现是，
obj1 = float()
func(obj1)
obj2 = str()
func(obj2)
obj = int()
func(obj)

# arg参数接收的是int类或int类型的子类，这就是多态

# 静态字段：country   保存在类中
# 动态字段：self.name  保存在调用的对象中

class Province:
    country = ‘中国‘
    def __init__(self,name):
        self.name = name

hn = Province(‘河南‘)
hb = Province(‘河北‘)
sd = Province(‘山东‘)
db = Province(‘黑龙江‘)


# 一般情况下：自己访问自己的字段
# 规则：
#   动态字段只能用对象访问
#   静态字段用类访问（最好不要用对象访问）
hn = Province(‘河南‘)
print(hn.name)      # 对象访问动态字段
print(Province.country) # 类访问静态字段
print(hn.country) # 对象访问静态字段（不建议）        

# Python类中三种方法
#   1. 普通方法： 至少一个self， 对象执行
#   2. 静态方法： 任意参数       类执行（可对象执行，不建议）
#   3. 类方法：   至少一个cls,   类执行（可对象执行，不建议）
class Province:
    country = ‘中国‘
    def __init__(self,name):
        self.name = name
    # 普通方法，由对象去调用执行（方法属于类）
    def show(self):
        print(self.name)

    # 静态方法，由类去调用执行（当方法内部不需要对象中封装的值，可以将方法携程静态方法）
    @staticmethod
    def f1():
        print(‘test‘)
    
    # 类方法
    @classmethod
    def f2(cls):
        # cls  # 类名
        # cls()  # 对象
        print(cls)

# 使用类调用的静态方法
Province.f1()

# 使用对象调用普通类方法
obj = Province(‘111111‘)
obj.show()

# 属性使用的第一种方式
class Pager:

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

    @property
    def all_pager(self):
        return self.all_count

    @all_pager.setter
    def all_pager(self,value):
        self.all_count = value

    @all_pager.deleter
    def all_pager(self):
        del self.all_count

# 属性中的修改和删除
# 上边是将方法字段化，但是字段是可以被修改的，

p = Pager(110)
p.all_pager = 123     # 当我去修改它的时候，会执行@all_pager.setter装饰器下的函数进行修改（本身装饰器指引作用，并不会有帮你去实现修改功能）

print(p.all_pager)  # 现在已经被修改

del p.all_pager  # 同样，del会找到类 @all_pager.deleter装饰器下的all_pager方法，同样也不会实现删除功能
# p.all_pager  # 因为已经被删除，这样调用时会报错的

# 属性存在的第二种方式
class Pager:

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

    def f1(self):
        return self.all_count

    def f2(self,value):
        self.all_count = value

    def f3(self):
        del self.all_count

    foo = property(fget=f1, fset=f2, fdel=f3)

p = Pager(101)

result = p.foo   # 调用fget
print(result)

p.foo = 123   # 设置 fset
print(p.foo)

del p.foo      # 删除 fdel

# 成员修饰符
# 私有：
#    只有类自己本身（私有动态字段、静态字段， 私有静态方法、普通方法、类方法，  私有的属性）
# 公有：
#    可在类外访问，可在对象访问的都是公有
# PS: 不到万不得已，不要在外部强制访问私有成员  _类名__私有xxx

class Foo:
    __cc = ‘test‘    # 私有的静态字段
    def __init__(self,name):
        self.__name = name   # 私有动态字段

    @staticmethod
    def __f1():  # 私有的静态方法
        return ‘私有静态‘

    def __f2(self):  #私有的普通方法
        return ‘私有普通方法‘

    @classmethod
    def __f3(cls):  # 私有的类方法
        return cls, ‘私有类方法‘

    @property
    def __f4(self):
        return ‘私有属性‘

    def f10(self):
        print(Foo.__f1())   # 调用私有静态方法
        print(self.__f2())  # 调用私有普通方法
        print(Foo.__f3())   # 调用私有的类方法
        print(self.__f4)  # 调用私有属性

obj = Foo(‘eason‘)
obj.f10()

# 构造方法、析构方法、特殊方法

class Foo:

    # 构造方法，当对象被调用（例Foo() ）
    def __init__(self,name,age):
        self.name = name
        self.age = age

    # 析构方法，在内存垃圾回收之前，执行的方法
    def __del__(self):
        pass

    # 特殊方法
    # call ， 对象被调用时执行的方法
    def __call__(self):
        print(‘call‘)

    # str, 更改默认对象返回值
    def __str__(self):
        return  ‘%s - %d‘ % (self.name, self.age)

obj = Foo(‘jack‘,18)   # 构造方法执行
obj()         # call方法
Foo(‘eason‘,24)()       # 类调用call方法

obj1 = Foo(‘alex‘,55)

print(obj1)  # 默认没有__str__方法，将返回内存地址，有__str__方法执行__str__方法

# 获取对象中封装的数据
ret = obj1.__dict__
print(ret)