day26：静态方法，类方法和反射

时间 2019-11-11

原文原文链接

1，包内部不要去尝试应用使用相对导入，必定不会成功的，他不支持这个机制，包内导入时必定要用绝对导入python

2，复习接口类，抽象类，Python中没有接口类，有抽象类，抽象类是经过abc模块中的metaclass = ABCMeta 和@abstractmethod实现的git

3，接口类和抽象类本质是作代码规范用的，我但愿在子类中实现和父类方法名彻底同样的方法编程

4，两者区别，在JAVA的角度看是有区别的，JAVA没有多继承，因此为了接口隔离原则，就设计了接口这个概念，支持多继承；JAVA原本就支持单继承，因此就有了抽象类。Python中既支持单继承，也支持多继承，因此对于接口类和抽象类的区别就不那么明显了。甚至在Python中根本没有接口类，可是Python的扩展模块中有一个模块确实实现了接口类的概念，因此不能说根本没有，只是内置模块中没有，没有内置接口类。网络

5，多态和鸭子类型，多态---Python天生支持多态，给子类找个爸爸，传爸爸的参数，Python里面崇尚鸭子类型，不依赖父类的状况下，实现两个类中的同名方法。app

6，封装 ---私有的，在Python中只要__名字，就把这个名字私有化了，私有化以后，就不能从类的外部直接调用了，能够私有的有静态属性方法，对象的属性均可以私有化，这种私有化只是从代码级别作了变形，并无真的约束，变形机制 _类名__方法。在类外用这个调用，在类的外部__名字调用。函数

7，私有属性spa

class Room:
    def __init__(self,name,length,width):
        self.name = name
        self.__length =length
        self.__width = width
    
    def area(self):
        return self.__length * self.__width

jin = Room('jin',3,5)
print(jin.area())
jin.name = 'lisa'
print(jin.name)

8，get set 方法保护属性不被修改,私有属性的查看方法设计

class Room:
    def __init__(self,name,length,width):
        self.__name = name
        self.__length =length
        self.__width = width

    def get_name(self):
        return self.__name

    # 对私有对象的保护
    def set_name(self,new_name):
        if type(new_name) is str and new_name.isdigit() == False:
            self.__name = new_name
        else:
            print('invalid name')

    def area(self):
        return self.__length * self.__width

jin = Room('jin',3,5)
jin.name = '2' # 不是私有的话，能够随便改，要想办法约束一下
print(jin.name)

jin.set_name('lisa')
print(jin.get_name())
# C++ 里面全部的属性都设置成私有的，

9，父类的私有属性能够被子类调用吗？否代码规范

class Foo:
    __key = '123'  _Foo__key

class Son(Foo):
    print(Foo.__key) #_Son__key # 此句报错，因为不能够调用 
# AttributeError: type object 'Foo' has no attribute '_Son__key

10，总结：会用到私有概念的场景，隐藏起一个属性，不想让类的外部调用；我想保护这个属性，不想让属性随意被改变；我想保护这个属性不被子类继承code

11，以前老师欠着的三个内置函数：property,classmethod,staticmethod

12，property，内置装饰器函数，只在面向对象中使用，可是做为一个property属性，函数后面不能传递任何参数

from math import pi
class Circle:
    def __init__(self,r):
        self.r = r

    @property
    def perimeter(self):
        return 2 *pi *self.r

    @property
    def area(self):
        return self.r**2*pi

c1 = Circle(5)
# print(c1.area()) # 面积不是动做，是一个属性才合理，如何假装成一个属性呢？
print(c1.area)
print(c1.perimeter)
# c1.area = 70  # 不支持赋值

13，BMI指数，方法假装的属性，不被容许修改，怎么办？

class Person:
    def __init__(self,name,high,weight):
        self.name = name
        self.high = high
        self.weigh = weight
        # self.bmi = wight / (high **2)  # 这样写虽然能够，可是不规范，操做属性的方法咱们都是会在方法里面来写，各司其职，才更合理

    @property
    def bmi(self):
        return self.weigh/self.high**2

jin = Person('jin',1.75,70)
# print(jin.bmi())
print(jin.bmi)
jin.name = 'tiger'
# jin.bmi = '23'  # 不容许修改，怎么办？

14，方法一，name.setter 和 name.deleter

class Person:
    def __init__(self,name):
        self.__name = name

    @property
    def name(self):
        return self.__name + ' nb'

    @name.setter
    def name(self,new_name):  # 虽然是同名函数，可是不会覆盖
        self.__name = new_name

    @name.deleter
    def name(self):pass  # 里面不实现的话，是没有办法删除的def self.name

tiger = Person('tiger')
# print(tiger.name())  # tigernb,另外改为property以后就不能够这样覅用了
print(tiger.name)

tiger.name = 'all students' # 没法修改怎么办？再定义一个函数
print(tiger.name)

