类的封装

class Regular(object):
    __discount = 1
    def __init__(self,name,price):
        self.name = name
        self.__price = price
    def __course(self):
        print(‘AAA‘)
def course(person):        #即便你用  __course(person)：类函数里这么写    _Regular__course(person)：实际外部调用这么写
    return person.course() #都不可以这么用做归一化设计，因为这样你就暴露了，而course()根本不可能调用到

alex = Regular(‘alex‘,100)
print(alex.price) #真正获取方式是   alex._Regular__price
print(alex.course()) #真正获取方式是  alex._Regular__course(person)
print(Regular.discount) #真正回去方式是 _Regular__discount

class Regular(object):
    __discount = 1
    def __init__(self,name,price):  
        self.name = name
        self.__price = price　　加了双下划线的变量，只能在类的内部使用
    @property　　　　　　　　　　　　#将一个函数伪装成属性
    def price(self):
        return self.__price
    @price.setter
    def price(self,value):     #改变这个变量  value是改变为的值
        self.__price = value
    @price.deleter
    def price(self):　　　　　　　#删除这个变量这么做
        del self.__price
alex = Regular(‘alex‘,10000)
print(alex.price)
alex.price = 8
print(alex.price)
del alex.price
print(alex.price)

这下面的调用就都跟操作属性一样，这样就是做假操作，迷乱其他人的心智

class A(object):
    __discount = 100
    def __init__(self,name,price):
        self.name = name
        self.__price = price

    @classmethod
    def get_discount(cls):
        return cls.__discount

    @classmethod
    def change_discount(cls,value):
        cls.__discount = value

    @classmethod
    def del_discount(cls):
        del cls.__discount

print(A.get_discount())
A.change_discount(300)
print(A.get_discount())
A.del_discount()
print(A.get_discount())

    def func():    # 此时 func是一个静态方法
        print(‘既不操作和self相关的内容‘)
        print(‘也不操作和类名相关的内容‘)

A.func()


# login 登录

class Student:
    def __init__(self,name):
        self.name = name

    @staticmethod
    def login():
        pass

# 先获取这个学生的用户名和密码
# 判断他登录成功之后进行实例化
# Student.login()
# stu = Student(‘alex‘)