python面向对象之绑定方法与非绑定方法

Posted on | In

类中定义的函数分成两大类

一：绑定方法

绑定给谁，谁来调用就自动将它本身当作第一个参数传入

1.绑定到类的方法：用classmethod装饰器装饰的方法。

为类量身定制

类.boud_method(),自动将类当作第一个参数传入

(其实对象也可调用，但仍将类当作第一个参数传入)

2.绑定到对象的方法：没有被任何装饰器装饰的方法。

为对象量身定制

对象.boud_method(),自动将对象当作第一个参数传入

(属于类的函数，类可以调用，但是必须按照函数的规则来，没有自动传值那么一说)

二：非绑定方法

用staticmethod装饰器装饰的方法

1.不与类或对象绑定，类和对象都可以调用，但是没有自动传值那么一说。就是一个普通工具而已

注意：与绑定到对象方法区分开，在类中直接定义的函数，没有被任何装饰器装饰的，都是绑定到对象的方法，可不是普通函数，对象调用该方法会自动传值，而staticmethod装饰的方法，不管谁来调用，都没有自动传值一说

绑定方法

绑定给对象的方法

首先我们明确一个知识点，凡是类中的方法或函数，默认情况下都是绑定给对象使用的。下面，我们通过实例，来慢慢解析绑定方法的应用。

1
2
3
4
5
6
7
8
9
10
11
12
class People:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def talk(self):
        pass
    
p = People('xiaohua',18)
print(p.talk)

输出结果：
<bound method People.talk of <__main__.People object at 0x000000F802C69358>>

从上面的输出结果来看，talk()這个类中的方法，是绑定给对象使用的。下面，我在看看另外一种情况。

1
2
3
4
5
6
7
8
9
10
11
12
class People:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def talk():
        pass

p = People('xiaohua',18)
print(p.talk)

输出结果：
<bound method People.talk of <__main__.People object at 0x000000FF68F39358>>

　现在，我们将talk()函数的参数去掉，结果显示与上面是一样。这说明，不管是类中的方法，还是类中函数，默认情况下都是绑定给对象使用的。绑定给对象使用有一种好处，那就是不用手动将对象传入。对象是自动传到类中。如果你不信，我们来看看下面的例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class People:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def talk():
        pass

p = People('xiaohua',18)
print(People.talk)
print(p.talk)

输出结果：
<function People.talk at 0x000000C54E3D0A60>  类来调用仅仅是当作函数使用
<bound method People.talk of <__main__.People object at 0x000000C54E249358>>  而对象来调用则为绑定方法

上面很好说明了，如果类来调用类中的方法，那么这个方法仅仅只是一个函数，那么既然是函数，就不会有自动传值这一功能。来看看下面代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class People:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def talk(self):
        pass

p = People('xiaohua',18)
People.talk() 1
p.talk() 2

#代码1处报错
talk() missing 1 required positional argument: 'self'
#代码2处正常

从上面输出结果来看，当类调用类中的方法时候，是不会进行自动传值的，也就是说，函数有几个参数，我们就得传递进去几个参数。如果想结果正常运行，那么在类名调用talk()的时候，将参数一一都传递进去。即：

1
People.talk(312312)

這个参数可以是任意的，但是，必须传递进去。而，当对象调用类中方法时候，则不用传递，如上面的2正常执行。既然知道了区别，那么，我们来看看下面代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class People:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def talk():
        pass

p = People('xiaohua',18)
People.talk() 1
p.talk() 2

# 1处正常执行
# 2 处报错
talk() takes 0 positional arguments but 1 was given

从输出结果来看，People来调用talk()方法时候，并不需要传递参数；而当对象来调用talk()的时候，由于对象调用自己的绑定方法，会自动将对象当作第一个参数传递进去，所以，当类中talk()方法没有带参数时，而你又给它传递了一个，显然是会报错的。

综上所述，我们可以得出以下结论：　

1.凡是类中的方法和函数，都是绑定给对象使用的；

2.绑定方法都有自动传值的功能。传递进去的值，就是对象本身。

3.如果类想调用绑定方法，就必须遵循函数的参数规则，有几个参数，就必须传递几个参数。

绑定给类的方法（classmethod）

classmehtod是给类用的，即绑定到类，类在使用时会将类本身当做参数传给类方法的第一个参数（即便是对象来调用也会将类当作第一个参数传入），python为我们内置了函数classmethod来把类中的函数定义成类方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import settings
class MySQL:
    def __init__(self,host,port):
        self.host=host
        self.port=port
 
    @classmethod
    def from_conf(cls):
        print(cls)
        return cls(settings.HOST,settings.PORT)
 
print(MySQL.from_conf) #<bound method MySQL.from_conf of <class '__main__.MySQL'>>
conn=MySQL.from_conf()
 
conn.from_conf() #对象也可以调用，但是默认传的第一个参数仍然是类

非绑定方法

在类内部用staticmethod装饰的函数即非绑定方法，就是普通函数

statimethod不与类或对象绑定，谁都可以调用，没有自动传值效果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import hashlib
import time
class MySQL:
    def __init__(self,host,port):
        self.id=self.create_id()
        self.host=host
        self.port=port
    @staticmethod
    def create_id(): #就是一个普通工具
        m=hashlib.md5(str(time.time()).encode('utf-8'))
        return m.hexdigest()
 
 
print(MySQL.create_id) #<function MySQL.create_id at 0x0000000001E6B9D8> 
#查看结果为普通函数
conn=MySQL('127.0.0.1',3306)
print(conn.create_id) #<function MySQL.create_id at 0x00000000026FB9D8> 
#查看结果为普通函数

classmethod与staticmethod的区别

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import settings
class MySQL:
    def __init__(self,host,port):
        self.host=host
        self.port=port
 
    @staticmethod
    def from_conf():
        return MySQL(settings.HOST,settings.PORT)
 
    # @classmethod #哪个类来调用,就将哪个类当做第一个参数传入
    # def from_conf(cls):
    #     return cls(settings.HOST,settings.PORT)
 
    def __str__(self):
        return '就不告诉你'
 
class Mariadb(MySQL):
    def __str__(self):
        return '<%s:%s>' %(self.host,self.port)
 
 
m=Mariadb.from_conf()
print(m) 
#我们的意图是想触发Mariadb.__str__,但是结果触发了MySQL.__str__的执行，打印就不告诉你：