Import模块分析
------------------

::

    >>> dis.dis(compile("import os", "<none>", "exec"))
      1           0 LOAD_CONST               0 (-1)
                  3 LOAD_CONST               1 (None)
                  6 IMPORT_NAME              0 (os)
                  9 STORE_NAME               0 (os)
                 12 LOAD_CONST               1 (None)
                 15 RETURN_VALUE

    Python/ceval.c
    ==============

    case IMPORT_NAME:
        w = GETITEM(names, oparg);

        // 取__import__这个builtin函数
        x = PyDict_GetItemString(f->f_builtins, "__import__");
        if (x == NULL) {
            PyErr_SetString(PyExc_ImportError,
                            "__import__ not found");
            break;
        }
        Py_INCREF(x);

        // 打包参数
        v = POP();
        u = TOP();
        if (PyInt_AsLong(u) != -1 || PyErr_Occurred())
            w = PyTuple_Pack(5,
                        w,
                        f->f_globals,
                        f->f_locals == NULL ?
                              Py_None : f->f_locals,
                        v,
                        u);
        else
            w = PyTuple_Pack(4,
                        w,
                        f->f_globals,
                        f->f_locals == NULL ?
                              Py_None : f->f_locals,
                        v);
        Py_DECREF(v);
        Py_DECREF(u);
        if (w == NULL) {
            u = POP();
            Py_DECREF(x);
            x = NULL;
            break;
        }
        READ_TIMESTAMP(intr0);

        // 调用__import__函数
        // __import__(name, globals={}, locals={}, fromlist=[], level=-1) -> module
        v = x;
        x = PyEval_CallObject(v, w);
        Py_DECREF(v);
        READ_TIMESTAMP(intr1);
        Py_DECREF(w);
        SET_TOP(x);
        if (x != NULL) continue;
        break;

    Python/bltinmodule.c
    ====================

    static PyMethodDef builtin_methods[] = {
        {"__import__",      (PyCFunction)builtin___import__, METH_VARARGS | METH_KEYWORDS, import_doc},
        ...
    };

    static PyObject *
    builtin___import__(PyObject *self, PyObject *args, PyObject *kwds)
    {
        static char *kwlist[] = {"name", "globals", "locals", "fromlist",
                                 "level", 0};
        char *name;
        PyObject *globals = NULL;
        PyObject *locals = NULL;
        PyObject *fromlist = NULL;
        int level = -1;

        if (!PyArg_ParseTupleAndKeywords(args, kwds, "s|OOOi:__import__",
                        kwlist, &name, &globals, &locals, &fromlist, &level))
            return NULL;

        // ok，import模块的入口
        return PyImport_ImportModuleLevel(name, globals, locals,
                                          fromlist, level);
    }

    Python/import.c
    =================

    PyObject *
    PyImport_ImportModuleLevel(char *name, PyObject *globals, PyObject *locals,
                             PyObject *fromlist, int level)
    {
        PyObject *result;
        _PyImport_AcquireLock();

        // 好吧，这个才是最终的入口
        result = import_module_level(name, globals, locals, fromlist, level);
        if (_PyImport_ReleaseLock() < 0) {
            Py_XDECREF(result);
            PyErr_SetString(PyExc_RuntimeError,
                            "not holding the import lock");
            return NULL;
        }
        return result;
    }

    static PyObject *
    import_module_level(char *name, PyObject *globals, PyObject *locals,
                        PyObject *fromlist, int level)
    {
        char buf[MAXPATHLEN+1];
        Py_ssize_t buflen = 0;
        PyObject *parent, *head, *next, *tail;

        if (strchr(name, '/') != NULL
    #ifdef MS_WINDOWS
            || strchr(name, '\\') != NULL
    #endif
            ) {
            PyErr_SetString(PyExc_ImportError,
                            "Import by filename is not supported.");
            return NULL;
        }

        // 获取import语句所在的package
        parent = get_parent(globals, buf, &buflen, level);
        if (parent == NULL)
            return NULL;

        head = load_next(parent, level < 0 ? Py_None : parent, &name, buf,
                            &buflen);
        if (head == NULL)
            return NULL;

        tail = head;
        Py_INCREF(tail);
        while (name) {
            next = load_next(tail, tail, &name, buf, &buflen);
            Py_DECREF(tail);
            if (next == NULL) {
                Py_DECREF(head);
                return NULL;
            }
            tail = next;
        }
        if (tail == Py_None) {
            /* If tail is Py_None, both get_parent and load_next found
               an empty module name: someone called __import__("") or
               doctored faulty bytecode */
            Py_DECREF(tail);
            Py_DECREF(head);
            PyErr_SetString(PyExc_ValueError,
                            "Empty module name");
            return NULL;
        }

        if (fromlist != NULL) {
            if (fromlist == Py_None || !PyObject_IsTrue(fromlist))
                fromlist = NULL;
        }

        if (fromlist == NULL) {
            Py_DECREF(tail);
            return head;
        }

        Py_DECREF(head);
        if (!ensure_fromlist(tail, fromlist, buf, buflen, 0)) {
            Py_DECREF(tail);
            return NULL;
        }

        return tail;
    }

reload一个模块会复用已经载入的该模块的md_dict。对于pure python的模块，如果要干净
的reload，可以先将该模块从sys.modules中删除。当然这个对于builtin和c module是无效
的。 ::


    $ cat foo.py
    a = 1
    b = 2

    print 'foo'

    >>> import foo
    foo
    >>> dir(foo)
    ['__builtins__', '__doc__', '__file__', '__name__', '__package__', 'a', 'b']

    $cat foo.py
    a = 1
    c = 2

    print 'foo'

    >>> reload(foo)
    foo
    <module 'foo' from 'foo.py'>
    >>> dir(foo)
    ['__builtins__', '__doc__', '__file__', '__name__', '__package__', 'a', 'b', 'c']

    >>> import sys
    >>> del sys.modules['foo']
    >>> import foo
    foo
    >>> dir(foo)
    ['__builtins__', '__doc__', '__file__', '__name__', '__package__', 'a', 'c']