python's twenty-second day for me 封装，property方法

面对对象的三大特性：继承，多态，封装。

　　函数和属性装到了一个非全局的命名空间----封装。

封装：

　　　　在类中，静态属性，方法，对象属性都可以变成私有的，只需要在这些名字前加上‘__’(双下划线)。

　　　　在类内，只要你的代码遇到‘__’(双下划线).名字，就会被python解释器自动转换_类名__名字。

class A:
    __N = 'aaa'     # 静态变量
    def func(self):
        print(A.__N)    # 在类的内部使用正常 ‘aaa’
print(A.__dict__)   #  会以这种形式存储到字典中：{'_A__N': 'aaa'}
# print(A.__N)        # 直接在外部调用会报错
# print(A._A__N)      # 所以可以使用这种方式调用，但是不能这样调用。
a = A()
a.func()
# 一个私有的名字，在存储的过程中仍然会出现在A.__dict__中，所以我们仍然可以调用到。
# python对其的名字进行了修改：_类名__名字。
# 只不过在类的外部调用: '_类名__名字'去使用。
# 在类的内部可以正常的使用名字调用。

　　私有的名字不能被子类继承：

class D:
    def __func(self):       # _D_func
        print('in func')
class E(D):
    def __init__(self):
        self.__func()     # 它会找   _E__func 这样的名字。

e = E()  #  会报错，因为私有的名字不能被继承，

class D:
    def __init__(self):
        self.__func()       # 在哪个类中定义的名字就会以固定方式存储： _D__func
    def __func(self):       # _D__func
        print('in D')
class E(D):
    def __func(self):    # _E__func
        print('in E')
e = E()

# 私有的名字，在类内使用的时候，就是会变成：   _该类名__方法名
# 以上为例：没有双下划线会先找E中的func
# 但是有了双下划线，会在调用这个名字的类D中直接找_D__func

　　变形只在类的内部发生：

class F:pass
F.__name = 'alex'   # 并不是创建私有属性。
print(F.__name)
print(F.__dict__)       # {'__name': 'alex'}  并不是私有属性

Java中的对比：

　　public　　共有的　　在类的内部可以使用，子类可以使用，外部可以使用　　python中所有正常的名字。

　　prctect　　保护的　　在类的内部可以使用，子类可以使用，外部不可以使用，　　python中没有

　　private　　私有的　　只能在类的内部使用，子类和外部都不可以使用　　python中的  __名字。（双下划线）

私有的用法：

　　  1，当一个方法不想被子类继承的时候。

　　2，有些属性或者方法不希望从外部被调用，只想提供给内部的方法使用。

@property　　能够将一个方法伪装成一个属性。将代码变得更美观。

从原来的对象的对象名.方法名()，变成了对象名.方法名。

class Person:
    def __init__(self,name,weight,height):
        self.name = name
        self.__height = height
        self.__weight = weight
    @property
    def bmi(self):
        return self.__weight/self.__height**2
print(Person.__dict__)
p = Person('顾小白',70,1.75)
print(p.__dict__)    #{'name': '顾小白', '_Person__weight': 70, '_Person__height': 1.75}
# 被property装饰的bmi仍然是一个方法，存在Person.__dict__
# 对象的.__dict__中不会存储这个属性。

# 在一个类加载的过程中，会先加载这个的名字，包括被property装饰的。
# 在实例化对象的时候，python解释器会先到类的空间里看看有没有这个被装饰的属性。
# 如果有就不能在自己的对象空间中创建这个属性了。

@property ---> func　　将方法伪装成属性，只能看，不能对之操作。

@func.setter ---> func　　对伪装的属性进行赋值的时候调用这个方法，一般情况用来修改属性。

@func.deleter ---> func　　在执行del 对象.func的时候调用这个方法，一般情况用来删除属性，一般不用。

class Person:
    def __init__(self,name):
        self.__name = name   # 私有属性
    @property       # 将方法装饰成属性使用。  现在 p.name 相当于 p.name()
    def name(self):
        return self.__name
    @name.setter
    def name(self,new_name):
        if type(new_name) is str:       # 类型不对无法替换，防止乱改。
            self.__name = new_name  # 将new_name 赋值给 self.__name 这一步改变了值。
        else:
            print('类型不对，无法替换...')
    @name.deleter       
    def name(self):
        del self.__name     # 删除self.__name属性
p = Person('alex')
print(p.name)       # alex
p.name = 'alex_sb'
print(p.name)       # alex_sb
del p.name
print(p.name)  # 报错：AttributeError: 'Person' object has no attribute '_Person__name'

@classmethod : 类方法，可以直接被类调用，不需要默认传对象参数，只需要传一个类参数就行了。

# 全场改动折扣，不能单个改动。
class Goods():
    __discount = 0.8    # 静态属性
    def __init__(self,name,origin_price):
        self.name = name
        self.__price = origin_price
    @property
    def price(self):
        return self.__price * Goods.__discount
    @classmethod
    def change_discount(cls,new_discount):
        cls.__discount = new_discount
Goods.change_discount(1)        # 可以在实例化之前使用。
g = Goods('薯片',10)
print(g.price)

staticmethod:

　　当一个方法要使用对象的属性时，就是使用普通的方法。

　　当一个方法要使用类中的静态属性时，就是用类方法。

　　当一个方法要既不使用对象的属性也不使用类中的静态属性时，就可以使用 staticmethod 静态方法。

class Student:
    def __init__(self,name):pass
    @staticmethod
    def login():    # login就是一个类中的静态方法，静态方法没有默认参数，就当成普通函数。
        pass

Student.login()