class Student:
def __init__(self,name):
self.__name = name
@property
def name(self): # 类中的函数，被property装饰器装饰好，就由函数伪装成了属性
return self.__name
# 当类中的函数，被@property装饰器，装饰后，且有同名函数的再实现 ，并且该函数又被setter装饰器装饰了的话，
@name.setter
# 那么对该 属性 进行 赋值操作，将触发被setter装饰器装饰的方法
def name(self,new):
if type(new) is str:
self.__name = new
student = Student("袁天军")
# print(student.name()) # 这是通对象的公共方法，来获得对象的私有属性__name
print(student.name) # 访问属性，就变成调用被@property装饰器装饰方法
student.name = "王大进"
print(student.name) #
class Goods:
__discount = 0.7
def __init__(self,name,price):
self.__price = price # 变量变形 _Goods__price,存放在对象名称空间里
self.name = name
@property
def price(self): # 通过 property装饰器，将被装饰函数伪装成类的属性
return self.__price
@price.setter # 对伪装的属性 进行 赋值操作时，触发被装饰函数的执行
def price(self,newPrice):
if type(newPrice) is int:
self.__price = newPrice
else:
print("价格修改失败")
@price.deleter # 对伪装属性进行，删除操作，触发被detter装饰器 装饰的函数的执行
def price(self):
del self.__price
pear = Goods("pear",10) # 实现化一个pear对象
apple = Goods("apple",5.8) # 实现化一个apple对象
print(pear.name)
print(apple.name)
print(pear.price)
print(apple.price)
pear.price = 22 # 对伪装的属性 进行 赋值操作时，触发被装饰函数的执行
print(pear.price)
pear.price = "aaa" # 价格修改失败
print(pear.__dict__) # {'_Goods__price': 22, 'name': 'pear'}
del pear.price # 对用detter装饰器伪装的属性，进行删除操作时，解被被装饰器函数的执行。
print(pear.__dict__) # {'name': 'pear'}
# 总结： 一个方法被伪装成属性之后，应该可以执行一个属性的 增删改查 操作
# 那么 增加 和 修改 操作， 就应对被setter装饰的方法，这个方法有一个必传的参数newPrice,表示赋值时等号 后面的值。
# 删除一个属性， 对应着 被deleter 装饰的方法，这个方法并不能在执行的时候真的删除这个属性，而是你在代码 中 执行什么就有
# 什么的效果。
# @classmethod 类方法装饰器
class Goods:
__discount = 0.9 # 类的私有静态属性,是共享属性，且只能在类中访问
def __init__(self,name,price):
self.__price = price # 对象 的 私有属性
self.name = name
@property
def discount(self):
# return self.__discount
return Goods.__discount
@property
def price(self):
return self.__price
def change_discount(self,new): # 类的普通方法
print(self) # <__main__.Goods object at 0x0000023B6AA35048> 类的对象
self.__discount = new # 对象.类变量 进行修改的操作，实际是在对象中创建一个新变量，对象不能修改类变量
@classmethod # classmethod 装饰器 装饰的方法，是类方法
def change_discount2(cls,new):
print(cls) # <class '__main__.Goods'> 是类名，类名相当于变量名，是指向类的指针
cls.__discount = new
def func(self):
print("sss")
banala = Goods("banala",6.2)
banala.change_discount(12.5)
print(banala.price) # 6.2
print(banala.discount) # 0.9
print(banala.__dict__) # {'_Goods__price': 6.2, 'name': 'banala', '_Goods__discount': 12.5}
banala.change_discount2(0.65) # 对于类方法，当对象调用类方法时，是将类对象指针，传递给 类方法的第一个参数的，通常取名cls
# 类方法，编程规范 用 类名 去调用
print(banala.discount)
print(Goods.discount) # <property object at 0x0000020071687A98>
Goods.func(11) # 类名 调用 类的普通函数，不会主动传参给第一个参数
# 类方法的特点：
# 只使用类中的资源，且这个资源，可以直接用类名去引用使用，那这个方法应该改写为类方法
# 类中的资源：
# 静态属性 （
# 普通方法
# 类方法
# property方法
class Student:
@staticmethod # 被staticmethod 装饰器 装饰的类中的方法，叫做静态方法，可以没有任何参数
def login():
print("in login")
def xx(self): # 普通方法，对象调用时，自动将对象传参给第一个参数，类调用时，不会主动传参，需要手动传参
pass
wang = Student()
Student.login() # in login
wang.login() # in login
# 类：
# 静态属性： 类 所有的对象都统一拥有的属性
# 类方法： 类 如果这个方法涉及到操作静态属性，类方法，静态方法 参数 cls 表示类
# 静态方法 类 普通方法，不使用类中的命名空间 也不使用对象 名称 空间，一个普通的函数，没有默认参数
# 普通方法 对象 self 表示对象
# property方法 对象 self 表示对象
# 类：
# 静态属性： 类 所有的对象都 统一拥有的属性
# 类方法 类 中的类，表示只能操作类中的资源即命名空间。如果这个方法涉及到操作静态属性、类方法，静态方法。
# 静态方法 类 普通方法， 不使用类中的命名空间，也不使用对象 的命名空间。即 既不会传对象 ，也不会传类 给第一个参数。
# 方法 对象 调用
#
# 关于type()方法 与 isinstance()方法 的区别？
# print(type("aaa")) # 判断一个对象的直接类
# print(isinstance("aaa",str)) # True 判断一个对象 是否是一个类的实例 ，支持继承的类
#
# class A:
# pass
#
# class B(A):
# pass
#
# a = A()
# b = B()
#
# print(type(a)) # <class '__main__.A'> type()方法，返回的是对象的直接类
# print(type(b)) # <class '__main__.A'>
#
# print(type(a) is A) # True
# print(type(b) is B) # True
#
# print(isinstance(a,A)) # True
# print(isinstance(b,A)) # True
# 最后，总结成词，type()方法，获取对象的直接类，即创建这个对象的类，
# 而isinstance()方法，判断一个对象 是否是它的直接类，或直接类的父类的实例
# 假设，现在有两个类 class A 和 class B ,且 class B 继承 class A ，那么当我通过 B(),实例化了一个B类的对象b，
# 这时 b 既是B类的实例 ，也是B类的父类A 的实例 。
