python模型管道函数 Python中哪个函数可以构建线性回归模型

Python的函数都有哪些

【常见的内置函数】

成都网站建设、网站设计服务团队是一支充满着热情的团队，执着、敏锐、追求更好，是创新互联的标准与要求，同时竭诚为客户提供服务是我们的理念。创新互联把每个网站当做一个产品来开发，精雕细琢，追求一名工匠心中的细致，我们更用心！

1、enumerate(iterable,start=0)

是python的内置函数，是枚举、列举的意思，对于一个可迭代的(iterable)/可遍历的对象(如列表、字符串)，enumerate将其组成一个索引序列，利用它可以同时获得索引和值。

2、zip(*iterables,strict=False)

用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用*号操作符，可以将元组解压为列表。

3、filter(function,iterable)

filter是将一个序列进行过滤，返回迭代器的对象，去除不满足条件的序列。

4、isinstance(object,classinfo)

是用来判断某一个变量或者是对象是不是属于某种类型的一个函数，如果参数object是classinfo的实例，或者object是classinfo类的子类的一个实例，

返回True。如果object不是一个给定类型的的对象， 则返回结果总是False

5、eval(expression[,globals[,locals]])

用来将字符串str当成有效的表达式来求值并返回计算结果，表达式解析参数expression并作为Python表达式进行求值(从技术上说是一个条件列表)，采用globals和locals字典作为全局和局部命名空间。

【常用的句式】

1、format字符串格式化

format把字符串当成一个模板，通过传入的参数进行格式化，非常实用且强大。

2、连接字符串

常使用+连接两个字符串。

3、if...else条件语句

Python条件语句是通过一条或多条语句的执行结果(True或者False)来决定执行的代码块。其中if...else语句用来执行需要判断的情形。

4、for...in、while循环语句

循环语句就是遍历一个序列，循环去执行某个操作，Python中的循环语句有for和while。

5、import导入其他脚本的功能

有时需要使用另一个python文件中的脚本，这其实很简单，就像使用import关键字导入任何模块一样。

Python函数和模块的定义与使用，包括变量的类型及匿名函数用法

函数是组织好，可重复使用的，用来实现相关功能的代码段

函数提高了代码的重复利用率和应用的模块性。

除Python自带的函数之外，也可以自己创建函数，叫做自定义函数

语法：

函数代码块以 def 开头

参数为 输入值 ，放于函数名后口号里面，

函数内容以冒号:开始，函数体缩进， return 返回 输出值

函数调用使用关键字参数来确定传入的参数值，此时，如果多个函数则不需要按照指定顺序。

在定义函数时，指定参数默认值。调用时如果不传入参数，则使用默认值

不定长部分如果没有指定参数，传入是一个空元组

加了 两个星号 ** 的参数会以字典的形式导入

/ 用来指明函数形参必须使用指定位置参数，不能使用关键字参数的形式。

3.8版本之后的才能使用

不使用 def 定义函数，没有函数名

lamdba主体时一个表达式，而不是代码块，函数体比def简单很多

定义在函数内部的为局部变量，仅能在函数内部使用

定义在函数外部的为全局变量，可在全局使用

模块是将包含所有定义的函数和变量的文件，一般将同类功能的函数组和在一起称为模块。

模块需要导入后，在调用相应函数进行使用

模块导入的方法：

从模块中导入一个指定的部分

把一个模块的所有内容全都导入

Python 数据模型

Python 风格的关键完全体现在 Python 的数据模型上，数据模型所描述的 API ，为使用最地道的语言特性来构建开发者自己的对象提供了工具。

当 Python 解析器遇到特殊句法时，会使用特殊方法去激活一些基本的对象操作。特殊方法以双下划线开头，以双下划线结尾。如： obj[key] 的背后就是 __getitem__ 方法。魔术方法是特殊方法的昵称，特殊方法也叫双下方法。

使用 __getitem__ 和 __len__ 创建一摞有序的纸牌：

上面的例子，使用 collections.namedtuple 构建了一个简单的类来表示一张纸牌， namedtuple 用以构建只有少数属性但没有方法的类。

