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

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

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

3，接口类和抽象类本质是做代码规范用的，我希望在子类中实现和父类方法名完全一样的方法

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

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

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

7，私有属性

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 = '' # 不是私有的话，可以随便改，要想办法约束一下

print(jin.name)

jin.set_name('lisa')

print(jin.get_name())

# C++ 里面所有的属性都设置成私有的，

9，父类的私有属性可以被子类调用吗？否

class Foo:

    __key = ''  _Foo__key

class Son(Foo):

    print(Foo.__key) #_Son__key # 此句报错，由于不可以调用 
# AttributeError: type object 'Foo' has no attribute '_Son__key

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

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','')

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，面向对象思维导图和计算器作业先欠着，后补

巴特西

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

最新文章

热门文章