día 28 de tipo paquete

La introducción de una

La programación orientada a objetos tiene tres características: encapsulación, herencia, polimorfismo, la característica más importante es el paquete. El paquete se refiere a los datos y las funciones están integradas entre sí, no suena muy familiar, sí, hemos dicho antes "integrado", la palabra es en realidad un paquete de argumento popular. Además, para el paquete a un objeto o clase atributos, podemos controlar estrictamente el acceso a ellos, realizado en dos etapas: las interfaces abiertas y ocultas

Dos atributo oculto

Python es mecanismos dobles de clase subrayada empleadas en el inicio del atributo oculto manera (dispuestos privado), pero de hecho esto es sólo una variante de funcionamiento, cuando el comienzo de la clase de todas las propiedades son líneas dobles que caen en la detección gramática automática fase de definición de clase se convierte en "_ __ nombre de la clase nombre del atributo" forma:

class Foo:
    __N=0 # 变形为_Foo__N

    def __init__(self): # 定义函数时，会检测函数语法，所以__开头的属性也会变形
        self.__x=10 # 变形为self._Foo__x

    def __f1(self): # 变形为_Foo__f1
        print('__f1 run')

    def f2(self):  # 定义函数时，会检测函数语法，所以__开头的属性也会变形
        self.__f1() #变形为self._Foo__f1()

print(Foo.__N) # 报错AttributeError:类Foo没有属性__N

obj = Foo()
print(obbj.__x) # 报错AttributeError:对象obj没有属性__x

Este problemas de deformación que la atención necesidad son:

1, en las propiedades fuera de la clase no se puede acceder directamente al comienzo de la decadencia en la línea doble, pero ya se sabe los nombres de las clases y atributos que puede deletrear el nombre: nombre de la clase _ __ propiedad, entonces usted puede visitar, como Foo._A__N, por lo que este no hay límite de acceso externo y operar sobre el terreno en el sentido estricto, sólo una deformación del significado gramatical.

>>> Foo.__dict__
mappingproxy({..., '_Foo__N': 0, ...})

>>> obj.__dict__
{'_Foo__x': 10}

>>> Foo._Foo__N
0
>>> obj._Foo__x
10
>>> obj._Foo__N
0

2, dentro del atributo de clase es líneas directamente accesibles dobles que comienzan a disminuir, como self .__ f1 (), ya que una deformación uniforme en la definición de clase en el principio de la doble tipo de fase interna propiedades de línea declive.

>>> obj.f2()
__f1 run

3, una vez que la definición de la asignación de clase tras la modificación se produce sólo durante la etapa de la definición de clase, no va a ser deformado.

>>> Foo.__M=100
>>> Foo.__dict__
mappingproxy({..., '__M': 100,...})
>>> Foo.__M
100

>>> obj.__y=20
>>> obj.__dict__
{'__y': 20, '_Foo__x': 10}
>>> obj.__y
20

Tres interfaces abiertas

Las propiedades personalizadas es de uso, no es el propósito de su escondite

3.1 Datos atributo oculto

La clase de datos oculta limita operación externa directa sobre los datos, entonces la interfaz debe proporcionar clase permitida datos de operación externos indirectos, la interfaz puede estar unido en la lógica adicional para controlar estrictamente la operación de los datos