我们自定义的 FrenchDeck 类可以像任何 python 标准集合类型一样使用 len() 函数，查看一叠牌有多少张：

也可以像列表一样，使用位置索引， d[i] 将调用 __getitem__ 方法：

也可以使用标准库模块提供的 random.choice 方法，从序列中随机选取一个元素。下面，我们如随机取出一张纸牌：

现在我们已经体会到通过 python 特殊方法，来使用 Python 数据模型的 2 个好处：

因为 __getitem__ 方法把 [] 操作交给了 self.cards 列表，所以我们的 FrenchDeck 实例自动支持切片：

仅仅实现了 __getitem__ 方法，这一摞牌即变得可迭代：

运行结果：

也可以直接调用内置的 reversed 函数，反向迭代 FrenchDeck 实例：

运行结果：

迭代通常是隐式的，比如一个集合类型没有实现 __contains__ 方法，那么 in 运算符就会按顺序做一次迭代搜索。

因此， in 运算符可以用在我们的 FrenchDeck 实例上，因为它是可迭代的：

FrenchDeck 还可以使用 Python 标准库中的 sorted 函数，实现排序：

首先定义一个排序依据的函数：

优先按 rank 的大小排序，rank 相同时则比较 suit 的值：

运行结果：

优先按 suit 的大小排序，suit 相同时则比较 rank 的值：

运行结果：

按照目前的设计，FrenchDeck 还不支持洗牌，因为它是不可变的：

shuffle 函数要调换集合中元素的位置，而 FrenchDeck 只实现了不可变的序列协议，可变的序列还必须提供 __setitem__ 方法：

洗牌：

没有任何的返回值，可见 random.shuffle 就地修改了可变序列 d 。为便于观察结果，我们定义输入的输出函数：

运行结果：

每次洗牌，都是一个随机的序列：

首先明确一点，特殊方法的存在是为了被 Python 解析器调用的，例如：我们不会使用 obj.__len__() 这种写法，而是 len(obj) 。在执行 len(obj) 时，如果 obj 是一个自定义类的对象，那么 Python 会自己去调用我们实现的 __len__ 方法。

对于 Python 内置的数据类型，比如列表、字符串、字节序列等，那么 CPython 会抄个近路， __len__ 实际上会返回 PyVarObject 里的 ob_size 属性，这是因为直接读取属性比调用一个方法要快得多。

很多时候，特殊方法的调用是隐式的，比如 for i in x: 这个语句其实是调用 iter(x) ，而这个函数的背后是 x.__iter__() 方法。

通过内置函数如来使用特殊方法是最好的选择。这些内置函数不仅会调用这些方法，通常还提供额外的好处，对于内置类型来说，它们的速度更快。

下面，我们通过定义一个简单的二维向量类，再来体会一下 Python 特殊方法的美妙：

使用 Vector 类，就像使用 Python 内置的数据类型一样简单：

python 8个常用内置函数解说

8个超好用内置函数set（），eval（），sorted（），reversed（），map（），reduce（），filter（），enumerate（）

python中有许多内置函数，不像print那么广为人知，但它们却异常的强大，用好了可以大大提高代码效率。

这次来梳理下8个好用的python内置函数

1、set()

当需要对一个列表进行去重操作的时候，set()函数就派上用场了。

用于创建一个集合，集合里的元素是无序且不重复的。集合对象创建后，还能使用并集、交集、差集功能。

2、eval()之前有人问如何用python写一个四则运算器，输入字符串公式，直接产生结果。用eval()来做就很简单：eval(str_expression)作用是将字符串转换成表达式，并且执行。

3、sorted()在处理数据过程中，我们经常会用到排序操作，比如将列表、字典、元组里面的元素正/倒排序。这时候就需要用到sorted() ，它可以对任何可迭代对象进行排序，并返回列表。对列表升序操作：

对元组倒序操作：

使用参数：key，根据自定义规则，按字符串长度来排序：

根据自定义规则，对元组构成的列表进行排序：

4、reversed()如果需要对序列的元素进行反转操作，reversed()函数能帮到你。reversed()接受一个序列，将序列里的元素反转，并最终返回迭代器。

