第27天面向对象之反射，绑定方法，特定的

绑定方法（其实并没有这样的说法，只是为了解释三个装饰器而说出来的比较容易记名词）
　　绑定方法的核心就是，谁绑定的就应该给谁来调用，谁来调用我们就会将谁作为第一个参数传递进去。
　　绑定对象方法：应该被对象来调用，python会自动的将对象当做第一个参数传递进来，__init__方法就是这个道理
　　绑定类的方法：应该被类来调用，python会自动的将类当做第一个参数传递进来。

非绑定方法
　　既不绑定对象，也不绑定类，就是一个普通的函数，不会自动传值。
三个装饰器
　　classmathod: 指定这个方法是绑定类的方法
　　staticmethod：指定这个方法是非绑定方法
　　property: 和绑定方法没什么关系，只是他也是一个装饰器，就放在这里来一块说了

注意：绑定方法理论上是谁绑定的就由谁来调用，但是并不是强制的。

1. 对象去调用的时候，自动传值
2. 类去调用的时候，就是一个普通的函数，需要自己去传值

class Foo:
    # 类中的函数如果没有加入装饰器默认的就是绑定对象的方法
    def func1(self):
        print('func1', self)

    # 通过装饰器classmethod定义了一个绑定类的方法
    @classmethod
    def func2(cls):
        print('func2', cls)

    # 通过装饰器staticmethod定义了一个非绑定方法
    @staticmethod
    def func3(x, y):
        print('func3', x, y)

obj = Foo()
# 1. 绑定对象的方法应该用对象去调用
# 2. 对象调用的时候会自动的将对象作为第一个参数传递进去
obj.func1()

# 如果用类去调用,就相当于一个普通的函数，需要自己去传值
Foo.func1(obj)

无论是对象还是累调用的时候都是自动的把类当做第一个参数传递进去

class Foo:
    # 类中的函数如果没有加入装饰器默认的就是绑定对象的方法
    def func1(self):
        print('func1', self)

    # 通过装饰器classmethod定义了一个绑定类的方法
    @classmethod
    def func2(cls):
        print('func2', cls)

    # 通过装饰器staticmethod定义了一个非绑定方法
    @staticmethod
    def func3(x, y):
        print('func3', x, y)

obj = Foo()
obj.func2()
Foo.func2()

# 结果：打印出来的结果是一样的
# func2 <class '__main__.Foo'>
# func2 <class '__main__.Foo'>

无论是类还是对象去调用的时候都是作为普通函数，不会进行自动的传值

class Foo:
    # 类中的函数如果没有加入装饰器默认的就是绑定对象的方法
    def func1(self):
        print('func1', self)

    # 通过装饰器classmethod定义了一个绑定类的方法
    @classmethod
    def func2(cls):
        print('func2', cls)

    # 通过装饰器staticmethod定义了一个非绑定方法
    @staticmethod
    def func3(x, y):
        print('func3', x, y)



obj = Foo()
obj.func3(1, 2)
Foo.func3(1, 2)
# 打印出来的结果也是一样的
# func3 1 2
# func3 1 2

class Mysql:
    # 之前的时候我们都是直接用init函数，但是现在有了几个不同类型的方法，我们就要考虑一下为什么要使用默认的对象绑定方法
    # 因为__init__函数中我们要用到对象，并且要给对象赋予不同的属性，所以我们把这个方法设置成了对象绑定方法
    def __init__(self, ip, port):
        self.id = self.create_id()
        self.ip = ip
        self.port = port
    # 这个查询方法也一样，我们需要通过传递一个对象来查看对象的属性，所以设置成了对象绑定方法
    def tell_info(self):
        print('<%s:%s>' %(self.ip, self.port))
    # 因为代码体中要用到类，所以定义这个方法为类绑定方法
    @classmethod
    def from_conf(cls):
        return cls(settings.IP, settings.PORT)
    
    # 因为此方法没有用到对象或者类，所以定义成一个静态方法
    @staticmethod
    def create_id():
        import uuid
        return uuid.uuid4()
    
