2、序列初始化存储过程,本文分四个部分梳理

1、创建序列

图片 1Swift.png

函数是任何一个语言的核心构成要素。首先,我想对于绝大部分的程序员,函数是我们在学习编程过程中,接触到的第一个逻辑解耦工具。在我们学习C语言编程的头一两次课里,我们就开始学会使用函数封装逻辑,然后在别处调用。另一方面,函数的调用,是程序运行的根本驱动力。对于大部分编程语言而言,其应用程序的启动,都是从执行入口函数开始的。因此,在我们尝试了解一个语言的底层构造机制时,函数是一个重要的话题。

软件测试性能问题隐藏在你的每一行代码里!

类的加载与对象创建过程

Java中每个类的编译代码都存在于他自己的独立的文件中。该文件只在需要使用程序代码时才会被加载初始化。一般来说“类的代码在初次使用时才加载”,这通常是指加载发生于创建类的第一个对象之时,但访问static域或static方法时,也会发生加载。
“初始化”和“创建”是捆绑在一起的,二者不能分离。假设有个名为Dog的类,那么该类的创建过程如:

  1. 即使没有显示地使用static关键字,构造器实际上也是静态方法。因此,当首次创建Dog的对象时,或者Dog的静态方法/静态域被首次访问时,Java解释器必须查找类路径,以定位Dog.class文件。
  2. 然后载入Dog.class,有关静态初始化的所有动作都会执行。因此,静态初始化只在Class对象首次加载的时候进行一次。
  3. 当用new创建Dog对象时,首先在堆上为Dog对象分匹配足够的存储空间。
  4. 这块存储空间会被清零,这就自动的将Dog对象中的所有基本类型设置成默认值,而引用类型被设置成了null。
  5. 执行所有出现于字段定义处的初始化动作。
  6. 执行构造器

2、序列初始化存储过程

如果有这样的一个需求,我希望能像数组一样,用 for 循环遍历一个类或结构体中的所有属性。就像下面这样:

本文分四个部分梳理python 函数的底层机制。首先是介绍与python函数有关的对象(python 处处皆对象),第二部分和第三部分分别讨论函数的创建与运行。
而最后一部分讨论的是函数中可能用到的各种类型的变量。

一、Python中变量的类型

构造器初始化

成员变量在声明后如果没有为其赋值,则编译器会默认为其赋上默认值,而局部变量则不会,在运行时如果局部变量没有初始化则会抛出异常。编译器在通过构造器创建对象的过程中发现该类中有成员变量,则先初始化成员变量然后再执行构造器的初始化内容。如:

public class Test {
    int i ;

    { 
        System.out.println(i);    //构造代码块优先于构造方法执行
        i++;
    }
   public Test (){
       System.out.println(i);
    }

    public static void main(String[] args){
         new Test();
    }

}

输出:0;   1

我们可以用构造器来进行初始化,在运行时刻,可以调用方法或执行某些动作来确定初始值;但是,我们无法阻止自动初始化的进行,他将在构造器被调用之前发生。正如上面示例所见,成员变量先被初始化为0,然后变为1。

create procedure proDemo

let persion = Persion()for i in persion { print}

与函数有关的python对象

python 处处皆对象,任何一个python的组成元素,其在本质上,都是以一个对象表现的。对于python的函数系统,有三类对象与之有密切的关系,分别是
PyCodeObject,PyFunctionObject,PyFrameObject。

了解过python语言的同学都知道,Python中的变量不需要声明,变量是在我们給它赋值的时候创建的,要使用一个变量必须先对它进行赋值。

非静态数据初始化

在类的内部,变量定义的先后顺序决定了初始化的顺序。即使成员变量定义散布于方法之间,他们仍旧会在任何方法包括构造器执行之前得到初始化。例如:

class Window{
    public Window(int marker){
        System.out.println("Window ("+marker+")");
    }
}

class House{
    Window w1 = new Window(1);
    public House(){
        System.out.println("House()");
        w3 = new Window(33);
    }

    Window w2 = new Window(2);
    public void f(){
        System.out.println("f()");
    }
    Window w3 = new Window(3);
}