5、map()做文本处理的时候，假如要对序列里的每个单词进行大写转化操作。这个时候就可以使用map()函数。

map()会根据提供的函数，对指定的序列做映射，最终返回迭代器。也就是说map()函数会把序列里的每一个元素用指定的方法加工一遍，最终返回给你加工好的序列。举个例子，对列表里的每个数字作平方处理：

6、reduce()前面说到对列表里的每个数字作平方处理，用map()函数。那我想将列表里的每个元素相乘，该怎么做呢？这时候用到reduce()函数。

reduce()会对参数序列中元素进行累积。第一、第二个元素先进行函数操作，生成的结果再和第三个元素进行函数操作，以此类推，最终生成所有元素累积运算的结果。再举个例子，将字母连接成字符串。

你可能已经注意到，reduce()函数在python3里已经不再是内置函数，而是迁移到了functools模块中。这里把reduce()函数拎出来讲，是因为它太重要了。

7、filter()一些数字组成的列表，要把其中偶数去掉，该怎么做呢？

filter()函数轻松完成了任务，它用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象。filter()函数和map()、reduce()函数类似，都是将序列里的每个元素映射到函数，最终返回结果。我们再试试，如何从许多单词里挑出包含字母w的单词。

8、enumerate()这样一个场景，同时打印出序列里每一个元素和它对应的顺序号，我们用enumerate()函数做做看。

enumerate翻译过来是枚举、列举的意思，所以说enumerate()函数用于对序列里的元素进行顺序标注，返回(元素、索引)组成的迭代器。再举个例子说明，对字符串进行标注，返回每个字母和其索引。

如何用 Python 实现一个图数据库（Graph Database）？

本文章是 重写 500 Lines or Less 系列的其中一篇，目标是重写 500 Lines or Less 系列的原有项目：Dagoba: an in-memory graph database。

Dagoba 是作者设计用来展示如何从零开始自己实现一个图数据库（ Graph Database ）。该名字似乎来源于作者喜欢的一个乐队，另一个原因是它的前缀 DAG 也正好是有向无环图 （ Directed Acyclic Graph ） 的缩写。本文也沿用了该名称。

图是一种常见的数据结构，它将信息描述为若干独立的节点（ vertex ，为了和下文的边更加对称，本文中称为 node ），以及把节点关联起来的边（ edge ）。我们熟悉的链表以及多种树结构可以看作是符合特定规则的图。图在路径选择、推荐算法以及神经网络等方面都是重要的核心数据结构。

既然图的用途如此广泛，一个重要的问题就是如何存储它。如果在传统的关系数据库中存储图，很自然的做法就是为节点和边各自创建一张表，并用外键把它们关联起来。这样的话，要查找某人所有的子女，就可以写下类似下面的查询：

还好，不算太复杂。但是如果要查找孙辈呢？那恐怕就要使用子查询或者 CTE(Common Table Expression) 等特殊构造了。再往下想，曾孙辈又该怎么查询？孙媳妇呢？

这样我们会意识到，SQL 作为查询语言，它只是对二维数据表这种结构而设计的，用它去查询图的话非常笨拙，很快会变得极其复杂，也难以扩展。针对图而言，我们希望有一种更为自然和直观的查询语法，类似这样：

为了高效地存储和查询图这种数据结构，图数据库（ Graph Database ）应运而生。因为和传统的关系型数据库存在极大的差异，所以它属于新型数据库也就是 NoSql 的一个分支（其他分支包括文档数据库、列数据库等）。图数据库的主要代表包括 Neo4J 等。本文介绍的 Dagoba 则是具备图数据库核心功能、主要用于教学和演示的一个简单的图数据库。

原文代码是使用 JavaScript 编写的，在定义调用接口时大量使用了原型（ prototype ）这种特有的语言构造。对于其他主流语言的用户来说，原型的用法多少显得有些别扭和不自然。

考虑到本系列其他数据库示例大多是用 Python 实现的，本文也按照传统，用 Python 重写了原文的代码。同样延续之前的惯例，为了让读者更好地理解程序是如何逐步完善的，我们用迭代式的方法完成程序的各个组成部分。

