凤凰平台注册开户_凤凰彩票app下载安装_凤凰彩票投注网

热门关键词: 凤凰平台注册开户,凤凰彩票app下载安装,凤凰彩票投注网

深入通晓python之函数系统,sqlserver类别依期最早

作者: MySQL数据库  发布:2019-11-05

1、创建序列

图片 1Swift.png

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

2、序列初始化存储过程

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

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

create procedure proDemo

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

与函数有关的python对象

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

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

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

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

     restart with 0;

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

小结

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

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

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

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

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

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()

图片 2

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

图片 3

Alt text

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

__name__ == '__main__'

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

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

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

函数中的变量

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

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

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

图片 4

Alt text

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

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

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

对 Sequence 和 IteratorProtocol 有了基础了解后,要实现开头提到的需求就很简单了。比如我想迭代输出一个 Person 实例的所有属性,我们可以这样做:

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

Persion 遵守了 Sequence 协议,并返回了一个自定义的迭代器。迭代器的实现也很简单:

struct MyIterator: IteratorProtocol { var children: Mirror.Children init(obj: Persion) { children = Mirror(reflecting: obj).children } mutating func next() -> String? { guard let child = children.popFirst() else { return nil } return "(child.label.wrapped) is (child.value)" }}

迭代器中的 childrenAnyCollection<Mirror.Child> 的集合类型,每次迭代返回一个值后,更新 children 这个状态,这样我们的迭代器就可以持续的输出正确的值了,直到输出完 children 中的所有值。

现在可以使用 for 循环输出 Persion 中所有的属性值了:

for item in Persion.author { print}// out put:// name is jewelz// age is 23// email is hujewelz@gmail.com

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

struct _Iterator: IteratorProtocol { var children: Mirror.Children init { children = Mirror(reflecting: obj).children } mutating func next() -> String? { guard let child = children.popFirst() else { return nil } return "(child.label.wrapped) is (child.value)" }}protocol Sequencible: Sequence { }extension Sequencible { func makeIterator() -> _Iterator { return _Iterator(obj: self) }}

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

struct Demo: Sequencible { var name = "Sequence" var author = Persion.author}

现在需求又变了,我想将所有遵守了 Sequencible 协议的任何序列存到一个数组中,然后 for 循环遍历数组中的元素,因为数组中的元素都遵守了 Sequencible 协议,所以又可以使用 for 循环输出其所有属性,就像下面这样:

for obj in array { for item in obj { print }}

那么这里的 array 应该定义成什么类型呢?定义成 [Any] 类型肯定是不行的,这样的话在循环中得将 item 强转为 Sequencible,那么是否可以定义成 [Sequencible] 类型呢?答案是否定的。当这样定义时编辑器会报出这样的错误:

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

熟悉 Swift 协议的同学应该对这个报错比较熟了。就是说含有 Self 或者关联类型的协议,只能被当作泛型约束使用。所以像下面这样定义我们的 array 是行不通的。

let sequencibleStore: [Sequencible] = [Persion.author, Demo()]

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

回想一下 Sequence 协议的内容,我们只要通过 makeIterator() 返回一个迭代器就可以了。那么我们可以实现一个封装类,里面用一个属性存储了迭代器的实现,然后在 makeIterator() 方法中通过存储的这个属性构造一个迭代器。类似这样:

func makeIterator() -> _AnyIterator<Element> { return _AnyIterator(iteratorImpl)}

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

struct _AnySequence<Element>: Sequence { private var iteratorImpl: () -> Element?}

对于刚刚上面的那个数组就可以这样初始化了:

let sequencibleStore: [_AnySequence<String>] = [_AnySequence(Persion.author), _AnySequence]

这里的 _AnySequence 就将具体的 Sequence 类型隐藏了,调用者只知道数组中的元素是一个可以迭代输出字符串类型的序列。

现在我们可以一步步来实现上面的 _AnyIterator 和 _AnySequence。_AnyIterator 的实现跟上面提到的 _AnySequence 的思路一致。我们不直接存储迭代器,而是让封装类存储迭代器的 next 函数。要做到这一点,我们必须首先将 iterator 参数复制到一个变量中,这样我们就可以调用它的 next 方法了。下面是具体实现:

struct _AnyIterator<Element> { var nextImpl: () -> Element?}extension _AnyIterator: IteratorProtocol { init<I>(_ iterator: I) where Element == I.Element, I: IteratorProtocol { var mutatedIterator = iterator nextImpl = { mutatedIterator.next() } } mutating func next() -> Element? { return nextImpl() }}

现在,在 _AnyIterator 中,迭代器的具体类型(比如上面用到的_Iterator)只有在创建实例的时候被指定。在那之后具体的类型就被隐藏了起来。我们可以使用任意类型的迭代器来创建 _AnyIterator 实例:

var iterator = _AnyIterator(_Iterator(obj: Persion.author))while let item = iterator.next() { print}// out put:// name is jewelz// age is 23// email is hujewelz@gmail.com

我们希望外面传入一个闭包也能创建一个 _AnyIterator,现在我们添加下面的代码:

 init(_ impl: @escaping () -> Element?) { nextImpl = impl }

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

_AnyIterator 实现完后就可以来实现我们的 _AnySequence 了。我这里直接给出代码,同学们可以自己去实现:

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) }}

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

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")

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

let s = _AnySequence { () -> _AnyIterator<String> in return _AnyIterator { () -> String? in return arc4random() % 10 == 5 ? nil : String(Int(arc4random }}array.append

上面的代码中通过一个闭包初始化了一个 _AnySequence,这里我就不给出自己的实现,同学们可以自己动手实现一下。

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

本文由凤凰平台注册开户发布于MySQL数据库,转载请注明出处:深入通晓python之函数系统,sqlserver类别依期最早

关键词:

上一篇:没有了
下一篇:没有了