知识共享许可协议
本作品采用知识共享署名-非商业性使用-禁止演绎 3.0 未本地化版本许可协议进行许可。

Python 源码整理 - 1

说明
使用的源码是 Python 2.7.9 - 2014-12-10
下载源码
https://www.python.org/downloads/source/
代码结构及主要目录说明
total 1784
drwxr-xr-x@  23 nate  staff     782 Dec 10 23:59 Demo
drwxr-xr-x@  29 nate  staff     986 Jan 28 01:17 Doc
drwxr-xr-x@   3 nate  staff     102 Dec 10 23:59 Grammar
drwxr-xr-x@  93 nate  staff    3162 Dec 10 23:59 Include
-rw-r--r--@   1 nate  staff   12755 Dec 10 23:59 LICENSE
drwxr-xr-x@ 254 nate  staff    8636 Dec 10 23:59 Lib
drwxr-xr-x@  15 nate  staff     510 Dec 10 23:59 Mac
-rw-r--r--@   1 nate  staff   45329 Dec 10 23:59 Makefile.pre.in
drwxr-xr-x@  34 nate  staff    1156 Dec 10 23:59 Misc
drwxr-xr-x@ 137 nate  staff    4658 Jan 28 01:16 Modules
drwxr-xr-x@  46 nate  staff    1564 Dec 10 23:59 Objects
drwxr-xr-x@  39 nate  staff    1326 Dec 10 23:59 PC
drwxr-xr-x@  54 nate  staff    1836 Dec 10 23:59 PCbuild
drwxr-xr-x@  25 nate  staff     850 Dec 10 23:59 Parser
drwxr-xr-x@  75 nate  staff    2550 Dec 10 23:59 Python
-rw-r--r--@   1 nate  staff   53978 Dec 10 23:59 README
drwxr-xr-x@  11 nate  staff     374 Dec 10 23:59 RISCOS
drwxr-xr-x@  23 nate  staff     782 Dec 11 00:00 Tools
-rwxr-xr-x@   1 nate  staff   42856 Dec 11 00:00 config.guess
-rwxr-xr-x@   1 nate  staff   35740 Dec 11 00:00 config.sub
-rwxr-xr-x@   1 nate  staff  428607 Dec 11 00:00 configure
-rw-r--r--@   1 nate  staff  134982 Dec 11 00:00 configure.ac
-rwxr-xr-x@   1 nate  staff    7122 Dec 11 00:00 install-sh
-rw-r--r--@   1 nate  staff   34898 Dec 11 00:00 pyconfig.h.in
-rw-r--r--@   1 nate  staff   97660 Dec 11 00:00 setup.py