原文在 500lines 系列的 Github 仓库中只包含了实现代码，并未包含测试。按照代码注释说明，测试程序位于作者的另一个代码库中，不过和 500lines 版本的实现似乎略有不同。

本文实现的代码参考了原作者的测试内容，但跳过了北欧神话这个例子——我承认确实不熟悉这些神祇之间的亲缘关系，相信中文背景的读者们多数也未必了解，虽然作者很喜欢这个例子，想了想还是不要徒增困惑吧。因此本文在编写测试用例时只参考了原文关于家族亲属的例子，放弃了神话相关的部分，尽管会减少一些趣味性，相信对于入门级的代码来说这样也够用了。

本文实现程序位于代码库的 dagoba 目录下。按照本系列程序的同意规则，要想直接执行各个已完成的步骤，读者可以在根目录下的 main.py 找到相应的代码位置，取消注释并运行即可。

本程序的所有步骤只需要 Python3 ，测试则使用内置的 unittest , 不需要额外的第三方库。原则上 Python3.6 以上版本应该都可运行，但我只在 Python3.8.3 环境下完整测试过。

本文实现的程序从最简单的案例开始，通过每个步骤逐步扩展，最终形成一个完整的程序。这些步骤包括：

接下来依次介绍各个步骤。

回想一下，图数据库就是一些点（ node ）和边（ edge ）的集合。现在我们要做出的一个重大决策是如何对节点/边进行建模。对于边来说，必须指定它的关联关系，也就是从哪个节点指向哪个节点。大多数情况下边是有方向的——父子关系不指明方向可是要乱套的！

考虑到扩展性及通用性问题，我们可以把数据保存为字典（ dict ），这样可以方便地添加用户需要的任何数据。某些数据是为数据库内部管理而保留的，为了明确区分，可以这样约定：以下划线开头的特殊字段由数据库内部维护，类似于私有成员，用户不应该自己去修改它们。这也是 Python 社区普遍遵循的约定。

此外，节点和边存在互相引用的关系。目前我们知道边会引用到两端的节点，后面还会看到，为了提高效率，节点也会引用到边。如果仅仅在内存中维护它们的关系，那么使用指针访问是很直观的，但数据库必须考虑到序列化到磁盘的问题，这时指针就不再好用了。

为此，最好按照数据库的一般要求，为每个节点维护一个主键（ _id ），用主键来描述它们之间的关联关系。

我们第一步要把数据库的模型建立起来。为了测试目的，我们使用一个最简单的数据库模型，它只包含两个节点和一条边，如下所示：

按照 TDD 的原则，首先编写测试：

与原文一样，我们把数据库管理接口命名为 Dagoba 。目前，能够想到的最简单的测试是确认节点和边是否已经添加到数据库中：

assert_item 是一个辅助方法，用于检查字典是否包含预期的字段。相信大家都能想到该如何实现，这里就不再列出了，读者可参考 Github 上的完整源码。

现在，测试是失败的。用最简单的办法实现数据库：

需要注意的是，不管添加节点还是查询，程序都使用了拷贝后的数据副本，而不是直接使用原始数据。为什么要这样做？因为字典是可变的，用户可以在任何时候修改其中的内容，如果数据库不知道数据已经变化，就很容易发生难以追踪的一致性问题，最糟糕的情况下会使得数据内容彻底混乱。

拷贝数据可以避免上述问题，代价则是需要占用更多内存和处理时间。对于数据库来说，通常查询次数要远远多于修改，所以这个代价是可以接受的。

现在测试应该正常通过了。为了让它更加完善，我们可以再测试一些边缘情况，看看数据库能否正确处理异常数据，比如：

例如，如果用户尝试添加重复主键，我们预期应抛出 ValueError 异常。因此编写测试如下：

为了满足以上测试，代码需要稍作修改。特别是按照 id 查找主键是个常用操作，通过遍历的方法效率太低了，最好是能够通过主键直接访问。因此在数据库中再增加一个字典：

完整代码请参考 Github 仓库。

