类的绑定方法和隐藏属性

1. 绑定方法

定义：定义完类之后，可以在类里面写一些方法，在类的外部直接调用类内部的方法不能调用那么，类中得方法到底是使用类调用还是使用对象来调用?

类中得方法类能来调用，对象也能来调用，就看该方法绑定给谁了，绑定给谁就有谁来调用
# 对象的绑定方法：

class Student():
    school = 'BJ'

    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender

    def func(self,username,password):     # self.name 调用的是对象的 name  如果这个方法有参数 就在调用的时候需要另外传进来 username
        print('name %s age % age gender %s username %s password %s' % (self.name,self.age,self.gender,username,password))

obj = Student('huang',18,'male') # 默认情况下，在类内部写方法是绑定给对象的，就有对象来调用，就把对象当作第一个参数自动来传参
"""绑定给对象的方法有什么特殊之处：对象来调用方法，会把对象自己当成第一个参数传递给方法的第一个形参"""
obj.func('huang',123) # stu.tell_info('kevin', password=123)



类的绑定方法：

class Student():

    def __init__(self,ip,port):
        self.ip = ip
        self.port = port

    @classmethod
    def func(cla,ip,port): # cla 就是类
        return cla(ip,port)  # 这里写上参数就不会再写死 但是需要从 调用 func函数中传过来

obj = Student.func('127.0.0.1',3306)  # obj 是func 函数的返回值 不是对象 是类
obj.func('127.0.0.1',3306)

obj1 = Student('127.0.0.2',3307)
obj1.func('127.0.0.2',3307)

print(obj1.port)
print(obj1.ip)
"""
总结:
    此时该方法就是绑定给类的，那么就由类来调用，有什么特殊之处：就是会把类自动当成第一个参数传递给方法的第一个形参cls
    条件：
        1. 加一个装饰器@classmethod
        2. 把方法的第一个形参改为cls
        3. 外部调用该方法的时候使用类来调用即可 把类当作第一个参数传过来
        4. 绑定给类的方法中没有self这个参数了
        5. 绑定给对象的方法中，就没有cls这个参数了
"""

非绑定方法（实际叫做 静态方法）static 装饰器

class Student():
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender
        self.id = self.func() # 直接调用函数得到的结果或返回值
        
    @staticmethod
    def func(): 
"""当你在函数中不需要对象，也不需要类的时候，就把函数设置为静态方法，类能来调用，对象也能来调用，而且不用传递任何的参数"""
        import uuid
        return uuid.uuid4()

obj = Student('huang',18,'male')
print(obj.id) 

2. 隐藏属性

1. 怎么隐藏

2. 为什么要隐藏
# 类属性
# 对象属性
"""
1. 隐藏属性在类的定义阶段发生了变形：_类名__属性名
2. 隐藏属性在类的外部能不能取到? 理论上是取不到了，但是非要取，也能取到，在类的外部取隐藏之后的属性不是目的
3. 类属性、类方法、对象属性都可以被隐藏
4. 隐藏属性对外不对内
5. 为什么要隐藏?
        就是可以对修改类内部的属性的时候，可以在类的内部做更好的限制，然后在类的内部开放一个公共的接口，对外返回内部隐藏的值
"""

class Student():
    
    __school = 'SH' # _Student__school

    def __init__(self, name, age, gender):
        self.__name = name # _Student__name  # 前面加了双下划线的 都是隐藏了 增强了逻辑判断的 增删改查
        self.age = age
        self.gender = gender

    def __func(self): # _Student__func
        print('from func')

　　 def del_school():
　　　　　del self.__name
　　　　　print('属性已删除')

def get_school(self):  # 对外开放的查看函数接口 
        return self.__school # self.__name  # 如果有多个参数 可以在修改接口进行逻辑判断 或者再开一个接口

    def set_school(self, v):  # 对外修改开放的函数接口
        """隐藏属性对外不对内"""
        if type(v) is str:
            Student.__school = v # Student._Student__school = 'BJ'

　　　　　if type(v) is int:
　　　　　　　self.__name = v

        else:
            print('修改的数据必须是字符串')

stu = Student('ly', 20, 'male') # 产生一个对象

stu.get_school()  # 只能进行查看操作

stu.set_school('aaa') # 只能进行修改操作 但是里面有逻辑 只能进行修改字符串
stu.set_scholl('123') # ('aaa', 123)
stu.del_school()      # 只能进行删除操作 删除之后进行访问会报错
print(stu._Student__name) # 强行访问接口也可以的

print(stu.__dict__) # 通过查看字典的形式显示出隐藏的属性

3. property装饰器

1. 装饰器的基本使用
class Student():
    def __init__(self,name,age,gender):
        self.__name = name
        self.age = age
        self.gender = gender

    @property    # 装饰器就是把方法伪装成属性 对象查看的时候就点就可以了 不需要加括号
    def func(self):
        return self.__name
    
stu = Student('huang',18,'male')

print(stu.func) # 直接访问 不需要加括号

2. 装饰器可以进行对外开放接口的操作进行调用函数
第一种方法：

class Student():
    __school = 'SH'  # _Student__school

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

    def __func(self):
        print('from func')

    def get_name(self):
        return self.__name

    def set_name(self,v):

        if type(v) is str:
            Student._Student__name = v
            return
        else:
            print('必须是字符串')

    def del_name(self):
        del self.__name
        print('属性已删除')
    """
    第一种方法：
    必须一一对应 第一个是 get  set  del 顺序不能乱 
    执行相关操作的时候 装饰器会判断执行对应的函数功能 
    """
    name = property(get_name,set_name,del_name,)

stu = Student('huang',18,'male')

# print(stu.name)
del stu.name  # 删除
stu.name = 'lu'  # 修改
print(stu.name)  # 查看


第二种方法：
class Student():
    __school = 'SH'  # _Student__school

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

    def __func(self):
        print('from func')

    @property
    def name(self):      # 直接位置成 属性 .就能查看
        return self.__name

    @name.setter         # 执行修改的时候会触发这个函数执行 不需要加括号
    def name(self,v):

        if type(v) is str:
            self.__name = v
            return
        else:
            print('必须是字符串')
    @name.deleter        # 删除的时候会进行 这个函数的执行 不用加括号
    def name(self):
        del self.__name
        print('属性已删除')

stu = Student('huang',18,'fale')

# print(stu.name)  # 查看

stu.name = 'lu'  # 修改

del stu.name
# print(stu.name)