Python: 函数与方法的区别 以及 Bound Method 和 Unbound Method

函数与方法的区别

随着我们越来越频繁使用Python, 我们难免会接触到类, 接触到类属性和方法.但是很多新手包括我, 不知道方法函数 的区别,这次简单来讨论下, 如果有哪里认识不正确, 希望大神提点指教! 先来看两个定义吧:

function(函数) —— A series of statements which returns some value toa caller. It can also be passed zero or more arguments which may beused in the execution of the body. method(方法) —— A function which is defined inside a class body. Ifcalled as an attribute of an instance of that class, the methodwill get the instance object as its first argument (which isusually called self).

从上面可以看出, 别的编程语言一样, Function也是包含一个函数头和一个函数体, 也同样支持0到n个形参,而Method则是在function的基础上, 多了一层类的关系, 正因为这一层类, 所以区分了 functionmethod.而这个过程是通过 PyMethod_New实现的

PyObject *
PyMethod_New(PyObject *func, PyObject *self, PyObject *klass)
{
    register PyMethodObject *im;   // 定义方法结构体
    im = free_list;
    if (im != NULL) {
        free_list = (PyMethodObject *)(im->im_self);
        PyObject_INIT(im, &PyMethod_Type);  // 初始化
        numfree--;
    }
    else {
        im = PyObject_GC_New(PyMethodObject, &PyMethod_Type);
        if (im == NULL)
            return NULL;
    }
    im->im_weakreflist = NULL;
    Py_INCREF(func);
    
    /* 往下开始通过 func 配置 method*/
    im->im_func = func;
    Py_XINCREF(self);
    im->im_self = self;
    Py_XINCREF(klass);
    im->im_class = klass;
    _PyObject_GC_TRACK(im);
    return (PyObject *)im;

所以本质上, 函数和方法的区别是: 函数是属于 FunctionObject, 而 方法是属 PyMethodObject 简单来看下代码:

def aa(d, na=None, *kasd, **kassd):
    pass
class A(object):
    def f(self):
        return 1
a = A()
print '#### 各自方法描述 ####'
print '## 函数     %s' % aa
print '## 类方法   %s' % A.f
print '## 实例方法 %s' % a.f

输出结果:

#### 各自方法描述 ####
## 函数   <function aa at 0x000000000262AB38>
## 类方法   <unbound method A.f>
## 实例方法 <bound method A.f of <__main__.A object at 0x0000000002633198>>

Bound Method 和 Unbound Method

method 还能再分为 Bound MethodUnbound Method, 他们的差别是什么呢? 差别就是 Bound method 多了一个实例绑定的过程! A.funbound method, 而 a.fbound method, 从而验证了上面的描述是正确的!

看到这, 我们应该会有个问题:

 方法的绑定, 是什么时候发生的? 又是怎样的发生的?

带着这个问题, 我们继续探讨.很明显, 方法的绑定, 肯定是伴随着class的实例化而发生,我们都知道, 在class里定义方法, 需要显示传入self参数, 因为这个self是代表即将被实例化的对象。 我们需要dis模块来协助我们去观察这个绑定的过程:

[root@iZ23pynfq19Z ~]# cat 33.py
class A(object):
    def f(self):
        return 123
a = A()
print A.f()
print a.f()

## 命令执行 ##
[root@iZ23pynfq19Z ~]# python -m dis 33.py
  1           0 LOAD_CONST               0 ('A')
              3 LOAD_NAME                0 (object)
              6 BUILD_TUPLE              1
              9 LOAD_CONST               1 (<code object A at 0x7fc32f0b5030, file "33.py", line 1>)
             12 MAKE_FUNCTION            0
             15 CALL_FUNCTION            0
             18 BUILD_CLASS         
             19 STORE_NAME               1 (A)

  4          22 LOAD_NAME                1 (A)
             25 CALL_FUNCTION            0
             28 STORE_NAME               2 (a)

  5          31 LOAD_NAME                1 (A)
             34 LOAD_ATTR                3 (f)
             37 CALL_FUNCTION            0
             40 PRINT_ITEM          
             41 PRINT_NEWLINE       

  6          42 LOAD_NAME                2 (a)
             45 LOAD_ATTR                3 (f)
             48 CALL_FUNCTION            0
             51 PRINT_ITEM          
             52 PRINT_NEWLINE       
             53 LOAD_CONST               2 (None)
             56 RETURN_VALUE   

dis输出说明: 第一列是代码的行数, 第二列是指令的偏移量, 第三列是可视化指令, 第四列是参数, 第五列是指令根据参数计算或者查找的结果 咱们可以看到 第4列 和第五列, 分别就是对应: print A.f() 和 print a.f()

他们都是同样的字节码, 都是从所在的codeobject中的co_name取出参数对应的名字, 正因为参数的不同, 所以它们分别取到 A 和 a,下面我们需要来看看 LOAD_ATTR 的作用是什么:

//取自: python2.7/objects/ceval.c
        TARGET(LOAD_ATTR)
        {
            w = GETITEM(names, oparg);  // 从co_name 取出 f
            v = TOP();                  // 将刚才压入栈的 A/a 取出来
            x = PyObject_GetAttr(v, w); // 取得真正的执行函数
            Py_DECREF(v);
            SET_TOP(x);
            if (x != NULL) DISPATCH();
            break;
        }

通过 SET_TOP, 已经将我们需要真正执行的函数压入运行时栈, 接下来就是通过 CALL_FUNCTION 来调用这个函数对象, 继续来看看具体过程:

//取自: python2.7/objects/ceval.c
TARGET(CALL_FUNCTION)
        {
            PyObject **sp;
            PCALL(PCALL_ALL);
            sp = stack_pointer;
#ifdef WITH_TSC
            x = call_function(&sp, oparg, &intr0, &intr1);
#else
            x = call_function(&sp, oparg);  // 细节请往下看
#endif
            stack_pointer = sp;
            PUSH(x);
            if (x != NULL) DISPATCH();
            break;
        }
       
static PyObject *
call_function(PyObject ***pp_stack, int oparg)     
{
    int na = oparg & 0xff;                // 位置参数个数
    int nk = (oparg>>8) & 0xff;           // 关键位置参数的个数
    int n = na + 2 * nk;                  // 总的个数和
    PyObject **pfunc = (*pp_stack) - n - 1;  // 当前栈位置-参数个数,得到函数对象
    PyObject *func = *pfunc;  
    PyObject *x, *w;
    ... // 省略前面细节, 只看关键调用
    if (PyMethod_Check(func) && PyMethod_GET_SELF(func) != NULL) {
            /* optimize access to bound methods */
            PyObject *self = PyMethod_GET_SELF(func);
            PCALL(PCALL_METHOD);
            PCALL(PCALL_BOUND_METHOD);
            Py_INCREF(self);
            func = PyMethod_GET_FUNCTION(func);
            Py_INCREF(func);
            Py_SETREF(*pfunc, self);
            na++;
            n++;
        } else
            Py_INCREF(func);
        READ_TIMESTAMP(*pintr0);
        if (PyFunction_Check(func))
            x = fast_function(func, pp_stack, n, na, nk);
        else
            x = do_call(func, pp_stack, na, nk);
        READ_TIMESTAMP(*pintr1);
        Py_DECREF(func);
}

咱们来捋下调用顺序:

CALL_FUNCTION -> call_function -> 根据函数的类型 -> 执行对应的操作

当程序运行到call_function时, 主要有的函数类型判断有: PyCFunction, PyMethod, PyFunction 在这里, 虚拟机已经判断出func是不属于PyCFunction, 所以将会落入上面源码的判断分支中, 而它将要做的,就是分别通过 PyMethod_GET_SELF, PyMethod_GET_FUNCTION 获得self对象和func函数, 然后通过调用 Py_SETREF(*pfunc, self):

// Py_SETREF 定义如下
#define Py_SETREF(op, op2)                      \
    do {                                        \
        PyObject *_py_tmp = (PyObject *)(op);   \
        (op) = (op2);                           \
        Py_DECREF(_py_tmp);                     \
    } while (0)

可以看出, Py_SETREF是用这个self对象替换了pfunc指向的对象了, 而pfunc在上面已经提及到了, 就是当时压入运行时栈的函数对象. 除了这几步, 还有更重要的就是, na 和 n 都分别自增1 看回上面的 a.f(), 咱们可以知道, 它是不需要参数的, 所以理论上 na,nk和n都是0, 但是因为f是method(方法), 经过上面一系列操作, 它将会传入一个self,而na也会变成1, 又因为*pfunc已经被替换成self, 相应代码:

if (PyFunction_Check(func))
            x = fast_function(func, pp_stack, n, na, nk);
        else
            x = do_call(func, pp_stack, na, nk);

所以它不再进入function的寻常路了, 而是走do_call, 然后就开始真正的调用; 其实这个涉及到Python调用函数的整个过程, 因为比较复杂, 后期找个时间专门谈谈这个

聊到这里, 我们已经大致清楚, 一个method(方法) 在调用时所发生的过程.明白了函数和方法的本质区别, 那么回到主题上 来说下 UnboundBound, 其实这两者差别也不大. 从上面我们得知, 一个方法的创建, 是需要self, 而调用时, 也会使用self,而只有实例化对象, 才有这个self, class是没有的, 所以像下面的执行, 是失败的额

class A(object):
    def f(self):
        return 1
a = A()

print '#### 各自方法等效调用 ####'
print '## 类方法 %s' % A.f()
print '## 实例方法 %s' % a.f()

## 输出结果 ##
#### 各自方法等效调用 ####
Traceback (most recent call last):
  File "C:/Users/Administrator/ZGZN_Admin/ZGZN_Admin/1.py", line 20, in <module>
    print '## 类方法 %s' % A.f()
TypeError: unbound method f() must be called with A instance as first argument (got nothing instead)

错误已经很明显了: 函数未绑定, 必须要将A的实例作为第一个参数 既然它要求第一个参数是 A的实例对象, 那我们就试下修改代码:

class A(object):
    def f(self):
        return 1
a = A()

print '#### 各自方法等效调用 ####'
print '## 类方法 %s' % A.f(a)   #传入A的实例a
print '## 实例方法 %s' % a.f()

## 结果 ##
#### 各自方法等效调用 ####
## 类方法 1
## 实例方法 1

可以看出来, BoundUnbound判断的依据就是, 当方法真正执行时, 有没有传入实例, A.f(a) 和 a.f() 用法的区别只是在于, 第一种需要人为传入实例才能调用, 而第二种, 是虚拟机帮我们做好了传入实例的动作, 不用我们那么麻烦而已, 两种方法本质上是等价的

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏鸿的学习笔记

python源码阅读笔记之几个值得注意的点

922
来自专栏性能与架构

Mysql order by排序优化

1. 加大max_length_for_sort_data参数的设置 在MySQL中,排序算法分为两种,一是只加载排序字段到内存,排序完成后再到表中取其他字段,...

3645
来自专栏函数式编程语言及工具

FunDA(15)- 示范:任务并行运算 - user task parallel execution

    FunDA的并行运算施用就是对用户自定义函数的并行运算。原理上就是把一个输入流截分成多个输入流并行地输入到一个自定义函数的多个运行实例。这些函数运行实例...

1929
来自专栏GIS讲堂

geotools编写shp转sql,实现shp数据入Oracle Spatial库

用到Oracle Spatial就很难避免shp文件的入库问题,虽然有shp2sdo工具,但是用起来不是很习惯,所以,本文讲述如何结合geotools实现shp...

2674
来自专栏对角另一面

lodash源码分析之baseFindIndex中的运算符优先级

我悟出权力本来就是不讲理的——蟑螂就是海米;也悟出要造反,内心必须强大到足以承受任何后果才行。 ——北岛《城门开》 本文为读 lodash 源码的第十篇,后...

27811
来自专栏对角另一面

lodash源码分析之baseFindIndex中的运算符优先级

本文为读 lodash 源码的第十篇,后续文章会更新到这个仓库中,欢迎 star:pocket-lodash

2058
来自专栏鸿的学习笔记

Python写的Python解释器(二)

玩具解释器 首先从一个玩具解释器开始,这个微型解释器只能做加法,而且值包含了三个指令,这三个指令是:

992
来自专栏chenssy

【死磕Sharding-jdbc】---group by结果合并(2)

在sharding-jdbc源码之group by结果合并(1)中主要分析了sharding-jdbc如何在GroupByStreamResultSetMerg...

1032
来自专栏恰童鞋骚年

剑指Offer面试题:27.最小的k个数

  这道题是典型的TopK问题,其最简单的思路莫过于把输入的n个整数排序,排序之后位于最前面的k个数就是最小的k个数。这种思路的时间复杂度是O(nlogn),但...

1542
来自专栏菩提树下的杨过

java:快速文件分割及合并

文件分割与合并是一个常见需求,比如:上传大文件时,可以先分割成小块,传到服务器后,再进行合并。很多高大上的分布式文件系统(比如:google的GFS、taoba...

5269

扫码关注云+社区

领取腾讯云代金券