在上个步骤，我们在初始化数据库时为节点明确指定了主键。按照数据库设计的一般原则，主键最好是不具有业务含义的代理主键（ Surrogate key ），用户不应该关心它具体的值是什么，因此让数据库去管理主键通常是更为合理的。当然，在部分场景下——比如导入外部数据——明确指定主键仍然是有用的。

为了同时支持这些要求，我们这样约定：字段 _id 表示节点的主键，如果用户指定了该字段，则使用用户设置的值（当然，用户有责任保证它们不会重复）；否则，由数据库自动为它分配一个主键。

如果主键是数据库生成的，事先无法预知它的值是什么，而边（ edge ）必须指定它所指向的节点，因此必须在主键生成后才能添加。由于这个原因，在动态生成主键的情况下，数据库的初始化会略微复杂一些。还是先写一个测试：

为支持此功能，我们在数据库中添加一个内部字段 _next_id 用于生成主键，并让 add_node 方法返回新生成的主键：

接下来，再确认一下边是否可以正常访问：

运行测试，一切正常。这个步骤很轻松地完成了，不过两个测试（ DbModelTest 和 PrimaryKeyTest ）出现了一些重复代码，比如 get_item 。我们可以把这些公用代码提取出来。由于 get_item 内部调用了 TestCase.assertXXX 等方法，看起来应该使用继承，但从 TestCase 派生基类容易引起一些潜在的问题，所以我转而使用另一个技巧 Mixin ：

实现数据库模型之后，接下来就要考虑如何查询它了。

在设计查询时要考虑几个问题。对于图的访问来说，几乎总是由某个节点（或符合条件的某一类节点）开始，从与它相邻的边跳转到其他节点，依次类推。所以链式调用对查询来说是一种很自然的风格。举例来说，要知道 Tom 的孙子养了几只猫，可以使用类似这样的查询：

可以想象，以上每个方法都应该返回符合条件的节点集合。这种实现是很直观的，不过存在一个潜在的问题：很多时候用户只需要一小部分结果，如果它总是不计代价地给我们一个巨大的集合，会造成极大的浪费。比如以下查询：

为了避免不必要的浪费，我们需要另外一种机制，也就是通常所称的“懒式查询”或“延迟查询”。它的基本思想是，当我们调用查询方法时，它只是把查询条件记录下来，而并不立即返回结果，直到明确调用某些方法时才真正去查询数据库。

如果读者比较熟悉流行的 Python ORM，比如 SqlAlchemy 或者 Django ORM 的话，会知道它们几乎都是懒式查询的，要调用 list(result) 或者 result[0:10] 这样的方法才能得到具体的查询结果。

在 Dagoba 中把触发查询的方法定义为 run 。也就是说，以下查询执行到 run 时才真正去查找数据：

和懒式查询（ Lazy Query ）相对应的，直接返回结果的方法一般称作主动查询（ Eager Query ）。主动查询和懒式查询的内在查找逻辑基本上是相同的，区别只在于触发机制不同。由于主动查询实现起来更加简单，出错也更容易排查，因此我们先从主动查询开始实现。

还是从测试开始。前面测试所用的简单数据库数据太少，难以满足查询要求，所以这一步先来创建一个更复杂的数据模型：

此关系的复杂之处之一在于反向关联：如果 A 是 B 的哥哥，那么 B 就是 A 的弟弟/妹妹，为了查询到他们彼此之间的关系，正向关联和反向关联都需要存在，因此在初始化数据库时需要定义的边数量会很多。

当然，父子之间也存在反向关联的问题，为了让问题稍微简化一些，我们目前只需要向下（子孙辈）查找，可以稍微减少一些关联数量。

因此，我们定义数据模型如下。为了减少重复工作，我们通过 _backward 字段定义反向关联，而数据库内部为了查询方便，需要把它维护成两条边：

然后，测试一个最简单的查询，比如查找某人的所有孙辈：

这里 outcome/income 分别表示从某个节点出发、或到达它的节点集合。在原作者的代码中把上述方法称为 out/in 。当然这样看起来更加简洁，可惜的是 in 在 Python 中是个关键字，无法作为函数名。我也考虑过加个下划线比如 out_.in_ 这种形式，但看起来也有点怪异，权衡之后还是使用了稍微啰嗦一点的名称。

