面对对象-绑定与隐藏等

绑定方法

绑定方法分为2种
	1.绑定给对象用。
		对象调用
	2.绑定给类自身用
		类自身调用
对象调用：
    	class Student():
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender

    # 绑定给对象的方法，对象来调用，会把自己当成第一个参数传到函数里面self
    def tell_info(self):
        print('name: %s，age:%s, gender:%s' % (self.name, self.age, self.gender))


        stu = Student('ly', 18, 'male')
        # print(stu.name)
        stu.tell_info() # stu.tell_info(stu)
类自身调用：
    	
class Mysql():
    def __init__(self, ip, port):
        self.ip = ip
        self.port = port

    @classmethod  # 该方法绑定给类了，以后有类来调用，会自动把类名当成第一个参数传过来，cls
    def from_conf(cls):
        # cls => Oracle
        # obj = Oracle(settings.IP, settings.PORT)
        obj = cls(settings.IP, settings.PORT)
        return obj
 Mysql.from_conf()

定义类。
调用类。产生空对象，空对象自动使用__init__方法，将自己传入，制定自己独有的属性之后得到一个初始化的值，然后返回
接收初始化的值。定义为对象。
这个对象可以调用类里面的方法。会自动将自己传入。

类也可以使用自己的方法。但需要传入一个类的自身。
如果将这个方法设定为类使用的。
就会自动将类名传入，
如果对象要使用这个方法，会自动变成对象名__class(表示使用者还是类本身)


传入参数，直接实例化，得到一个对象。 # 但每次都要传入参数
将类放入自己的功能里，调用类的那个功能，就会实例化，并有个一个返回值。接收即可

静态方法

# 既不绑定给类，也不绑定给对象
# 谁也不需要绑定
class Student():
    school = 'SH'
    def __init__(self, name, age):
        self.name = name
        self.age = age

    @staticmethod  # 静态方法
    def create_id():
        import uuid
        return uuid.uuid4()  # 函数返回值

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

# print(stu.create_id())
# print(Student.create_id())
print(stu.create_id())  # 这个对象调用这个函数，得到这个函数的返回值

'''总结绑定方法与非绑定方法的使用：若类中需要一个功能，该功能的实现代码是给对象使用则将其定义成对象方法、是给类使用则将其定义成类方法、无需引用类或对象则将其定义成静态方法。'''

如何隐藏属性

1. 如何隐藏
'''
    1. 在类定义阶段，发生了语法上的变形_类名__属性名
    2. 隐藏对外不对内
    3. 只有在类定义阶段发生变形，其他情况都不发生变形了

为什么要隐藏: 类里面的隐藏属性， 类外部可以使用，但是目的不是让类外部使用的，类外部要是想用，在类内部开放接口进行访问
            可以达到对外部数据的严格控制
'''
class Student():
    __school = 'SH' # _Student__school  => _类名__属性名
    def __init__(self, name, age):
        self.__name = name
        self.age = age

    def __tell_info(self):  # _Student__tell_info  => _类名__函数名
        print('name: %s, age: %s' % (self.__name, self.age))

    def get_school(self):
        return self.__school  # self._Student__school

    def set_school(self, v):
        if type(v) is not str:
            print('数据类型不合法')
        # if isinstance(v, str):
            return
        self.__school = v


对象 = 类(参数)
返回值 = 对象.方法

property装饰器

class Student():
    __school = 'SH'  # _Student__school  => _类名__属性名

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

    def __tell_info(self):  # _Student__tell_info  => _类名__函数名
        print('name: %s, age: %s' % (self.__name, self.age))

    @property  # 把方法伪装成属性
    def name(self):
        return "name:%s" % self.__name

    @name.setter
    def name(self, v):
        if type(v) is not str:
            print('数据类型不合法')
        # if isinstance(v, str):
            return
        self.__name = v

    @name.deleter
    def name(self):
        print('不让删')

stu = Student('ly', 18)
print(stu.get_name())

stu.name = 123
print(stu.name)

del stu.name



class Bmi():
    def __init__(self, height, weight):
        self.height = height
        self.weight = weight

    @property
    def get_bmi(self):
        return self.weight / (self.height ** 2)

bmi = Bmi(1.8, 70)
print(bmi.get_bmi)


# 了解即可

class Student():
    __school = 'SH'  # _Student__school  => _类名__属性名

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

    def __tell_info(self):  # _Student__tell_info  => _类名__函数名
        print('name: %s, age: %s' % (self.__name, self.age))

    def get_name(self):
        return "name:%s" % self.__name

    def set_name(self, v):
        if type(v) is not str:
            print('数据类型不合法')
            # if isinstance(v, str):
            return
        self.__name = v

    def del_name(self):
        print('不让删')
    
    # 了解
    name = property(get_name, set_name, del_name)


stu = Student('ly', 18)
# print(stu.xxx)

stu.name = 'aaa'
print(stu.name)