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

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

成都创新互联主营白云鄂网站建设的网络公司,主营网站建设方案,app软件开发,白云鄂h5微信小程序搭建,白云鄂网站营销推广欢迎白云鄂等地区企业咨询

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绘图篇

1，xlable,ylable设置x，y轴的标题文字。

2，title设置标题。

3，xlim,ylim设置x,y轴显示范围。

plt.show()显示绘图窗口，通常情况下，show（）会阻碍程序运行，带-wthread等参数的环境下，窗口不会关闭。

plt.saveFig（）保存图像。

面向对象绘图

1，当前图表和子图可以用gcf(),gca()获得。

subplot()绘制包含多个图表的子图。

configure subplots,可调节子图与图表边框距离。

可以通过修改配置文件更改对象属性。

图标显示中文

1，在程序中直接指定字体。

2， 在程序开始修改配置字典reParams.

3，修改配置文件。

Artist对象

1，图标的绘制领域。

2，如何在FigureCanvas对象上绘图。

3，如何使用Renderer在FigureCanvas对象上绘图。

FigureCanvas和Render处理底层图像操作，Artist处理高层结构。

分为简单对象和容器对象，简单的Aritist是标准的绘图元件，例如Line 2D,Rectangle,Text,AxesImage等，而容器类型包含许多简单的的 Aritist对象，使他们构成一个整体，例如Axis,Axes,Figure等。

直接创建Artist对象进项绘图操作步奏：

1，创建Figure对象（通过figure（）函数，会进行许多初始化操作，不建议直接创建。）

2，为Figure对象创建一个或多个Axes对象。

3，调用Axes对象的方法创建各类简单的Artist对象。

Figure容器

如何找到指定的Artist对象。

1，可调用add_subplot()和add_axes()方法向图表添加子图。

2，可使用for循环添加栅格。

3，可通过transform修改坐标原点。

Axes容器

1，patch修改背景。

2，包含坐标轴，坐标网格，刻度标签，坐标轴标题等内容。

3，get_ticklabels(),,get-ticklines获得刻度标签和刻度线。

1，可对曲线进行插值。

2，fill_between()绘制交点。

3，坐标变换。

4，绘制阴影。

5，添加注释。

1，绘制直方图的函数是

2，箱线图（Boxplot）也称箱须图（Box-whisker Plot），是利用数据中的五个统计量：最小值、第一四分位

数、中位数、第三四分位数与最大值来描述数据的一种方法，它可以粗略地看出数据是否具有对称性以及分

布的分散程度等信息，特别可以用于对几个样本的比较。

3，饼图就是把一个圆盘按所需表达变量的观察数划分为若干份，每一份的角度（即面积）等价于每个观察

值的大小。

4,散点图

5,QQ图

低层绘图函数

类似于barplot()，dotchart()和plot()这样的函数采用低层的绘图函数来画线和点，来表达它们在页面上放置的位置以及其他各种特征。

在这一节中，我们会描述一些低层的绘图函数，用户也可以调用这些函数用于绘图。首先我们先讲一下R怎么描述一个页面；然后我们讲怎么在页面上添加点，线和文字；最后讲一下怎么修改一些基本的图形。

绘图区域与边界

R在绘图时，将显示区域划分为几个部分。绘制区域显示了根据数据描绘出来的图像，在此区域内R根据数据选择一个坐标系，通过显示出来的坐标轴可以看到R使用的坐标系。在绘制区域之外是边沿区，从底部开始按顺时针方向分别用数字1到4表示。文字和标签通常显示在边沿区域内，按照从内到外的行数先后显示。

添加对象

在绘制的图像上还可以继续添加若干对象，下面是几个有用的函数，以及对其功能的说明。

•points(x, y, ...)，添加点

•lines(x, y, ...)，添加线段

•text(x, y, labels, ...)，添加文字

•abline(a, b, ...)，添加直线y=a+bx

•abline(h=y, ...)，添加水平线

•abline(v=x, ...)，添加垂直线

•polygon(x, y, ...)，添加一个闭合的多边形

•segments(x0, y0, x1, y1, ...)，画线段

•arrows(x0, y0, x1, y1, ...)，画箭头

•symbols(x, y, ...)，添加各种符号

•legend(x, y, legend, ...)，添加图列说明

Python数据结构-哈希表（Hash Table）

哈希表（Hash Table） ：通过键 key 和一个映射函数 Hash(key) 计算出对应的值 value，把关键码值映射到表中一个位置来访问记录，以加快查找的速度。

哈希函数（Hash Function） ：将哈希表中元素的关键键值映射为元素存储位置的函数。

哈希冲突（Hash Collision） ：不同的关键字通过同一个哈希函数可能得到同一哈希地址。

哈希表的两个核心问题是： 「哈希函数的构建」 和 「哈希冲突的解决方法」 。