现在我们可以开始定义查询接口了。在前面已经说过，我们计划分别实现两种查询，包括主动查询（ Eager Query ）以及延迟查询（ Lazy Query ）。

它们的内在查询逻辑是相通的，看起来似乎可以使用继承。不过遵循 YAGNI 原则，目前先不这样做，而是只定义两个新类，在满足测试的基础上不断扩展。以后我们会看到，与继承相比，把共同的逻辑放到数据库本身其实是更为合理的。

接下来实现访问节点的方法。由于 EagerQuery 调用查询方法会立即返回结果，我们把结果记录在 _result 内部字段中。虽然 node 方法只返回单个结果，但考虑到其他查询方法几乎都是返回集合，为统一起见，让它也返回集合，这样可以避免同时支持集合与单结果的分支处理，让代码更加简洁、不容易出错。此外，如果查询对象不存在的话，我们只返回空集合，并不视为一个错误。

查询输入/输出节点的方法实现类似这样：

查找节点的核心逻辑在数据库本身定义：

以上使用了内部定义的一些辅助查询方法。用类似的逻辑再定义 income ，它们的实现都很简单，读者可以直接参考源码，此处不再赘述。

在此步骤的最后，我们再实现一个优化。当多次调用查询方法后，结果可能会返回重复的数据，很多时候这是不必要的。就像关系数据库通常支持 unique/distinct 一样，我们也希望 Dagoba 能够过滤重复的数据。

假设我们要查询某人所有孩子的祖父，显然不管有多少孩子，他们的祖父应该是同一个人。因此编写测试如下：

现在来实现 unique 。我们只要按照主键把重复数据去掉即可：

在上个步骤，初始化数据库指定了双向关联，但并未测试它们。因为我们还没有编写代码去支持它们，现在增加一个测试，它应该是失败的：

运行测试，的确失败了。我们看看要如何支持它。回想一下，当从边查找节点时，使用的是以下方法：

这里也有一个潜在的问题：调用 self.edges 意味着遍历所有边，当数据库内容较多时，这是巨大的浪费。为了提高性能，我们可以把与节点相关的边记录在节点本身，这样要查找边只要看节点本身即可。在初始化时定义出入边的集合：

在添加边时，我们要同时把它们对应的关系同时更新到节点，此外还要维护反向关联。这涉及对字典内容的部分复制，先编写一个辅助方法：

然后，将添加边的实现修改如下：

这里的代码同时添加正向关联和反向关联。有的朋友可能会注意到代码略有重复，是的，但是重复仅出现在该函数内部，本着“三则重构”的原则，暂时不去提取代码。

实现之后，前面的测试就可以正常通过了。

在这个步骤中，我们来实现延迟查询（ Lazy Query ）。

延迟查询的要求是，当调用查询方法时并不立即执行，而是推迟到调用特定方法，比如 run 时才执行整个查询，返回结果。

延迟查询的实现要比主动查询复杂一些。为了实现延迟查询，查询方法的实现不能直接返回结果，而是记录要执行的动作以及传入的参数，到调用 run 时再依次执行前面记录下来的内容。

如果你去看作者的实现，会发现他是用一个数据结构记录执行操作和参数，此外还有一部分逻辑用来分派对每种结构要执行的动作。这样当然是可行的，但数据处理和分派部分的实现会比较复杂，也容易出错。

本文的实现则选择了另外一种不同的方法：使用 Python 的内部函数机制，把一连串查询变换成一组函数，每个函数取上个函数的执行结果作为输入，最后一个函数的输出就是整个查询的结果。由于内部函数同时也是闭包，尽管每个查询的参数形式各不相同，但是它们都可以被闭包“捕获”而成为内部变量，所以这些内部函数可以采用统一的形式，无需再针对每种查询设计额外的数据结构，因而执行过程得到了很大程度的简化。

首先还是来编写测试。 LazyQueryTest 和 EagerQueryTest 测试用例几乎是完全相同的（是的，两种查询只在于内部实现机制不同，它们的调用接口几乎是完全一致的）。