Demo # 示例的相关Python代码目录
Doc  # 文档目录
Grammar # 语法分析目录
Include # 相关的C头文件目录
Lib # 相关的Python写的模块
Mac # Mac OS相关
Modules # 对性能有要求的C语言写的模块
Objects # 所有Python的内建对象的C语言实现
Parser # 词法分析和语法分析,Python代码解析的C语言实现
Python # Python引擎的C语言实现
Python对象
Python中所有的东西都是对象
内建对象的相关头文件都在Include下面
object.h
  • PyObject

    PyObject 用于定长对象的定义,比如int
    
    在 Include/object.h里可以查到PyObject结构体的定义:
    typedef struct _object {
        PyObject_HEAD
    } PyObject;
    
    PyObject_HEAD是一个宏,宏的定义在同一个文件,如下:
    #define PyObject_HEAD                   \
        _PyObject_HEAD_EXTRA                \
        Py_ssize_t ob_refcnt;               \
        struct _typeobject *ob_type;
    
    _PyObject_HEAD_EXTRA 是另一个宏,用于定义双向链表,需要开启Py_TRACE_REFS:
    #ifdef Py_TRACE_REFS
    #define _PyObject_HEAD_EXTRA            \
        struct _object *_ob_next;           \
        struct _object *_ob_prev;
    
    Py_ssize_t 的定义在 pyport.h
    #ifdef HAVE_SSIZE_T
        typedef ssize_t         Py_ssize_t;
    #elif SIZEOF_VOID_P == SIZEOF_SIZE_T
        typedef Py_intptr_t     Py_ssize_t;
    #else
    #   error "Python needs a typedef for Py_ssize_t in pyport.h."
    #endif
    
    py_intptr_t 定义:
    #ifdef HAVE_UINTPTR_T
    typedef uintptr_t       Py_uintptr_t;
    typedef intptr_t        Py_intptr_t;
    
    #elif SIZEOF_VOID_P <= SIZEOF_INT
    typedef unsigned int    Py_uintptr_t;
    typedef int             Py_intptr_t;
    
    #elif SIZEOF_VOID_P <= SIZEOF_LONG
    typedef unsigned long   Py_uintptr_t;
    typedef long            Py_intptr_t;
    
    #elif defined(HAVE_LONG_LONG) && (SIZEOF_VOID_P <= SIZEOF_LONG_LONG)
    typedef unsigned PY_LONG_LONG   Py_uintptr_t;
    typedef PY_LONG_LONG            Py_intptr_t;
    
    #else
    #   error "Python needs a typedef for Py_uintptr_t in pyport.h."
    #endif /* HAVE_UINTPTR_T */ 
    
    看出ob_refcnt 是个无符号整型或者无符号整型指针,用于定义引用计数,当有一个对象引用了这个对象,这个值就会自增1,相反就减1,当减到0就可以释放内存
    
    struct _typeobject *ob_type;
    
    _typeobject的定义如下:
    typedef struct _typeobject {
        PyObject_VAR_HEAD
        const char *tp_name; /* For printing, in format "<module>.<name>" */
        Py_ssize_t tp_basicsize, tp_itemsize; /* For allocation */
    
        /* Methods to implement standard operations */
    
        destructor tp_dealloc;
        printfunc tp_print;
        getattrfunc tp_getattr;
        setattrfunc tp_setattr;
        cmpfunc tp_compare;
        reprfunc tp_repr;
    
        /* Method suites for standard classes */
    
        PyNumberMethods *tp_as_number;
        PySequenceMethods *tp_as_sequence;
        PyMappingMethods *tp_as_mapping;
    
        /* More standard operations (here for binary compatibility) */
    
        hashfunc tp_hash;
        ternaryfunc tp_call;
        reprfunc tp_str;
        getattrofunc tp_getattro;
        setattrofunc tp_setattro;
    
        /* Functions to access object as input/output buffer */
        PyBufferProcs *tp_as_buffer;
    
        /* Flags to define presence of optional/expanded features */
        long tp_flags;
    
        const char *tp_doc; /* Documentation string */
    
        /* Assigned meaning in release 2.0 */
        /* call function for all accessible objects */
        traverseproc tp_traverse;
    
        /* delete references to contained objects */
        inquiry tp_clear;
    
        /* Assigned meaning in release 2.1 */
        /* rich comparisons */
        richcmpfunc tp_richcompare;
    
        /* weak reference enabler */
        Py_ssize_t tp_weaklistoffset;
    
        /* Added in release 2.2 */
        /* Iterators */
        getiterfunc tp_iter;
        iternextfunc tp_iternext;
    
        /* Attribute descriptor and subclassing stuff */
        struct PyMethodDef *tp_methods;
        struct PyMemberDef *tp_members;
        struct PyGetSetDef *tp_getset;
        struct _typeobject *tp_base;
        PyObject *tp_dict;
        descrgetfunc tp_descr_get;
        descrsetfunc tp_descr_set;
        Py_ssize_t tp_dictoffset;
        initproc tp_init;
        allocfunc tp_alloc;
        newfunc tp_new;
        freefunc tp_free; /* Low-level free-memory routine */
        inquiry tp_is_gc; /* For PyObject_IS_GC */
        PyObject *tp_bases;
        PyObject *tp_mro; /* method resolution order */
        PyObject *tp_cache;
        PyObject *tp_subclasses;
        PyObject *tp_weaklist;
        destructor tp_del;
    
        /* Type attribute cache version tag. Added in version 2.6 */
        unsigned int tp_version_tag;
    
    #ifdef COUNT_ALLOCS
        /* these must be last and never explicitly initialized */
        Py_ssize_t tp_allocs;
        Py_ssize_t tp_frees;
        Py_ssize_t tp_maxalloc;
        struct _typeobject *tp_prev;
        struct _typeobject *tp_next;
    #endif
    } PyTypeObject;
    
  • PyVarObject

    PyVarObject 用于变长对象,比如string
    
    在 Include/object.h里可以查到PyVarObject结构体的定义:
    typedef struct {
        PyObject_VAR_HEAD
    } PyVarObjec
    
    PyObject_VAR_HEAD是一个宏,定义如下:
    #define PyObject_VAR_HEAD               \
        PyObject_HEAD                       \
        Py_ssize_t ob_size; /* Number of items in variable part */
    
    可以看出他比PyObject 就多了个 Py_ssize_t ob_size, 用于表示元素的个数。
    
  • PyTypeObject

    typedef struct _typeobject {
        PyObject_VAR_HEAD //对象头
        const char *tp_name; //名称,格式: <module>.<name>
        Py_ssize_t tp_basicsize, tp_itemsize; //分配内存的信息
    
        destructor tp_dealloc;  //析构函数
        printfunc tp_print;
        getattrfunc tp_getattr;
        setattrfunc tp_setattr;
        cmpfunc tp_compare;
        reprfunc tp_repr;
    
        PyNumberMethods *tp_as_number; //数值对象的操作
        PySequenceMethods *tp_as_sequence; //序列对象的操作
        PyMappingMethods *tp_as_mapping; //关联对象的操作
    
        hashfunc tp_hash; //生成hash值的函数指针
        ternaryfunc tp_call;
        reprfunc tp_str;
        getattrofunc tp_getattro;
        setattrofunc tp_setattro;
    
        PyBufferProcs *tp_as_buffer;
    
        long tp_flags;
    
        const char *tp_doc; //文档信息
    
        traverseproc tp_traverse;
    
        inquiry tp_clear;
    
        richcmpfunc tp_richcompare;
    
        Py_ssize_t tp_weaklistoffset;
    
        getiterfunc tp_iter;
        iternextfunc tp_iternext;
    
        struct PyMethodDef *tp_methods;
        struct PyMemberDef *tp_members;
        struct PyGetSetDef *tp_getset;
        struct _typeobject *tp_base; //指向基类的指针
        PyObject *tp_dict;
        descrgetfunc tp_descr_get;
        descrsetfunc tp_descr_set;
        Py_ssize_t tp_dictoffset;
        initproc tp_init; //初始化对象
        allocfunc tp_alloc;
        newfunc tp_new; //创建对象
        freefunc tp_free;
        inquiry tp_is_gc;
        PyObject *tp_bases; 
        PyObject *tp_mro; 
        PyObject *tp_cache;
        PyObject *tp_subclasses;
        PyObject *tp_weaklist;
        destructor tp_del;
    
        unsigned int tp_version_tag;
    
    #ifdef COUNT_ALLOCS
        Py_ssize_t tp_allocs;
        Py_ssize_t tp_frees;
        Py_ssize_t tp_maxalloc;
        struct _typeobject *tp_prev;
        struct _typeobject *tp_next;
    #endif
    } PyTypeObject;
    
  • PyNumberMethods

    typedef struct {
        binaryfunc nb_add;
        binaryfunc nb_subtract;
        binaryfunc nb_multiply;
        binaryfunc nb_divide;
        binaryfunc nb_remainder;
        binaryfunc nb_divmod;
        ternaryfunc nb_power;
        unaryfunc nb_negative;
        unaryfunc nb_positive;
        unaryfunc nb_absolute;
        inquiry nb_nonzero;
        unaryfunc nb_invert;
        binaryfunc nb_lshift;
        binaryfunc nb_rshift;
        binaryfunc nb_and;
        binaryfunc nb_xor;
        binaryfunc nb_or;
        coercion nb_coerce;
        unaryfunc nb_int;
        unaryfunc nb_long;
        unaryfunc nb_float;
        unaryfunc nb_oct;
        unaryfunc nb_hex;
    
        binaryfunc nb_inplace_add;
        binaryfunc nb_inplace_subtract;
        binaryfunc nb_inplace_multiply;
        binaryfunc nb_inplace_divide;
        binaryfunc nb_inplace_remainder;
        ternaryfunc nb_inplace_power;
        binaryfunc nb_inplace_lshift;
        binaryfunc nb_inplace_rshift;
        binaryfunc nb_inplace_and;
        binaryfunc nb_inplace_xor;
        binaryfunc nb_inplace_or;
    
        binaryfunc nb_floor_divide;
        binaryfunc nb_true_divide;
        binaryfunc nb_inplace_floor_divide;
        binaryfunc nb_inplace_true_divide;
    
        unaryfunc nb_index;
    } PyNumberMethods;
    
  • PySequenceMethods

    typedef struct {
        lenfunc sq_length;
        binaryfunc sq_concat;
        ssizeargfunc sq_repeat;
        ssizeargfunc sq_item;
        ssizessizeargfunc sq_slice;
        ssizeobjargproc sq_ass_item;
        ssizessizeobjargproc sq_ass_slice;
        objobjproc sq_contains;
        /* Added in release 2.0 */
        binaryfunc sq_inplace_concat;
        ssizeargfunc sq_inplace_repeat;
    } PySequenceMethods;
    
  • PyMappingMethods

    typedef struct {
        lenfunc mp_length;
        binaryfunc mp_subscript;
        objobjargproc mp_ass_subscript;
    } PyMappingMethods;
    