常用的哈希函数方法有：直接定址法、除留余数法、平方取中法、基数转换法、数字分析法、折叠法、随机数法、乘积法、点积法等。

常用的哈希冲突的解决方法有两种：开放地址法和链地址法。

给你一个整数数组 nums 和两个整数 k 和 t 。请你判断是否存在 两个不同下标 i 和 j，使得 abs(nums[i] - nums[j]) = t ，同时又满足 abs(i - j) = k 。

如果存在则返回 true，不存在返回 false。

给定两个数组 nums1 和 nums2 ，返回 它们的交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。

给你两个整数数组 nums1 和 nums2 ，请你以数组形式返回两数组的交集。返回结果中每个元素出现的次数，应与元素在两个数组中都出现的次数一致（如果出现次数不一致，则考虑取较小值）。可以不考虑输出结果的顺序。

请你判断一个 9 x 9 的数独是否有效。只需要 根据以下规则 ，验证已经填入的数字是否有效即可。

数字 1-9 在每一行只能出现一次。

数字 1-9 在每一列只能出现一次。

数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图）

力扣217

力扣389

力扣496

内容参考：

学习Python元组，有哪些必须要掌握的内容

学习Python元组，有哪些必须要掌握的内容？

1.Python元组

定义

元组是Python的一种内建数据结构。关于元组：

1、元组属于序列，可以存放任意元素（任意类型对象），且有序（前后位置关系）。

2、元组支持整数索引访问其中的数据，也支持切片。

3、元组和列表不同是，元组不可变，列表可变。

元组不可变，某些操作比列表高效。

创建元组

可以用以下两种方法创建元组：

1、使用()创建

2、使用构造函数tuple()

图：使用()创建元组

使用()可以创建元组，元组元素间使用”,”分隔，元组内部元素可以是任意元素，也可以是元组。

图：创建元组代码示例

元组不可变除了不能修改，也不能删除元组元素，但删除与元组绑定的变量是没问题的。

图：元组不可变

使用（）方式创建只有一个元素的元组时要注意，因为一个元素使用()括起来，表示元素本身，如100， （100），两者等价，如果创建只包含100的元组应该使用：(100,)方式。

图：使用（）创建只有一个元素的元组

使用构造函数tuple()创建元组。了解更多信息可以使用help(tuple)来查看具体帮助内容。

图：tuple函数帮助

1、tuple()如果没有参数创建一个空元组。

2、tuple(可迭代对象) 由可迭代对象创建一个元组，如字符串，列表。如果参数是元组将返回该元组。

图：使用tuple函数创建元组

2.元组的访问

和字符串列表一样，元组支持使用整数索引（下标方式访问），也支持切片方式访问元组的元素。

下标索引如果是正整数则从0开始表示第一个元素，…… 最有一个元素用 元组长度-1表示；如果使用负整数做下标，-1表示最后一个元素，-2表示倒数第二个元素，…… 负的长度表示第一个元素。

！！！需要注意的是下标索引不能越界！！！

1、使用索引访问：

图：使用索引访问元组元素

2、切片访问：

图：使用切片访问元组

3.使用内建的常用函数操作元组

常用内建函数len、max、min、sum、reversed可以操作元组，函数解释如下：

操作示例如下:

注意事项：

使用min，max，sum函数操作元组，元组元素类型能被函数接受才可以，否则将报异常等错误。

4.元组常用方法

主要有count和index方法：

count返回元组中对应值的个数，index返回对应值的位置（索引）。

5.元组运算

元组支持 + 连接， * 复制运算，in /not in 运算

图：元组运算

6.序列

字符串，元组，列表都属于Python的序列结构，序列具有很多相同的属性和操作方法，如：序列中的每个元素被分配一个序号（位置，也叫索引），序号（索引）从0开始，依次类推；序列都支持切片操作等等。

图：序列通用操作

Python内置了多种序列结构:字符串、列表、元组、Unicode字符串、buffer对象、range对象。序列是Python中一种重要的数据结构，必须要掌握，也很容易掌握。

python图形界面GUI——Tkinter的构造函数问题

嗯，怎么说呢。每一个gui程序都有一个称为顶层(toplevel)的窗口管理器用于管理那些窗口部件，如按钮，输入框之类的，这个窗口管理器就是这些下级部件的master，顶级窗口的master是None即，它自己管理自己。

回到你的问题，（1）第4行的master=None是表示Application这个类的master默认为None，即它是顶层窗口。

（2）第13行中的app.master是返回当前顶层窗口的对象，然后再调用title这个方法设置title，master=None只是表明app是顶层窗口而已。

我自己理解的。

当前名称：python函数结构图 python的三种基本结构流程图
分享路径：http://scyanting.com/article/hghpse.html