因此我们可以把 EagerQueryTest 的测试原样不变拷贝到 LazyQueryTest 中。当然拷贝粘贴不是个好注意，对于比较冗长而固定的初始化部分，我们可以把它提取出来作为两个测试共享的公共函数。读者可参考代码中的 step04_lazy_query/tests/test_lazy_query.py 部分。

程序把查询函数的串行执行称为管道（ pipeline ），用一个变量来记录它：

然后依次实现各个调用接口。每种接口的实现都是类似的：用内部函数执行真正的查询逻辑，再把这个函数添加到 pipeline 调用链中。比如 node 的实现类似下面：

其他接口的实现也与此类似。最后， run 函数负责执行所有查询，返回最终结果；

完成上述实现后执行测试，确保我们的实现是正确的。

在前面我们说过，延迟查询与主动查询相比，最大的优势是对于许多查询可以按需要访问，不需要每个步骤都返回完整结果，从而提高性能，节约查询时间。比如说，对于下面的查询：

以上查询的意思是从孙辈中找到一个符合条件的节点即可。对该查询而言，主动查询会在调用 outcome('son') 时就遍历所有节点，哪怕最后一步只需要第一个结果。而延迟查询为了提高效率，应在找到符合条件的结果后立即停止。

目前我们尚未实现 take 方法。老规矩，先添加测试：

主动查询的 take 实现比较简单，我们只要从结果中返回前 n 条记录：

延迟查询的实现要复杂一些。为了避免不必要的查找，返回结果不应该是完整的列表（ list ），而应该是个按需返回的可迭代对象，我们用内置函数 next 来依次返回前 n 个结果：

写完后运行测试，确保它们是正确的。

从外部接口看，主动查询和延迟查询几乎是完全相同的，所以用单纯的数据测试很难确认后者的效率一定比前者高，用访问时间来测试也并不可靠。为了测试效率，我们引入一个节点访问次数的概念，如果延迟查询效率更高的话，那么它应该比主动查询访问节点的次数更少。

为此，编写如下测试：

我们为 Dagoba 类添加一个成员来记录总的节点访问次数，以及两个辅助方法，分别用于获取和重置访问次数：

然后浏览代码，查找修改点。增加计数主要在从边查找节点的时候，因此修改部分如下：

此外还有 income/outcome 方法，修改都很简单，这里就不再列出。

实现后再次运行测试。测试通过，表明延迟查询确实在效率上优于主动查询。

不像关系数据库的结构那样固定，图的形式可以千变万化，查询机制也必须足够灵活。从原理上讲，所有查询无非是从某个节点出发按照特定方向搜索，因此用 node/income/outcome 这三个方法几乎可以组合出任意所需的查询。

但对于复杂查询，写出的代码有时会显得较为琐碎和冗长，对于特定领域来说，往往存在更为简洁的名称，例如：母亲的兄弟可简称为舅舅。对于这些场景，如果能够类似 DSL （领域特定语言）那样允许用户根据专业要求自行扩展，从而简化查询，方便阅读，无疑会更为友好。

如果读者去看原作者的实现，会发现他是用一种特殊语法 addAlias 来定义自己想要的查询，调用方法时再进行查询以确定要执行的内容，其接口和内部实现都是相当复杂的。

而我希望有更简单的方法来实现这一点。所幸 Python 是一种高度动态的语言，允许在运行时向类中增加新的成员，因此做到这一点可能比预想的还要简单。

为了验证这一点，编写测试如下：

无需 Dagoba 的实现做任何改动，测试就可以通过了！其实我们要做的就是动态添加一个自定义的成员函数，按照 Python 对象机制的要求，成员函数的第一个成员应该是名为 self 的参数，但这里已经是在 UnitTest 的内部，为了和测试类本身的 self 相区分，新函数的参数增加了一个下划线。

此外，函数应返回其所属的对象，这是为了链式调用所要求的。我们看到，动态语言的灵活性使得添加新语法变得非常简单。

到此，一个初具规模的图数据库就形成了。