public class Initialization {

    public static void main(String[] args){
        House h = new House();
        h.f();
    }
}

输出:
Window (1)
Window (2)
Window (3)
House()
Window (33)
f()

as

要实现这样的需求,我们需要让自定义的类型遵守 Sequence 协议。

PyCodeObject

在固有印象里,python是一个脚本语言,然而python也是需要编译的。python每次在执行一个脚本的时候,其前端编译器都需要对脚本代码进行编译,这个编译的过程和java等语言的编译过程是相似的,都会生成平台无关的中间代码以及一些其他的静态信息。而这个信息就被保存在PyCodeObject对象里。

python在编译过程中,生成PyCodeObject 的原则是,针对于每一个作用域,生成一个PyCodeObject。由于作用域的嵌套性,PyCodeObject之间也存在嵌套关系。举例来说
针对于写在 test.py 文件中的如下代码:

class Test:
    def f():
        pass

其在编译时就会产生三个PyCodeObject,针对于整个文件的PyCodeObject,针对于类Test的PyCodeObject和针对于函数f的PyCodeObject。三个PyCodeObject 之间互相嵌套,嵌套的关系与它们之间的作用域关系一致。

PycodeObject 对象是可以离线存储的,我们经常见到的.pyc 文件就是用来存储一个模块所对应的PycodeObject的。

PyCodeObject 的数据结构如下:

/* Bytecode object */
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;    
    void *co_zombieframe;     /* for optimization only (see frameobject.c) */
    PyObject *co_weakreflist;   /* to support weakrefs to code objects */
} PyCodeObject;

如前所述,PyCodeObject主要存储的是编译器解析出的代码静态信息。如果当前的PyCodeObject 对应于一个函数,那么PyCodeObject中将记录这个函数的参数个数(co_argcount),局部变量个数(co_nlocals)等信息。函数本身编译产生的指令代码序列以字符串的形式被存储在co_code中。

说了这么多,这里可以得到一个结论,对于函数来说,PyCodeObject存储的是,python函数在编译以后,执行以前的静态信息

在Python中变量就是变量,它没有类型限制,我们所说的类型是指给变量赋值后,变量所指向的内存中对象的类型。

静态数据的初始化

无论创建多少个对象,静态数据只占用一份存储区域。static关键字不能应用于局部变量,因此它只能作用于域。如果一个域是基本类型域,而且也没有对它进行初始化,那么它就会获得基本类型的初始值;如果是引用对象,那么它的默认初始值就是null。下面的示例说明静态域是如何初始化的。

class Bowl {
    public Bowl(int marker) {
        System.out.println("Bowl(" + marker + ")");
    }

    public void f1(int marker) {
        System.out.println("f1(" + marker + ")");
    }
}

class Table {
    static Bowl bowl = new Bowl(1);

    public Table() {
        System.out.println("Table()");
        bow2.f1(1);
    }

    public void f2(int marker) {
        System.out.println("f2(" + marker + ")");
    }

    static Bowl bow2 = new Bowl(2);
}

class Cupboard {
    Bowl bowl3 = new Bowl(3);
    static Bowl bowl4 = new Bowl(4);

    public Cupboard() {
        System.out.println("Cupboard()");
        bowl4.f1(2);
    }

    public void f3(int marker) {
        System.out.println("f3(" + marker + ")");
    }

    static Bowl bowl5 = new Bowl(5);
}

public class StaticInitialization {

    public static void main(String[] args) {
        System.out.println("Creating new Cupboard() in main 1");
        new Cupboard();
        System.out.println("Creating new Cupboard() in main 2");
        new Cupboard();
        table.f2(1);
        cupboard.f3(1);
    }

    static Table table = new Table();
    static Cupboard cupboard = new Cupboard();

}

输出:
Bowl(1)
Bowl(2)
Table()
f1(1)
Bowl(4)
Bowl(5)
Bowl(3)
Cupboard()
f1(2)
Creating new Cupboard() in main 1
Bowl(3)
Cupboard()
f1(2)
Creating new Cupboard() in main 2
Bowl(3)
Cupboard()
f1(2)
f2(1)
f3(1)

