python基础 day26 面向对象-super方法、封装、property装饰器、反射

一、super 方法

class A:
    def func(self):
        print('A')
class B(A):
    def func(self):
        super().func()
        print('B')
class C(A):
    def func(self):
        super().func()
        print('C')
class D(B,C):
    def func(self):
        super().func()
        print('D')
print(D.mro())
# [<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]
D().func()
'''
A
C
B
D
'''

• super 是按照mro顺序来寻找当前类的下一个类的
• 在python3中不需要传参数，自动就帮我们寻找当前类的mro顺序的下一个类中的同名方法
• 在python2中的新式类中，需要我们主动传递参数super(子类的名字, 子类的对象).函数名()，这样才能够帮我们调用到这个子类的mro顺序的下一个类中的方法。
• 在python2的经典类中，并不支持使用super来找下一个类。

即上面代码在D类中找super的func，可以写super().func()，也可写成super(D, self).func()，但是在python2中必须写成super(D, self).func()

在单继承的程序中，super就是找父类。

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

class VIPUser(User):
    def __init__(self, name, level, start_time, end_time):
        super().__init__(name)
        self.level = level
        self.start_time = start_time
        self.end_time = end_time

jason = VIPUser('jason', 10, '05-03', '06-03')
print(jason.__dict__)
# {'name': 'jason', 'level': 10, 'start_time': '05-03', 'end_time': '06-03'}

二、封装

封装：把属性和方法装起来

广义：把属性和方法装起来，外部不能直接调用，要通过类的名字调用

狭义：把属性和方法藏起来，外部不能调用，只能在内部偷偷调用

• 给一个名字前面加上双下划线的时候，这个名字就变成了一个私有的
  所有的私有的内容或名字都不能在类的外部直接调用，只能在类的内部使用

class User:
    def __init__(self, username, password):
        self.usr = username
        self.__pwd = password  # 私有的实例变量/私有的对象属性

jason = User('jason', '123456')
print(jason.usr)  # jason
print(jason.__pwd)  # 此时会报错

• 如果想要查看或者修改私有的实例变量只能在类中定义函数来查看

class User:
    def __init__(self, username, password):
        self.usr = username
        self.__pwd = password  # 私有的实例变量/私有的对象属性
    def get_pwd(self):
        return self.__pwd
    def change_pwd(self):
        old_pwd = input('enter old password:')
        if old_pwd == self.__pwd:
            new_pwd1 = input('enter new password:')
            new_pwd2 = input('enter new password again:')
            if new_pwd1 == new_pwd2:
                self.__pwd = new_pwd2
jason = User('jason', '123456')
print(jason.usr)  # jason
print(jason.get_pwd())  # 123456
jason.change_pwd()
print(jason.get_pwd())

同理，也可以有私有的静态变量

class Map:
    country = 'china'
    __language = 'chinese'
    def get(self):
        return Map.__language

a = Map()
print(a.country)  # china
print(a.__language)  # 报错
print(a.get())  # chinese

同理，也可以有私有的方法

import hashlib
class User:
    def __init__(self,name,password):
        self.usr = name
        self.__pwd = password  # 私有的实例变量
    def __md5_pwd(self):  # 私有的方法
        ret = hashlib.md5()
        ret.update(self.__pwd.encode('utf-8'))
        return ret.hexdigest()
    def get_pwd(self):
        return self.__md5_pwd()

jason = User('jason', 'abcd')
print(jason.get_pwd())

所有的私有化都是为了让用户不在外部调用类中的某个名字
如果完成私有化，那么这个类的封装度就更高了，封装度越高各种属性和方法的安全性也越高 ，但是代码越复杂

私有的内容能不能被子类使用？ 不能

class Foo:
    def __init__(self):
        self.func()
    def func(self):
        print("in Foo")
class Son(Foo):
    def func(self):
        print("in Son")

Son()  # in Son

class Foo:
    def __init__(self):
        self.__func()
    def __func(self):
        print("in Foo")
class Son(Foo):
    def __func(self):
        print("in Son")

Son()  # in Foo

class Foo:
    def __func(self):
        print("in Foo")
class Son(Foo):
    def __init__(self):
        self.__func()
Son()  # 报错

三、类中的装饰器

• property

property 应用场景一：把一个方法伪装成属性，在调用这个方法时不需要加()就可以直接得到返回值

import time
class Person:
    def __init__(self, name, birth):
        self.name = name
        self.birth = birth
    @property
    def age(self):  # 装饰的这个方法，不能有参数
        return time.localtime().tm_year - self.birth

jason = Person('jason', 1996)
print(jason.age)

property 应用场景二：和私有属性合作

class User:
    def __init__(self,username,password):
        self.usr = username
        self.__pwd = password
    @property
    def pwd(self):
        return self.__pwd

jason = User('jason', 1234)
print(jason.pwd)

property 进阶

class Goods:
    discount = 0.8
    def __init__(self,name,origin_price):
        self.name = name
        self.__price = origin_price
    @property
    def price(self):
        return self.__price * self.discount
    @price.setter
    def price(self,new_value):
        if isinstance(new_value,int):
            self.__price = new_value

apple = Goods('apple', 10)
print(apple.price)  # 调用的是被@property装饰的price
apple.price = 20  # 调用的是被setter装饰的price
print(apple.price)

三、反射

反射使用场景
1.反射对象的实例变量
2.反射类的静态变量/绑定方法/其他方法
3.模块中的所有变量：导入的模块/当前.py文件

语法

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def func(self):
        print('aloha')

j = Person('jason', 24)
d = Person('dog', 5)
ret = getattr(j, 'name')
print(ret)
ret = getattr(d, 'func')
ret()

使用反射实现归一化

import sys
class Wechat:
    def __init__(self, name):
        self.name = name
    def pay(self, money):
        print(f'{self.name}通过微信支付了{money}元。')
class Alipay:
    def __init__(self, name):
        self.name = name
    def pay(self, money):
        print(f'{self.name}通过支付宝支付了{money}元。')


def pay(name, price, type):
    class_name = getattr(sys.modules['__main__'], type)
    obj = class_name(name)
    obj.pay(price)

pay('jason', 400, 'Wechat')

反射的另一个函数 hasattr

class A:
    def __init__(self):
        self.name = 'jason'
        self.age = 24
    def func(self):
        return 666
j = A()
if hasattr(j,'name'):
    print(getattr(j,'name'))
if hasattr(j,'age'):
    print(getattr(j,'age'))
if hasattr(j,'sex'):
    print(getattr(j,'sex'))