intobject.h
  • PyIntObject

    typedef struct {
        PyObject_HEAD
        long ob_ival;
    } PyIntObject;
    
longobject.h
  • PyLongObject

    typedef struct _longobject PyLongObject;
    
    而_longobject的定义在longintrepr.h, 定义如下:
    typedef unsigned short digit;
    
    struct _longobject {
        PyObject_VAR_HEAD
        digit ob_digit[1];
    };
    
floatobject.h
  • PyFloatObject

    typedef struct {
        PyObject_HEAD
        double ob_fval;
    } PyFloatObject;
    
boolobject.h
  • PyBoolObject

    typedef PyIntObject PyBoolObject;
    
stringobject.h
  • PyStringObject

    typedef struct {
        PyObject_VAR_HEAD
        long ob_shash;
        int ob_sstate;
        char ob_sval[1];
    } PyStringObject;
    
tupleobject.h
  • PyTupleObject

    typedef struct {
        PyObject_VAR_HEAD
        PyObject *ob_item[1];
    } PyTupleObject;
    
listobject.h
  • PyListObject

    typedef struct {
        PyObject_VAR_HEAD
        PyObject **ob_item;
        Py_ssize_t allocated;
    } PyListObject;
    
setobject.h
  • PySetObject

    typedef struct _setobject PySetObject;
    struct _setobject {
        PyObject_HEAD
    
        Py_ssize_t fill;  /* # Active + # Dummy */
        Py_ssize_t used;  /* # Active */
    
        /* The table contains mask + 1 slots, and that's a power of 2.
         * We store the mask instead of the size because the mask is more
         * frequently needed.
         */
        Py_ssize_t mask;
    
        /* table points to smalltable for small tables, else to
         * additional malloc'ed memory.  table is never NULL!  This rule
         * saves repeated runtime null-tests.
         */
        setentry *table;
        setentry *(*lookup)(PySetObject *so, PyObject *key, long hash);
        setentry smalltable[PySet_MINSIZE];
    
        long hash;                  /* only used by frozenset objects */
        PyObject *weakreflist;      /* List of weak references */
    };
    
