28days

绑定方法

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

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

"""1. 绑定给对象的方法"""
class Student():
    school = 'SH'

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

    """绑定给对象来调用的，"""
    def tell_info(self, username, password):
        print("name:%s age:%s gender:%s %s %s" % (self.name, self.age, self.gender, username, password))
    """默认情况下，在类内部写方法是绑定给对象的，就有对象来调用，就会自动来传递参数"""
stu = Student('ly', 20, 'male')

## 如何调用方法
"""绑定给对象的方法有什么特殊之处：对象来调用方法，会把对象自己当成第一个参数传递给方法的第一个形参"""
# 谁来调用方法就是谁，对象自己
# stu.tell_info('kevin', password=123) # stu.tell_info(stu) # name:ly age:20 gender:male


## 问题是：绑定给对象的方法，类能不能来调用? 能来调用，只不过是方法中需要几个参数就要传递几个参数，包括self形参也需要自己传递
Student.tell_info(stu, 'kevin', 123)



**********************************绑定给类的方法*****************************************

## MySQL类： IP+PORT
# 127.0.0.1:3306

class Oracle():
    def __init__(self, ip, port):
        self.ip = ip
        self.port = port
    
    """
        此时该方法就是绑定给类的，那么就有类来调用，有什么特殊之处：就是会把类自动当成第一个参数传递给方法的第一个形参cls
        条件：
            1. 加一个装饰器@classmethod
            2. 把方法的第一个形参改为cls
            3. 外部调用该方法的时候使用类来调用即可
            4. 绑定给类的方法中没有self这个参数了
            5. 绑定给对象的方法中，就没有cls这个参数了
    """
    @classmethod
    def from_func(cls):
        # cls:就是类
        return cls('127.0.0.1', 3306)

obj = Oracle('127.0.0.1', 3306)
# print(obj.ip)
# print(obj.port)

# mysql_obj=obj.from_func()
# print(mysql_obj.ip)

obj1=Oracle.from_func()
print(obj1)
print(obj1.ip)

非绑定方法(静态方法static)

class Student():
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender
        self.id = self.create_id()

    @staticmethod
    def create_id():
        """当你在函数中不需要对象，也不需要类的时候，就把函数设置为静态方法，类能来调用，对象也能来调用，而且不用传递任何的参数"""
        import uuid
        return uuid.uuid4()
	
    def func(self):
        """如果你在方法中即需要对象，也需要类，就把方法绑定给对象"""
        # self.__class__ # 返回该对象的类
        # self.__class__.__name__ # Student # 类名字的字符串形式的
        # return self.__class__() # Student()

        
stu = Student('ly', 20, 'female')
print(stu.id)
print(stu.create_id())

"""只要生成的随机数长度固定，理论上就一定会出现重复的可能!!!"""
# import uuid
# print(uuid.uuid4()) # 191fd3ed-cdf0-40ad-8eb7-25cbdd82938a b49fbd62-f02f-4acd-a8e4-78cf196fd124

隐藏属性

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 get_school(self):
        return self.__school

    def set_school(self, v):
        """隐藏属性对外不对内"""
        if type(v) is str:
            Student.__school = v # Student._Student__school = 'BJ'
        else:
            print('修改的数据必须是字符串')

stu = Student('ly', 20, 'male')
# print(stu._Student__school) # SH

# print(Student.__dict__)
# stu._Student__func()

# print(stu.__dict__) # {'_Student__name': 'ly', 'age': 20, 'gender': 'male'}
# print(stu._Student__name)


# Student.school = 123
# print(stu.school)

stu.set_school('BEIJING')
# print(Student._Student__school)

res=stu.get_school()
print(res)

property装饰器

它是一个内置的装饰器，它是把方法伪装成属性来使用

class Student():
    __school = 'SH'  # _Student__school
    __country = 'CHINA'
    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')

    @property
    def school(self):
        return self.__school

    @school.setter
    def school(self, v):
        print('from school')
        """隐藏属性对外不对内"""
        if type(v) is str:
            Student.__school = v  # Student._Student__school = 'BJ'
        else:
            print('修改的数据必须是字符串')
    @school.deleter
    def school(self):
        print('delete school')
        del Student.__school

    @property
    def country(self):
        return self.__school

    @country.setter
    def country(self, v):
        print('from school')
        """隐藏属性对外不对内"""
        if type(v) is str:
            Student.__school = v  # Student._Student__school = 'BJ'
        else:
            print('修改的数据必须是字符串')

    @country.deleter
    def country(self):
        print('delete school')
        del Student.__school
	
    
    
    def get_country1(self):
        return self.__school

    def set_country(self, v):
        print('from school')
        """隐藏属性对外不对内"""
        if type(v) is str:
            Student.__school = v  # Student._Student__school = 'BJ'
        else:
            print('修改的数据必须是字符串')

    def del_country(self):
        print('delete school')
        del Student.__school
    """有顺序要求"""
    xxx = property(get_country1, set_country, del_country)  # 了解
    
stu = Student('ly', 20, 'male')

# print(stu.get_school())
# print(stu.school) # SH 把方法伪装成属性来使用

stu.school = 'BJ'
print(stu.school)
del stu.school


练习题：
# 计算人的bmi值
class People():
    def __init__(self, height, weight):
        self.height = height
        self.weight = weight

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

stu = People(1.8, 75)
print(stu.bmi)

封装

    封装指的就是把数据与功能都整合到一起，听起来是不是很熟悉，没错，我们之前所说的”整合“二字其实就是封装的通俗说法。
    
    什么是封装
在程序设计中，封装（Encapsulation）是对具体对象的一种抽象，即将某些部分隐藏起来，在程序外部看不到，其含义是其他程序无法调用。

要了解封装，离不开“私有化”，就是将类或者是函数中的某些属性限制在某个区域之内，外部无法调用。

为什么要封装
封装数据的主要原因是：保护隐私（把不想别人知道的东西封装起来）