类和对象的绑定方法及非绑定方法 - 好文

目录

* 一、绑定方法 <https://www.cnblogs.com/nickchen121/p/10990544.html#一绑定方法>
* 1.1 对象的绑定方法 <https://www.cnblogs.com/nickchen121/p/10990544.html#对象的绑定方法>
* 1.2 类的绑定方法 <https://www.cnblogs.com/nickchen121/p/10990544.html#类的绑定方法>
* 二、非绑定方法 <https://www.cnblogs.com/nickchen121/p/10990544.html#二非绑定方法>
* 三、练习 <https://www.cnblogs.com/nickchen121/p/10990544.html#三练习>
* 3.1 绑定方法小结 <https://www.cnblogs.com/nickchen121/p/10990544.html#绑定方法小结>
* 3.2 非绑定方法小结 <https://www.cnblogs.com/nickchen121/p/10990544.html#非绑定方法小结>
类中定义的方法大致可以分为两类：绑定方法和非绑定方法。其中绑定方法又可以分为绑定到对象的方法和绑定到类的方法。

一、绑定方法

1.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
1.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 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() # 默认的实例化方式：类名() obj =
Mysql('10.10.0.9', 3307, 27) obj.tell_info() 10.10.0.9:3307
3.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'>>
3.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

热门工具换一换