sliceobject.h
  • PySliceObject

    typedef struct {
        PyObject_HEAD
        PyObject *start, *stop, *step;  /* not NULL */
    } PySliceObject;
    
bytearrayobject.h
  • PyByteArrayObject

    typedef struct {
        PyObject_VAR_HEAD
        /* XXX(nnorwitz): should ob_exports be Py_ssize_t? */
        int ob_exports; /* how many buffer exports */
        Py_ssize_t ob_alloc; /* How many bytes allocated */
        char *ob_bytes;
    } PyByteArrayObject;
    
cellobject.h
  • PyCellObject

    typedef struct {
        PyObject_HEAD
        PyObject *ob_ref;   /* Content of the cell or NULL when empty */
    } PyCellObject;
    
classobject.h
  • PyClassObject

    typedef struct {
        PyObject_HEAD
        PyObject    *cl_bases;  /* A tuple of class objects */
        PyObject    *cl_dict;   /* A dictionary */
        PyObject    *cl_name;   /* A string */
        /* The following three are functions or NULL */
        PyObject    *cl_getattr;
        PyObject    *cl_setattr;
        PyObject    *cl_delattr;
        PyObject    *cl_weakreflist; /* List of weak references */
    } PyClassObject;
    
  • PyInstanceObject

    typedef struct {
        PyObject_HEAD
        PyClassObject *in_class;    /* The class object */
        PyObject      *in_dict; /* A dictionary */
        PyObject      *in_weakreflist; /* List of weak references */
    } PyInstanceObject;
    
  • PyMethodObject

    typedef struct {
        PyObject_HEAD
        PyObject *im_func;   /* The callable object implementing the method */
        PyObject *im_self;   /* The instance it is bound to, or NULL */
        PyObject *im_class;  /* The class that asked for the method */
        PyObject *im_weakreflist; /* List of weak references */
    } PyMethodObject;
    
