13 python学习笔记-面向对象编程2

一、构造函数和析构函数

class Person:
    def __init__(self): #构造函数  类在实例化的时候自动调用的方法
        self.__base_price = 8000
        print('构造函数')

    def __del__(self): #析构函数  实例被销毁之后自动调用
        print('析构函数')

    def say(self):
        print('say')

    def set_price(self,discount):  #实例方法
        self.__base_price = self.__base_price - self.__base_price * discount
        return self.__base_price

    def get_price(self):
        return self.__base_price

if __name__ == '__main__':
    xh = Person() #实例化
    xh.say()
    print(xh.set_price(0.5))
    print(xh.get_price())

#结果
构造函数
say
4000.0
4000.0
析构函数

二、私有方法和私有属性

私有就是只有在类里面可以访问，实例化之后不可以访问和调用，有私有方法和私有属性。私有就把变量名或者函数名前面加上"__"两个下划线，其实就是通过私有来实现封装的。

class Dog(object):
    __type = '狗'  # 私有属性

    def cry(self):
        self.__test()  # 调用私有方法
        print('私有属性%s' % self.__type)
        print('狗 [%s] 汪汪汪' % self.name)

    def __test(self):  # 私有方法
        self.name = 'test'  #


d = Dog()
d.cry()  # 正常可以调用
d.__type  # 报错，因为是私有属性，在外面不能访问
d.__test()  # 报错，因为是私有方法，在外面不能访问

三、静态方法和类方法

class Person: #经典类
    #属性就是变量
    #功能就是函数
    country = 'China' #类变量
    base_price = 8000
    discount = 0.1

    def __del__(self):
        pass

    @staticmethod  #静态方法，和类本身没有什么关系了，就相当于在类里面定义了一个方法而已
    def help():
        print("这个类是造机器人的")

    @classmethod   #类方法，和静态方法不同的是，它可以使用类变量，必须要传一个值，代表的就是这个类
    def getClassname(cls):
        print('Person')

    @classmethod
    def sayCountry(cls):
        #代表的本身这个类，可直接调用类方法
        cls.getClassname()
        print(cls.country)

    def __init__(self,uid,name):  #构造方法
        print('self的内存地址:',id(self))
        self.id = uid #实例变量
        self.name = name #pep8

    def cook(self): #实例方法
        print('%s鱼香肉丝'%self.name)

    def housework(self):
        print('%s正在做家务'%self.name)
        print('国籍是%s'%self.country)

    @property  #私有方法
    def price(self,):
        return self.base_price - self.base_price * self.discount

if __name__ == '__main__':
    Person.country = 'USA' #修改类属性
    Person.sayCountry()  #直接调用类方法，无需实例化
    Person.help() #直接调用静态方法，无需实例化

    xh = Person(1,'小黑')  #__init__(xh,1,'小黑')，实例化
    xh.housework() #housework(xh)，调用实例方法
    xh.sayCountry() #实例化后调用类方法
    xh.help()  #静态方法可直接调用，也可实例化后再调用
    print(xh.country)

#结果：
Person
USA
这个类是造机器人的
self的内存地址: 2048490123392
小黑正在做家务
国籍是USA
Person
USA

四、抽象类和反射

1、抽象类：

import abc

class BaseCar(metaclass=abc.ABCMeta): #这个是一个抽象类，只是用来继承的
    def __init__(self,uid):
        self.uid = uid

    @abc.abstractmethod #如果抽象类里面的函数通过abstractmethod修饰，那就在子类里面必须实现
    def run(self):
        pass
    
class Bmw(BaseCar): #子类，继承父类BaseCar
    def run(self):  #重写父类里的抽象类
        print('run')

m = Bmw('uid') #因父类构造函数有参数uid，因此子类实例化的时候要传这个参数
m.run() #调用实例方法

 2、反射：

指程序可以访问、检测和修改它本身状态或行为的一种能力（自省）。python面向对象中的反射：即通过字符串的形式操作对象相关的属性；python中的一切事物都是对象（都可以使用反射）

四种可以实现自省的函数：1.hasattr 2.setattr 3.getattr 4.delattr

class Custom:
    feature='black'
    def __init__(self,name,addr):
        self.name=name
        self.addr=addr
    def buy_house(self):
        print('%s正在买房子'%self.name)
    def rent_house(self):
        print('%s正在租房子' %self.name)
z1=Custom('李梅','北京')
#对象是否有某种属性
print(hasattr(z1,'name'))  #True
print(hasattr(z1,'buy_house'))   #True
print(hasattr(z1,'zyy'))  #False
#取对象的某种属性
print(getattr(z1,'name'))  #李梅
print(getattr(z1,'rent_house'))
print(getattr(z1,'i am a sheep','没有这个属性')) #没有这个属性，找不到只会返回后面的值，不会报错
#为对象设置某种属性
setattr(z1,'李白',True)
print(z1.__dict__)  #{'name': '李梅', 'addr': '北京', '李白': True}
#删除对象某种属性
delattr(z1,'李白')
print(z1.__dict__)  #{'name': '李梅', 'addr': '北京'}

#结果
True
True
False
李梅
<bound method Custom.rent_house of <__main__.Custom object at 0x0000020FDC26E7F0>>
没有这个属性
{'name': '李梅', 'addr': '北京', '李白': True}
{'name': '李梅', 'addr': '北京'}