《Python》 property、classmethod、staticmethod、isinstance、issubclass

import math
class Circle:
    def __init__(self,radius): #圆的半径radius
        self.radius=radius

    @property
    def area(self):
        return math.pi * self.radius**2 #计算面积

    @property
    def perimeter(self):
        return 2*math.pi*self.radius #计算周长

c=Circle(10)
print(c.radius)
print(c.area) #可以向访问数据属性一样去访问area,会触发一个函数的执行,动态计算出一个值
print(c.perimeter) #同上
‘‘‘
输出结果:
314.1592653589793
62.83185307179586
‘‘‘

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

    @property   # 把方法伪装成属性
    def name(self):
        return self.__name

    @name.setter    # 用setter装饰一个跟property同名的方法
    def name(self,new):
        if type(new) is str:
            self.__name = new

obj = Student(‘小明‘)
print(obj.name)     # 小明
obj.name = ‘小红‘   # 赋值的时候，就触发被setter装饰器装饰的方法
print(obj.name)     # 小红

# 好处：用来保护一个变量，在修改的时候能够添加一些保护条件

class Goods:
    __discount = 0.8    # 全场8折
    def __init__(self,price):
        self.__price = price    # 商品原价

    @property
    def price(self):
        return Goods.__discount * self.__price  # 折后价

    @price.setter
    def price(self,new):
        self.__price = new  # 更改原价

    @price.deleter
    def price(self):
        del self.__price    # 删除商品价格

apple = Goods(10)
print(apple.price)  # 8.0
apple.price = 8　　　# 重新赋值
print(apple.price)  # 6.4
del apple.price     # 删除属性

# 一个方法被伪装成属性后
# 应该可以执行一个属性的增删改查操作
# 那么增加和修改，就对应这setter装饰的方法：这个方法有一个必传的参数new，表示赋值的时候等号后面的值
# 删除一个属性，对应着被deleter装饰的方法，这个方法并不能在执行的时候真的删除这个属性，而是你在代码中执行什么就有什么效果

class A:
    def __init__(self):
        self.__f = open(‘aaa‘,‘w‘)
        
    @property
    def f(self):
        return self.__f
    
    @f.deleter
    def f(self):
        self.__f.close()    # 删除一个文件，要先关闭文件
        del self.__f

class Goods:
    __discount = 0.8    # 静态属性（全场8折）
    def __init__(self,price):
        self.__price = price    # 对象属性
        self.name = ‘apple‘

    @property
    def price(self):
        print(self)
        return self.__price * Goods.__discount  # 折后价

    @classmethod
    def change_discount(cls,new):   # 类方法
        cls.__discount = new

# Goods.change_discount(0.7)  # 把折扣价改成7折
# print(Goods.__dict__)
‘‘‘
{‘__module__‘: ‘__main__‘, ‘_Goods__discount‘: 0.7, ‘__init__‘: ,    ‘price‘: , ‘change_discount‘: ,    ‘__dict__‘: ,    ‘__weakref__‘: , ‘__doc__‘: None}
‘‘‘

apple = Goods(10)
banana = Goods(20)
apple.change_discount(0.7)  # 把折扣价改成7折
print(apple.price)  # 7
print(banana.price) # 14

# 类：
# 　　静态属性　　类　　所有的对象都统一拥有的属性　　　　　　　　　　　　　　　　　　　　　　　　
# 　　类方法　　　类　　如果这个方法涉及到操作静态属性、类方法、静态方法　　　　　　　　　　　　　　cls 表示类
# 　　静态方法　　类　　普通方法，不使用类中的命名空间也不使用对象的命名空间 ： 一个普通的函数　　　没有默认参数
# 　　方法　　　　对象　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　self 表示对象
# 　　property　 对象　　

class Staticmethod_Demo():
    role = ‘dog‘

    @staticmethod
    def func():
        print("当普通方法用")

Staticmethod_Demo.func()

class Foo:
    @classmethod
    def class_method(cls):pass

    @staticmethod
    def static_method():pass

from types import MethodType,FunctionType
obj = Foo()
print(isinstance(Foo.class_method,MethodType))      # True  判断它是否一个方法
print(isinstance(Foo.static_method,FunctionType))   # True  判断它是否一个函数
print(obj.class_method)     # >
print(obj.static_method)    # 

print(type(123) is int)     # True
print(isinstance(123,int))  # True

class A:
    pass
class B(A):
    pass
a = A()
b = B()
print(type(a) is A) # True
print(type(a) is B) # False
print(type(b) is A) # False
print(type(b) is B) # True

print(isinstance(a,A))  # True
print(isinstance(b,A))  # True
print(isinstance(a,B))  # False
print(isinstance(b,B))  # True

# isinstance就是检测对象与类之间的关系

class A:
    pass
class B(A):
    pass
print(issubclass(A,B))  # False
print(issubclass(B,A))  # True

# issubclass就是检测类与类之间的关系