import settings
# 这种方法是之后经常要用到的另外一种创建对象的方法
obj = Mysql.from_conf()

class Mysql:
    # 之前的时候我们都是直接用init函数，但是现在有了几个不同类型的方法，我们就要考虑一下为什么要使用默认的对象绑定方法
    # 因为__init__函数中我们要用到对象，并且要给对象赋予不同的属性，所以我们把这个方法设置成了对象绑定方法
    def __init__(self, name, age):
        self.name = name
        self.age = age 

obj = Mysql('1.1.1.1', 3306)

class Mysql:
    # 之前的时候我们都是直接用init函数，但是现在有了几个不同类型的方法，我们就要考虑一下为什么要使用默认的对象绑定方法
    # 因为__init__函数中我们要用到对象，并且要给对象赋予不同的属性，所以我们把这个方法设置成了对象绑定方法
    def __init__(self, ip, port):
        self.ip = ip
        self.port = port
    # 这个查询方法也一样，我们需要通过传递一个对象来查看对象的属性，所以设置成了对象绑定方法
    def tell_info(self):
        print('<%s:%s>' %(self.ip, self.port))
import settings
obj = Mysql(settings.IP, settings.PORT)

# 应该写入这样一个函数，把之前创建对象的表达式放进去，但是这样子有一个问题，也就是当类名发生变化的时候，这个函数就不能用了
def from_conf():
    return Mysql(settings.IP, settings.PORT)
# 为了解决上面的问题，作为一个参数传递进去，这个参数本质上一个类，因此写到类中应该是一个绑定类的方法
def from_conf(xx):
    return xx(settings.IP, settings.PORT)

class Mysql:
    # 之前的时候我们都是直接用init函数，但是现在有了几个不同类型的方法，我们就要考虑一下为什么要使用默认的对象绑定方法
    # 因为__init__函数中我们要用到对象，并且要给对象赋予不同的属性，所以我们把这个方法设置成了对象绑定方法
    def __init__(self, ip, port):
        self.ip = ip
        self.port = port
    # 这个查询方法也一样，我们需要通过传递一个对象来查看对象的属性，所以设置成了对象绑定方法
    def tell_info(self):
        print('<%s:%s>' %(self.ip, self.port))
    # 因为代码体中要用到类，所以定义这个方法为类绑定方法
    @classmethod
    def from_conf(cls):
        return cls(settings.IP, settings.PORT)
import settings
# 这种方法是之后经常要用到的另外一种创建对象的方法
obj = Mysql.from_conf()

class Mysql:
    # 之前的时候我们都是直接用init函数，但是现在有了几个不同类型的方法，我们就要考虑一下为什么要使用默认的对象绑定方法
    # 因为__init__函数中我们要用到对象，并且要给对象赋予不同的属性，所以我们把这个方法设置成了对象绑定方法
    def __init__(self, ip, port):
        self.id = self.create_id()
        self.ip = ip
        self.port = port
    # 这个查询方法也一样，我们需要通过传递一个对象来查看对象的属性，所以设置成了对象绑定方法
    def tell_info(self):
        print('<%s:%s>' %(self.ip, self.port))
    # 因为代码体中要用到类，所以定义这个方法为类绑定方法
    @classmethod
    def from_conf(cls):
        return cls(settings.IP, settings.PORT)
    
    # 因为此方法没有用到对象或者类，所以定义成一个静态方法
    @staticmethod
    def create_id():
        import uuid
        return uuid.uuid4()
    
import settings
# 这种方法是之后经常要用到的另外一种创建对象的方法
obj = Mysql.from_conf()

property装饰器
    主要作用是用来对于一些需要计算得到的属性，我们必须要通过一个方法去获得，但是这样用户去使用的时候就会添加一些不必要的障碍，为了解决这样的问题，通过property装饰器把类的方法属性转换成数据属性，使用者可以直接进行使用

BMI指数（bmi是计算而来的，但很明显它听起来像是一个属性而非方法，如果我们将其做成一个属性，更便于理解）

