python之路 -- 面向对象进阶

property、classmethod、staticmethod

1.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)     
# 圆的面积   #之前的调用方法为c1.area()
print(c1.perimeter) 
# 圆的周长   #之前的调用方法为c1.perimter()

#练习
#BMI指数（BMI是计算而来的，但很明显它听起来像是一个属性而非方法，如果我们将其做成一个属性，更便于理解）
# 成年人的BMI数值
# 过轻：低于18.5
# 正常：18.5~23.9
# 过重：24~27
# 肥胖：28~32
# 非常肥胖：28~32
#     体质指数（BMI）=体重（kg）/身高^2(m)
#     例如:70kg÷（1.75*1.75）=22.86

class People:
    def __init__(self,name,high,weight):
        self.name = name
        self.high = high
        self.weight = weight

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

xiaoli = People("小黎",1.66,47)
print(xiaoli.bmi()) #未加@property时，用此调用
print(xiaoli.bmi)   #加了@property时，用此调用

class Goods:
    def __init__(self):
        # 原价
        self.original_price = 100
        # 折扣
        self.discount = 0.8

    @property
    def price(self):
        # 实际价格 = 原价 * 折扣
        new_price = self.original_price * self.discount
        return new_price

    @price.setter    #使用了这个可以修改类中的属性
    def price(self, value):
        self.original_price = value

    @price.deleter
    def price(self):
        del self.original_price
        print('已删除')
obj = Goods()
print(obj.price)  # 获取商品价格
obj.price = 100   # 修改商品原价
print(obj.price)
del obj.price     # 删除商品原价
#执行del,会调用deleter装饰的方法

#执行结果为：
# 80.0
# 80.0
# 已删除

classmethod   类方法

把一个方法 变成一个类中的方法，这个方法就直接可以被类调用，不需要依托任何对象

class Classmethod_Demo():
    role = 'dog'

    @classmethod
    def func(cls):
        print(cls.role)

Classmethod_Demo.func()
#输出结果为：dog

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):  # 修改折扣
        cls.__discount = new_discount
apple = Goods('苹果',5)
print(apple.price)  #--》4.0
Goods.change_discount(0.5)   # Goods.change_discount(Goods)
print(apple.price)  #--》2.5
# 当这个方法的操作只涉及静态属性的时候 就应该使用classmethod来装饰这个方法

staticmathod 静态的方法

用staticmethod将这个函数变成一个静态方法

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

    @staticmethod
    def get_usr_pwd():   # 静态方法
        usr = input('用户名 ：')
        pwd = input('密码 ：')
        Login(usr,pwd)

Login.get_usr_pwd()
# 在完全面向对象的程序中，
# 如果一个函数 既和对象没有关系 也和类没有关系 那么就用staticmethod将这个函数变成一个静态方法

# 类方法和静态方法 都是类调用的

# 对象可以调用类方法和静态方法。但是，一般情况下 推荐用类名调用

# 类方法 有一个默认参数 cls 代表这个类 cls

# 静态方法 没有默认的参数 就像函数一样

---

内置函数isinstance()和issubclass()

isinstance(obj,cls)检查是否obj是否是类 cls 的对象

issubclass(sub, super)检查sub类是否是 super 类的子类

class A:pass
class B(A):pass
a = A()
print(isinstance(a,A)) ->True   #检查对象a是否是类A中的对象，是返回True
print(issubclass(B,A)) ->True   #检查类B是否是类A的子类
print(issubclass(A,B)) ->False

---

反射

python面向对象中的反射：通过字符串的形式操作对象相关的属性。

python中的一切事物都是对象（都可以使用反射）

面向对象中的几个内置函数

　　——hasattr,setattr,getattr,delattr

class Foo:
    f = '类的静态变量'
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say_hi(self):
        print('hi,%s'%self.name)

obj=Foo('egon',73)

#检测某个类是否含有某属性
print(hasattr(obj,'name'))    
print(hasattr(obj,'say_hi'))

#获取某个类中的属性
#第一个位置为所属的对象，第二个为变量的字符串形式
n=getattr(obj,'name')    #等价于obj.name
print(n)
func=getattr(obj,'say_hi')
func()

print(getattr(obj,'aaaaaaaa','不存在啊')) #报错

#设置属性
setattr(obj,'*名字*',True)
setattr(obj,'show_name',lambda self:self.name+'-名字')
print(obj.__dict__)
print(obj.show_name(obj))

#删除属性
delattr(obj,'age')
delattr(obj,'show_name')
# delattr(obj,'show_name111')#不存在,报错

