Python类和对象的绑定方法及非绑定方法

Posted 2023-03-03

类中定义的方法大致可以分为两类：绑定方法和非绑定方法。其中绑定方法又可以分为绑定到对象的方法和绑定到类的方法。

一、绑定方法

1 对象的绑定方法

在类中没有被任何装饰器修饰的方法就是 绑定到对象的方法，这类方法专门为对象定制。

class Person:
    country = "China"

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

    def speak(self):
        print(self.name + ,  + str(self.age))


p = Person(Kitty, 18)
print(p.__dict__)

name: Kitty, age: 18

print(Person.__dict__[speak])
<function Person.speak at 0x10f0dd268>

speak即为绑定到对象的方法，这个方法不在对象的名称空间中，而是在类的名称空间中。

通过对象调用绑定到对象的方法，会有一个自动传值的过程，即自动将当前对象传递给方法的第一个参数（self，一般都叫self，也可以写成别的名称）；若是使用类调用，则第一个参数需要手动传值。

p = Person(Kitty, 18)
p.speak()  # 通过对象调用
#输出
Kitty, 18

Person.speak(p)  # 通过类调用
#输出
Kitty, 18

2 类的绑定方法

类中使用 @classmethod 修饰的方法就是绑定到类的方法。这类方法专门为类定制。通过类名调用绑定到类的方法时，会将类本身当做参数传给类方法的第一个参数。

class Operate_database():
    host = 192.168.0.5
    port = 3306
    user = abc
    password = 123456

    @classmethod
    def connect(cls):  # 约定俗成第一个参数名为cls，也可以定义为其他参数名
        print(cls)
        print(cls.host + : + cls.port +   + cls.user + / + cls.password)


Operate_database.connect()

输出

<class __main__.Operate_database>
192.168.0.5:3306 abc/123456

通过对象也可以调用，只是默认传递的第一个参数还是这个对象对应的类。

Operate_database().connect()  # 输出结果一致

#输出
<class __main__.Operate_database>
192.168.0.5:3306 abc/123456

二、非绑定方法

在类内部使用 @staticmethod 修饰的方法即为非绑定方法，这类方法和普通定义的函数没有区别，不与类或对象绑定，谁都可以调用，且没有自动传值的效果。

import hashlib


class Operate_database():
    def __init__(self, host, port, user, password):
        self.host = host
        self.port = port
        self.user = user
        self.password = password

    @staticmethod
    def get_passwrod(salt, password):
        m = hashlib.md5(salt.encode(utf-8))  # 加盐处理
        m.update(password.encode(utf-8))
        return m.hexdigest()


hash_password = Operate_database.get_passwrod(lala, 123456)  # 通过类来调用
print(hash_password)

#输出
f7a1cc409ed6f51058c2b4a94a7e1956

```python
p = Operate_database(192.168.0.5, 3306, abc, 123456)
hash_password = p.get_passwrod(p.user, p.password)  # 也可以通过对象调用
print(hash_password)
#输出
0659c7992e268962384eb17fafe88364

简而言之，非绑定方法就是将普通方法放到了类的内部。

三、练习

假设我们现在有一个需求，需要让mysql实例化出的对象可以从文件settings.py中读取数据。

# settings.py
IP = 1.1.1.10
PORT = 3306
NET = 27

# test.py
import uuid


class Mysql:
    def __init__(self, ip, port, net):
        self.uid = self.create_uid()
        self.ip = ip
        self.port = port
        self.net = net

    def tell_info(self):
        """查看ip地址和端口号"""
        print(%s:%s % (self.ip, self.port))

    @classmethod
    def from_conf(cls):
        return cls(IP, NET, PORT)

    @staticmethod
    def func(x, y):
        print(不与任何人绑定)

    @staticmethod
    def create_uid():
        """随机生成一个字符串"""
        return uuid.uuid1()

#学习中遇到问题没人解答？小编创建了一个Python学习交流：711312441
# 默认的实例化方式：类名()
obj = Mysql(10.10.0.9, 3307, 27)

obj.tell_info()

10.10.0.9:3307

1 绑定方法小结

如果函数体代码需要用外部传入的类，则应该将该函数定义成绑定给类的方法

如果函数体代码需要用外部传入的对象，则应该将该函数定义成绑定给对象的方法

# 一种新的实例化方式：从配置文件中读取配置完成实例化
obj1 = Mysql.from_conf()
obj1.tell_info()

#输出
1.1.1.10:27



print(obj.tell_info)
#输出
<bound method Mysql.tell_info of <__main__.Mysql object at 0x10f469240>>



print(obj.from_conf)
#输出
<bound method Mysql.from_conf of <class __main__.Mysql>>

2 非绑定方法小结

如果函数体代码既不需要外部传入的类也不需要外部传入的对象，则应该将该函数定义成非绑定方法/普通函数

obj.func(1, 2)
#输出
不与任何人绑定


Mysql.func(3, 4)
#输出
不与任何人绑定


print(obj.func)
#输出
<function Mysql.func at 0x10f10e620>


print(Mysql.func)
#输出
<function Mysql.func at 0x10f10e620>


print(obj.uid)
#输出
a78489ec-92a3-11e9-b4d7-acde48001122