这里以 Python 2.7为例，探讨 __builtin__ 模块和 __builtins__ 模块的区别和联系。

在 Python3 中，__builtin__ 模块被命名为 builtins

1 名称空间（Namespace）

名称空间指的是名称（标识符）到对象的映射，在一个正常的Python程序的执行过程中，至少存在两个名称空间：

• 内建名称空间
• 全局名称空间

如果定义了函数，则还会有局部名称空间，全局名称空间一般由在程序的全局变量和它们对应的映射对象组成，而局部名称空间则在函数内部由函数局部变量和它们对应的映射对象组成，这里关键的是内建名称空间，它到底是怎么产生的？

2 内建函数

在启动 Python 解释器之后，即使没有创建任何的变量或者函数，还是会有许多函数可以使用，比如：

>>> abs(-1)
1
>>> max(1,2)
2
>>> abs
<built-in function abs>
>>> max
<built-in function max>

这些函数是内建函数，因为它们不需要我们程序员作任何定义，在启动 Python 解释器的时候，就已经导入到内存当中供我们使用

3 内建名称空间与 __builtins__

那么内建函数也是函数，虽然我们没有人为导入这些，但是正如前面所说，在启动 Python 解释器的时候，会自动帮我们导入，那么内建函数存在于哪里呢？

其实准确地来说，是 Python 解释器在启动的时候会首先加载内建名称空间，内建名称空间有许多名字到对象之间映射，而这些名字其实就是内建函数的名称，对象就是这些内建函数本身（注意区分函数名称和函数对象的区别）。这些名称空间由 __builtins__ 模块中的名字构成：

>>>  dir ()
[ '__builtins__' ,  '__doc__' ,  '__name__' ,  '__package__' ]

可以看到有一个 __builtins__ 的模块名称，这个模块本身定义了一个名称空间，即内建名称空间，我们不妨 dir 一下：

会看到我们熟悉的内建函数的名称，如 list、dict 等，当然还有一些异常和其它属性。

4 __builtins__ 与 __builtin__ 的简单区别

既然内建名称空间由 __builtins__ 模块中的名称空间定义，那么是不是也意味着内建名称空间中所对应的这些函数也是在 __builtins__ 模块中实现的呢？

显然不是的，我们可以在解释器中直接输入 __builtins__：

>>> __builtins__
<module '__builtin__' (built-in)>

结果中可以看到，__builtins__ 其实还是引用了 __builtin__ 模块而已，这说明真正的模块是 __builtin__，也就是说，前面提到的内建函数其实是在内建模块 __builtin__ 中定义的，即 __builtins__ 模块包含内建名称空间中内建名字的集合（因为它引用或者说指向了 __builtin__ 模块），而真正的内建函数、异常和属性来自 __builtin__ 模块。也就是说，在Python中，其实真正是只有 __builtin__ 这个模块，并不存在 __builtins__ 这个模块：

>>> import __builtin__
>>> import __builtins__
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ImportError: No module named __builtins__

可以看到，导入 __builtin__ 模块并没有问题，但导入 __builtins__ 模块时就会提示不存在，这充分说明了前面的结论，现在再次总结如下：

在 Python 中并没有 __builtins__这个模块，只有 __builtin__ 模块，__builtins__ 模块只是在启动 Python 解释器时，解释器为我们自动创建的一个到 __builtin__ 模块的引用

至于这种引用到底是怎么样，可以看下面的深入区别。

5 __builtins__ 与 __builtin__ 的深入区别

上面只是大概说了下 __builtins__ 与 __builtin__ 两个模块的简单区分而已，其实深究下去，要分成下面所提及的两种情况。

5.1 在主模块 __main__ 中

其实我们在使用 Python 交互器的时候就是在主模块中进行操作，可以做如下验证：

>>> print __name__
__main__

在这种情况，__builtins__ 与 __builtin__ 是完全一样的，它们指向的都是__builtin__ 这个内建模块