成人的BMI数值：
过轻：低于18.5
正常：18.5-23.9
过重：24-27
肥胖：28-32
非常肥胖, 高于32
　　体质指数（BMI）=体重（kg）÷身高^2（m）
　　EX：70kg÷（1.75×1.75）=22.86

class Bmi:
    def __init__(self, name, weight, height):
        self.name = name
        self.weight = weight
        self.height = height
        self.bmi = weight / (height ** 2)  # 通过设置一个属性来直接计算bmi的值

    def tell_info(self):
        print('bmi:<%s>' % self.bmi)

b = Bmi('egon', 60, 1.5)
print(b.bmi)

class Bmi:
    def __init__(self, name, weight, height):
        self.name = name
        self.weight = weight
        self.height = height
        self.bmi = weight / (height ** 2)

    def tell_info(self):
        print('bmi:<%s>' % self.bmi)

b = Bmi('egon', 60, 1.4)
print(b.bmi)
b.weight = 50
print(b.bmi)
# 问题所在
# 结果：
# 30.612244897959187
# 30.612244897959187

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

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

    def tell_info(self):
        print('bmi:<%s>' % self.bmi)

b = Bmi('egon', 60, 1.4)
print(b.bmi())  
b.weight = 50
print(b.bmi())

class Bmi:
    def __init__(self, name, weight, height):
        self.name = name
        self.weight = weight
        self.height = height
    
    # 通过property装饰器将方法转换成数据
    @property
    def bmi(self):
        return self.weight / (self.height ** 2)

    def tell_info(self):
        print('bmi:<%s>' % self.bmi)

b = Bmi('egon', 60, 1.4)
print(b.bmi)  # 使用者就像是使用数据属性的时候一样直接使用
b.weight = 50
print(b.bmi)

反射就是通过字符串的形式处理类的属性
    hasattr    # 判断是否存在此属性
    setattr　　 #  设置属性
    getattr　　# 获得属性
    delattr　　# 删除属性

class Foo:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def func1(self):
        print('func1')
    def tell_info(self):
        print('%s:%s' %(self.name, self.age))
obj = Foo('egon', 11)

# hasattr，参数一为属性，参数二为字符串式的属性名
print(hasattr(obj, 'name'))
print(hasattr(obj, 'named'))
# getattr 参数一为属性，参数二为字符串式的属性名
res = getattr(obj, 'name')
res1 = getattr(obj, 'func1')
print(res)
print(res1())
getattr(obj, 'func2', None)
# setattr 参数一为属性，参数二为字符串式的属性名，参数三是设置的属性的值
print(setattr(obj, 'name', 'EGON'))
print(setattr(obj, 'func1', 'aaa'))
print(obj.__dict__)
# delattr 参数一为属性，参数二为字符串式的属性名
delattr(obj, 'func1')
print(obj.__dict__)

__str__   自定义打印对象的值
__del__　　在删除对象之前释放操作系统资源

class Foo:
    def __init__(self, name, age):
        self.name = name
        self.age = age
obj = Foo('egon', 11)
print(obj)
# 结果
# <__main__.Foo object at 0x02E01B10>

class Foo:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def __str__(self):
        print('=======>')

obj = Foo('egon', 11)
print(1)      # 从结果中我们看出来，首先执行打印了1
print(obj)　　 # 当打印对象的时候会去触发执行__str__方法，然后打印出=====>但是此时没有返回值，报错了
print(2)
# 结果
# 1
# =======>

class Foo:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def __str__(self):
        return '<%s:%s>' %(self.name, self.age)

obj = Foo('egon', 11)
print(obj)
# 结果
# <egon:11>

class Foo:
    def __init__(self, name, age, file_path):
        self.name = name
        self.age = age
        # 这个系统资源并不会跟着对象的删除而释放掉，因此我们需要定义__del__释放系统资源
        self.f = open(file_path, 'rt', encoding='utf-8')
    def __del__(self):
        self.f.close()
    def __str__(self):
        return '<%s:%s>' %(self.name, self.age)

obj = Foo('egon', 11, 'a')
print(obj)