面对对象进阶2
类的封装
封装：隐藏属性或方法，外部无法使用，内部可以使用，再类定义阶段就执行了，真的想引用，就使__类名__属性名
隐藏模块内部的函数/变量_x:from module import *(无法导入)，from module import _x(不合理)
@property：被 @property 装饰的函数会从函数变成属性，也就是说直接.函数名，不需要加括号使用
class People:
def __init__(self,pwd):
self.__pwd = pwd
@property #被property 装饰的函数会从函数变成属性
def pwd(self):
return f'无法获取你的密码'
p = People('123')
print(p.pwd) #无法获取你的密码
对属性这个封装有什么用：藏起来，保护了你的隐私，类内部的属性不想让其他人访问，
class F1: # F1类名
__count = 0 # __count属性名
f= F1()
print(f._F1__count) #如果真的要拿,_类名__属性去拿（不可能这样做）
#0
对方法封装有什么好处：精简了代码，你吃饭就使用chifan这个方法就行了，不需要去关心其他的操作，并且外部调用者也不知道你内部发生了什么
class Foo:
def f1(self):
print('FOO.f1')
def f2(self):
print('Foo.f2')
self.f1()
class Bar(Foo):
def f1(self):
print('Bar.f1')
foo = Bar()
foo.f2() #先从Bar对象中寻找f2，再从Bar类中寻找f2，再从Bar的父类中的对象进行查找f2，找到了，再从Bar对象中寻找f1，找到了
Foo.f2
Bar.f1
class Foo:
def __f1(self):
print('FOO.f1')
def f2(self):
print('Foo.f2')
self.__f1()
print(Foo.__dict__) #类中所有的方法和属性,使用时点出来
class Bar(Foo):
def __f1(self):
print('Bar.f1')
bar = Bar() #执行Bar类，Bar类继承了Foo父类，可以使用父类中的所有方法
bar.f2() #使用父类中f2的函数,由于__f1()函数，在定义阶段，就已经被封装了,会把私有属性__f1变成__Foo__f1，之后都不会做这种处理
{'__module__': '__main__', '_Foo__f1': <function Foo.__f1 at 0x00D538A0>, 'f2': <function Foo.f2 at 0x00D53C90>, '__dict__': <attribute '__dict__' of 'Foo' objects>, '__weakref__': <attribute '__weakref__' of 'Foo' objects>, '__doc__': None}
Foo.f2
FOO.f1
class Foo():
__count = 0 #类的内部
foo = Foo()
print(foo)
foo.__y = 1 #类的外部
print(foo.__y)
<__main__.Foo object at 0x00B96B90>
1
类的property特性
@property：会让函数方法bmi()变成属性，我们就应该用@property。
@方法名.setter:被@方法名.setter装饰的函数，让这个函数方法bmi()可以进行属性一样的修改，所以@bmi.setter装饰器的函数方法必须是property装饰的函数方法名bmi(),而不可以是随意定义的函数名字，如果换成其他名字会报错，显示的就是该属性（实际是个函数）无法进行修改或删除
随意定义函数方法名是类属性方法使用property可以使用的
@方法名.deleter:被@方法名.deleter装饰的函数，方法名删除，会执行这个装饰的函数，
class People():
def __init__(self,height,weight):
self.height = height
self.weight = weight
@property #获取值的时候触发，你不需要加括号使用，不能加参数
def bmi(self):
return self.weight/(self.height**2)
@bmi.setter #修改bmi的时候触发，函数里面必须得加参数
def bmi(self,value):
print(f'你已经成功修改为{value}')
@bmi.deleter #在删除bmi的时候触发，函数里面不能加参数
def bmi(self):
print('delter')
peo = People(1.8,70)
print(peo.bmi)
print('*'*50)
peo.bmi = 50
print('*'*50)
del peo.bmi
21.604938271604937
**************************************************
你已经成功修改为50
**************************************************
delter
类与对象的绑定方法和非绑定方法
什么时候使用？
需要使用类做为参数的时候就得使用类绑定方法@classmethod
需要使用对象作为参数的时候就得使用对象绑定方法
既不需要类作为参数又不需要对象作为参数，使用费非绑定方法，@staticmethod
@classmethod让被装饰的函数给类使用，约定俗成参数为cls
绑定类的方法，类能使用，对象也可以使用，但是参数依然是类
@staticmethod什么都不绑定，非绑定方法，定义了普通的函数
class Foo:
#绑定给对象，只有对象能用，但是类也能使用，使用的时候必须得传参
def f1(self):
print(self)
@classmethod #让被装饰的函数给类使用，约定俗成参数为cls
#绑定给类的方法，类能使用，对象也可以使用，但是参数依然是类
@staticmethod #什么都不绑定，非绑定方法，定义了普通的函数
class Foo:
# 绑定给对象，只有对象能用，但是类也能使用，使用的时候必须得传参
def f1(self):
print(self)
@classmethod #让被装饰的对象给类使用，约定俗成参数为cls
def f2(cls):
print(cls)
# 什么都不绑定，非绑定方法，定义了普通的函数
@staticmethod
def f3(self):
print(self)
f = Foo() # 实例化对象
f.f1() #绑定给对象，对象使用功能
Foo.f1(1111) #类中使用对象的功能，需要添加参数,打印传参的值
print('*'*50)
Foo.f2() #类中使用对象的功能，
f.f2() #没有传参数，打印类的名字
print('*'*50)
Foo.f3(2222) #传参的值，就是打印的值
f.f3(2222) # 运行类中的函数，打印结果
<__main__.Foo object at 0x00B56BB0>
1111
**************************************************
<class '__main__.Foo'>
<class '__main__.Foo'>
**************************************************
2222
2222
python2中类属性调用的方法
对象的绑定方法：没有加任何装饰的方法就是对象的绑定方法
类的绑定方法：加了@classmethod装饰器的方法就是类的绑定方法
非绑定方法：加了staticmethod装饰器的方法就是非绑定方法，其实就是一个普通的函数