>>> import __builtin__
>>> __builtin__
<module '__builtin__' (built-in)>
>>> __builtins__
<module '__builtin__' (built-in)>
>>> __builtin__.__name__
'__builtin__'
>>> __builtins__.__name__
'__builtin__'
>>> __builtin__ == __builtins__
True
>>> __builtin__ is __builtins__
True
>>> id(__builtins__)
139655361473296
>>> id(__builtin__)
139655361473296

可以看到，这时候 __builtins__ 和 __builtin__ 是完全一样的，它们都指向了同一个模块对象，其实这也是 Python 中引用传递的概念。

其实这种情况跟我们创建一个变量并对它做一次引用传递时的情况是一样的，可以做如下测试：

>>> def func():
...     print "test"
... 
>>> funcs = func
>>> func
<function func at 0x7f040c21ccd0>
>>> funcs
<function func at 0x7f040c21ccd0>
>>> func.__name__
'func'
>>> funcs.__name__
'func'
>>> func == funcs
True
>>> func is funcs
True
>>> id(func)
139655360138448
>>> id(funcs)
139655360138448

显然，这完全验证了我们上面的结论。

5.2 不是在主模块中

如果不是在主模块中使用 __builtins__，这时候，__builtins__ 只是对__builtin__.__dict__ 的一个简单引用而已，可以通过下面的测试来验证说明。

先创建一个 test.py 模块，后面我们需要在 Python 交互器中导入它，那么这时候对于 test 模块来说，它就不是主模块了。如下：

import  __builtin__


print  'Module name:' , __name__

print  '*==test __builtin__ and __builtins__==*'
print  '__builtin__ == __builtins__' , __builtin__  ==  __builtins__
print  '__builtin__ is __builtins__' , __builtin__  is  __builtins__
print  'id(__builtin__)' ,  id (__builtin__)
print  'id(__builtins__)' ,  id (__builtins__)

print  '=' * 50

print  '*==test __builtin__.__dict__ and __builtins__==*'
print  '__builtin__.__dict__ == __builtins__' , __builtin__.__dict__  ==  __builtins__
print  '__builtin__ is __builtins__' , __builtin__.__dict__  is  __builtins__
print  'id(__builtin__)' ,  id (__builtin__.__dict__)
print  'id(__builtins__)' ,  id (__builtins__)

在 Python 交互器中导入上面这个 test 模块，如下：

>>> import test
Module name: test
*==test __builtin__ and __builtins__==*
__builtin__ == __builtins__ False
__builtin__ is __builtins__ False
id(__builtin__) 140032283536144
id(__builtins__) 140032283615600
==================================================
*==test __builtin__.__dict__ and __builtins__==*
__builtin__.__dict__ == __builtins__ True
__builtin__ is __builtins__ True
id(__builtin__) 140032283615600
id(__builtins__) 140032283615600

可以看到输出的结果跟我们想的是完全一样的，即这时候 __builtins__ 其实是对__builtin__.__dict__ 模块的引用

6 总结

不管怎么说，在启动 Python 解释器或运行一个 Python 程序时，内建名称空间都是从 __builtins__ 模块中加载的，只是 __builtins__ 本身是对 Python 内建模块 __builtin__ 的引用，而这种引用又分下面两种情况：

• 如果是在主模块 __main__ 中，__builtins__ 直接引用 __builtin__ 模块，此时模块名 __builtins__ 与模块名 __builtin__ 指向的都是同一个模块，即<builtin>内建模块（这里要注意变量名和对象本身的区别）
• 如果不是在主模块中，那么 __builtins__ 只是引用了__builtin__.__dict__

builtins模块详解

1.介绍

1.1 builtins: python内建模块

内建模块就是在使用的时候不需要进行import， 在python启动之后，在没有执行程序员编写的任何代码之前，python会加载内建模块中函数到内存（python的内建函数，例如：abs(),str(),type()等）。在python2.x中为builtins。

