python面向对象（绑定方法与非绑定方法）

# 一、绑定方法：特殊之处在于将调用者本身当做第一个参数自动传入
#       1）绑定给对象的方法：调用者是对象，自动传入的是对象
#       2）绑定给类的方法：调用者是类，自动传入的是类

# 类方法的应用
# 需求一
class MySQL:
    def __init__(self, host, port):
        self.host = host
        self.port = port

    def func(self):
        print('{}:{}'.format(self.host, self.port))

obj1 = MySQL('127.0.0.1', 3306)
obj1.func()  # 绑定对象的方法，对象直接传入
# 127.0.0.1:3306
MySQL.func(obj1)
# 127.0.0.1:3306
print(obj1.__dict__)
# {'host': '127.0.0.1', 'port': 3306}

# 需求二(实例化传参，从配置文件中来）
import settings

class MySQL:
    def __init__(self, host, port):
        self.host = host
        self.port = port

    def func(self):
        print('{}:{}'.format(self.host, self.port))

obj2 = MySQL(settings.HOST, settings.PORT)
print(obj2.__dict__)

# 需求三(参数写活，构造函数，涉及到传类）
import settings

class MySQL:
    def __init__(self, host, port):
        self.host = host
        self.port = port

    def func(self):
        print('{}:{}'.format(self.host, self.port))

    @classmethod  # 将下面的函数装饰成绑定给类的方法
    def from_conf(cls):  # 从配置文件中读取配置进行初始化
        return cls(settings.HOST, settings.PORT)

obj3 = MySQL.from_conf()  # 调用类方法，自动将类MySQL当作第一个参数传给cls
print(obj3.__dict__)
print(MySQL.from_conf)
# <bound method MySQL.from_conf of <class '__main__.MySQL'>> 绑定到类
print(obj3.func)
# <bound method MySQL.func of <__main__.MySQL object at 0x000002C1EC073190>> 绑定到对象

# 二、非绑定方法--》静态方法
#       没有绑定给任何人：调用者可以是类、对象，没有自动传参的效果
class MySQL:
    def __init__(self, host, port):
        self.nid = self.create_id()  # 实例化几次，就调用create_id函数几次
        self.host = host
        self.port = port

    @staticmethod  # 将下述函数装饰成一个静态方法
    def create_id():
        import uuid
        return uuid.uuid4()

obj1 = MySQL('1.1.0.1', 3306)

MySQL.create_id()
obj1.create_id()
print(obj1.__dict__)
# {'nid': UUID('0eeba8ce-ce15-4f56-bd62-78c10a6230c4'), 'host': '1.1.0.1', 'port': 3306}
print(MySQL.create_id)
# <function MySQL.create_id at 0x0000021B017F2550> 没有自动传参的效果，普通函数，有几个参数就传几个参数
print(obj1.create_id)
# <function MySQL.create_id at 0x0000021B017F2550> 没有自动传参的效果，普通函数，有几个参数就传几个参数

总结绑定方法与非绑定方法的使用：若类中需要一个功能，

该功能的实现代码中需要引用对象则将其定义成对象方法、

需要引用类则将其定义成类方法、无需引用类或对象则将其定义成静态方法。

内置函数：

print(abs(-1))  # 绝对值
print(all([1, 'aaa', 'e']))  # and运算，返回布尔值
print(all([]))

print(any([0, None, 1]))  # or运算，返回布尔值
print(any([]))

print(bin(10))
print(oct(10))
print(hex(10))

print(bool(''))

class Foo:
    pass

print(callable(Foo))  # 是否可被调用

# -----掌握
print(divmod(1000, 33))  # 商和余数 (30, 10)

# -----掌握

class Foo:
    pass

obj = Foo()
obj.xxx = 1
print(dir(obj))  # obj.哪些属性

# -----掌握
for k, v in enumerate(['a', 'b', 'c']):  # 列表的索引和对应的值
    print(k, v)
'''
0 a
1 b
2 c
'''

# -----掌握
res = eval('2+3')  # 执行字符串中的表达式
print(res)  # 5

# -----掌握
class C1:
    pass

obj = C1()
print(isinstance(obj, C1))
print(isinstance([], list))  # 类型判断推荐使用isinstance
print(type([]) is list)  # 不推荐使用

time=__import__('time')