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

Posted 2023-04-14 coderxueshan

# 一、绑定方法：特殊之处在于将调用者本身当做第一个参数自动传入
#       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\')

 

Python----面向对象---绑定方法与非绑定方法的应用

1、绑定到对象的方法的应用

 1 class People:
 2     def __init__(self, name, age, sex):
 3         self.name = name
 4         self.age = age
 5         self.sex = sex
 6 
 7     def tell_info(self):  # 绑定到对象的方法
 8         print(‘Name:%s Age:%s Sex:%s‘ % (self.name, self.age, self.sex))
 9 
10 p = People(‘egon‘, 18, ‘male‘)
11 p.tell_info()  # tell_info(p)
12 
13 结果为：
14 
15 Name:egon Age:18 Sex:male

绑定给对象，就应该由对象来调用，自动将对象本身当做第一个参数传入

2、绑定给类，就应该由类来调用，自动将类本身当做第一个参数传入

 1 import setting
 2 
 3 class People:
 4     def __init__(self, name, age, sex):
 5         self.name = name
 6         self.age = age
 7         self.sex = sex
 8 
 9     def tell_info(self):  # 绑定到对象的方法
10         print(‘Name:%s Age:%s Sex:%s‘ % (self.name, self.age, self.sex))
11 
12     @classmethod
13     def from_conf(cls):
14         obj = cls(
15             setting.name,
16             setting.age,
17             setting.sex
18         )
19         return obj
20 
21 # p = People(‘egon‘, 18, ‘male‘)
22 # p.tell_info()  # tell_info(p)
23 p = People.from_conf()
24 p.tell_info()
25 
26 结果为:
27 
28 Name:xudachen Age:18 Sex:male

3、非绑定方法

 1 import setting
 2 import hashlib
 3 import time
 4 
 5 class People:
 6     def __init__(self, name, age, sex):
 7         self.id = self.create_id()
 8         self.name = name
 9         self.age = age
10         self.sex = sex
11 
12     def tell_info(self):  # 绑定到对象的方法
13         print(‘Name:%s Age:%s Sex:%s‘ % (self.name, self.age, self.sex))
14 
15     @classmethod
16     def from_conf(cls):
17         obj = cls(
18             setting.name,
19             setting.age,
20             setting.sex
21         )
22         return obj
23 
24     @staticmethod
25     def create_id():
26         m = hashlib.md5(str(time.time()).encode(‘utf-8‘))
27         return m.hexdigest()
28 
29 # p = People(‘egon‘, 18, ‘male‘)
30 # p.tell_info()  # tell_info(p)
31 # p = People.from_conf()
32 # p.tell_info()
33 
34 p1 = People(‘xudachen1‘, 18, ‘male‘)
35 p2 = People(‘xudachen2‘, 28, ‘male‘)
36 p3 = People(‘xudachen3‘, 38, ‘male‘)
37 
38 print(p1.id)
39 print(p2.id)
40 print(p3.id)
41 
42 结果为：
43 
44 1dadcd98fe26e278ce864c2f0cf2e753
45 bc09cd38527ef257fa3158d4e342ea1b
46 bc09cd38527ef257fa3158d4e342ea1b

非绑定方法，不与类或者对象绑定，谁都可以调用，没有自动传值一说