print(obj.__dict__)

输出结果为：
True
True
egon
hi,egon
不存在啊
{'name': 'egon', 'age': 73, '*名字*': True, 'show_name': <function <lambda> at 0x000002DBD32D2E18>}
egon-名字
{'name': 'egon', '*名字*': True}

__str__、__repr__

当使用print输出对象的时候，只要自己定义了__str__(self)方法，那么就会打印从在这个方法中return的数据 

class Car:
    def __init__(self, newWheelNum, newColor):
        self.wheelNum = newWheelNum
        self.color = newColor

    def __str__(self):
        msg = "嘿。。。我的颜色是" + self.color + "我有" + int(self.wheelNum) + "个轮胎..."
        return msg

    def move(self):
        print('车在跑，目标:夏威夷')

BMW = Car(4, "白色")
print(BMW)
#输出结果：嘿。。。我的颜色是白色，我有4个轮胎...

class B:
    def __str__(self):
        return 'str : class B'

    def __repr__(self):
        return 'repr : class B'

b = B()
print('%s' % b)
print('%r' % b)
#执行结果为：
# str : class B
# repr : class B

__del__

创建对象后，python解释器默认调用__init__()方法；

当删除一个对象时，python解释器也会默认调用一个方法，这个方法为__del__()方法

(在实例化一个对象的时候也会调用__del__方法)

class Foo:

    def __del__(self):
        print('执行我啦')

f1=Foo()
del f1
print('------->')

#输出结果
执行我啦
------->
#在调用del时自动执行了类的内部__del__方法

__getitem__、__setitem__、__delitem__

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

    def __getitem__(self, item):
        print(self.__dict__[item])

    def __setitem__(self, key, value):
        self.__dict__[key]=value
    def __delitem__(self, key):
        print('del obj[key]时,我执行')
        self.__dict__.pop(key)
    def __delattr__(self, item):
        print('del obj.key时,我执行')
        self.__dict__.pop(item)

f1=Foo('sb')
f1['age']=18
f1['age1']=19
del f1.age1
del f1['age']
f1['name']='alex'
print(f1.__dict__)

#执行结果为：
# del obj.key时,我执行
# del obj[key]时,我执行
# {'name': 'alex'}

__new__

__new__至少要有一个参数cls，代表要实例化的类，此参数在实例化时由Python解释器自动提供

__new__必须要有返回值，返回实例化出来的实例，这点在自己实现__new__时要特别注意，可以return父类__new__出来的实例，或者直接是object的__new__出来的实例

class A(object):
    def __init__(self):
        print("这是 init 方法")

    def __new__(cls):
        print("这是 new 方法")
        return object.__new__(cls)

A()
#输出结果为：
#这是init方法
#这是new方法

类在实例化的时候会自动执行__init__方法和__new__方法 

class A:
    def __init__(self):
        self.x = 1
        print('in init function')
    def __new__(cls, *args, **kwargs):
        print('in new function')
        return object.__new__(A, *args, **kwargs)

a = A()
#实例化时自动会调用__new__方法和__init__方法，先调用__new__方法

#执行结果为：
# in new function
# in init function

class Foo(object):
    def __init__(self):
        print(111)

    def __new__(cls, *args, **kwargs):
        return 'new'

obj = Foo()
print(obj)

# new

# 只会输出new，不会打印111

__call__

对象后面加括号，触发执行。
注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()

class Foo:
    def __init__(self):
        pass
    
    def __call__(self, *args, **kwargs):

        print('__call__')

obj = Foo() # 执行 __init__
obj()       # 执行 __call__

#执行结果：__call__

__len__

class A:
    def __init__(self):
        self.a = 1
        self.b = 2
        self.c = 1

    def __len__(self):
        return len(self.__dict__)   #返回内中属性的个数
a = A()
print(len(a))
#执行结果为：3
#执行len方法会自动调用类中的__len__方法

__hash__

class A:
    def __init__(self):
        self.a = 1
        self.b = 2

    def __hash__(self):
        return hash(str(self.a)+str(self.b))
a = A()
print(hash(a))
#类的外部执行hash()时会调用类中的__hash__方法

__eq__

当判断两个对象的值是否相等时，就会执行类中__eq__方法,且得到的返回值将和在类中定义的__eq__的返回值的真假一致

class A:
    def __init__(self):
        self.a = 1
        self.b = 2

    def __eq__(self,obj):
        if  self.a == obj.a and self.b == obj.b:
            return True
a = A()
b = A()
print(a == b)
#True

文章中大部分实例都来自Eva_J老师的文章，原文见博客