Bowl类是的看到类的创建,而Table类和Cupboard类在它们的类定义中加入了Bowl类型的静态成员变量。注意,在静态数据定义之前,Cupboard类先定义了一个Bowl类型的非静态数据成员bowl3.
由输出可见,静态初始化只有在必要时刻才会进行。如果不创建Table对象,也不引用Table.bowl1或Table.bowl2,那么静态的Bowl bowl1和bowl2永远都不会被创建,只有在第一个Table对象被创建(或者第一次访问静态数据)的时候,它们才会被初始化。此后,静态数据不会再被初始化。
类的初始化顺序:先静态对象(如果它们未因前面的对象创建过程而被初始化),然后非静态对象。从输出结果可以这看出这一点。要执行main()方法,必须加载StaticInitialization类,然后静态域table和cupboard被初始化,这导致它们对应的类也被加载,并且由于它们包含静态的Bowl对象,因此Bowl随后也被加载,这样在这个特殊的程序中,所有类在main()开始之前就都被夹在了。实际开发中遇到这样的情况很少。

begin

Sequence 协议是集合类型结构中的基础。一个序列 代表的是一系列具有相同类型的值,你可以对这些值进行迭代。Sequence 协议提供了许多强大的功能,满足该协议的类型都可以直接使用这些功能。上面这样步进式的迭代元素的能力看起来十分简单,但它却是 Sequence 可以提供这些强大功能的基础。

PyFunctionObject

python 是一种动态语言。一些在传统语言当中编译期发生的事情,在python里却是在运行时发生的。比如 函数的定义。python中函数的定义,发生在虚拟机执行def 语句对应的指令序列时。而函数定义语句的产物就是本小节的主角,PyFunctionObject。

PyFunctionObject的数据结构如下:

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;

PyFunctionObject 作为函数的定义载体,理所当然的要载有函数体内的指令代码序列等静态信息。PyFunctionObject 中的func_code就是用于引用函数对应的PycodeObject的指针。

除了pyCodeObject,PyFunctionObject还保存了函数外的全局名字空间(func_globals),函数的默认参数列表(func_defaults),以及函数的闭包变量引用(func_closures)。这些信息,我个人把它们看做是一个函数运行时的上下文环境,显然这些信息对于函数的运行至关重要。

那么这里,我们可以得到一个结论,PyFuctionObject 是函数指令序列与函数执行环境的载体。

图片 2

数组初始化

数组只是相同类型的,用一个标识符名称封装到一起的一个对象序列或基本类型数据序列。类似于 int[] arr 和 int arr[]都称之为数组;由于编译器不允许指定数组大小,所以我们现在拥有的只是对数组的一个引用(我们已经为该引用分配了足够的内存空间),而且没有给数组对象本身分配任何空间。为了给创建相应的存储空间,必须写初始化表达式。数组可以用类似于:int[] arr = {1,2,3};这样特殊的方式初始化。
在Java中可以将一个数组赋值给另一个数组:

int[] a1 = {1,2,3,4,5};
int[] a2;
a2 = a1;

其实这是只是复制了一个引用,就像下面这样:

public class ArrayTest {

    public static void main(String[] args) {
        int[] a1 = {1, 2, 3, 4, 5};
        int[] a2;
        a2 = a1;

        for (int i = 0; i < a2.length; i++) {
            a2[i] = a2[i] + 1;
        }

        for (int i = 0; i < a1.length; i++) {
            System.out.println("a1[+" + i + "]= " + a1[i]);
        }

    }

}
输出:
a1[+0]= 2
a1[+1]= 3
a1[+2]= 4
a1[+3]= 5
a1[+4]= 6

有以上实例可以看出,a1有初始值,a2没有,把a1赋值给a2后,由于a1和a2都是相同数组的别名,所以a2对数组做的修改在a1中也能看到。所有数组中都有一个固定成员,那就是length,这与String里获取长度的方法不同,String是length()方法,不是成员。

