Python之绑定

绑定方法--绑定给对象的方法
定义完类之后，可以在类里面写一些方法，在类的外部直接调用类内部的方法不能调用

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

def tell_info(self, username, password):
        print("name:%s  %s %s" % (self.name, username, password))
stu = Student('ly', 20, 'male')
stu.tell_info('kevin', 123)
# 绑定给对象的方法，类也能调用，但是方法中需要传递几个就要传几个，包括self

           # 一般不用，直接对象调用

Student.tell_info(stu , 'kevin' ,123)

绑定方法--绑定给类的方法
## MySQL类： IP+PORT（端口）     # 127.0.0.1:3306

with  上下文管理器

class Oracle():
    def __init__(self, ip, port):
        self.ip = ip
        self.port = port
 
    @classmethod
    def from_func(cls):    # cls:就是类
        return cls('127.0.0.1', 3306)
 
obj = Oracle('127.0.0.1', 3306)
obj1=Oracle.from_func()
print(obj1)
print(obj1.ip)

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

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

import uuid
print(uuid.uuid4())    # cbde8fd7-89aa-41b2-b151-0861e24f6785 ，长度固定16

# 可能会重复：只要生成的随机数的长度一样，就会有重复的可能性

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()
 
stu = Student('ly', 20, 'female')
print(stu.id)
print(stu.create_id())
# 当你在函数中不需要对象，也不需要类的时候，就把函数设置为静态方法，类能来调用，     对象也能来调用，而且不用传递任何的参数

"""如果你在方法中即需要对象，也需要类，就把方法绑定给对象"""

def func(self):
        self.__class__ # 返回该对象的类
        self.__class__.__name__ # Student # 类名字的字符串形式的
        return self.__class__()   # Student()
隐藏属性
class Student():
    __school = 'SH'    # 隐藏与开放接口，其他程序无法调用
stu = Student()
print(stu.school)   # 取不到了，隐藏 
# 可以查看类的名称空间，隐藏属性在类的定义发生了变形：_类名__属性名

# 隐藏属性在类的外部能取到，在类的外部取隐藏之后的属性不是目的

print(Student.__dict__)   # 藏外不藏内，查看类的名称空间
print(stu._Student__school)   # SH

# 类属性、类方法、对象属性都可以被隐藏
# 隐藏属性对外不对内，可以对修改类内部的属性的时候，可以在类的内部做更好的限制，     然后在类的内部开放一个公共的接口，对外返回内部隐藏的值

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
# stu.set_school('BEIJING')
# print(Student._Student__school)  # BEIJING
res=stu.get_school()
print(res)   # SH
property装饰器
它是一个内置的装饰器，它是把方法伪装成属性来使用

装饰器方法一：重点是@property

class Student():
    __school = 'SH'  # _Student__school
 
    def __init__(self, name, age, gender):
        self.__name = name  # _Student__name
        self.age = age
        self.gender = gender
 
    @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
    
stu = Student('ly', 20, 'male')
stu.school = 'BJ'    # 可以直接取
print(stu.school)
del stu.school       # 可以直接删

装饰器方法二：了解

class Student():
    __school = 'SH'
 
    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')
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):
        bim1 = self.weight / (self.height ** 2)
        return bim1
outer = People(1.65,50)
print(outer.bmi)

面向对象的三大特征
1、封装：就是把数据与功能都整合到一起。
  # 封装（Encapsulation）是对具体对象的一种抽象，即将某些部分隐藏起来，在程序外部         看不到，其含义是其他程序无法调用。

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

2、继承
3、多态