和原文相比，本文还缺少一些内容，比如如何将数据库序列化到磁盘。不过相信读者都看到了，我们的数据库内部结构基本上是简单的原生数据结构（列表+字典），因此序列化无论用 pickle 或是 JSON 之类方法都应该是相当简单的。有兴趣的读者可以自行完成它们。

我们的图数据库实现为了提高查询性能，在节点内部存储了边的指针（或者说引用）。这样做的好处是，无论数据库有多大，从一个节点到相邻节点的访问是常数时间，因此数据访问的效率非常高。

但一个潜在的问题是，如果数据库规模非常大，已经无法整个放在内存中，或者出于安全性等原因要实现分布式访问的话，那么指针就无法使用了，必须要考虑其他机制来解决这个问题。分布式数据库无论采用何种数据模型都是一个棘手的问题，在本文中我们没有涉及。有兴趣的读者也可以考虑 500lines 系列中关于分布式和集群算法的其他一些文章。

本文的实现和系列中其他数据库类似，采用 Python 作为实现语言，而原作者使用的是 JavaScript ，这应该和作者的背景有关。我相信对于大多数开发者来说， Python 的对象机制比 JavaScript 基于原型的语法应该是更容易阅读和理解的。

当然，原作者的版本比本文版本在实现上其实是更为完善的，灵活性也更好。如果想要更为优雅的实现，我们可以考虑使用 Python 元编程，那样会更接近于作者的实现，但也会让程序的复杂性大为增加。如果读者有兴趣，不妨对照着去读读原作者的版本。

python编程中 os.mkfifo()和os.mknod()函数具体用法？最好有例子，里面参数具体怎么配置就能创建管道或节

mkfifo函数使用

[code]mkfifo（建立实名管道）

相关函数

pipe，popen，open，umask

表头文件

#include

#include

定义函数

int mkfifo(const char * pathname,mode_t mode);

函数说明

mkfifo() 会依参数pathname建立特殊的FIFO文件，该文件必须不存在，而参数mode为该文件的权限（mode%~umask），因此 umask值也会影响到FIFO文件的权限。Mkfifo()建立的FIFO文件其他进程都可以用读写一般文件的方式存取。当使用open()来打开 FIFO文件时，O_NONBLOCK旗标会有影响

1、当使用O_NONBLOCK 旗标时，打开FIFO 文件来读取的操作会立刻返回，但是若还没有其他进程打开FIFO 文件来读取，则写入的操作会返回ENXIO 错误代码。

2、没有使用O_NONBLOCK 旗标时，打开FIFO 来读取的操作会等到其他进程打开FIFO文件来写入才正常返回。同样地，打开FIFO文件来写入的操作会等到其他进程打开FIFO 文件来读取后才正常返回。

返回值

若成功则返回0，否则返回-1，错误原因存于errno中。

错误代码

EACCESS 参数pathname所指定的目录路径无可执行的权限

EEXIST 参数pathname所指定的文件已存在。

ENAMETOOLONG 参数pathname的路径名称太长。

ENOENT 参数pathname包含的目录不存在

ENOSPC 文件系统的剩余空间不足

ENOTDIR 参数pathname路径中的目录存在但却非真正的目录。

EROFS 参数pathname指定的文件存在于只读文件系统内。

示例1:

#include

#include

#include

#include

int main(void)

{

char buf[80];

int fd;

unlink( "zieckey_fifo" );

mkfifo( "zieckey_fifo", 0777 );

if ( fork() 0 )

{

char s[] = "Hello!\n";

fd = open( "zieckey_fifo", O_WRONLY );

write( fd, s, sizeof(s) );

//close( fd );

}

else

{

fd = open( "zieckey_fifo", O_RDONLY );

read( fd, buf, sizeof(buf) );

printf("The message from the pipe is:%s\n", buf );

//close( fd );

}

return 0;

}

执行

hello!

示例2:

#include

#include

#include

#include

#include

int main( int argc, char **argv )

{

mode_t mode = 0666;

if ( argc !=2 )

{

printf( "Usage:[%s] fifo_filename\n", argv[0] );

return -1;

}

if (mkfifo( argv[1], mode)0 )

{

perror( "mkfifo");

return -1;

}

return 0;

} [/code]