cobject.h
  • PyCObject

    typedef struct {
        PyObject_HEAD
        void *cobject;
        void *desc;
        void (*destructor)(void *);
    } PyCObject;
    
    code.h
  • PyCodeObject

    typedef struct {
        PyObject_HEAD
        int co_argcount;        /* #arguments, except *args */
        int co_nlocals;     /* #local variables */
        int co_stacksize;       /* #entries needed for evaluation stack */
        int co_flags;       /* CO_..., see below */
        PyObject *co_code;      /* instruction opcodes */
        PyObject *co_consts;    /* list (constants used) */
        PyObject *co_names;     /* list of strings (names used) */
        PyObject *co_varnames;  /* tuple of strings (local variable names) */
        PyObject *co_freevars;  /* tuple of strings (free variable names) */
        PyObject *co_cellvars;      /* tuple of strings (cell variable names) */
        /* The rest doesn't count for hash/cmp */
        PyObject *co_filename;  /* string (where it was loaded from) */
        PyObject *co_name;      /* string (name, for reference) */
        int co_firstlineno;     /* first source line number */
        PyObject *co_lnotab;    /* string (encoding addr<->lineno mapping) See
                    Objects/lnotab_notes.txt for details. */
        void *co_zombieframe;     /* for optimization only (see frameobject.c) */
        PyObject *co_weakreflist;   /* to support weakrefs to code objects */
    } PyCodeObject;
    
fileobject.h
  • PyFileObject

    typedef struct {
        PyObject_HEAD
        FILE *f_fp;
        PyObject *f_name;
        PyObject *f_mode;
        int (*f_close)(FILE *);
        int f_softspace;            /* Flag used by 'print' command */
        int f_binary;               /* Flag which indicates whether the file is
                                   open in binary (1) or text (0) mode */
        char* f_buf;                /* Allocated readahead buffer */
        char* f_bufend;             /* Points after last occupied position */
        char* f_bufptr;             /* Current buffer position */
        char *f_setbuf;             /* Buffer for setbuf(3) and setvbuf(3) */
        int f_univ_newline;         /* Handle any newline convention */
        int f_newlinetypes;         /* Types of newlines seen */
        int f_skipnextlf;           /* Skip next \n */
        PyObject *f_encoding;
        PyObject *f_errors;
        PyObject *weakreflist; /* List of weak references */
        int unlocked_count;         /* Num. currently running sections of code
                               using f_fp with the GIL released. */
        int readable;
        int writable;
    } PyFileObject;
    
funcobject.h
  • PyFuncObject

    typedef struct {
        PyObject_HEAD
        PyObject *func_code;    /* A code object */
        PyObject *func_globals; /* A dictionary (other mappings won't do) */
        PyObject *func_defaults;    /* NULL or a tuple */
        PyObject *func_closure; /* NULL or a tuple of cell objects */
        PyObject *func_doc;     /* The __doc__ attribute, can be anything */
        PyObject *func_name;    /* The __name__ attribute, a string object */
        PyObject *func_dict;    /* The __dict__ attribute, a dict or NULL */
        PyObject *func_weakreflist; /* List of weak references */
        PyObject *func_module;  /* The __module__ attribute, can be anything */
    
    } PyFunctionObject;
    
