反射，静态方法，类方法

@property

property修饰的类中的方法，会 变成类的属性，调用的时候不用带括号，按照类属性的方法就能调用

class Teacher:
    dic = {'查看学生信息':'','查看讲师信息':''}
    def __init__(self,name):
        self.__name = name
    @property
    def name(self):
        return  self.__name

alex = Teacher('alex')
print(alex.name)

这个例子中，name属性被封装成了类的私有属性，这样就从代码的层面上，对name属性进行了私有化，在外部就不能通过  实例化的对象进行调用
Alex.name 这样是调不到类中的__name属性的，alex.__name，这样的方式也不能调用，应为在类中 定义的私有name属性，在类的创建过程中
就对name 属性进行了变形，可以通过对象的__dic__方法进行查看

class Teacher:
    dic = {'查看学生信息':'','查看讲师信息':''}
    def __init__(self,name):
        self.__name = name
    @property
    def name(self):
        return  self.__name

alex = Teacher('alex')
print(alex.__dict__)

{'_Teacher__name': 'alex'}

可见在对象的命名空间中，类的__name属性进行了变形，变成了_Teacher__name这样的形式，，虽然知道了他的保密的规则，但是

在平常中使用，不建议用这样的方式调用类的私有属性，应该通过类名去进行调用，Teacher.__name，这样的方式。

class Teacher:
    dic = {'查看学生信息':'','查看讲师信息':''}
    def __init__(self,name):
        self.__name = name
    @property
    def name(self):
        return  self.__name

这个类中的name方法被@property修饰了，就从类的方法变成了类的属性，可以通过调用类属性的方式进行调用，

要注意：在被@property修饰的方法不能有参数，只能有一个self

Alex.name在这个例子中类的name属性被私有化，但是通过@property的修饰，在外部我们依然可以通过alex.name这样的形式调用__name属性

但是，由于name被私有化，所以在外部我们不能在对他进行修改，

要想对__name进行修改，要在定义一个name方法被@name.setter修饰，这样就可以了

def __init__(self,name):
    self.__name = name

@property
def name(self):
    return  self.__name
@name.setter
def name(self,new_name):
    self.__name = new_name

但是，要注意这三个重点位置的名字要保持一致

类方法

指的是类中的方法被@classmethod修饰的方法，可以直接使用类名 . 的方法进行调用 

# method 方法
# staticmathod 静态的方法 ***
# classmethod 类方法 ****
# 类的操作行为
# class Goods:
# __discount = 0.8
# def __init__(self,name,price):
# self.name = name
# self.__price = price
# @property
# def price(self):
# return self.__price * Goods.__discount
# @classmethod # 把一个方法 变成一个类中的方法，这个方法就直接可以被类调用，不需要依托任何对象
# def change_discount(cls,new_discount): # 修改折扣
# cls.__discount = new_discount
# apple = Goods('苹果',5)
# print(apple.price)
# Goods.change_discount(0.5) # Goods.change_discount(Goods)
# print(apple.price)
# 当这个方法的操作只涉及静态属性的时候 就应该使用classmethod来装饰这个方法

# java
class Login:
def __init__(self,name,password):
self.name = name
self.pwd = password
def login(self):pass

@staticmethod
def get_usr_pwd(): # 静态方法
usr = input('用户名 ：')
pwd = input('密码 ：')
Login(usr,pwd)

Login.get_usr_pwd()
# 在完全面向对象的程序中，
# 如果一个函数 既和对象没有关系 也和类没有关系 那么就用staticmethod将这个函数变成一个静态方法

反射

#反射 *****
# name = 'alex'
# 'name'

class Teacher:
dic = {'查看学生信息':'show_student','查看讲师信息':'show_teacher'}
def show_student(self):
print('show_student')

def show_teacher(self):
print('show_teacher')

@classmethod
def func(cls):
print('hahaha')
alex = Teacher()
for k in Teacher.dic:
print(k)
key = input('输入需求 ：')
# print(Teacher.dic[key])
if hasattr(alex,Teacher.dic[key]):
func = getattr(alex,Teacher.dic[key])
func()
# # alex.show_student() 'show_student'
# func = getattr(alex,'show_student')
# func()

# hasattr getattr delattr
# if hasattr(Teacher,'dic'):
# ret = getattr(Teacher,'dic') # Teacher.dic # 类也是对象
# # ret2 = getattr(Teacher,'func') # 类.方法 teacher.func
# # ret2()
# print(ret)

# menu = Teacher.dic
# for k in menu:
# print(k)

# 通过反射
# 对象名 获取对象属性 和 普通方法
# 类名 获取静态属性 和类方法 和 静态方法

# 普通方法 self
# 静态方法 @staticmethod
# 类方法 @classmethod
# 属性方法 @property