del tiger.name # 删除属性
print(tiger.name) 

# 注意三个函数的名字必须同样，而且必定要有一个@property方法，才能够有后面两个

15，和类属性的结合

class Goods:
    discount = 0.8
    def __init__(self,name,price):
        self.name = name
        self.__price = price # 私有价格，只有本身知道

    @property
    def price(self):
        return self.__price * Goods.discount

apple = Goods('apple',5)
print(apple.price)

16，staticmethod 静态的方法三颗星，classmethod 类方法四颗星，property 四星半，重要程度，私有属性，五颗星

17，classmethod ，把一个方法变成一个类中的方法，这个方法就能够直接被类调用，不被须要依托于任何对象

class Goods:
    __discount = 0.8
    def __init__(self,name,price):
        self.name = name
        self.__price = price

    @property
    def price(self):
        return self.__price * Goods.__discount

    @classmethod
    def change_discount(cls,new_discount): # 去掉self，咱们不推荐这样写,标准写法，不要写成其余的
        cls.__discount = new_discount


# apple = Goods('apple',5)
# print(apple.price)

# 这个折扣修改的动做，咱们如何不本身来完成，而是用一个函数来完成？
# 若是咱们定义成一个对象函数，那么我必须拿一个对象来进行折扣的修改，可是这个折扣是类属性，我但愿全部的对象都自动修改
# 而不是经过某一个
# apple.change_discount(0.7)
Goods.change_discount(0.9)
# 当这个方法的操做只涉及静态属性的时候，就应该使用classmethod

18，staticmethod，若是一个函数自己和类和对象都没有什么关系，可是我就想把这个函数写入到类里面，想象春面向对象的语言，例如JAVA，C#

class Login:
    def __init__(self,name,password):
        self.name = name
        self.pwd = password

    def login(self):pass

    @staticmethod  # 不须要和类和对象产生任何关系，可是还能够放在类里面
    def get_usr_pwd():  # 必须把它扔进类里面，才是面向对象
        input('input usrname:')
        input('input password:')


l  = Login('alex','3714')
l.get_usr_pwd() # 静态方法既能够被对象来访问，也能够用类来访问
Login.get_usr_pwd()

# 什么时候使用静态方法
# 在彻底面向对象的程序中，若是一个函数，既和对象没有关系，也和类没有关系，那么就用staticmethod将这个函数编程一个静态方法

# 类方法和静态方法都是类来调用的，那么对象能够调用吗？
# 能够的，想象对象能够调用静态属性吗？同样的道理，可是通常状况下，推荐用类名来调用
# 类方法，有一个默认参数 cls 表明这个类
# 静态方法，没有默认参数，就像函数同样

19，反射，很是重要，五颗星，把字符串当变量使用

# name = 'lisa'
# 'name'

class Teacher:
    dic = {'show stu info','show teacher info'}

    def show_student(self):
        print('show student')

    def show_teacher(self):
        print('show teacher')

# menu = Teacher.dic
# for k in menu:
#     print(k)

'dic'

# 最后三个内置函数
# hasattr
# getattr
# defattr

ret = getattr(Teacher,'dic')  # 左右对应 Teacher.dic
print(ret)  # {'show stu info', 'show teacher info'}

# python中一切皆是对象，包括类和模块

20，反射类属性和类方法

class Teacher:
    dic = {'show stu info','show teacher info'}

    def show_student(self):
        print('show student')

    def show_teacher(self):
        print('show teacher')

    @classmethod
    def func(cls):
        print('hahaha')


ret = getattr(Teacher,'dic')  # 左右对应 Teacher.dic，类.属性
print(ret)  # {'show stu info', 'show teacher info'}

ret2 = getattr(Teacher,'func')
ret2() # hahaha

if hasattr(Teacher,'func2'):
    ret = getattr(Teacher,'func')
    ret()

if hasattr(Teacher,'dic'):
    ret = getattr(Teacher,'dic')
    print(ret)

21，反射对象方法

# 反射对象函数
lisa = Teacher()
func = getattr(lisa,'show_student')
func()

22，使用实例，有了反射我就不用去一条条判断了，我只须要一条反射，去掉用相应的方法就好了，反射的妙用

for k in Teacher.dic:
    print(k)

key = input("输入需求：")
# print(Teacher.dic[key])
# 这个地方好在不须要去判断if key = 1 怎么样，key =2怎么样，用反射，程序自动就去调用了
if hasattr(lisa,Teacher.dic[key]):
    func = getattr(lisa,Teacher.dic[key])
    func()

23，反射很是的重要，也许如今只在面向对象这儿还体会不到他的好，可是到了之后网络编程，文件操做的时候，会用的很是多

24，经过反射能够对象名获取对象属性和普通方法，类名获取静态属性和类方法和静态方法

25，面向对象思惟导图和计算器做业先欠着，后补