封装和 property方法

封装其实就是一个类用双下划线把自己的属性或者方法给限制住 不让其他的类直接调用或者修改  必须通过这个类来进行操作，这个类通过双下划线__把自己的属性和方法给限制住了

封装就是私有的过程 把父类中的属性和方法用双下划线__给装饰后就是只能这个类中使用了 你想使用的需要这个父类名或者super（）来掉用 字类不可以继承这个方法或属性了  但是在python解释器中 你私有的过程它的存储是以_类名__私有的内容   来存储的
当你的代码中遇到__名字   python解释器就会自动把它转化为_类名__名字的内容
当你私有的过程你在内存中的存储会以_类名__你私有的方法或者属性名存储 你在外部不可以直接的调用 
父类私有的属性或者方法你子类无法继承：

class D(object):
    def __init__(self, name, sex):
        self.name = name
        self.__sex =sex
    def __func(self):
        print('in D')
class  E(D):  #E继承D
    def func1(self):
        print(111)

d = D('ni', 'hao')
e = E ('说', '不')  #因为继承了父类的init方法你需要给继承的init方法传递参数  已经默认继承了 会自动给你的对象的内存空间内分配init内的属性
e.__func()  #调用父类方法  这肯定会报错因为父类的方法已经给私有了你不可以调用的

class D(object):
    def __init__(self, name, sex):
        self.name = name
        self.__sex =sex
    def __func(self):
        print('in D')
d = D('ni', 'hao')
print(d.__dict__)  #大家看到没有 私有的属性会自动改成_类名__属性名存储起来
# d._D__func()  #一定不可以这个样你这样是错误的写法  因为大家都不这样写 你这样写就会直接被公司pass

# 在类中，静态属性，方法，对象属性都可以变成私有的，只需要在这些名字之前加上__

# class D:
# def __func(self): # '_D__func'
# print('in func')
#
# class E(D):
# def __init__(self):
# self.__func() # '_E__func'
# e = E()

给大家来两道面试题 掌握了它你就掌握了封装：

上一题就是：

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

property方法：

这是一个可以让你使用的时候省略方法的括号的方法  你引用这个类似于装饰器的方法

就好比你在调用方法的时候需要加上括号 但是你用了这个类似于装饰器的方法修饰后就不会这样了  只选哟类名.方法名 不需要加括号

class Person(object):
    def __init__(self, name, weight,height):
        self.name = name
        self.__weight = weight
        self.__height = height
    @property
    def add(self):
        return self.__weight/self.__height**2

p =Person('alex', 78,1.8)
# print(p.add)  # 因为被property装饰过后就不需要加括号了
print(p.__dir__())

将一个方法伪装成一个属性
并不会让你的代码有什么逻辑上的提高
只是从调用者的角度上换了一种方式，使之看起来更合理

class Person:
    def __init__(self, name):
        self.__name = name
    @property
    def name(self):
        return self.__name
    def set_name(self, new_name):
        if type(new_name) is str :
            self.__name = new_name
        else :
            print('您提供的数据类型不合法')
p = Person('alex')
print(p.name)
# p.set_name(123)
p.set_name('老昂')
print(p.name)

@classmethod 把你的方法变成类方法 可以能用类名来调用和用对象名来调用  如果你用对象来调用的时候只是你对象的内存空间该变  你用类来调用是所有的都改变

下面就是可以把私有的属性全局都修改 然后所有的都改变

class Goods:
    __discount = 0.8
    def __init__(self, name, orange_price):
        self.name = name
        self.__price = orange_price
    @property
    def price(self):
        return self.__price*Goods.__discount
    @classmethod
    def change_discount(cls, new_discount):  # 类方法 可以直接被类调用 不需要默认传对象参数 只需要传一个类参数就可以了
        cls.__discount = new_discount
Goods.change_discount(4)#不依赖对象的方法 就应该定义成类方法 类方法可以任意的操作类中的静态变量
apple = Goods('apple', 5)

print(apple.price)

@staticmethod
当一个方法要使用对象的属性时 就是用普通的方法
当一个方法要使用类中的静态属性时 就是用类方法
当一个方法要既不使用对象的属性也不使用类中的静态属性时，就可以使用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)

完全面向对象编程
先登录 后 实例化
还没有一个具体的对象的时候 就要执行login方法

使用什么样的方法要看具体用到了哪些名称空间中的变量
    当一个方法要使用对象的属性时 就是用普通的方法
    当一个方法要使用类中的静态属性时 就是用类方法
    当一个方法要既不使用对象的属性也不使用类中的静态属性时，就可以使用staticmethod静态方法