如果需要向内建模块中添加自己的函数，则必须import builtins在__main__模块中可以直接通过__builtins__添加函数，不需要import builtins。

1.2 builtins 与 __builtins__的区别

.在__main__模块中

在__main__模块中，__builtins__与builtins是同一个东西，可以使用两个中的任意一个来导入自己的函数到内建模块中，而使用builtins的时候需要import builtins，__builtins__不需要import。

.在非__main__模块中

__builtins__是对builtins的__dict__引用，而不是builtins本身

2.示例

代码

1.
#test.py
import builtins

def Test():
    print(__builtins__ is builtins)
    print(__builtins__ is builtins.__dict__)
    print(type(__builtins__))
   
Test() 

2.
import builtins

def Test():
    print(__builtins__ is builtins)
    print(__builtins__ is builtins.__dict__)
    print(type(__builtins__))

# 
if __name__ == '__main__':
    Test()

3. --->2
## test2.py
import test

test.Test()


4.--->1
## test2.py
import test

test.Test()

结果

1
2
3
4

为何Python源码builtins.py中的函数体都是pass？

目录

为何Python源码builtins.py中的函数体都是pass？

1.突发奇想看看源代码

2.如何查看源代码？

为何Python源码builtins.py中的函数体都是pass？

1.突发奇想看看源代码

今天在敲代码的时候好奇强大的list是怎么定义的，其中的函数是如何优化的，想着学习一下，于是点进了它的源代码，没想到竟然是下面的内容：

class list(object):
    """
    list() -> new empty list
    list(iterable) -> new list initialized from iterable's items
    """
    def append(self, p_object): # real signature unknown; restored from __doc__
        """ L.append(object) -> None -- append object to end """
        pass

    def clear(self): # real signature unknown; restored from __doc__
        """ L.clear() -> None -- remove all items from L """
        pass

    def copy(self): # real signature unknown; restored from __doc__
        """ L.copy() -> list -- a shallow copy of L """
        return []

    def count(self, value): # real signature unknown; restored from __doc__
        """ L.count(value) -> integer -- return number of occurrences of value """
        return 0

    def extend(self, iterable): # real signature unknown; restored from __doc__
        """ L.extend(iterable) -> None -- extend list by appending elements from the iterable """
        pass

    def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
        """
        L.index(value, [start, [stop]]) -> integer -- return first index of value.
        Raises ValueError if the value is not present.
        """
        return 0

    def insert(self, index, p_object): # real signature unknown; restored from __doc__
        """ L.insert(index, object) -- insert object before index """
        pass

    def pop(self, index=None): # real signature unknown; restored from __doc__
        """
        L.pop([index]) -> item -- remove and return item at index (default last).
        Raises IndexError if list is empty or index is out of range.
        """
        pass

    def remove(self, value): # real signature unknown; restored from __doc__
        """
        L.remove(value) -> None -- remove first occurrence of value.
        Raises ValueError if the value is not present.
        """
        pass

    def reverse(self): # real signature unknown; restored from __doc__
        """ L.reverse() -- reverse *IN PLACE* """
        pass

    def sort(self, key=None, reverse=False): # real signature unknown; restored from __doc__
        """ L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE* """
        pass

没想到源代码中只有函数功能的描述，函数体无一例外全是pass，WTF？？？

于是我去百度了一下，哦，这是Pycharm在糊弄老子呢

python是C语言实现的，尽管有很多标准库是由python代码实现，但是涉及到底层支撑架构的功能还是C代码。 一些IDE为了对这些进行友好代码提示，会弄和底层一样的访问接口，而其实现直接写 pass 略过。

2.如何查看源代码？

答：到github上查看Cpython项目，其地址为：https://github.com/python/cpython

在这里可以看到所有python基类的定义，所有函数的内容，例如我感兴趣的List就在Objects/listobject.c目录下，总共有3409行代码........

