【封装】
隐藏对象的属性和实现细节，仅对外提供公共访问方式。
【好处】
1. 将变化隔离；
2. 便于使用；
3. 提高复用性；
4. 提高安全性；
【封装原则】
1. 将不需要对外提供的内容都隐藏起来；
2. 把属性都隐藏，提供公共方法对其访问。
私有变量和私有方法
在python中用双下划线开头的方式将属性隐藏起来（设置成私有的）
# 私有的用途：
# 当一个方法不想被子类继承的时候
# 有些属性或者方法不希望从外部被调用，只想提供给内部的方法使用
# java中的对比 # public 公有的 在类的内部可以使用，子类可以使用，外部可以使用 python中所有正常的名字 # protect 保护的 在类的内部可以使用，子类可以使用，外部不可以使用 python中没有 # private 私有的 只能在类的内部使用，子类和外部都不可以使用 python中的__名字
# 描述一个房子 #单价 #面积 class Room: def __init__(self,name,price,length,width,height): self.name = name self.price = price self.__length = length self.__width = width self.height = height @property def area(self): return self.__length * self.__width r = Room('peng',100,2,1,5) print(r.name) print(r.area)
# 一个私有的名字，在存储的过程中仍然会出现在A.__dict__中，所以我们仍然可以调用到
# python对其的名字进行了修改：__类名__名字
# 只不过在类的外部调用：需要'_类名__名字'去使用
# 在类的内部可以正常的使用名字
class Person: # def __init__(self,name,pwd): # self.name = name # self.__pwd(pwd) # def __pwd(self,pwd): # # '12345' ---> ascii ---> 2175981070935 # self.my_secret_pwd = 2175981070935
# _A__N # 在类内 只要你的代码遇到__名字，就会被python解释器自动的转换成_类名__名字 # 私有的属性 class B: def __init__(self,name): self.__name = name def func(self): print('in func: %s'%self.__name) b = B('alex') print(b._B__name) b.func()
# 私有的方法 class C: def __wahaha(self): print('wahaha') def ADca(self): self.__wahaha() c= C() c._C__wahaha() c.ADca()
# 在类中，静态属性，方法，对象属性都可以变成私有的，只要在这些名字之前加上__
class D: def __func(self): #存储'_D__func' print('in func') class E(D): def __init__(self): # self.__func() 报错 self._D__func() #'_E__func' e = E()
》》》in func
#私有的名字不能被子类继承 class D: def __init__(self): self.__func() #_D__func def __func(self): print('in D') class E(D): def __func(self): print('in E') e = E()
》》》in D
class D: def __init__(self): self.__func() #_D__func def __func(self): print('in D') class E(D): def _D__func(self): print('in E') e = E()
>>>in E
# 私有的名字，在类内使用的时候，就是会变形成 _该类名__方法名
# 以此为例，没有双下划线会找到E中的func
# 但是有了双下划线，会在调用这个名字的类D 中直接找_D__func
class F:pass F.__name = 'alex' #不是在创建私有属性，只有在类的内部才关心下划线操作，变形只在类的内部发生，不会在外部发生 print(F.__name) print(F.__dict__)
alex
{'__dict__': <attribute '__dict__' of 'F' objects>, '__module__': '__main__', '__doc__': None, '__weakref__': <attribute '__weakref__' of 'F' objects>, '__name': 'alex'}
class F: def ADCa(self): self.__name = 'alex' f = F() f.ADCa() # print(f.__name) #报错 print(f._F__name) 真正工作的时候不可以这么写，只是为了应付面试
Property
例一：BMI指数（bmi是计算而来的，但很明显它听起来像是一个属性而非方法，如果我们将其做成一个属性，更便于理解） 成人的BMI数值： 过轻：低于18.5 正常：18.5-23.9 过重：24-27 肥胖：28-32 非常肥胖, 高于32 体质指数（BMI）=体重（kg）÷身高^2（m） EX：70kg÷（1.75×1.75）=22.86 class Person: def __init__(self,name,weight,height): self.name = name self.__weight =weight self.__height = height @property def BMI(self): return self.__weight /self.__height ** 2 kate = Person('kate',58,1.59) print(round(kate.BMI)) print(round(kate.BMI)) print(Person.__dict__) BMI': <property object at 0x102138958>,
BMI 是个名词
将一个方法伪装成一个属性
并不会让你的代码有什么逻辑上的提高
只是从调用者的角度上换了一种方式，使它看起来更合理
有了property装饰，bmi不能重名，也不能重新赋值，否则会报错，说白了就是只能看了，不能修改
@property能够将一个方法伪装成一个属性
从原来的对象名.方法名()变成了对象名.方法名
只是让代码变得更美观，并不会起到改变逻辑的作用
被property装饰的bmi仍然是一个方法 存在Person.__dict__
对象的__dict__ 中不会存储这个属性
在一个类加载的过程中，会先加载这个中的名字，包括被property装饰
在实例化对象的时候，python解释器会先到类的空间里看看有咩有这个被装饰的属性
如果有就不能再在自己的空间中创建这个属性了
# 将方法伪装成属性，方法中一般设计的就是一些计算过程
from math import pi class Circle: def __init__(self,r): self.r = r @property def area(self): return pi * self.r**2 @property def perimeter(self): return pi * 2* self.r p = Circle(10) print(round(p.area)) print(round(p.perimeter))
# 这样不能随意改姓名name,并且通过setname约束 class Person: def __init__(self,name): self.__name = name #私有的属性 @property def name(self): return self.__name def set_name(self,newname): if type(newname) is str: self.__name = newname else: print('您输入的姓名数据类型不合法') p = Person('alex') p.set_name('alex_sb') # p.set_name(123) 报错 print(p.name)
# 方法伪装成的属性的修改 class Person: def __init__(self,name): self.__name = name #私有的属性 @property def name(self): return self.__name @name.setter def name(self,newname): if type(newname) is str: print(newname) else: print('数据类型错误') p = Person('alex') print(p.name) #def name(self) p.name = 'SBBBBBB' #def name(self,newname): print(p.name) #def name(self) p.name = 123 print(p.name) #三个name必须一致
alex
SBBBBBB
alex
数据类型错误
#方法伪装成属性的删除
class Person: def __init__(self,name): self.__name = name @property def name(self): return self.__name @name.deleter def name(self): print('name 被删除') # @name.deleter # def name(self): # del self.__name #这个可以真正删除 p = Person('egon') print(p.name) del p.name #只相当于执行了被@name.deleter这个函数，并没有真正删除 print(p.name)
# @property--->func 将方法伪装成属性，只是看的事儿
# @func.setter ---->func 让伪装的属性进行赋值的时候用这个方法
# @func.deleter --->func 在执行del对象，func的时候调用这个方法，一般情况不用
# 商品的折扣
# 想看折后价格
class Goods:
def __init__(self,name,price,discount): self.name = name self.__price = price self.__discount = discount @property def price(self): return self.__price *self.__discount @price.setter def price(self,new_price): if type(new_price) is int or type(new_price) is float: self.__price = new_price else: print('您输入的数据类型错误') apple = Goods('apple',5,0.8) print(apple.price) # 修改苹果价格 apple.price = 8 print(apple.price)
店庆全场八折# 折扣结束 折扣变了 恢复折扣 class Product: __discount = 0.8 def __init__(self,name,price): self.name = name self.__price = price @property def price(self): return self.__price * Product.__discount @classmethod #不依赖对象的方法，就应该定义为类方法，类方法可以任意的操作类中的静态变量 def change_discount(cls,new_discount): # 类方法，可以直接被类调用，不需要默认传对象参数，只需要传一个类参数就可以了 cls.__discount = new_discount Product.change_discount(1) apple = Product('apple',5) banana = Product('banana',8) print(apple.price) print(banana.price)
#使用什么样的方法要看具体用到了哪些名称空间中的值
# 当一个方法要使用对象的属性时，就使用普通的方法
# 当一个方法要使用类中的静态属性时，就使用类方法
# 当一个方法既不使用对象的属性也不使用类中的静态属性时，就可以使用staticmethod静态方法
# def login(): # user= input('user :') # if user == 'alex':print('success') # else :print('faild') # # login() class Student: def __init__(self,name):pass @staticmethod def login(a): # login就是一个类中的静态方法 静态方法没有默认参数 就当成普通的函数使用即可 user = input('user :') if user == 'alex': print('success') else: print('faild') Student.login(1)
class A: __role = 'CHINA' @classmethod def show_role(cls): print(cls.__role) @staticmethod def get_role(): return A.__role @property def role(self): return self.__role a = A() print(a.role) print(a.get_role()) a.show_role()
CHINA
CHINA
CHINA