数组的创建发生在运行时期,所以在编译时期不能确定数组里需要多少个元素,可以直接用new在数组里创建元素。尽管创建的是基本数据类型数组,new任然可以工作。如:

public class ArrayTest {

    public static void main(String[] args) {
      int[] a;
        Random random = new Random(12324);
        a = new int[random.nextInt(20)];  //产生0到20之间的一个随机数
        System.out.println("length of a = "+a.length);
        System.out.println(Arrays.toString(a));
    }

}
输出:
length of a = 12
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

如果可能的话尽量在数组定义时就初始化。

     alter sequence dbo.序列名

满足 Sequence 协议的要求十分简单,你需要做的所有事情就是提供一个返回迭代器 的 makeIterator() 方法:

PyFrameObject

在很多编程语言中,都有函数栈帧这一概念。我想对于绝大部分程序员,这都是一个非常熟悉的概念了。而python函数运行时的栈就是用PyFrameObject对象表示的。

    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 */
        PyObject **f_stacktop;
        PyObject *f_trace;      /* Trace function */


        PyObject *f_exc_type, *f_exc_value, *f_exc_traceback;

        PyThreadState *f_tstate;
        int f_lasti;        /* Last instruction if called */

        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;

我们清楚的在这个结构中看见了 f_valuestack和f_stacktop ,显然这组指针用于指向一个函数栈帧空间的栈底和栈顶。

除了保存函数栈帧空间的位置以外,PyFrameObject对象还保存了一个函数执行时的全局名字空间(f_globals),这个名字空间就是PyfunctionObject携带的func_globals,函数的运行时全局名字空间会在函数开始运行前的初始化阶段,由PyFunctionObject对象传递到PyFrameObject对象。

此外,成员 f_localsplus用于存储函数实参等作用范围在函数体内的变量。

那么这里可以看到,作为函数栈帧对象PyFrameObject 用来保存函数运行时的动态信息。其生命周期从函数开始运行到函数运行结束。

二、Python中基本的数据类型

继承与初始化

class Insect {
    private int i = 9;
    protected int j;

    public Insect() {
        System.out.println("i = " + i + " ,j = " + j);
        j = 39;
    }

    private static int x1 = printInit("static Insect.x1 initialized");

    public static int printInit(String s) {
        System.out.println(s);
        return 47;
    }

}

public class Beetle extends Insect {
    private int k = printInit("Beetle.k initialized");

    public Beetle() {
        System.out.println("k= " + k);
        System.out.println("j= " + j);
    }

    private static int x2 = printInit("static Beetle.x2 initialized");

    public static void main(String[] srgs) {
        System.out.println("Beetle constructor");
        Beetle beetle = new Beetle();
    }
}

输出:
static Insect.x1 initialized
static Beetle.x2 initialized
Beetle constructor
i = 9 ,j = 0
Beetle.k initialized
k= 47
j= 39

从以上实例可以得知:程序运行后的第一件事就是试图访问Beetle的main方法,于是加载器开始启动并找到Beetle类的编译代码。在对它进行加载的过程中发现它有一个基类,于是他继续进行加载。即使在Beetle类中没有创建该基类对象,这也会发生。如果该基类还有它自身的基类,那么第二个基类就会被加载,如此类推。接下来,根基类中的static初始化,然后是下一个导出类(子类),如此类推。这种方式很重要,因为导出类的static初始化可能依赖于基类成员是否被正确初始化。

参考自《Java编程思想》

     restart with 0;

