Python 小栈_19：Python 面向对象之多态、封装和反射

import abc
class Animal(metaclass=abc.ABCMeta): #同一类事物:动物
    @abc.abstractmethod
    def talk(self):
        pass

    def func(obj):
        obj.talk()

class People(Animal): #动物的形态之一:人
    def talk(self):
        print(‘say hello‘)

class Dog(Animal): #动物的形态之二:狗
    def talk(self):
        print(‘say wangwang‘)

class Pig(Animal): #动物的形态之三:猪
    def talk(self):
        print(‘say aoao‘)

p1=People()    #实例化
d1=Dog()
z1=Pig()

p1.talk()      #子类调用基类的属性
d1.talk()
z1.talk()

p1.func()     #也可以定义一个接口函数func()，然后在该函数调用talk方法，则在调用func时就相当于调用talk函数
d1.func()     #这就是多态，基于继承而来，且不同实例化的对象在调用方法时实现方式有多种
z1.func()


>>>
say hello
say wangwang
say aoao
say hello
say wangwang
say aoao

#str,list,tuple都是序列类型
s=str(‘hello‘)
l=list([1,2,3])
t=tuple((4,5,6))

print(s.__len__())
print(l.__len__())
print(t.__len__())
#两种不同的调用方法，平时所用的len()函数就相当于调用了对象下的__len__函数
print(len(s))
print(len(l))
print(len(t))

>>>
5
3
3
5
3
3

#类的设计者
class Room:
    def __init__(self,name,owner,width,length,high):
        self.name=name
        self.owner=owner
        self.__width=width
        self.__length=length
        self.__high=high
    def tell_area(self):            #接口函数，对外提供的接口，隐藏了内部的实现细节
        return self.__width * self.__length    #内部可以调用内部的逻辑，但外部使用者则不能看到该实现逻辑


#使用者
r1=Room(‘卧室‘,‘egon‘,20,20,20)
a=r1.tell_area() #使用者调用接口tell_area
print(a)       

--> 400

#类的设计者，轻松的扩展了功能，而类的使用者完全不需要改变自己的代码
class Room:
    def __init__(self,name,owner,width,length,high):
        self.name=name
        self.owner=owner
        self.__width=width
        self.__length=length
        self.__high=high
    def tell_area(self): #对外提供的接口，隐藏内部实现，此时我们想求的是体积,内部逻辑变了,只需求修该下列一行就可以很简答的实现,而且外部调用感知不到,仍然使用该方法，但是功能已经变了
        return self.__width * self.__length * self.__high


#对于仍然在使用tell_area接口的人来说，根本无需改动自己的代码，就可以用上新功能
r1=Room(‘卧室‘,‘egon‘,20,20,20)
b=r1.tell_area()
print(b)

-->8000

#取款是功能,而这个功能有很多功能组成:插卡、密码认证、输入金额、打印账单、取钱
#对使用者来说,只需要知道取款这个功能即可,其余功能我们都可以隐藏起来,很明显这么做
#隔离了复杂度,同时也提升了安全性

class ATM:
    def __card(self):
        print(‘插卡‘)
    def __auth(self):
        print(‘用户认证‘)
    def __input(self):
        print(‘输入取款金额‘)
    def __print_bill(self):
        print(‘打印账单‘)
    def __take_money(self):
        print(‘取款‘)

    def withdraw(self):    #接口函数，内部调用设定的私有函数
        self.__card()
        self.__auth()
        self.__input()
        self.__print_bill()
        self.__take_money()

a=ATM()
a.withdraw()

#1、hasattr()判断object中有没有一个name字符串对应的方法或属性,返回值是一个布尔值
class A:
    def __init__(self,name):
        self.name=name

    def test(self):
        print("我的名字是%s" %self.name)

class B(A):
    def __init__(self):
        pass


b1=B()
print(hasattr(b1,"test"))
print(hasattr(b1,"test1111"))

>>>
True
False

#2、getattr()是用来获取属性
class A:
    def __init__(self,name):
        self.name=name

    def test(self):
        print("我的名字是%s" %self.name)


b1=A("alex")

print(getattr(b1,"test"))   #获取属性test()
func=getattr(b1,"test")     #可为其赋予函数，然后运行该函数
func()
#getattr还有第三个参数，可用来传入若找不到属性可输出的内容，默认报错
print(getattr(b1,"asflka","找不到啊"))    #第三个参数设置找不到是输出的内容


>>>
<bound method A.test of <__main__.A object at 0x000002AB12C9AA60>>
我的名字是alex
找不到啊

#3、setattr()是用来设置属性
class A:
    def __init__(self,name):
        self.name=name

    def test(self):
        print("我的名字是%s" %self.name)


b1=A("alex")
setattr(b1,"happy","asjdhaf")     #三个参数：类名、实例；属性名；属性内容。缺一不可
print(b1.__dict__)
setattr(b1,‘show_name‘,lambda self:self.name+‘sb‘)     #属性内容也可设置为函数
print(b1.show_name(b1))        #在添加属性后，也可以用同样的方法去调用

>>>
{‘name‘: ‘alex‘, ‘happy‘: ‘asjdhaf‘}
alexsb

#4、delattr()是用来删除属性
class A:
    def __init__(self,name):
        self.name=name

    def test(self):
        print("我的名字是%s" %self.name)


b1=A("alex")
setattr(b1,"happy","asjdhaf")     #三个参数：类名、实例；属性名；属性内容。缺一不可
print(b1.__dict__)
setattr(b1,‘show_name‘,lambda self:self.name+‘sb‘)     #属性内容也可设置为函数
print(b1.show_name(b1))        #在添加属性后，也可以用同样的方法去调用

delattr(b1,"show_name")      #删除属性，类名/实例；属性名
print(b1.__dict__)


>>>
{‘name‘: ‘alex‘, ‘happy‘: ‘asjdhaf‘}
alexsb
{‘name‘: ‘alex‘, ‘happy‘: ‘asjdhaf‘}