最后给大家看一下几个list中比较常用的函数在Cpython中的写法

大佬append()，源码并不长...

/*[clinic input]
list.append
     object: object
     /
Append object to the end of the list.
[clinic start generated code]*/

static PyObject *
list_append(PyListObject *self, PyObject *object)
/*[clinic end generated code: output=7c096003a29c0eae input=43a3fe48a7066e91]*/
{
    if (app1(self, object) == 0)
        Py_RETURN_NONE;
    return NULL;
}

POP（）

/*[clinic input]
list.pop
    index: Py_ssize_t = -1
    /
Remove and return item at index (default last).
Raises IndexError if list is empty or index is out of range.
[clinic start generated code]*/

static PyObject *
list_pop_impl(PyListObject *self, Py_ssize_t index)
/*[clinic end generated code: output=6bd69dcb3f17eca8 input=b83675976f329e6f]*/
{
    PyObject *v;
    int status;

    if (Py_SIZE(self) == 0) {
        /* Special-case most common failure cause */
        PyErr_SetString(PyExc_IndexError, "pop from empty list");
        return NULL;
    }
    if (index < 0)
        index += Py_SIZE(self);
    if (!valid_index(index, Py_SIZE(self))) {
        PyErr_SetString(PyExc_IndexError, "pop index out of range");
        return NULL;
    }
    v = self->ob_item[index];
    if (index == Py_SIZE(self) - 1) {
        status = list_resize(self, Py_SIZE(self) - 1);
        if (status >= 0)
            return v; /* and v now owns the reference the list had */
        else
            return NULL;
    }
    Py_INCREF(v);
    status = list_ass_slice(self, index, index+1, (PyObject *)NULL);
    if (status < 0) {
        Py_DECREF(v);
        return NULL;
    }
    return v;
}

index()

/*[clinic input]
list.index
    value: object
    start: slice_index(accept={int}) = 0
    stop: slice_index(accept={int}, c_default="PY_SSIZE_T_MAX") = sys.maxsize
    /
Return first index of value.
Raises ValueError if the value is not present.
[clinic start generated code]*/

static PyObject *
list_index_impl(PyListObject *self, PyObject *value, Py_ssize_t start,
                Py_ssize_t stop)
/*[clinic end generated code: output=ec51b88787e4e481 input=40ec5826303a0eb1]*/
{
    Py_ssize_t i;

    if (start < 0) {
        start += Py_SIZE(self);
        if (start < 0)
            start = 0;
    }
    if (stop < 0) {
        stop += Py_SIZE(self);
        if (stop < 0)
            stop = 0;
    }
    for (i = start; i < stop && i < Py_SIZE(self); i++) {
        PyObject *obj = self->ob_item[i];
        Py_INCREF(obj);
        int cmp = PyObject_RichCompareBool(obj, value, Py_EQ);
        Py_DECREF(obj);
        if (cmp > 0)
            return PyLong_FromSsize_t(i);
        else if (cmp < 0)
            return NULL;
    }
    PyErr_Format(PyExc_ValueError, "%R is not in list", value);
    return NULL;
}

count()

/*[clinic input]
list.count
     value: object
     /
Return number of occurrences of value.
[clinic start generated code]*/

static PyObject *
list_count(PyListObject *self, PyObject *value)
/*[clinic end generated code: output=b1f5d284205ae714 input=3bdc3a5e6f749565]*/
{
    Py_ssize_t count = 0;
    Py_ssize_t i;

    for (i = 0; i < Py_SIZE(self); i++) {
        PyObject *obj = self->ob_item[i];
        if (obj == value) {
           count++;
           continue;
        }
        Py_INCREF(obj);
        int cmp = PyObject_RichCompareBool(obj, value, Py_EQ);
        Py_DECREF(obj);
        if (cmp > 0)
            count++;
        else if (cmp < 0)
            return NULL;
    }
    return PyLong_FromSsize_t(count);
}