frameobject.h
  • PyFrameObject

    typedef struct {
        int b_type;         /* what kind of block this is */
        int b_handler;      /* where to jump to find handler */
        int b_level;        /* value stack level to pop to */
    } PyTryBlock;
    
    typedef struct _frame {
        PyObject_VAR_HEAD
        struct _frame *f_back;  /* previous frame, or NULL */
        PyCodeObject *f_code;   /* code segment */
        PyObject *f_builtins;   /* builtin symbol table (PyDictObject) */
        PyObject *f_globals;    /* global symbol table (PyDictObject) */
        PyObject *f_locals;     /* local symbol table (any mapping) */
        PyObject **f_valuestack;    /* points after the last local */
        /* Next free slot in f_valuestack.  Frame creation sets to f_valuestack.
           Frame evaluation usually NULLs it, but a frame that yields sets it
           to the current stack top. */
        PyObject **f_stacktop;
        PyObject *f_trace;      /* Trace function */
    
        /* If an exception is raised in this frame, the next three are used to
         * record the exception info (if any) originally in the thread state.  See
         * comments before set_exc_info() -- it's not obvious.
         * Invariant:  if _type is NULL, then so are _value and _traceback.
         * Desired invariant:  all three are NULL, or all three are non-NULL.  That
         * one isn't currently true, but "should be".
         */
        PyObject *f_exc_type, *f_exc_value, *f_exc_traceback;
    
        PyThreadState *f_tstate;
        int f_lasti;        /* Last instruction if called */
        /* Call PyFrame_GetLineNumber() instead of reading this field
           directly.  As of 2.3 f_lineno is only valid when tracing is
           active (i.e. when f_trace is set).  At other times we use
           PyCode_Addr2Line to calculate the line from the current
           bytecode index. */
        int f_lineno;       /* Current line number */
        int f_iblock;       /* index in f_blockstack */
        PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
        PyObject *f_localsplus[1];  /* locals+stack, dynamically sized */
    } PyFrameObject;
    
genobject.h
  • PyGenObject

    struct _frame; /* Avoid including frameobject.h */
    
    typedef struct {
        PyObject_HEAD
        /* The gi_ prefix is intended to remind of generator-iterator. */
    
        /* Note: gi_frame can be NULL if the generator is "finished" */
        struct _frame *gi_frame;
    
        /* True if generator is being executed. */
        int gi_running;
    
        /* The code object backing the generator */
        PyObject *gi_code;
    
        /* List of weak reference. */
        PyObject *gi_weakreflist;
    } PyGenObject;
    
memoryobject.h
  • PyMemoryViewObject

    typedef struct {
        PyObject_HEAD
        PyObject *base;
        Py_buffer view;
    } PyMemoryViewObject;
    
    unicodeobject.h
  • PyUnicodeObject

    typedef struct {
        PyObject_HEAD
        Py_ssize_t length;          /* Length of raw Unicode data in buffer */
        Py_UNICODE *str;            /* Raw Unicode buffer */
        long hash;                  /* Hash value; -1 if not set */
        PyObject *defenc;           /* (Default) Encoded version as Python
                                       string, or NULL; this is used for
                                       implementing the buffer protocol */
    } PyUnicodeObject;
    
methodobject.h
  • PyCFunctionObject

    typedef struct {
        PyObject_HEAD
        PyMethodDef *m_ml; /* Description of the C function to call */
        PyObject    *m_self; /* Passed as 'self' arg to the C func, can be NULL */
        PyObject    *m_module; /* The __module__ attribute, can be anything */
    } PyCFunctionObject;
    
datetime.h
  • PyDateTime_Delta

    typedef struct
    {
        PyObject_HEAD
        long hashcode;              /* -1 when unknown */
        int days;                   /* -MAX_DELTA_DAYS <= days <= MAX_DELTA_DAYS */
        int seconds;                /* 0 <= seconds < 24*3600 is invariant */
        int microseconds;           /* 0 <= microseconds < 1000000 is invariant */
    } PyDateTime_Delta;
    
  • PyDateTime_TZInfo

    typedef struct
    {
        PyObject_HEAD               /* a pure abstract base class */
    } PyDateTime_TZInfo;