public protocol Sequence { associatedtype Iterator : IteratorProtocol public func makeIterator() -> Self.Iterator // ...}

小结

这里对三种函数相关的对象做一个总结。

PyCodeObject存储的是函数的代码,声明等静态信息。

PyFrameObject存储的是函数栈帧等函数运行时的动态信息。

而PyFunctionObject,是函数在定义后运行前的一个暂存对象。
保存有函数的静态信息和运行时上下文环境。

某种程度上,PyFuctionObject,是连接PyCodeObject 与 PyFrameObject的桥梁。

Python中给我们内置了很多的数据类型,其中常见基本的数据类型有以下几种:

end

在 Sequence 协议有个关联类型 Iterator,而且它必须遵守 IteratorProtocol 协议。从这里我们可以看出 Sequence 是一个可以创建迭代器协议的类型。所以在搞清楚它的步进式的迭代元素能力之前,有必要了解一下迭代器是什么。

函数创建

就像我们所共知的,python 是一门脚本语言,其语言运行的基本机制是虚拟机逐句执行python语句,说的更准确一点, python虚拟机逐句执行预先编译产生的PyCodeObject 中的python中间代码指令序列

不同于传统的静态语言,python中函数的定义行为,也是在运行时,由虚拟机执行相应的指令序列完成的。

这里我们通过一个例子,来演示函数的定义过程。首先我们建立一个名字为test.py的python文件,其内容如下:

def f():
    print "hello world"

紧接着,我们通过python内置的compile函数,可以得到test.py编译产生的PyCodeObject 对象,利用dis模块,我们可以提取得到test.py这个模块所对应的指令码序列:

0   LOAD_CONST    0 (<code object f at 0x1055df430, file "test.py", line 1>)
3   MAKE_FUNCTION   0
6   STORE_NAME      0 (f)
9   LOAD_CONST      1 (None)
12  RETURN_VALUE        

到这里,我们看见了python 中间代码指令序列的“庐山真面目”。

dis函数的输出分为三列,第一列是指令相对于代码段起始位置的偏移,第二列是指令码,第三列为指令参数。关于指令码的意义,官网上有一个较为权威的介绍。

观察 test.py 所对应的指令序列:

LOAD_CONST    0 (<code object f at 0x1055df430, file "test.py", line 1>)
 # 从test.py对应的PyCodeObject对象的co_const成员中,读取函数f对应的PyCodeObject

MAKE_FUNCTION   0
 # 利用f的PyCodeObject创建函数对象 PyFunctionObject

STORE_NAME      0 (f)
 # 存储函数对象到当前名字空间

可以看到,上述三条指令,完成了python语句层面的def操作。
其中的一个核心指令是 MAKE_FUNCTION.

python虚拟机在执行MAKE_FUNTION命令时,首先创建一个PyFunctionObject对象,之后会将函数对应的PyCodeObject 以及一个当前的全局名字空间(CurrentFrame.f_globals)绑定到PyFunctionObject对象上。

PyFunctionObject.func_code=PyCodeObejct
PyFunctionObject.func_globals= CurrentFrame.f_globals

此外,如果函数有默认参数的话,也在这个过程中将默认参数值传递给PyFunctiobObject保存

PyFunctionObejct.func_defaults=tuple(默认参数1,默认参数2...)

至此,我们可以看出python函数的定义语句,完成的核心功能就是生成并初始化一个PyFunctionObject对象。其目的在于完成对于函数静态信息与执行上下文环境的封装,为函数的调用做好准备。

◆ 数值类型:

3、创建定时任务自动执行序列初始化存储过程。

序列通过创建一个迭代器来提供对元素的访问。迭代器每次产生一个序列的值,并且当遍历序列时对遍历状态进行管理。在 IteratorProtocol 协议中唯一的一个方法是 next(),这个方法需要在每次被调用时返回序列中的下一个值。当序列被耗尽时,next() 应该返回 nil,不然迭代器就会一直工作下去,直到资源被耗尽为止。

函数运行

现在,我们已经知道,函数在python中,是以PyFunctionObject 对象的形式,存储在当前名字空间中的。那么接下来要介绍的事情就是函数的调用。

函数调用对应的python中间代码指令是 CALL_FUNCTION。概括的讲,函数的调用分为两个部分:创建PyFrameObject对象与执行PyEval_EvalFrameEx函数。

整数、浮点数、布尔值

 

IteratorProtocol 的定义非常简单:

创建PyFrameObject

如同其他语言一样,python语言中也存在函数栈帧的概念,其作用也与其他语言中的函数栈帧相似-- 作为函数运行与调用的活动记录,保存局部动态数据。

追踪python的底层源码,我们可以定位到pyFrameObject 对象的创建代码:

f=Frame_New(tstate,co,globals,NUll);

其中,co 是一个PyCodeObject 对象,globals,则是一个全局名字空间,

如前所述,这里的PyCodeObject,和globals 名字空间,是从PyFrameObject对象里获得的!!

到这里,我们可以看清楚函数从创建到调用过程中,底层相关对象的转换过程:

编译期:生成PycodeObject。保存静态信息

运行期(1):执行def语句。创建PyFunctionObject对象封装PyCodeObject和全局名字空间。

运行期 (2):执行函数调用,利用PyFunctionObject对象创建并初始化PyFrameObject对象。

PyFrameObject中有一个很重要的成员:f_back;可以看到,这是一个指向另一个PyFrameObject 的指针,这暗示着我们,PyFrameObject对象在python运行时环境中是以链表形式组织的。

实际上,调用函数的栈帧与被调用函数的栈帧对象之间正式通过这个指针联系的。

def caller():
    calle()

图片 3

Alt text

生成PyFrameObject后,还需要将函数调用的实参从当前的函数调用栈复制到PyFrameObject 的f_locals
plus区,从而完成函数的参数传递工作。

◆ 序列类型:

public protocol IteratorProtocol { associatedtype Element public mutating func next() -> Self.Element?}

执行PyEval_EvalFrameEx函数

结束了PyFrameObject 对象的创建与初始化之后,python虚拟机开始执行PyEval_EvalFrameEx 函数。

可以这么讲,PyEval_EvalFrameEx函数是整个python虚拟机驱动的关键。

其代码的骨干结构如下:

PyEval_EvalFrameEx()
{
    while(1)
    {
        switch(opcode)
        {
            case “LOAD_CONST”:
                ...

            case "MAKE_FUNCTION":
                ...

            ...
            ...

            case "CALL_FUNCTION":
                ...
                PyEval_EvalFrameEx();
                ...

        }
    }
}

通过执行这个函数,python虚拟机可以执行当前python函数对应的PyFrameObject 对象中f_code成员内保存的python中间代码指令序列。
从而可以完成对于函数逻辑的执行。

这里我们注意到,PyEval_EvalFrameEx 函数中,包含着对于CALL_FUNCTION 指令的处理,而CALL_FUNCTION 指令本身的处理流程,又包含了一个对于PyEval_EvalFrameEx函数的调用。

所以,本质上,python通过这种对于PyEval_EvalFrameEx的递归调用,实现了对于函数之间调用的处理。

上述PyEval_EvalFrameEx 内的这种中间代码处理逻辑,个人认为是一种比较经典的虚拟机主干逻辑设计。在我学习过的llvm项目中,其后端解释器的构造也是相似的。

在这里可以看到的是,虚拟机是通过PyEval_EvalFrameEx内的主干逻辑来执行中间代码序列的。而函数间的调用,是在PyEval_EvalFrameEx代码内,MAKE_FUNCTION 指令处理分支上,递归调用PyEval_EvalFrameEx完成的。

如果追溯整个python虚拟机运行过程中,PyEval_EvalFrameEx
的调用轨迹,我们大概可以得到如下一幅图:

图片 4

Alt text

比较特殊的一点是,最外层的PyEval_EvalFrameEx所执行的中间代码,并不是属于某个函数对应的PyCodeObject的。而是属于一个名字叫做“__ main __”的模块所对应的PyCodeObject的

__name__ == '__main__'

python 虚拟机在一开始,取寻找这个名字叫做“__ main __”的模块,提取他的PyCodeObject,调用PyEval_EvalFrameEx 去执行 从而触发了整个虚拟机的运转。

某种程度上,这个特殊的“main” 模块,就是python语言应用程序的“入口函数”。

字符串、元组、列表

本文由必威发布于必威-数据,转载请注明出处:2、序列初始化存储过程,本文分四个部分梳理

TAG标签:
Ctrl+D 将本页面保存为书签,全面了解最新资讯,方便快捷。