sqlserver序列定时初始化

图片 3

begin

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

函数中的变量

函数运行过程中访问的变量概括的讲,可以分为三类:全局变量,局部变量,参数变量。这其中,局部变量和参数变量的作用域范围和存储形式是很相近的。其存储的位置都在PyFrameObject的f_localsplus数组中。而全局变量则是存储在PyFrameObject的f_globals
所引用的名字空间中。

在python的中间代码指令中,对于全局名字空间的访问命令是:
LOAD_GLOBAL/STORE_GLOBAL。其语义分别是:从全局名字空间中取出某个全局对象压栈,将函数栈中的某个对象写入全局名字空间。

相似的,对于局部变量和参数变量的读写命令分别是:
LOAD_FAST/ STORE_FAST.

图片 1

Alt text

函数运行过程中,变量的访问广泛的存在于以下两个抽象过程中:

读取数据作为命令参数:
python虚拟机从当前栈帧的局部空间(f_localsplus)或者全局空间(f_globals)中读取数据并压栈,作为接下来中间代码指令的执行参数。

读取数据作为返回值:
python虚拟机执行命令的返回结果会存储在当前的函数栈中,通过弹栈操作,将命令执行的结果写入到全局或者局部空间中。

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

这里我定义了一个继承 Sequence 的空协议,是为了不影响 Sequence
的默认行为。现在只要我们自定义的类或结构体遵守 Sequencible 就能使用 for
循环输出其所有属性值了。就像下面这样:

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
是函数指令序列与函数执行环境的载体。

1、创建序列

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

小结

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

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

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

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

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

     restart with 0;

struct Persion: Sequence { var name: String var age: Int var email: String func makeIterator() -> MyIterator { return MyIterator(obj: self) }}

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函数在编译以后,执行以前的静态信息

end

得益于 Swift 的类型推断,这里的 array 可以不用显式地指明其类型,点击
option 键,你会发现它是 [_AnySequence<String>]
类型。也就是说只有其元素是 String
的任意序列都可以作为数组的元素。这就跟我们平时使用类似 “一个 Int
类型的数组”
的语义是一致的了。如果要向数组中插入一个新元素,可以这样创建一个序列:

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

2、序列初始化存储过程

struct _AnySequence<Element> { typealias Iterator = _AnyIterator<Element> private var iteratorImpl: () -> Element?}extension _AnySequence: Sequence { init<S>(_ base: S) where Element == S.Iterator.Element, S: Sequence { var iterator = base.makeIterator() iteratorImpl = { iterator.next() } } func makeIterator() -> _AnyIterator<Element> { return _AnyIterator(iteratorImpl) }}

函数运行

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

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

     alter sequence dbo.序列名

Protocol 'Sequencible' can only be used as a generic constraint because it has Self or associated type requirements

与函数有关的python对象

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

 

在标准库中,其实已经提供了 AnyIterator
AnySequence。我还没去看标准库的实现,有兴趣的同学可以点击这里查看。
我这里实现了自己的 _AnyIterator 和 _AnySequence
就是为了提供一种实现类型擦除的思路。如果你在项目中频繁地使用带有关联类型或
Self
的协议,那么你也一定会遇到跟我一样的问题。这时候实现一个类型擦除的封装,将具体的类型隐藏了起来,你就不用为
Xcode 的报错而抓狂了。

函数创建

就像我们所共知的,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对象。其目的在于完成对于函数静态信息与执行上下文环境的封装,为函数的调用做好准备。

create procedure proDemo

如果现在有另外一个结构体或类也需要迭代输出所以属性呢?,这很好办,让我们的结构体遵守
Sequence
协议,并返回一个我们自定义的迭代器就可以了。这种拷贝代码的方式确实能满足需求,但是如果我们利用协议拓展就能写出更易于维护的代码,类似下面这样:

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
用来保存函数运行时的动态信息。其生命周期从函数开始运行到函数运行结束。

as

如果有这样一个类型,可以隐藏 Sequencible
这个具体的类型不就解决这个问题了吗?这种将指定类型移除的过程,就被称为类型擦除。

执行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
的调用轨迹,我们大概可以得到如下一幅图:

图片 2

Alt text

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

__name__ == '__main__'

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

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

关联类型 Element 指定了迭代器产生的值的类型。这里next() 被标记了
mutating,表明了迭代器是可以存在可变的状态的。这里的 mutating
也不是必须的,如果你的迭代器返回的值并没有改变迭代器本身,那么没有
mutating 也是没有任何问题的。
不过几乎所有有意义的迭代器都会要求可变状态,这样它们才能够管理在序列中的当前位置。

创建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区,从而完成函数的参数传递工作。

我们的这个封装可以这样定义:

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

_AnySequence 的指定构造器也被定义为泛型,接受一个遵循 Sequence
协议的任何序列作为参数,并且规定了这个序列的迭代器的 next()
的返回类型要跟我们定义的这个泛型结构的 Element
类型要一致。这里的这个泛型约束其实就是我们实现类型擦除的魔法所在了。它将具体的序列的类型隐藏了起来,只要序列中的值都是相同的类型就可以当做同一种类型来使用。就像下面的例子中的
array 就可以描述为 “元素类型是 String 的任意序列的集合”。

let s = _AnySequence { () -> _AnyIterator<String> in return _AnyIterator { () -> String? in return arc4random() % 10 == 5 ? nil : String(Int(arc4random }}array.append
func makeIterator() -> _AnyIterator<Element> { return _AnyIterator(iteratorImpl)}
let array = [_AnySequence(Persion.author), _AnySequence]for obj in array { print("+-------------------------+") for item in obj { print }}// out put:// name is jewelz// age is 23// email is hujewelz@gmail.com// +-------------------------+// name is Sequence// author is Persion(name: "jewelz", age: 23, email: "hujewelz@gmail.com")

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

添加这个初始化方法其实为了方便后面实现 _AnySequence 用的。上面说过
_AnySequence 有个属性存储了迭代器的实现,所以我们的 _AnyIterator
能通过一个闭包来初始化。

You can leave a response, or trackback from your own site.

Leave a Reply

网站地图xml地图