>>> class Teacher:
...     def __init__(self,name,age): #将名字和年纪都隐藏起来
...         self.__name=name
...         self.__age=age
...     def tell_info(self): #对外提供访问老师信息的接口
...         print('姓名:%s,年龄:%s' %(self.__name,self.__age))
...     def set_info(self,name,age): #对外提供设置老师信息的接口，并附加类型检查的逻辑
...         if not isinstance(name,str):
...             raise TypeError('姓名必须是字符串类型')
...         if not isinstance(age,int):
...             raise TypeError('年龄必须是整型')
...         self.__name=name
...         self.__age=age
... 
>>>
>>> t=Teacher('lili',18)
>>> t.set_info(‘LiLi','19') # 年龄不为整型，抛出异常
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 11, in set_info
TypeError: 年龄必须是整型
>>> t.set_info('LiLi',19) # 名字为字符串类型，年龄为整形，可以正常设置
>>> t.tell_info() # 查看老师的信息
姓名:LiLi,年龄:19

3.2 Funciones propiedad oculta

El propósito es aislar la complejidad, tales como retiros en cajeros automáticos del programa funcional, que cuenta con muchos otros componentes funcionales, tales como tarjetas, autenticación, introduzca la cantidad, impresión de billetes pequeños, retiros, etc., pero para los usuarios que sólo necesitan retiros pueden desarrollar esta interfaz de la función, podemos toda la funcionalidad del resto escondido

>>> class ATM:
...     def __card(self): #插卡
...         print('插卡')
...     def __auth(self): #身份认证
...         print('用户认证')
...     def __input(self): #输入金额
...         print('输入取款金额')
...     def __print_bill(self): #打印小票
...         print('打印账单')
...     def __take_money(self): #取钱
...         print('取款')
...     def withdraw(self): #取款功能
...         self.__card()
...         self.__auth()
...         self.__input()
...         self.__print_bill()
...         self.__take_money()
...
>>> obj=ATM()
>>> obj.withdraw()

Resume las interfaces de atributos y abiertos ocultos, la esencia es distinguir claramente entre el interior y el exterior, el interior de la clase puede modificar algo en un paquete sin afectar a la persona que llama externa código, y fuera de la clase sólo para tener una interfaz, siempre y cuando el nombre de la interfaz, los parámetros sin cambios, no importa cómo el diseñador para cambiar el código de aplicación interna, los usuarios no tienen necesidad de cambiar el código. Esto proporciona una buena base para la cooperación, siempre y cuando la interfaz para el mismo acuerdo básico, modificar el código de causa de preocupación.

cuatro propiedad

Índice IMC es un indicador utilizado para medir el peso de una persona y los efectos de la altura y de salud, se calcula como

体质指数（BMI）=体重（kg）÷身高^2（m）
EX：70kg÷（1.75×1.75）=22.86

Altura o el peso está en constante cambio, por lo que cada vez que desee ver los valores de IMC tienen que ser calculados antes, pero obviamente suena IMC más como una característica más que funcional, para Python decorador especializado en una propiedad, se puede en la clase de "encubierta" propiedad de datos del objeto, la propiedad del objeto cuando se accede a que la función ejecución particulares disparadores, y el valor de retorno como resultado de esta visita, por ejemplo,

>>> class People:
...     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)
...
>>> obj=People('lili',75,1.85)
>>> obj.bmi #触发方法bmi的执行，将obj自动传给self，执行后返回值作为本次引用的结果
21.913805697589478

Utilice la propiedad garantizar de forma eficaz la consistencia de acceso a la propiedad. En la propiedad Además también proporciona una función de configuración y las propiedades de eliminación, de la siguiente manera

>>> class Foo:
...     def __init__(self,val):
...         self.__NAME=val #将属性隐藏起来
...     @property
...     def name(self):
...         return self.__NAME
...     @name.setter
...     def name(self,value):
...         if not isinstance(value,str):  #在设定值之前进行类型检查
...             raise TypeError('%s must be str' %value)
...         self.__NAME=value #通过类型检查后,将值value存放到真实的位置self.__NAME
...     @name.deleter
...     def name(self):
...         raise PermissionError('Can not delete')
...
>>> f=Foo('lili')
>>> f.name
lili
>>> f.name='LiLi' #触发name.setter装饰器对应的函数name(f,’Egon')
>>> f.name=123 #触发name.setter对应的的函数name(f,123),抛出异常TypeError
>>> del f.name #触发name.deleter对应的函数name(f),抛出异常PermissionError