python-igraph API 参考

类文档

class GraphBase

已知子类：igraph.Graph

图的底层表示。

不要直接使用，请使用 igraph.Graph 代替。

未知字段: deffield
ref	参考

方法	`__new__`	创建并返回一个新对象。有关准确的签名，请参见 help(type)。
方法	`add_edges`	向图中添加边。
方法	`add_vertices`	向图中添加顶点。
方法	`邻接矩阵`	从其邻接矩阵生成一个图。
方法	`all_minimal_st_separators`	返回一个列表，其中包含图的所有最小 s-t 分离器。
方法	`all_st_cuts`	返回有向图中源顶点和目标顶点之间的所有割。
方法	`all_st_mincuts`	返回有向图中源顶点和目标顶点之间的所有最小割。
方法	`are_connected`	确定两个给定的顶点是否直接连接。
方法	`articulation_points`	返回图中铰接点的列表。
方法	`assortativity`	基于顶点的数值属性返回图的 assortativity。
方法	`assortativity_degree`	基于顶点度数返回图的 assortativity。
方法	`assortativity_nominal`	基于顶点类别返回图的 assortativity。
方法	`Asymmetric_Preference`	基于非对称顶点类型和连接概率生成图。
方法	`Atlas`	从图谱生成图。
方法	`attributes`	无摘要
方法	`authority_score`	计算图中顶点的 Kleinberg 权威分数
方法	`average_path_length`	计算图中的平均路径长度。
方法	`Barabasi`	基于 Barabasi-Albert 模型生成图。
方法	`betweenness`	计算或估计图中顶点的介数。
方法	`bfs`	对图进行广度优先搜索 (BFS)。
方法	`bfsiter`	构造图的广度优先搜索 (BFS) 迭代器。
方法	`bibcoupling`	计算图中给定顶点的书目耦合分数。
方法	`biconnected_components`	计算图的双连通分量。
方法	`bipartite_projection`	内部函数，无文档。
方法	`bipartite_projection_size`	内部函数，无文档。
方法	`bridges`	返回图中桥的列表。
方法	`canonical_permutation`	使用 BLISS 同构算法计算图的规范置换。
方法	`chordal_completion`	chordal_complation(alpha=None, alpham1=None) --
方法	`clique_number`	返回图的团数。
方法	`cliques`	返回图的一些或所有团，作为元组列表。
方法	`closeness`	计算图中给定顶点的接近度中心性。
方法	`clusters`	计算给定图的（强或弱）聚类。
方法	`cocitation`	计算图中给定顶点的共被引分数。
方法	`cohesive_blocks`	计算图的凝聚块结构。
方法	`community_edge_betweenness`	基于网络中边的介数进行社群结构检测。此算法由 M Girvan 和 MEJ Newman 发明，请参见：M Girvan 和 MEJ Newman：社交和生物网络中的社群结构，Proc...
方法	`community_fastgreedy`	根据 Clauset 等人的算法查找图的社群结构，该算法基于模块化的贪婪优化。
方法	`community_infomap`	根据 Martin Rosvall 和 Carl T. Bergstrom 的 Infomap 方法查找网络的社区结构。
方法	`community_label_propagation`	根据 Raghavan 等人的标签传播方法查找图的社区结构。
方法	`community_leading_eigenvector`	Newman 的特征向量社群结构检测的正确实现。每次分割都是通过最大化关于原始网络的模块化来完成的。有关详细信息，请参见参考资料。
方法	`community_leiden`	使用 Traag、van Eck 和 Waltman 的 Leiden 算法查找图的社区结构。
方法	`community_multilevel`	根据 Blondel 等人的多级算法查找图的社群结构。这是一种自下而上的算法：最初，每个顶点都属于一个单独的社群，并且顶点在社群之间迭代移动，以最大化顶点对整体模块化分数的局部贡献...
方法	`community_optimal_modularity`	计算图的最佳模块化分数和相应的社区结构。
方法	`community_spinglass`	根据 Reichardt & Bornholdt 的自旋玻璃社区检测方法查找图的社区结构。
方法	`community_walktrap`	根据 Latapy & Pons 的随机游走方法查找图的社群结构。
方法	`complementer`	返回图的补图
方法	`compose`	返回两个图的组合。
方法	`constraint`	计算图中给定顶点的 Burt 的约束分数。
方法	`contract_vertices`	收缩图中的一些顶点，即将顶点组替换为单个顶点。边不受影响。
方法	`convergence_degree`	未记录（尚未）。
方法	`convergence_field_size`	未记录（尚未）。
方法	`copy`	创建图的副本。
方法	`coreness`	查找网络顶点的 coreness（壳索引）。
方法	`count_isomorphisms_vf2`	确定图与另一个图之间的同构数
方法	`count_multiple`	计算给定边的重数。
方法	`count_subisomorphisms_vf2`	确定图与另一个图之间的子同构数
方法	`De_Bruijn`	生成具有参数 (m, n) 的 de Bruijn 图
方法	`decompose`	将图分解为子图。
方法	`degree`	从图中返回一些顶点度数。
方法	`Degree_Sequence`	生成具有给定度数序列的图。
方法	`delete_edges`	从图中删除边。
方法	`delete_vertices`	从图中删除顶点及其所有边。
方法	`density`	计算图的密度。
方法	`dfsiter`	构造图的深度优先搜索 (DFS) 迭代器。
方法	`diameter`	计算图的直径。
方法	`difference`	从原始图中减去给定的图
方法	`diversity`	计算顶点的结构多样性指数。
方法	`dominator`	从给定根节点返回支配树
方法	`dyad_census`	Holland 和 Leinhardt 定义的二元统计
方法	`eccentricity`	计算图中给定顶点的离心率。
方法	`ecount`	计算边的数量。
方法	`edge_attributes`	无摘要
方法	`edge_betweenness`	计算或估计图中边的介数。
方法	`edge_connectivity`	计算图或某些顶点之间的边连通性。
方法	`eigen_adjacency`	未归档
方法	`eigenvector_centrality`	计算图中顶点的特征向量中心性。
方法	`Erdos_Renyi`	基于 Erdos-Renyi 模型生成图。
方法	`Establishment`	基于具有顶点类型的简单增长模型生成图。
方法	`Famous`	基于其名称生成一个著名的图。
方法	`farthest_points`	返回两个顶点 ID，它们的距离等于图的实际直径。
方法	`feedback_arc_set`	计算近似或精确的最小反馈弧集。
方法	`Forest_Fire`	基于森林火灾模型生成图
方法	`Full`	生成一个完整的图（有向或无向，带有或不带有环）。
方法	`Full_Citation`	生成一个完整的引用图
方法	`get_adjacency`	返回图的邻接矩阵。
方法	`get_all_shortest_paths`	计算从/到图中给定节点的所有最短路径。
方法	`get_diameter`	返回具有图的实际直径的路径。
方法	`get_edgelist`	返回图的边列表。
方法	`get_eid`	返回顶点 v1 和 v2 之间任意边的边 ID
方法	`get_eids`	返回某些顶点之间某些边的边 ID。
方法	`get_incidence`	内部函数，无文档。
方法	`get_isomorphisms_vf2`	返回图与另一个图之间的所有同构
方法	`get_shortest_paths`	计算从/到图中给定节点的最短路径。
方法	`get_subisomorphisms_lad`	使用 LAD 算法返回图与另一个图之间的所有子同构。
方法	`get_subisomorphisms_vf2`	返回图与另一个图之间的所有子同构
方法	`girth`	返回图的 girth。
方法	`gomory_hu_tree`	内部函数，无文档。
方法	`Growing_Random`	生成一个增长随机图。
方法	`harmonic_centrality`	计算图中给定顶点的谐波中心性。
方法	`has_multiple`	检查图是否有多条边。
方法	`hub_score`	计算图中顶点的 Kleinberg hub 分数
方法	`incident`	返回给定顶点所在的边。
方法	`independence_number`	返回图的独立数。
方法	`independent_vertex_sets`	返回图的一些或所有独立顶点集，作为元组列表。
方法	`induced_subgraph`	返回由给定顶点生成的子图。
方法	`is_bipartite`	确定图是否为二分图。
方法	`is_chordal`	返回图是否为弦图。
方法	`is_connected`	确定图是否已连接。
方法	`is_dag`	检查图是否为 DAG（有向无环图）。
方法	`is_directed`	检查图是否为有向图。
方法	`is_loop`	检查一组特定的边是否包含环边
方法	`is_minimal_separator`	确定给定的顶点集是否为最小分隔符。
方法	`is_multiple`	检查边是否为多条边。
方法	`is_mutual`	检查边是否具有相反的边对。
方法	`is_separator`	确定删除给定的顶点是否会断开图的连接。
方法	`is_simple`	检查图是否为简单图（没有环或多条边）。
方法	`is_tree`	检查图是否为（有向或无向）树图。
方法	`Isoclass`	生成具有给定同构类的图。
方法	`isoclass`	返回图或其子图的同构类。
方法	`isomorphic`	检查图是否与另一个图同构。
方法	`isomorphic_bliss`	使用 BLISS 同构算法检查图是否与另一个图同构。
方法	`isomorphic_vf2`	使用 VF2 同构算法检查图是否与另一个图同构。
方法	`K_Regular`	生成一个 k-正则随机图
方法	`Kautz`	生成具有参数 (m, n) 的 Kautz 图
方法	`knn`	计算每个顶点的邻居的平均度数，以及作为顶点度数函数的相同数量。
方法	`laplacian`	返回图的拉普拉斯矩阵。
方法	`largest_cliques`	返回图的最大团，作为元组列表。
方法	`largest_independent_vertex_sets`	返回图的最大独立顶点集，作为元组列表。
方法	`Lattice`	生成一个规则晶格。
方法	`layout_bipartite`	将二分图的顶点放置在两层中。
方法	`layout_circle`	将图的顶点均匀地放置在圆或球面上。
方法	`layout_davidson_harel`	根据 Davidson-Harel 布局算法将顶点放置在 2D 平面上。
方法	`layout_drl`	根据 DrL 布局算法将顶点放置在 2D 平面或 3D 空间中。
方法	`layout_fruchterman_reingold`	根据 Fruchterman-Reingold 算法将顶点放置在 2D 平面上。
方法	`layout_graphopt`	这是 Michael Schmuhl 的 graphopt 布局算法的端口。 graphopt 版本 0.4.1 已用 C 重写，并且删除了对层的支持。
方法	`layout_grid`	将图的顶点放置在 2D 或 3D 网格中。
方法	`layout_kamada_kawai`	根据 Kamada-Kawai 算法将顶点放置在平面上。
方法	`layout_lgl`	根据 Large Graph Layout 将顶点放置在 2D 平面上。
方法	`layout_mds`	使用多维缩放将顶点放置在具有给定维数的欧几里得空间中。
方法	`layout_random`	随机放置图的顶点。
方法	`layout_reingold_tilford`	根据 Reingold-Tilford 布局算法将顶点放置在 2D 平面上。
方法	`layout_reingold_tilford_circular`	树的圆形 Reingold-Tilford 布局。
方法	`layout_star`	计算图的星形布局。
方法	`LCF`	从 LCF 表示法生成图。
方法	`linegraph`	返回图的线图。
方法	`maxdegree`	返回图中顶点集的最大度数。
方法	`maxflow`	返回源顶点和目标顶点之间的最大流量。
方法	`maxflow_value`	返回源顶点和目标顶点之间的最大流的值。
方法	`maximal_cliques`	返回图的最大团，作为元组列表。
方法	`maximal_independent_vertex_sets`	返回图的最大独立顶点集，作为元组列表。
方法	`maximum_cardinality_search`	对图进行最大基数搜索。该函数计算每个顶点的秩 alpha，使得以递减秩顺序访问顶点对应于始终选择具有最多已访问邻居的顶点作为下一个要访问的顶点。
方法	`mincut`	计算源顶点和目标顶点之间或整个图中的最小割。
方法	`mincut_value`	返回源顶点和目标顶点之间或整个图中的最小割。
方法	`minimum_size_separators`	返回一个列表，其中包含所有最小尺寸的分隔符顶点集。
方法	`modularity`	计算图相对于某些顶点类型的模块化。
方法	`motifs_randesu`	计算图中 motif 的数量
方法	`motifs_randesu_estimate`	计算图中 motif 的总数
方法	`motifs_randesu_no`	计算图中 motif 的总数
方法	`neighborhood`	对于 vertices 指定的每个顶点，返回最多 order 步可以从该顶点到达的顶点。如果 mindist 大于零，则排除少于 mindist 步可到达的顶点。
方法	`neighborhood_size`	对于 vertices 指定的每个顶点，返回最多 order 步可以从该顶点到达的顶点数。如果 mindist 大于零，则少于 mindist 可到达的顶点...
方法	`neighbors`	返回给定顶点的相邻顶点。
方法	`path_length_hist`	计算图的路径长度直方图
方法	`permute_vertices`	根据给定的置换置换图的顶点并返回新图。
方法	`personalized_pagerank`	计算图的个性化 PageRank 值。
方法	`前任`	返回给定顶点的前身。
方法	`Preference`	基于顶点类型和连接概率生成图。
方法	`radius`	计算图的半径。
方法	`random_walk`	从给定节点执行给定长度的随机游走。
方法	`Read_DIMACS`	从符合 DIMACS 最小成本流文件格式的文件中读取图。
方法	`Read_DL`	读取 UCINET DL 文件并基于它创建一个图。
方法	`Read_Edgelist`	从文件中读取边列表并基于它创建一个图。
方法	`Read_GML`	读取 GML 文件并基于它创建一个图。
方法	`Read_GraphDB`	读取 GraphDB 格式文件并基于它创建一个图。
方法	`Read_GraphML`	读取 GraphML 格式文件并基于它创建一个图。
方法	`Read_Lgl`	读取 LGL 使用的 .lgl 文件。
方法	`Read_Ncol`	读取 LGL 使用的 .ncol 文件。
方法	`Read_Pajek`	读取 Pajek 格式文件并基于它创建一个图。
方法	`Realize_Degree_Sequence`	从度数序列生成图。
方法	`Recent_Degree`	基于随机模型生成图，其中边获得新节点的概率与给定时间窗口中获得的边成正比。
方法	`reciprocity`	互易性定义了有向图中相互连接的比例。它最常定义为有向边的相反对应物也包含在图中的概率...
方法	`rewire`	随机重新连接图，同时保留度数分布。
方法	`rewire_edges`	以恒定概率重新连接图的边。
方法	`Ring`	生成一个环图。
方法	`SBM`	基于随机块模型生成图。
方法	`shortest_paths`	计算图中给定顶点的最短路径长度。
方法	`similarity_dice`	顶点的 Dice 相似性系数。
方法	`similarity_inverse_log_weighted`	顶点的反向对数加权相似性系数。
方法	`similarity_jaccard`	顶点的 Jaccard 相似性系数。
方法	`simplify`	通过删除自环和/或多条边来简化图。
方法	`st_mincut`	计算图中源顶点和目标顶点之间的最小割。
方法	`Star`	生成一个星形图。
方法	`Static_Fitness`	生成一个非增长图，其边概率与节点适应度成正比。
方法	`Static_Power_Law`	生成具有规定的幂律度数分布的非增长图。
方法	`strength`	从图中返回某些顶点的强度（加权度数）
方法	`subcomponent`	确定与给定顶点位于同一组件中的顶点的索引。
方法	`subgraph_edges`	返回由给定边生成的子图。
方法	`subisomorphic_lad`	检查图的子图是否与另一个图同构。
方法	`subisomorphic_vf2`	检查图的子图是否与另一个图同构。
方法	`后继`	返回给定顶点的后继者。
方法	`to_directed`	将无向图转换为有向图。
方法	`to_prufer`	将树图转换为 Prufer 序列。
方法	`to_undirected`	将有向图转换为无向图。
方法	`topological_sorting`	计算图的可能拓扑排序。
方法	`transitivity_avglocal_undirected`	计算图的顶点传递性的平均值。
方法	`transitivity_local_undirected`	计算图中给定顶点的局部传递性（聚类系数）。
方法	`transitivity_undirected`	计算图的全局传递性（聚类系数）。
方法	`Tree`	生成一棵几乎所有顶点都具有相同数量子节点的树。
方法	`Tree_Game`	通过从具有给定数量节点的标记树集中均匀采样来生成随机树。
方法	`triad_census`	Davis 和 Leinhardt 定义的三元统计
方法	`unfold_tree`	通过使用 BFS 展开图到一棵树，必要时复制顶点。
方法	`vcount`	计算顶点数。
方法	`vertex_attributes`	无摘要
方法	`vertex_connectivity`	计算图的顶点连通性或某些顶点之间的顶点连通性。
方法	`Watts_Strogatz`	无摘要
方法	`Weighted_Adjacency`	从其邻接矩阵生成一个图。
方法	`write_dimacs`	以 DIMACS 格式将图写入给定的文件。
方法	`write_dot`	以 DOT 格式将图写入给定文件。
方法	`write_edgelist`	将图的边列表写入文件。
方法	`write_gml`	以 GML 格式将图写入给定文件。
方法	`write_graphml`	将图写入 GraphML 文件。
方法	`write_leda`	以 LEDA 本机格式将图写入文件。
方法	`write_lgl`	以 .lgl 格式将图的边列表写入文件。
方法	`write_ncol`	以 .ncol 格式将图的边列表写入文件。
方法	`write_pajek`	以 Pajek 格式将图写入给定文件。
方法	`__graph_as_capsule`	__graph_as_capsule()
方法	`__register_destructor`	注册一个析构函数，以便在 Python 释放对象时调用。igraph 用户不应直接使用此函数。
方法	`_Bipartite`	内部函数，无文档。
方法	`_Full_Bipartite`	内部函数，无文档。
方法	`_get_all_simple_paths`	内部函数，无文档。
方法	`_GRG`	内部函数，无文档。
方法	`_Incidence`	内部函数，无文档。
方法	`_is_matching`	内部函数，无文档。
方法	`_is_maximal_matching`	内部函数，无文档。
方法	`_layout_sugiyama`	内部函数，无文档。
方法	`_maximum_bipartite_matching`	内部函数，无文档。
方法	`_Random_Bipartite`	内部函数，无文档。
方法	`_raw_pointer`	以普通 Python 整数形式返回 Python 对象封装的 igraph 图的内存地址。
方法	`_spanning_tree`	内部函数，无文档。

def __new__(*args, **kwargs): ¶

创建并返回一个新对象。有关准确的签名，请参见 help(type)。

def add_edges(es): ¶

在 igraph.Graph 中重写

向图中添加边。

参数
es	要添加的边列表。每条边都用一个元组表示，其中包含两个端点的顶点 ID。顶点从零开始枚举。

def add_vertices(n): ¶

在 igraph.Graph 中重写

向图中添加顶点。

参数
n	要添加的顶点数

def Adjacency(matrix, mode='directed'): ¶

在 igraph.Graph 中重写

从其邻接矩阵生成一个图。

参数

矩阵邻接矩阵

模式

要使用的模式。可能的值为

"directed"- 图将是有向图，并且矩阵元素给出两个顶点之间的边数。
"undirected"- 别名为"max"为方便起见。
"max"- 将创建无向图，并且顶点 i 和 j 之间的边数为 max(A(i, j), A(j, i))
"min"- 类似于"max"，但使用 min(A(i, j), A(j, i))
"plus"- 类似于"max"，但使用 A(i, j) + A(j, i)
"upper"- 具有矩阵右上三角形（包括对角线）的无向图
"lower"- 具有矩阵左下三角形（包括对角线）的无向图

def all_minimal_st_separators(): ¶

返回一个列表，其中包含图的所有最小 s-t 分离器。

最小分隔符是一组顶点，删除这些顶点会断开图的连接，而删除该集合的任何子集都会保持图的连接。

返回值
一个列表，其中每个项目列出了给定最小 s-t 分隔符的顶点索引。
未知字段：newfield
ref	参考
未知字段：ref
Anne Berry、Jean-Paul Bordat 和 Olivier Cogis：生成图的所有最小分隔符。在：Peter Widmayer、Gabriele Neyer 和 Stephan Eidenbenz（编辑）：计算机科学中的图论概念，1665，167--172，1999。Springer。

def all_st_cuts(source, target): ¶

在 igraph.Graph 中重写

返回有向图中源顶点和目标顶点之间的所有割。

此函数列出源顶点和目标顶点之间的所有边割。每个割都只列出一次。

参数
来源	源顶点 ID
目标	目标顶点 ID
返回值
一个元组，其中第一个元素是边 ID 列表的列表，表示一个割，第二个元素是顶点 ID 列表的列表，表示被割分隔的顶点集。
未知字段：attention
此函数在类 `Graph` 中具有更方便的接口，它将结果包装在 `Cut` 对象的列表中。建议使用该接口。

def all_st_mincuts(source, target): ¶

在 igraph.Graph 中重写

返回有向图中源顶点和目标顶点之间的所有最小割。

参数
来源	源顶点 ID
目标	目标顶点 ID
未知字段：attention
此函数在类 `Graph` 中具有更方便的接口，它将结果包装在 `Cut` 对象的列表中。建议使用该接口。

def are_connected(v1, v2): ¶

确定两个给定的顶点是否直接连接。

参数
v1	第一个顶点的 ID 或名称
v2	第二个顶点的 ID 或名称
返回值
`True`如果存在从 v1 到 v2 的边，`False`否则。

def articulation_points(): ¶

返回图中铰接点的列表。

如果删除一个顶点会增加图中连通分量的数量，则该顶点是一个割点。

def assortativity(types1, types2=None, directed=True): ¶

基于顶点的数值属性返回图的 assortativity。

此系数基本上是顶点的实际连接模式与顶点类型的分布所预期的模式之间的相关性。

有关正确的定义，请参见 Newman MEJ：网络中的混合模式，Phys Rev E 67:026126 (2003) 中的公式 (21)。实际计算使用同一篇论文中针对有向图的公式 (26) 和 Newman MEJ：网络中的自同类混合，Phys Rev Lett 89:208701 (2002) 中针对无向图的公式 (4) 执行。

参数
types1	顶点类型，以列表形式或保存顶点类型的顶点属性名称表示。理想情况下，类型由数值表示。
types2	在有向自同类计算中，每个顶点可以具有一个 out-type 和一个 in-type。在这种情况下，types1 包含 out-type，此参数包含 in-type，以列表形式或顶点属性名称表示。如果`None`，则假定它等于 types1。
有向	是否考虑边的方向。
返回值
自同类系数
参见
当类型是顶点度数时，使用 `assortativity_degree()`
未知字段：newfield
ref	参考
未知字段：ref
Newman MEJ：网络中的混合模式，Phys Rev E 67:026126, 2003。
Newman MEJ：网络中的自同类混合，Phys Rev Lett 89:208701,

def assortativity_degree(directed=True): ¶

基于顶点度数返回图的 assortativity。

有关详细信息，请参见 assortativity()。assortativity_degree() 只是使用顶点度数作为类型来调用 assortativity()。

参数
有向	是否考虑有向图的边的方向。对于无向图，此参数将被忽略。
返回值
自同类系数
参见
`assortativity()`

def assortativity_nominal(types, directed=True): ¶

基于顶点类别返回图的 assortativity。

假设顶点属于不同的类别，此函数计算自同类系数，该系数指定连接在类别内保持的程度。如果所有连接都在类别内保持，则自同类系数为 1，如果所有连接都连接不同类别的顶点，则为负 1。对于随机连接的网络，它渐近地为零。

有关正确的定义，请参见 Newman MEJ：网络中的混合模式，Phys Rev E 67:026126 (2003) 中的公式 (2)。

参数
types	顶点类型，以列表形式或保存顶点类型的顶点属性名称表示。类型应由数值表示。
有向	是否考虑边的方向。
返回值
自同类系数
未知字段：newfield
ref	参考
未知字段：ref
Newman MEJ：网络中的混合模式，Phys Rev E 67:026126, 2003。

def Asymmetric_Preference(n, type_dist_matrix, pref_matrix, attribute=None, loops=False): ¶

基于非对称顶点类型和连接概率生成图。

这是 Preference() 的非对称变体。生成给定数量的顶点。根据给定的联合类型概率，每个顶点都分配有一个“传入”和一个“传出”顶点类型。最后，评估每对顶点，并根据源顶点的“传出”类型和目标顶点的“传入”类型，创建一个顶点对之间的有向边，其概率取决于源顶点的“传出”类型和目标顶点的“传入”类型。

参数
n	图中的顶点数
type_dist_matrix	给出顶点类型的联合分布的矩阵
pref_matrix	给出不同顶点类型的连接概率的矩阵。
attribute	用于存储顶点类型的顶点属性名称。如果`None`，则不存储顶点类型。
循环	是否允许环边。

def Atlas(idx): ¶

从图谱生成图。

参数
idx	要生成的图的索引。索引从零开始，图按以下方式列出按顶点数量递增排序；对于固定数量的顶点，按边数量递增排序；对于固定数量的顶点和边，按度数序列的递增顺序排列，例如 111223 < 112222；对于固定的度序列，按自同构数递增排序。
未知字段：newfield
ref	参考
未知字段：ref
图谱，作者：Ronald C. Read 和 Robin J. Wilson，Oxford University Press，1998。

def attributes(): ¶

返回值
图的属性名称列表

def authority_score(weights=None, scale=True, arpack_options=None, return_eigenvalue=False): ¶

计算图中顶点的 Kleinberg 权威分数

参数
weights	要使用的边权重。可以是序列或可迭代对象，甚至可以是边属性名称。
scale	是否对分数进行归一化，以使最大分数为 1。
arpack_options	一个 `ARPACKOptions` 对象，用于微调 ARPACK 特征向量计算。如果省略，则使用名为`arpack_options`。
return_eigenvalue	是否返回最大特征值
返回值
列表中的权威分数，可以选择将最大特征值作为元组的第二个成员返回
参见
hub_score()

def average_path_length(directed=True, unconn=True): ¶

计算图中的平均路径长度。

参数
有向	是否考虑有向图中的有向路径。对于无向图，此参数将被忽略。
unconn	当图未连接时该怎么办。如果`True`，则计算组件中测地线长度的平均值。否则，对于所有未连接的顶点对，使用等于顶点数的路径长度。
返回值
图中平均路径长度

def Barabasi(n, m, outpref=False, directed=False, power=1, zero_appeal=1, implementation='psumtree', start_from=None): ¶

基于 Barabasi-Albert 模型生成图。

参数
n	顶点数
m	为每个顶点生成的传出边数或显式包含每个顶点的传出边数的列表。
outpref	`True`如果给定顶点的出度也应增加其引用概率（以及其入度），但默认为`False`.
有向	`True`生成的图是否应该是有向图（默认`False`).
power	非线性模型的功率常数。它可以省略，在这种情况下，将使用通常的线性模型。
zero_appeal	度数为零的顶点的吸引力。
implementation	用于生成网络的算法。可能的值为 `"bag"`：igraph 0.6 之前的默认算法。它的工作方式是将顶点的 ID 放入一个包（多重集）中，其次数与它们的入度数相同，再加上一次。然后从包中抽取所需数量的被引用顶点（带替换）。它仅适用于 power=1 和 zero_appeal=1。 `"psumtree"`：此算法使用部分前缀和树来生成图。它不会生成多条边，并且适用于 power 和 zero_appeal 的任何值。 `"psumtree_multiple"`：类似于`"psumtree"`，但它也会生成多条边。igraph 0.6 之前对于 powers 不为 1 的情况使用此算法。
start_from	如果给定且不`None`，则这必须是另一个 `GraphBase` 对象。igraph 将使用此图作为优先连接模型的起点。
未知字段：newfield
ref	参考
未知字段：ref
Barabasi, A-L 和 Albert, R. 1999。随机网络中缩放的出现。Science, 286 509-512。

def betweenness(vertices=None, directed=True, cutoff=None, weights=None): ¶

计算或估计图中顶点的介数。

关键字参数

参数
vertices	必须返回介数的顶点。如果`None`，则假定为图中的所有顶点。
有向	是否考虑有向路径。
cutoff	如果它是一个整数，则仅考虑小于或等于此长度的路径，从而有效地估计给定顶点的介数。如果`None`，则返回精确介数。
weights	要使用的边权重。可以是序列或可迭代对象，甚至可以是边属性名称。
返回值
列表中给定顶点的（可能估计的）介数

def bfs(vid, mode='out'): ¶

对图进行广度优先搜索 (BFS)。

参数
vid	根顶点 ID
模式	mode`"in"`之一或`"out"`之一或`"all"`，对于无向图将被忽略。
返回值
一个包含以下项目的元组访问的顶点 ID（按顺序）顶点列表中层的起始索引 BFS 中每个顶点的父节点

def bfsiter(vid, mode='out', advanced=False): ¶

构造图的广度优先搜索 (BFS) 迭代器。

参数
vid	根顶点 ID
模式	mode`"in"`之一或`"out"`之一或`"all"`.
advanced	如果`False`，迭代器在每一步都返回 BFS 顺序中的下一个顶点。如果`True`，则迭代器还返回顶点与根顶点的距离以及顶点在 BFS 树中的父节点。
返回值
BFS 迭代器，作为 `igraph.BFSIter` 对象。

def bibcoupling(vertices=None): ¶

计算图中给定顶点的书目耦合分数。

参数
vertices	要分析的顶点。如果`None`，则将考虑所有顶点。
返回值
矩阵中所有给定顶点的文献耦合分数。

def biconnected_components(return_articulation_points=True): ¶

在 igraph.Graph 中重写

计算图的双连通分量。

仅包含单个顶点的组件不被视为双连通。

参数
return_articulation_points	是否也返回割点
返回值
一个列表，其中包含构成双连通组件的生成树的边索引列表（每个组件一棵生成树），以及可选的割点列表

def bipartite_projection(types, multiplicity=True, probe1=-1, which=-1): ¶

在 igraph.Graph 中重写

内部函数，无文档。

参见
Graph.bipartite_projection()

def bipartite_projection_size(types): ¶

在 igraph.Graph 中重写

内部函数，无文档。

参见
Graph.bipartite_projection_size()

def bridges(): ¶

返回图中桥的列表。

如果删除边会增加图中（弱）连通分量的数量，则该边是一座桥。

def canonical_permutation(sh='fl', color=None): ¶

使用 BLISS 同构算法计算图的规范置换。

将此处返回的排列传递给 permute_vertices() 会将图转换为其规范形式。

有关 BLISS 算法和规范排列的更多信息，请参见 http://www.tcs.hut.fi/Software/bliss/index.html。

参数
sh	作为不区分大小写的字符串的图的分裂启发式方法，可能的值如下 `"f"`：第一个非单例单元格 `"fl"`：第一个最大的非单例单元格 `"fs"`：第一个最小的非单例单元格 `"fm"`：第一个最大非平凡连通的非单例单元格 `"flm"`：最大的最大非平凡连通的非单例单元格 `"fsm"`：最小的最大非平凡连通的非单例单元格
color	可选向量，用于存储顶点着色，相对于此顶点着色来计算同构。如果`None`，则所有顶点都具有相同的颜色。
返回值
一个包含顶点 ID 的排列向量。原始图中的顶点 0 将映射到此向量的第一个元素中包含的 ID；顶点 1 将映射到第二个，依此类推。

def chordal_completion(...): ¶

chordal_complation(alpha=None, alpham1=None) --

返回使图成为弦图需要添加到图中的边的列表。

如果其四个或更多节点的每个环都有一条弦，即一条连接环中不相邻的两个节点的边，则该图是弦图。一个等效的定义是，任何无弦环最多有三个节点。

图的弦图补全是要添加到图中以使其成为弦图的边列表。如果该图已经是弦图，则它是一个空列表。

请注意，目前 igraph 不保证返回的弦图补全是最小的；可能存在返回的弦图补集的子集，它仍然是有效的弦图补全。

参数
alpha	从调用图上的 `maximum_cardinality_search()` 结果中获得的 alpha 向量。仅当您已经有 alpha 向量时才有用；只需传递`None`这里将让 igraph 自行计算 alpha 向量。
alpham1	调用图的 `maximum_cardinality_search()` 的结果得到的逆 alpha 向量。仅当您已经有逆 alpha 向量时才有用；简单地传递`None`这里将让 igraph 自行计算逆 alpha 向量。
返回值
要添加到图中的边的列表；列表中的每个项目都是顶点索引的源-目标对。

def clique_number(): ¶

返回图的团数。

图的团数是最大团的大小。

参见
有关最大团的信息，请参见 `largest_cliques()`。

def cliques(min=0, max=0): ¶

返回图的一些或所有团，作为元组列表。

团是一个完整的子图——一组顶点，其中任意两个顶点之间都存在边（不包括环）。

参数
min	要返回的团的最小大小。如果为零或负数，则不使用下限。
max	要返回的团的最大大小。如果为零或负数，则不使用上限。

def closeness(vertices=None, mode='all', cutoff=None, weights=None, normalized=True): ¶

计算图中给定顶点的接近度中心性。

顶点的紧密度中心性衡量从它（或反过来：从其他顶点可以很容易地到达它）可以轻松到达其他顶点的程度。它定义为顶点数减一除以从/到给定顶点的所有测地线的长度之和。

如果图未连接，并且两个顶点之间没有路径，则使用顶点数代替测地线的长度。这总是比最长的可能测地线更长。

参数
vertices	必须返回紧密度的顶点。如果`None`，则使用图中的所有顶点。
模式	必须是以下之一`"in"`, `"out"`和`"all"`. `"in"`表示必须计算传入路径的长度，`"out"`表示必须计算传出路径的长度。`"all"`表示必须同时计算两者。
cutoff	如果它是一个整数，则只考虑小于或等于此长度的路径，从而有效地估计给定顶点的紧密度（这始终是对实际紧密度的低估，因为某些顶点对即使已连接也会显示为断开连接）。如果`None`，则返回确切的紧密度。
weights	要使用的边权重。可以是序列或可迭代对象，甚至可以是边属性名称。
normalized	是否通过乘以顶点数减一来归一化原始紧密度分数。
返回值
列表中计算出的紧密度

def clusters(mode='strong'): ¶

在 igraph.Graph 中重写

计算给定图的（强或弱）聚类。

参数
模式	必须是`"strong"`之一或`"weak"`之一，具体取决于要寻找的聚类。可选，默认为`"strong"`.
返回值
图中每个节点的组件索引。
未知字段：attention
此函数在类 `Graph` 中具有更方便的界面，它将结果包装在 `VertexClustering` 对象中。建议使用该界面。

def cocitation(vertices=None): ¶

计算图中给定顶点的共被引分数。

参数
vertices	要分析的顶点。如果`None`，则将考虑所有顶点。
返回值
矩阵中所有给定顶点的共引用分数。

def cohesive_blocks(): ¶

在 igraph.Graph 中重写

计算图的凝聚块结构。

未知字段：attention
此函数在类 `Graph` 中具有更方便的界面，它将结果包装在 `CohesiveBlocks` 对象中。建议使用该界面。

def community_edge_betweenness(directed=True, weights=None): ¶

在 igraph.Graph 中重写

基于网络中边的介数检测社区结构。此算法由 M Girvan 和 MEJ Newman 发明，请参见：M Girvan 和 MEJ Newman：社交和生物网络中的社区结构，Proc. Nat. Acad. Sci. USA 99, 7821-7826 (2002)。

其思想是连接两个社区的边的介数通常很高。因此，我们逐渐从网络中删除介数最高的边，并在每次删除后重新计算边介数，只要所有边都被删除即可。

参数
有向	在计算介数值时是否考虑边的方向。
weights	边属性的名称或包含边权重的列表。
返回值
一个元组，其中包含描述树状图的合并矩阵和每次合并之前的模块化分数。如果原始图是加权图，则模块化分数使用权重。
未知字段：attention
此函数在派生类 `Graph` 中以更方便的语法包装。建议使用该版本而不是此版本。

def community_fastgreedy(weights=None): ¶

在 igraph.Graph 中重写

根据 Clauset 等人的算法查找图的社群结构，该算法基于模块化的贪婪优化。

这是一个自下而上的算法：最初，每个顶点都属于一个单独的社区，并且社区逐个合并。在每个步骤中，合并的两个社区都是导致模块化最大增加的社区。

参数
weights	边属性的名称或包含边权重的列表
返回值
包含以下元素的元组合并列表每次合并之前的模块化分数
参见
modularity()
未知字段：attention
此函数在派生类 `Graph` 中以更方便的语法包装。建议使用该版本而不是此版本。
未知字段：newfield
ref	参考
未知字段：ref
A. Clauset, M. E. J. Newman 和 C. Moore：在非常大的网络中寻找社区结构。 Phys Rev E 70, 066111 (2004)。

def community_infomap(edge_weights=None, vertex_weights=None, trials=10): ¶

在 igraph.Graph 中重写

根据 Martin Rosvall 和 Carl T. Bergstrom 的 Infomap 方法查找网络的社区结构。

有关该算法的可视化效果，请参见 http://www.mapequation.org 或以下提供的参考文献之一。

参数
edge_weights	边属性的名称或包含边权重的列表。
vertex_weights	顶点属性的名称或包含顶点权重的列表。
trials	对网络进行分区的尝试次数。
返回值
计算出的成员向量和元组中相应的代码长度。
未知字段：newfield
ref	参考
未知字段：ref
M. Rosvall 和 C. T. Bergstrom：信息流图揭示了复杂网络中的社区结构。PNAS 105, 1118 (2008)。http://arxiv.org/abs/0707.0609
M. Rosvall, D. Axelsson 和 C. T. Bergstrom：地图方程。Eur Phys J Special Topics 178, 13 (2009)。http://arxiv.org/abs/0906.1405

def community_label_propagation(weights=None, initial=None, fixed=None): ¶

在 igraph.Graph 中重写

根据 Raghavan 等人的标签传播方法查找图的社区结构。

最初，每个顶点都被分配一个不同的标签。之后，每个顶点在每次迭代中选择其邻域中的主要标签。平局是随机打破的，并且在每次迭代之前随机化顶点被更新的顺序。当顶点达成共识时，算法结束。

请注意，由于平局是随机打破的，因此不能保证算法在每次运行后返回相同的社区结构。事实上，它们经常不同。有关如何提出聚合社区结构的信息，请参见 Raghavan 等人的论文。

参数
weights	边属性的名称或包含边权重的列表
initial	包含初始顶点标签的顶点属性的名称或列表。标签由从零到 n − 1 的整数标识，其中 n 是顶点数。此向量中也可能存在负数，它们表示未标记的顶点。
fixed	每个顶点的布尔值列表。`True`对应于其标签在算法期间不应更改的顶点。仅当也给出初始标签时才有意义。未标记的顶点无法修复。请注意，此处不接受顶点属性名称。
返回值
生成的成员向量
未知字段：newfield
ref	参考
未知字段：ref
Raghavan, U.N.、Albert, R. 和 Kumara, S. 近线性时间算法，用于检测大规模网络中的社区结构。Phys Rev E 76:036106, 2007。http://arxiv.org/abs/0709.2938。

def community_leading_eigenvector(n=-1, arpack_options=None, weights=None): ¶

在 igraph.Graph 中重写

Newman 的特征向量社群结构检测的正确实现。每次分割都是通过最大化关于原始网络的模块化来完成的。有关详细信息，请参见参考资料。

参数
n	所需的社区数量。如果为负数，则算法会尝试进行尽可能多的拆分。请注意，如果主导特征向量的符号都相同，则算法不会进一步拆分社区。
arpack_options	一个 `ARPACKOptions` 对象，用于微调 ARPACK 特征向量计算。如果省略，则使用名为`arpack_options`。
weights	边属性的名称或包含边权重的列表
返回值
一个元组，其中第一个元素是聚类的成员向量，第二个元素是合并矩阵。
未知字段：attention
此函数在派生类 `Graph` 中以更方便的语法包装。建议使用该版本而不是此版本。
未知字段：newfield
ref	参考
未知字段：ref
MEJ Newman：使用矩阵的特征向量在网络中寻找社区结构，arXiv:physics/0605087

def community_leiden(edge_weights=None, node_weights=None, resolution_parameter=1.0, normalize_resolution=False, beta=0.01, initial_membership=None, n_iterations=2): ¶

在 igraph.Graph 中重写

使用 Traag、van Eck 和 Waltman 的 Leiden 算法查找图的社区结构。

参数
edge_weights	要使用的边权重。可以是序列或可迭代对象，甚至可以是边属性名称。
node_weights	Leiden 算法中使用的节点权重。
resolution_parameter	要使用的分辨率参数。较高的分辨率会导致更多较小的社区，而较低的分辨率会导致较少较大的社区。
normalize_resolution	如果设置为 true，则分辨率参数将除以节点权重的总和。如果未提供此参数，则默认为节点度，或者在提供 edge_weights 的情况下为加权度。
beta	影响 Leiden 算法中随机性的参数。这仅影响算法的优化步骤。
initial_membership	如果提供，Leiden 算法将尝试改进此提供的成员资格。如果没有提供参数，则算法只从单例分区开始。
n_iterations	迭代 Leiden 算法的次数。每次迭代可能会进一步改进分区。
返回值
社区成员向量。

def community_multilevel(weights=None, return_levels=True, resolution=1): ¶

在 igraph.Graph 中重写

根据 Blondel 等人的多层算法查找图的社区结构。这是一种自下而上的算法：最初，每个顶点都属于一个单独的社区，并且顶点以最大化顶点对整体模块化分数的本地贡献的方式在社区之间迭代移动。当达成共识时（即，没有一次移动会增加模块化分数），原始图中的每个社区都会缩小为单个顶点（同时保持入射边的总权重），并且该过程在下一层继续。当无法在将社区缩小为顶点之后再增加模块化时，算法停止。

参数
weights	边属性的名称或包含边权重的列表
return_levels	如果`True`，返回多层结果。如果`False`，则仅返回最佳层（对应于最佳模块化）。
resolution	在模块化度量中使用的分辨率参数。较小的值会导致较少数量的较大聚类，而较大的值会导致大量的小聚类。经典模块化度量假定分辨率参数为 1。
返回值
描述每个顶点的社区成员身份的单个列表（如果`return_levels`是`False`），或者社区成员身份向量的列表，一个对应于每个级别和相应的模块化列表（如果`return_levels`是`True`).
参见
modularity()
未知字段：attention
此函数在派生类 `Graph` 中以更方便的语法包装。建议使用该版本而不是此版本。
未知字段：newfield
ref	参考
未知字段：ref
VD Blondel, J-L Guillaume, R Lambiotte 和 E Lefebvre：大型网络中社区层次结构的快速展开。J Stat Mech P10008 (2008), http://arxiv.org/abs/0803.0476

def community_optimal_modularity(weights=None): ¶

在 igraph.Graph 中重写

计算图的最佳模块化分数和相应的社区结构。

此函数使用 GNU 线性规划工具包来解决大型整数优化问题，以便找到最佳模块化分数和相应的社区结构，因此它不太可能适用于大于几个（小于一百个）顶点的图。如果您有这么大的图，请考虑使用启发式方法之一。

参数
weights	边属性的名称或包含边权重的列表。
返回值
计算出的成员向量和元组中相应的模块化。

def community_spinglass(weights=None, spins=25, parupdate=False, start_temp=1, stop_temp=0.01, cool_fact=0.99, update_rule='config', gamma=1, implementation='orig', lambda_=1): ¶

在 igraph.Graph 中重写

根据 Reichardt & Bornholdt 的自旋玻璃社区检测方法查找图的社区结构。

参数
weights	要使用的边权重。可以是序列或可迭代对象，甚至可以是边属性名称。
spins	整数，要使用的自旋数。这是社区数的上限。在这里提供（合理）大的数字没有问题，在这种情况下，某些自旋状态将不会被填充。
parupdate	是否并行（同步）更新顶点的自旋
start_temp	起始温度
stop_temp	停止温度
cool_fact	模拟退火的冷却因子
update_rule	指定模拟的零模型。可能的值为`"config"`（具有与输入图相同的顶点度的随机图）或`"simple"`（具有相同数量边的随机图）
gamma	算法的 gamma 参数，指定社区内存在边和缺失边之间的重要性平衡。默认值 1.0 为两者分配相同的重要性。
implementation	当前 igraph 包含自旋玻璃社区检测算法的两个实现。更快的原始实现是默认设置。另一个实现能够考虑负权重，可以通过设置来选择此实现`implementation`到`"neg"`.
lambda_	算法的 lambda 参数，它指定社区内存在负加权边和缺失负加权边之间的重要性平衡。lambda 的较小值会导致社区的负内部连通性较小。如果参数为零，则算法将简化为图形着色算法，使用自旋数作为颜色。如果使用原始实现，则忽略此参数。
返回值
社区成员向量。

def community_walktrap(weights=None, steps=None): ¶

在 igraph.Graph 中重写

根据 Latapy & Pons 的随机游走方法查找图的社群结构。

该算法的基本思想是短随机游走倾向于停留在同一社区中。该方法提供了一个树状图。

参数
weights	边属性的名称或包含边权重的列表
steps	未归档
返回值
包含合并列表和与每次合并对应的模块化分数的元组
参见
modularity()
未知字段：attention
此函数在派生类 `Graph` 中以更方便的语法包装。建议使用该版本而不是此版本。
未知字段：newfield
ref	参考
未知字段：ref
Pascal Pons, Matthieu Latapy：使用随机游走计算大型网络中的社区，http://arxiv.org/abs/physics/0512106。

def complementer(loops=False): ¶

返回图的补图

参数
循环	是否在补集中包含环边。
返回值
图的补集

def compose(other): ¶

返回两个图的组合。

def constraint(vertices=None, weights=None): ¶

计算图中给定顶点的 Burt 的约束分数。

如果自我拥有更少或相互更强相关（即更多冗余）的联系人，则 Burt 的约束更高。Burt 对顶点 i 的自我网络 V[i] 的约束度量 C[i] 定义为定向和加权图，如下所示

C[i] = sum( sum( (p[i,q] p[q,j])^2, q in V[i], q != i,j ), j in V[], j != i)

对于阶数为（即顶点数）N 的图，其中比例联系强度定义如下

p[i,j]=(a[i,j]+a[j,i]) / sum(a[i,k]+a[k,i], k in V[i], k != i), a[i,j] 是 A 的元素，后者是图邻接矩阵。

对于孤立的顶点，约束未定义。

参数
vertices	要分析的顶点或`None`适用于所有顶点。
weights	与边关联的权重。也可以是属性名称。如果`None`，则每条边都将具有相同的权重。
返回值
矩阵中所有给定顶点的约束分数。

def contract_vertices(mapping, combine_attrs=None): ¶

收缩图中的一些顶点，即将顶点组替换为单个顶点。边不受影响。

参数
mapping	数字向量，给出旧顶点 ID 和新顶点 ID 之间的映射。在此向量中具有相同新顶点 ID 的顶点将被重新映射到单个新顶点。在这里传递 `VertexClustering` 对象的成员向量是安全的。
combine_attrs	指定如何合并折叠成一个顶点的顶点的属性。如果它是`None`，则所有属性都将丢失。如果它是一个函数，则将收集顶点的属性并将其传递给该函数，该函数将返回必须分配给单个折叠顶点的新属性值。它也可以是以下字符串常量之一，这些常量定义了内置的折叠函数`sum`, `prod`, `mean`, `median`, `max`, `min`, `first`, `last`, `random`。您还可以通过传递一个字典来为不同的属性指定不同的组合函数，该字典将属性名称映射到函数。有关更多详细信息，请参见 `simplify()`。
返回值
`None`.
参见
`simplify()`

def convergence_degree(): ¶

未记录（尚未）。

def convergence_field_size(): ¶

未记录（尚未）。

def copy(): ¶

创建图的副本。

属性通过引用复制；换句话说，如果您使用可变的 Python 对象作为属性值，则这些对象仍将在旧图和新图之间共享。如果需要真正深入地复制图形，可以使用 `copy` 模块中的 `deepcopy()`。

def coreness(mode='all'): ¶

查找网络顶点的 coreness（壳索引）。

图的 k-核是一个最大的子图，其中每个顶点的度数至少为 k。（这里的度数当然是指子图中的度数）。如果一个顶点是 k-核的成员而不是 k + 1-核的成员，则该顶点的核数为 k。

参数
模式	是否计算内核数（`"in"`）、外核数（`"out"`）或无向内核数（`"all"`）。忽略并假定为`"all"`对于无向图。
返回值
每个顶点的内核数。
未知字段：newfield
ref	参考
未知字段：ref
Vladimir Batagelj, Matjaz Zaversnik：网络核心分解的 O(m) 算法。

def count_isomorphisms_vf2(other=None, color1=None, color2=None, edge_color1=None, edge_color2=None, node_compat_fn=None, edge_compat_fn=None): ¶

确定图与另一个图之间的同构数

顶点和边的颜色可用于限制同构，因为只允许具有相同颜色的顶点和边相互匹配。

参数
other	另一个图。如果`None`，将返回自同构的数量。
color1	可选向量，存储第一个图的顶点的着色。如果`None`，则所有顶点都具有相同的颜色。
color2	可选向量，存储第二个图的顶点的着色。如果`None`，则所有顶点都具有相同的颜色。
edge_color1	可选向量，存储第一个图的边的着色。如果`None`，则所有边都具有相同的颜色。
edge_color2	可选向量，存储第二个图的边的着色。如果`None`，则所有边都具有相同的颜色。
node_compat_fn	一个函数，接收两个图和两个节点索引（一个来自第一个图，一个来自第二个图）并返回`True`如果由两个索引给出的节点是兼容的（即，它们可以相互匹配）或`False`否则。这可以用于基于节点特定标准来限制同构的集合，这些标准太复杂而无法由节点颜色向量表示（即，`color1`和`color2`参数）。`None`表示每个节点与每个其他节点都兼容。
edge_compat_fn	一个函数，接收两个图和两个边索引（一个来自第一个图，一个来自第二个图）并返回`True`如果由两个索引给出的边是兼容的（即，它们可以相互匹配）或`False`否则。这可以用于基于边特定标准来限制同构的集合，这些标准太复杂而无法由边颜色向量表示（即，`edge_color1`和`edge_color2`参数）。`None`表示每条边与每个其他节点都兼容。
返回值
两个给定图之间的同构的数量（或自同构的数量，如果`other`是`None`.

def count_multiple(edges=None): ¶

计算给定边的重数。

参数
边	我们想要计算其多重性的边索引。如果`None`，则计算所有边。
返回值
给定边的多重性作为列表。

def count_subisomorphisms_vf2(other, color1=None, color2=None, edge_color1=None, edge_color2=None, node_compat_fn=None, edge_compat_fn=None): ¶

确定图与另一个图之间的子同构数

顶点和边的颜色可用于限制同构，因为只允许具有相同颜色的顶点和边相互匹配。

参数
other	另一个图。
color1	可选向量，存储第一个图的顶点的着色。如果`None`，则所有顶点都具有相同的颜色。
color2	可选向量，存储第二个图的顶点的着色。如果`None`，则所有顶点都具有相同的颜色。
edge_color1	可选向量，存储第一个图的边的着色。如果`None`，则所有边都具有相同的颜色。
edge_color2	可选向量，存储第二个图的边的着色。如果`None`，则所有边都具有相同的颜色。
node_compat_fn	一个函数，接收两个图和两个节点索引（一个来自第一个图，一个来自第二个图）并返回`True`如果由两个索引给出的节点是兼容的（即，它们可以相互匹配）或`False`否则。这可以用于基于节点特定标准来限制同构的集合，这些标准太复杂而无法由节点颜色向量表示（即，`color1`和`color2`参数）。`None`表示每个节点与每个其他节点都兼容。
edge_compat_fn	一个函数，接收两个图和两个边索引（一个来自第一个图，一个来自第二个图）并返回`True`如果由两个索引给出的边是兼容的（即，它们可以相互匹配）或`False`否则。这可以用于基于边特定标准来限制同构的集合，这些标准太复杂而无法由边颜色向量表示（即，`edge_color1`和`edge_color2`参数）。`None`表示每条边与每个其他节点都兼容。
返回值
两个给定图之间的子同构的数量

def De_Bruijn(m, n): ¶

生成具有参数 (m, n) 的 de Bruijn 图

De Bruijn 图表示字符串之间的关系。使用 m 个字母的字母表，并考虑长度为 n 的字符串。一个顶点对应于每个可能的字符串，并且如果可以通过删除其第一个字母并将一个字母附加到它来将 v 的字符串转换为 w 的字符串，则存在从顶点 v 到顶点 w 的有向边。

请注意，该图将具有 mⁿ 个顶点，甚至更多的边，因此可能您不想为 m 和 n 提供太大的数字。

参数
m	字母表的大小
n	字符串的长度

def decompose(mode='strong', maxcompno=None, minelements=1): ¶

将图分解为子图。

参数
模式	必须是`"strong"`之一或`"weak"`之一，具体取决于要寻找的聚类。可选，默认为`"strong"`.
maxcompno	要返回的最大组件数。`None`表示所有可能的组件。
minelements	组件中的最小顶点数。通过将其设置为 2，孤立的顶点不会作为单独的组件返回。
返回值
子图的列表。每个返回的子图都是原始图的副本。

def degree(vertices, mode='all', loops=True): ¶

从图中返回一些顶点度数。

此方法接受单个顶点 ID 或顶点 ID 列表作为参数，并返回给定顶点的度数（以单个整数或列表的形式，具体取决于输入参数）。

参数
vertices	单个顶点 ID 或顶点 ID 列表
模式	要返回的度的类型（`"out"`表示出度，`"in"`表示入度或`"all"`表示它们的总和）。
循环	是否应计算自环。

def Degree_Sequence(out, in_=None, method='simple'): ¶

生成具有给定度数序列的图。

参数
out	有向图的出度序列。如果省略了入度序列，则生成的图将是无向的，因此这也将是入度序列
in_	有向图的入度序列。如果省略，则生成的图将是无向的。
method	要使用的生成方法。以下之一 `"simple"`-- 简单的生成器，有时会生成环边和多重边。不能保证生成的图是连通的。 `"no_multiple"`-- 类似于`"simple"`，但避免了生成多重边和环边，但代价是增加了时间复杂度。该方法每次都会重新启动生成，因为它卡在无法插入更多边而不创建环或多重边的配置中，并且迭代次数没有上限，但如果输入度序列是图形的，则最终会成功，如果输入度序列不是图形的，则会抛出异常。 `"vl"`-- 一个更复杂的生成器，可以均匀地采样无向的、连通的简单图。它使用 Monte-Carlo 方法来随机化图。如果要生成无向的、连通的图，并且不关心执行时间，则应优先使用此生成器。igraph 使用 Fabien Viger 的原始实现；有关算法的详细信息，请参见以下 URL 和其中引用的论文：https://www-complexnetworks.lip6.fr/~latapy/FV/generation.html。

def delete_edges(es): ¶

在 igraph.Graph 中重写

从图中删除边。

所有顶点都将被保留，即使它们失去所有边。非存在的边将被静默忽略。

参数
es	要删除的边的列表。边由边 ID 标识。此处也接受 `EdgeSeq` 对象。没有参数会删除所有边。

def delete_vertices(vs): ¶

从图中删除顶点及其所有边。

参数
vs	要删除的单个顶点 ID 或顶点 ID 列表。没有参数会删除所有顶点。

def density(loops=False): ¶

计算图的密度。

参数
循环	是否考虑环。如果`True`，则算法假定图中可能存在一些环，并相应地计算密度。如果`False`，则算法假定不能存在任何环。
返回值
图的密度。

def dfsiter(vid, mode='out', advanced=False): ¶

构造图的深度优先搜索 (DFS) 迭代器。

参数
vid	根顶点 ID
模式	mode`"in"`之一或`"out"`之一或`"all"`.
advanced	如果`False`，则迭代器在每一步中按 DFS 顺序返回下一个顶点。如果`True`，则迭代器还返回顶点与根的距离以及顶点在 DFS 树中的父级。
返回值
作为 `igraph.DFSIter` 对象的 DFS 迭代器。

def diameter(directed=True, unconn=True, weights=None): ¶

计算图的直径。

参数
有向	是否考虑有向路径。
unconn	如果`True`并且图未连接，则将返回组件中最长的测地线。如果`False`并且图未连接，则如果没有权重，则结果是顶点数，如果有权重，则结果是无穷大。
weights	要使用的边权重。可以是序列或可迭代对象，甚至可以是边属性名称。
返回值
直径

def difference(other): ¶

从原始图中减去给定的图

def diversity(vertices=None, weights=None): ¶

计算顶点的结构多样性指数。

一个顶点的结构多样性指数就是与该顶点关联的边的权重（归一化的）香农熵。

该度量仅针对无向图定义；边方向将被忽略。

参数
vertices	需要返回多样性指数的顶点。如果`None`，则使用图中的所有顶点。
weights	要使用的边权重。可以是序列或可迭代对象，甚至可以是边属性名称。
返回值
列表中计算出的多样性指数，如果只提供了一个顶点，则返回单个数字。
未知字段：newfield
ref	参考
未知字段：ref
Eagle N, Macy M 和 Claxton R: 网络多样性和经济发展，科学 328, 1029--1031, 2010。

def dominator(vid, mode='out'): ¶

从给定根节点返回支配树

参数
vid	根顶点 ID
模式	mode`"in"`之一或`"out"`
返回值
包含当前图的支配树的列表。

def dyad_census(): ¶

在 igraph.Graph 中重写

Holland 和 Leinhardt 定义的二元统计

Dyad census 意味着将有向图的每一对顶点分为三类：互惠的，存在从 *a* 到 *b* 以及从 *b* 到 *a* 的边；不对称的，存在从 *a* 到 *b* 或从 *b* 到 *a* 的边，但不是反向的；以及空的，*a* 和 *b* 之间没有边。

返回值
3 元组中互惠、不对称和空连接的数量。
未知字段：attention
此函数在 `Graph` 类中具有更方便的接口，它将结果包装在一个 `DyadCensus` 对象中。建议使用它。

def eccentricity(vertices=None, mode='all'): ¶

计算图中给定顶点的离心率。

顶点的离心率通过测量从（或到）该顶点到（或来自）图中所有其他顶点的最短距离，并取最大值来计算。

参数
vertices	必须返回离心率分数的顶点。如果`None`，则使用图中的所有顶点。
模式	必须是以下之一`"in"`, `"out"`和`"all"`. `"in"`表示遵循边的方向；`"out"`表示边的方向被反向遵循；`"all"`表示方向将被忽略。该参数对无向图没有影响。
返回值
列表中计算出的离心率，如果只提供了一个顶点，则返回单个数字。

def ecount(): ¶

计算边的数量。

返回值
整数	图中边的数量。

def edge_attributes(): ¶

返回值
图的边的属性名称列表

def edge_betweenness(directed=True, cutoff=None, weights=None): ¶

计算或估计图中边的介数。

参数
有向	是否考虑有向路径。
cutoff	如果它是一个整数，则只考虑小于或等于此长度的路径，从而有效地得到介数估计值。如果`None`，则返回精确的介数值。
weights	要使用的边权重。可以是序列或可迭代对象，甚至可以是边属性名称。
返回值
一个列表，包含所有边的（精确或估计的）边介数。

def edge_connectivity(source=-1, target=-1, checks=True): ¶

计算图或某些顶点之间的边连通性。

两个给定顶点之间的边连通性是为了将这两个顶点断开为两个独立的组件而必须删除的边的数量。这也是顶点之间边不相交的有向路径的数量。图的边连通性是所有顶点对上的最小边连通性。

如果给出了源顶点和目标顶点，则此方法计算给定顶点对的边连通性。如果两者都没有给出（或者两者都是负数），则返回整体边连通性。

参数
来源	计算中涉及的源顶点。
目标	计算中涉及的目标顶点。
检查	如果计算整个图的连通性，并且这是`True`，igraph 在计算之前执行一些基本检查。如果图不是强连通的，那么连通性显然为零。如果最小度为 1，那么连通性也为 1。这些简单检查比检查整个图快得多，因此建议将其设置为`True`。如果计算两个给定顶点之间的连通性，则忽略该参数。
返回值
边连通性

def eigen_adjacency(...): ¶

未归档

def eigenvector_centrality(directed=True, scale=True, weights=None, return_eigenvalue=False, arpack_options=None): ¶

计算图中顶点的特征向量中心性。

特征向量中心性是网络中节点重要性的度量。它基于来自高分节点的连接对问题节点的得分贡献大于来自低分节点的相等连接的原则，为网络中的所有节点分配相对分数。实际上，中心性是通过计算对应于邻接矩阵的最大正特征值的特征向量来确定的。在无向图中，此函数将邻接矩阵的对角线条目视为相应顶点上自环数的两倍。

在有向图中，计算邻接矩阵的左特征向量。换句话说，一个顶点的中心性与指向它的顶点的中心性之和成正比。

特征向量中心性仅对连通图有意义。非连通图应分解为连通分量，并分别计算每个分量的特征向量中心性。

参数
有向	是否考虑有向图中的边的方向。对于无向图将被忽略。
scale	是否对中心性进行归一化，使最大的中心性始终为 1。
weights	边权重以列表或边属性的形式给出。如果`None`，所有边都具有相同的权重。
return_eigenvalue	是否返回实际的最大特征值以及中心性
arpack_options	一个 `ARPACKOptions` 对象，可用于微调计算。如果省略，则使用模块级变量`arpack_options`。
返回值
列表中的特征向量中心性，以及可选的最大特征值（作为元组的第二个成员）

def Erdos_Renyi(n, p, m, directed=False, loops=False): ¶

基于 Erdos-Renyi 模型生成图。

参数
n	顶点的数量。
p	边的概率。如果给定，`m`必须缺少。
m	边的数量。如果给定，`p`必须缺少。
有向	是否生成有向图。
循环	是否允许自环。

def Establishment(n, k, type_dist, pref_matrix, directed=False): ¶

基于具有顶点类型的简单增长模型生成图。

在每个时间步添加一个顶点。这个新顶点尝试连接到图中的 k 个顶点。实现这种连接的概率取决于所涉及的顶点的类型。

参数
n	图中的顶点数
k	每步尝试的连接数
type_dist	列表，给出顶点类型的分布
pref_matrix	矩阵（列表的列表），给出不同顶点类型的连接概率
有向	是否生成有向图。

def Famous(name): ¶

基于其名称生成一个著名的图。

几个著名的图被igraph所知，包括（但不限于）Chvatal 图、Petersen 图或 Tutte 图。此方法基于其名称（不区分大小写）生成其中一个图。请参阅 C 界面的文档igraph以获取可用名称：https://igraph.cn/c/doc。

参数
名称	要生成的图的名称。

def farthest_points(directed=True, unconn=True, weights=None): ¶

返回两个顶点 ID，它们的距离等于图的实际直径。

如果存在多条直径长度的最短路径，它将返回找到的第一条路径。

参数
有向	是否考虑有向路径。
unconn	如果`True`并且图未连接，则将返回组件中最长的测地线。如果`False`并且图是不连通的，如果没有权重，结果包含顶点的数量，如果存在权重，结果包含无穷大。
weights	要使用的边权重。可以是序列或可迭代对象，甚至可以是边属性名称。
返回值
包含两个顶点 ID 及其距离的三元组。ID 为`None`如果图不连通，并且`unconn`是`False`.

def feedback_arc_set(weights=None, method='eades'): ¶

计算近似或精确的最小反馈弧集。

反馈弧集是一组边的集合，删除这些边会使图变成非循环图。由于总是可以通过删除所有边来实现这一点，因此我们通常感兴趣的是删除尽可能少的边，或总权重尽可能小的边集。此方法计算一个这样的边集。请注意，对于无向图，此任务很简单，因为找到生成树，然后删除生成树中所有不在的边就足够了。当然，对于有向图来说，这更复杂。

参数
weights	要使用的边权重。可以是序列或可迭代对象，甚至可以是边属性名称。给定此参数后，算法将努力删除轻量级边，以尽量减少反馈弧集的总权重。
method	要使用的算法。`"eades"`使用 Eades、Lin 和 Smyth 的贪婪循环中断启发式算法，该算法在边的数量上是线性的，但不一定是最佳的；但是，它保证要删除的边的数量小于 \|E\|/2 - \|V\|/6。`"ip"`使用整数规划公式，该公式保证产生最佳结果，但对于大型图来说太慢。
返回值
要删除的边的 ID，以列表形式给出。
未知字段：newfield
ref	参考
未知字段：ref
Eades P, Lin X 和 Smyth WF: 反馈弧集问题的一种快速有效的启发式算法。In: Proc Inf Process Lett 319-323, 1993。

def Forest_Fire(n, fw_prob, bw_factor=0.0, ambs=1, directed=False): ¶

基于森林火灾模型生成图

森林火灾模型是一个增长图模型。在每个时间步，都会向图中添加一个新的顶点。新顶点选择一个或多个大使（如果 ambs > 1，则选择多个大使），并在其大使处启动模拟森林火灾。火灾通过边蔓延。沿着边的蔓延概率由 fw_prob 给出。火灾也可能以 fw_prob*bw_factor 的概率沿边向后蔓延。当火灾结束后，新添加的顶点会连接到之前火灾中“燃烧”的顶点。

参数
n	图中的顶点数
fw_prob	正向燃烧概率
bw_factor	反向燃烧概率与正向燃烧概率的比率
ambs	每步选择的大使数量
有向	图是否将是有向的

def Full(n, directed=False, loops=False): ¶

生成一个完整的图（有向或无向，带有或不带有环）。

参数
n	顶点的数量。
有向	是否生成有向图。
循环	是否允许自环。

def Full_Citation(n, directed=False): ¶

生成一个完整的引用图

完整引文图是一个图，其中顶点的索引从 0 到 n − 1，顶点 i 具有指向所有索引小于 i 的顶点的有向边。

参数
n	顶点的数量。
有向	是否生成有向图。

def get_adjacency(type='both', eids=False): ¶

在 igraph.Graph 中重写

返回图的邻接矩阵。

参数
类型	以下之一`"lower"`（使用矩阵的下三角），`"upper"`（使用上三角）或`"both"`（使用两个部分）。对于有向图将被忽略。
eids	如果`True`，结果矩阵将包含非边的零和边的边 ID 加一的相应单元格。如果`False`，结果矩阵将包含每个顶点对的边数。
返回值
邻接矩阵。

def get_all_shortest_paths(v, to=None, weights=None, mode='out'): ¶

计算从/到图中给定节点的所有最短路径。

参数
v	计算路径的源
到	描述计算路径的目标的顶点选择器。它可以是单个顶点 ID、顶点 ID 列表、单个顶点名称、顶点名称列表或 `VertexSeq` 对象。`None`表示所有顶点。
weights	列表中的边权重或包含边权重的边属性的名称。如果`None`，则假定所有边都具有相同的权重。
模式	路径的方向性。`"in"`表示计算传入路径，`"out"`表示计算传出路径，`"all"`表示计算两者。
返回值
列表中从给定节点到图中每个其他可达节点的所有最短路径。请注意，在 mode=`"in"`的情况下，路径中的顶点以相反的顺序返回！

def get_diameter(directed=True, unconn=True, weights=None): ¶

返回具有图的实际直径的路径。

如果存在多条直径长度的最短路径，它将返回找到的第一条路径。

参数
有向	是否考虑有向路径。
unconn	如果`True`并且图未连接，则将返回组件中最长的测地线。如果`False`并且图未连接，则如果没有权重，则结果是顶点数，如果有权重，则结果是无穷大。
weights	要使用的边权重。可以是序列或可迭代对象，甚至可以是边属性名称。
返回值
路径中的顶点按顺序排列。

def get_edgelist(): ¶

返回图的边列表。

def get_eid(v1, v2, directed=True, error=True): ¶

返回顶点 v1 和 v2 之间任意边的边 ID

参数
v1	第一个顶点的 ID 或名称
v2	第二个顶点的 ID 或名称
有向	在有向图中是否应考虑边的方向。默认值为`True`。对于无向图将被忽略。
错误	如果`True`，当给定的边不存在时，将引发异常。如果`False`，在这种情况下将返回 -1。
返回值
顶点 v1 和 v2 之间的任意边的边 ID

def get_eids(pairs=None, path=None, directed=True, error=True): ¶

返回某些顶点之间某些边的边 ID。

此方法可以在两种不同的模式下运行，具体取决于关键字参数中的哪一个对和path被给定。

该方法不考虑多重边；如果一对顶点之间存在多重边，则仅返回其中一个边的 ID。

参数
对	整数对的列表。每个整数对都被视为源目标顶点对；在图中查找相应的边，并返回每个对的边 ID。
path	顶点 ID 的列表。该列表被视为从第一个顶点到最后一个顶点的连续路径，并穿过中间顶点。在图中查找第一个和第二个、第二个和第三个等之间的相应边 ID，并返回边 ID。如果两者都`path`和`对`被给定，则连接两个列表。
有向	在有向图中是否应考虑边的方向。默认值为`True`。对于无向图将被忽略。
错误	如果`True`，如果给定的边不存在，将引发异常。如果`False`，在这种情况下将返回 -1。
返回值
列表中边的 ID

def get_incidence(types): ¶

在 igraph.Graph 中重写

内部函数，无文档。

参见
Graph.get_incidence()

def get_isomorphisms_vf2(other=None, color1=None, color2=None, edge_color1=None, edge_color2=None, node_compat_fn=None, edge_compat_fn=None): ¶

返回图与另一个图之间的所有同构

顶点和边的颜色可用于限制同构，因为只允许具有相同颜色的顶点和边相互匹配。

参数
other	另一个图。如果`None`，将返回自同构。
color1	可选向量，存储第一个图的顶点的着色。如果`None`，则所有顶点都具有相同的颜色。
color2	可选向量，存储第二个图的顶点的着色。如果`None`，则所有顶点都具有相同的颜色。
edge_color1	可选向量，存储第一个图的边的着色。如果`None`，则所有边都具有相同的颜色。
edge_color2	可选向量，存储第二个图的边的着色。如果`None`，则所有边都具有相同的颜色。
node_compat_fn	一个函数，接收两个图和两个节点索引（一个来自第一个图，一个来自第二个图）并返回`True`如果由两个索引给出的节点是兼容的（即，它们可以相互匹配）或`False`否则。这可以用于基于节点特定标准来限制同构的集合，这些标准太复杂而无法由节点颜色向量表示（即，`color1`和`color2`参数）。`None`表示每个节点与每个其他节点都兼容。
edge_compat_fn	一个函数，接收两个图和两个边索引（一个来自第一个图，一个来自第二个图）并返回`True`如果由两个索引给出的边是兼容的（即，它们可以相互匹配）或`False`否则。这可以用于基于边特定标准来限制同构的集合，这些标准太复杂而无法由边颜色向量表示（即，`edge_color1`和`edge_color2`参数）。`None`表示每条边与每个其他节点都兼容。
返回值
列表的列表，列表的每个项目都包含从第二个图的顶点到第一个图的顶点的映射

def get_shortest_paths(v, to=None, weights=None, mode='out', output='vpath'): ¶

计算从/到图中给定节点的最短路径。

参数
v	计算路径的源/目标
到	描述计算路径的目标/源的顶点选择器。它可以是单个顶点 ID、顶点 ID 列表、单个顶点名称、顶点名称列表或 `VertexSeq` 对象。`None`表示所有顶点。
weights	列表中的边权重或包含边权重的边属性的名称。如果`None`，则假定所有边都具有相同的权重。
模式	路径的方向性。`"in"`表示计算传入路径，`"out"`表示计算传出路径，`"all"`表示计算两者。
输出	确定应返回的内容。如果这是`"vpath"`，将返回顶点 ID 列表，每个目标顶点一条路径。对于非连通图，某些列表元素可能为空。请注意，在 mode=`"in"`的情况下，路径中的顶点以相反的顺序返回。如果`output="epath"`，则返回边 ID 而不是顶点 ID。
返回值
请参阅的文档`输出`参数。

def get_subisomorphisms_lad(other, domains=None, induced=False, time_limit=0): ¶

使用 LAD 算法返回图与另一个图之间的所有子同构。

可选的domains参数可用于限制可能匹配的顶点。您还可以指定是否只对诱导子图感兴趣。

参数
other	我们在图中寻找的模式图。
domains	列表的列表，一个子列表属于模板图中的每个顶点。子列表 i 包含原始图中可能与模板图中的顶点 i 匹配的顶点的索引。`None`表示每个顶点都可能匹配每个其他顶点。
induced	是否仅考虑诱导子图。
time_limit	以秒为单位的最佳时间限制。仅考虑此数字的整数部分。如果超过时间限制，该方法将引发异常。
返回值
列表的列表，列表的每个项目都包含从第二个图的顶点到第一个图的顶点的映射

def get_subisomorphisms_vf2(other, color1=None, color2=None, edge_color1=None, edge_color2=None, node_compat_fn=None, edge_compat_fn=None): ¶

返回图与另一个图之间的所有子同构

顶点和边的颜色可用于限制同构，因为只允许具有相同颜色的顶点和边相互匹配。

参数
other	另一个图。
color1	可选向量，存储第一个图的顶点的着色。如果`None`，则所有顶点都具有相同的颜色。
color2	可选向量，存储第二个图的顶点的着色。如果`None`，则所有顶点都具有相同的颜色。
edge_color1	可选向量，存储第一个图的边的着色。如果`None`，则所有边都具有相同的颜色。
edge_color2	可选向量，存储第二个图的边的着色。如果`None`，则所有边都具有相同的颜色。
node_compat_fn	一个函数，接收两个图和两个节点索引（一个来自第一个图，一个来自第二个图）并返回`True`如果由两个索引给出的节点是兼容的（即，它们可以相互匹配）或`False`否则。这可以用于基于节点特定标准来限制同构的集合，这些标准太复杂而无法由节点颜色向量表示（即，`color1`和`color2`参数）。`None`表示每个节点与每个其他节点都兼容。
edge_compat_fn	一个函数，接收两个图和两个边索引（一个来自第一个图，一个来自第二个图）并返回`True`如果由两个索引给出的边是兼容的（即，它们可以相互匹配）或`False`否则。这可以用于基于边特定标准来限制同构的集合，这些标准太复杂而无法由边颜色向量表示（即，`edge_color1`和`edge_color2`参数）。`None`表示每条边与每个其他节点都兼容。
返回值
列表的列表，列表的每个项目都包含从第二个图的顶点到第一个图的顶点的映射

def girth(return_shortest_circle=False): ¶

返回图的 girth。

图的周长是其中最短圆的长度。

参数
return_shortest_circle	是否返回图中找到的最短圆之一。
返回值
最短圆的长度，或者（如果`return_shortest_circle`）为 true，则最短圆本身作为列表

def gomory_hu_tree(capacity=None): ¶

在 igraph.Graph 中重写

内部函数，无文档。

参见
Graph.gomory_hu_tree()

def Growing_Random(n, m, directed=False, citation=False): ¶

生成一个增长随机图。

参数
n	图中的顶点数
m	每步添加的边数（在添加新顶点后）
有向	图是否应该是有向的。
引文	新边是否应该源自最近添加的顶点。

def harmonic_centrality(vertices=None, mode='all', cutoff=None, weights=None, normalized=True): ¶

计算图中给定顶点的谐波中心性。

顶点的谐波中心性衡量其他顶点可以从该顶点轻松到达的程度（或者反过来：可以从其他顶点轻松到达该顶点的程度）。它定义为到所有其他顶点的平均反向距离。

如果图不是连通的，并且两个顶点之间没有路径，则反向距离被视为零。

参数
vertices	必须返回谐波中心性的顶点。如果`None`，则使用图中的所有顶点。
模式	必须是以下之一`"in"`, `"out"`和`"all"`. `"in"`表示必须计算传入路径的长度，`"out"`表示必须计算传出路径的长度。`"all"`表示必须同时计算两者。
cutoff	，如果不是`None`，则仅考虑小于或等于此长度的路径。
weights	要使用的边权重。可以是序列或可迭代对象，甚至可以是边属性名称。
normalized	是否对结果进行归一化。如果为 True，则结果是到其他顶点的平均反向路径长度，即它通过顶点数减一进行归一化。如果为 False，则结果是到其他顶点的反向路径长度之和。
返回值
列表中计算出的谐波中心性

def has_multiple(): ¶

检查图是否有多条边。

返回值
布尔值	`True`如果图至少有一条多重边，`False`否则。

def hub_score(weights=None, scale=True, arpack_options=None, return_eigenvalue=False): ¶

计算图中顶点的 Kleinberg hub 分数

参数
weights	要使用的边权重。可以是序列或可迭代对象，甚至可以是边属性名称。
scale	是否对分数进行归一化，以使最大分数为 1。
arpack_options	一个 `ARPACKOptions` 对象，用于微调 ARPACK 特征向量计算。如果省略，则使用名为`arpack_options`。
return_eigenvalue	是否返回最大特征值
返回值
列表中的枢纽分数，以及可选的最大特征值作为元组的第二个成员
参见
authority_score()

def incident(vertex, mode='out'): ¶

返回给定顶点所在的边。

参数
顶点	顶点 ID
模式	是否仅返回后继节点 (`"out"`)、前驱节点 (`"in"`) 或两者 (`"all"`）。对于无向图将被忽略。

def independence_number(): ¶

返回图的独立数。

图的独立数是最大独立顶点集的大小。

参见
`largest_independent_vertex_sets()` 用于最大独立顶点集

def independent_vertex_sets(min=0, max=0): ¶

返回图的一些或所有独立顶点集，作为元组列表。

如果两个顶点之间没有边，则这两个顶点是独立的。独立顶点集的成员是相互独立的。

参数
min	要返回的集合的最小大小。如果为零或负数，则不会使用下限。
max	要返回的集合的最大大小。如果为零或负数，则不会使用上限。

def induced_subgraph(vertices, implementation='auto'): ¶

返回由给定顶点生成的子图。

参数
vertices	一个列表，包含应包含在结果中的顶点 ID。
implementation	构造新子图时使用的实现。igraph 目前包含两种实现。`"copy_and_delete"`复制原始图并删除那些不在给定集合中的顶点。如果子图的大小与原始图相当，则此方法更有效。另一种实现 (`"create_from_scratch"`）从头开始构造结果图，然后相应地复制属性。如果子图与原始图相比相对较小，则这是一个更好的解决方案。`"auto"`基于子图的大小与原始图大小的比率，自动在两种实现之间进行选择。
返回值
子图

def is_bipartite(return_types=False): ¶

确定图是否为二分图。

二分图的顶点可以分为两组 A 和 B，所有边都在两组之间。

参数
return_types	如果`False`，该方法将只返回`True`之一或`False`，具体取决于图是否是二分图。如果`True`，实际组分配也会作为布尔值列表返回。（请注意，组分配不是唯一的，尤其是如果图由多个组件组成，因为组件的分配彼此独立）。
返回值
`True`如果图是二分图，`False`如果不是。如果`return_types`是`True`，则也会返回组分配。

def is_chordal(alpha=None, alpham1=None): ¶

返回图是否为弦图。

参数
alpha	从调用图上的 `maximum_cardinality_search()` 结果中获得的 alpha 向量。仅当您已经有 alpha 向量时才有用；只需传递`None`这里将让 igraph 自行计算 alpha 向量。
alpham1	调用图的 `maximum_cardinality_search()` 的结果得到的逆 alpha 向量。仅当您已经有逆 alpha 向量时才有用；简单地传递`None`这里将让 igraph 自行计算逆 alpha 向量。
返回值
`True`如果图是弦图，`False`否则。

def is_connected(mode='strong'): ¶

确定图是否已连接。

参数
模式	我们应该计算强连通性还是弱连通性。
返回值
`True`如果图是连通的，`False`否则。

def is_dag(): ¶

检查图是否为 DAG（有向无环图）。

DAG 是没有有向环的有向图。

返回值
布尔值	`True`如果它是 DAG，`False`否则。

def is_directed(): ¶

检查图是否为有向图。

返回值
布尔值	`True`如果它是有向的，`False`否则。

def is_loop(edges=None): ¶

检查一组特定的边是否包含环边

参数
边	我们要检查的边索引。如果`None`，则检查所有边。
返回值
布尔值列表，每个布尔值对应给定的每条边

def is_minimal_separator(vertices): ¶

确定给定的顶点集是否为最小分隔符。

最小分隔符是一组顶点，删除这些顶点会断开图的连接，而删除该集合的任何子集都会保持图的连接。

参数
vertices	单个顶点 ID 或顶点 ID 列表
返回值
`True`给定的顶点集是否是最小分隔符，`False`否则。

def is_multiple(edges=None): ¶

检查边是否为多条边。

也适用于一组边——在这种情况下，每条边都会逐一检查。请注意，如果一对顶点之间存在多重边，则始终会有一个边不报告为多重（只有其他边）。这允许人们轻松检测到必须删除的边，以使图没有多重边。

参数
边	我们要检查的边索引。如果`None`，则检查所有边。
返回值
布尔值列表，每个布尔值对应给定的每条边

def is_mutual(edges=None): ¶

检查边是否具有相反的边对。

也适用于一组边——在这种情况下，每条边都会逐一检查。结果将是布尔值列表（或者如果仅提供边索引，则为单个布尔值），每个布尔值对应于提供的边集中的边。True对于给定的边 a --> b 返回，如果在原始图（而不是给定的边集！）中存在另一条边 b --> a。无向图中的所有边都是互惠的。如果在 a 和 b 之间存在多重边，则在任一方向上至少有一条边报告它们之间的所有边都是互惠的就足够了，因此边的多重性无关紧要。

参数
边	我们要检查的边索引。如果`None`，则检查所有边。
返回值
布尔值列表，每个布尔值对应给定的每条边

def is_separator(vertices): ¶

确定删除给定的顶点是否会断开图的连接。

参数
vertices	单个顶点 ID 或顶点 ID 列表
返回值
`True`给定的顶点集是否是分隔符，`False`如果不是。

def is_simple(): ¶

检查图是否为简单图（没有环或多条边）。

返回值
布尔值	`True`如果它是简单的，`False`否则。

def is_tree(mode='out'): ¶

检查图是否为（有向或无向）树图。

对于有向树，该函数可能要求边从根向外定向或向内定向到根，具体取决于模式参数的值。

参数
模式	对于有向图，指定应如何考虑边的方向。`"all"`表示必须忽略边的方向，`"out"`表示边必须从根定向出来，`"in"`表示边必须向根定向。对于无向图将被忽略。
返回值
布尔值	`True`如果图是一棵树，`False`否则。

def Isoclass(n, cls, directed=False): ¶

生成具有给定同构类的图。

目前，我们支持大小为 3 和 4 的有向图，以及大小为 3、4、5 或 6 的无向图。使用 isoclass() 实例方法查找给定图的同构类。

参数
n	图中的顶点数
cls	同构类
有向	图是否应该是有向的。

def isoclass(vertices): ¶

返回图或其子图的同构类。

同构类计算仅针对具有 3 或 4 个顶点的有向图，或具有 3、4、5 或 6 个顶点的无向图实现。

参数
vertices	如果我们只想计算顶点子集的同构类，则这是顶点列表。`None`表示使用完整图。
返回值
（子）图的同构类

def isomorphic(other): ¶

检查图是否与另一个图同构。

所使用的算法是使用简单的启发式方法选择的

如果一个图是有向的，另一个图是无向的，则会引发异常。
如果两个图的顶点和边的数量不同，则返回False
如果图有三个或四个顶点，则使用预计算数据的 O(1) 算法。
否则，如果图是有向的，则使用 VF2 同构算法（请参阅 isomorphic_vf2）。
否则，使用 BLISS 同构算法，请参阅 isomorphic_bliss。

返回值
`True`如果图是同构的，则为真，`False`否则。

def isomorphic_bliss(other, return_mapping_12=False, return_mapping_21=False, sh1='fl', sh2=None, color1=None, color2=None): ¶

使用 BLISS 同构算法检查图是否与另一个图同构。

有关 BLISS 算法的更多信息，请参阅 http://www.tcs.hut.fi/Software/bliss/index.html。

参数
other	我们要与之比较的另一个图。
return_mapping_12	如果`True`，计算将第一个图的顶点映射到第二个图的映射。
return_mapping_21	如果`True`，计算将第二个图的顶点映射到第一个图的映射。
sh1	第一个图的拆分启发式方法，表示为不区分大小写的字符串，具有以下可能值 `"f"`：第一个非单例单元格 `"fl"`：第一个最大的非单例单元格 `"fs"`：第一个最小的非单例单元格 `"fm"`：第一个最大非平凡连通的非单例单元格 `"flm"`：最大的最大非平凡连通的非单例单元格 `"fsm"`：最小的最大非平凡连通的非单例单元格
sh2	要用于第二个图的拆分启发式方法。这必须与`sh1`相同；或者，它可以是`None`，在这种情况下，它将自动使用与`sh1`相同的值。目前仅出于向后兼容性而存在。
color1	可选向量，存储第一个图的顶点的着色。如果`None`，则所有顶点都具有相同的颜色。
color2	可选向量，存储第二个图的顶点的着色。如果`None`，则所有顶点都具有相同的颜色。
返回值
如果没有计算映射，则结果为`True`如果图是同构的，则为真，`False`否则。如果计算了任何一个或两个映射，则结果是一个 3 元组，第一个元素是上面提到的布尔值，第二个元素是 1 -> 2 映射，第三个元素是 2 -> 1 映射。如果未计算相应的映射，则`None`将在 3 元组的相应元素中返回。

def isomorphic_vf2(other=None, color1=None, color2=None, edge_color1=None, edge_color2=None, return_mapping_12=False, return_mapping_21=False, node_compat_fn=None, edge_compat_fn=None, callback=None): ¶

使用 VF2 同构算法检查图是否与另一个图同构。

顶点和边的颜色可用于限制同构，因为只允许具有相同颜色的顶点和边相互匹配。

参数
other	我们要与之比较的另一个图。如果`None`，将测试图的自同构。
color1	可选向量，存储第一个图的顶点的着色。如果`None`，则所有顶点都具有相同的颜色。
color2	可选向量，存储第二个图的顶点的着色。如果`None`，则所有顶点都具有相同的颜色。
edge_color1	可选向量，存储第一个图的边的着色。如果`None`，则所有边都具有相同的颜色。
edge_color2	可选向量，存储第二个图的边的着色。如果`None`，则所有边都具有相同的颜色。
return_mapping_12	如果`True`，计算将第一个图的顶点映射到第二个图的映射。
return_mapping_21	如果`True`，计算将第二个图的顶点映射到第一个图的映射。
node_compat_fn	一个函数，接收两个图和两个节点索引（一个来自第一个图，一个来自第二个图）并返回`True`如果由两个索引给出的节点是兼容的（即，它们可以相互匹配）或`False`否则。这可以用于基于节点特定标准来限制同构的集合，这些标准太复杂而无法由节点颜色向量表示（即，`color1`和`color2`参数）。`None`表示每个节点与每个其他节点都兼容。
edge_compat_fn	一个函数，接收两个图和两个边索引（一个来自第一个图，一个来自第二个图）并返回`True`如果由两个索引给出的边是兼容的（即，它们可以相互匹配）或`False`否则。这可以用于基于边特定标准来限制同构的集合，这些标准太复杂而无法由边颜色向量表示（即，`edge_color1`和`edge_color2`参数）。`None`表示每条边与每个其他节点都兼容。
回调	如果不是`None`，同构搜索不会在第一次匹配时停止；相反，对于找到的每个同构，它都会调用此回调函数。回调函数必须接受四个参数：第一个图、第二个图、从第一个图的节点到第二个图的映射以及从第二个图的节点到第一个图的映射。该函数必须返回`True`如果搜索应继续或`False`否则。
返回值
如果没有计算映射，则结果为`True`如果图是同构的，则为真，`False`否则。如果计算了任何一个或两个映射，则结果是一个 3 元组，第一个元素是上面提到的布尔值，第二个元素是 1 -> 2 映射，第三个元素是 2 -> 1 映射。如果未计算相应的映射，则`None`将在 3 元组的相应元素中返回。

def K_Regular(n, k, directed=False, multiple=False): ¶

生成一个 k-正则随机图

k 正则随机图是每个顶点都有度数 k 的随机图。如果图是有向的，则每个顶点的入度和出度都将为 k。

参数
n	图中的顶点数
k	如果图是无向的，则每个顶点的度数；如果图是有向的，则为每个顶点的入度和出度
有向	图是否应该是有向的。
多个	是否允许创建多条边。

def Kautz(m, n): ¶

生成具有参数 (m, n) 的 Kautz 图

Kautz 图是一个标记图，顶点由长度为 n + 1 的字符串标记，该字符串位于具有 m + 1 个字母的字母表之上，并且限制是字符串中的每两个连续字母必须不同。如果可以将 v 的字符串转换为 w 的字符串，方法是删除第一个字母并向其附加一个字母，则存在从顶点 v 到另一个顶点 w 的有向边。

参数
m	字母表大小减一
n	字符串长度减一

def knn(vids=None, weights=None): ¶

计算每个顶点的邻居的平均度数，以及作为顶点度数函数的相同数量。

参数
vids	执行计算的顶点。`None`表示所有顶点。
weights	要使用的边权重。可以是一个序列或可迭代对象，甚至是边属性名称。如果给出了此值，则在计算中将使用顶点强度而不是顶点度数，但结果中的第二个（取决于度数）列表将使用“普通”顶点度数。
返回值
元组中的两个列表。第一个列表包含每个顶点的邻居的平均度数，第二个列表包含邻居的平均度数作为顶点度数的函数。此列表的第零个元素对应于度数为 1 的顶点。

def laplacian(weights=None, normalized=False): ¶

返回图的拉普拉斯矩阵。

拉普拉斯矩阵类似于邻接矩阵，但边用 -1 表示，对角线包含节点度数。

归一化拉普拉斯矩阵的对角线中包含 1 或 0（对于没有边的顶点，则为 0），边用 1 / sqrt(d_i * d_j) 表示，其中 d_i 是节点 i 的度数。

多条边和自环将被静默忽略。虽然可以计算有向图的拉普拉斯矩阵，但这没有多大意义。

参数
weights	要使用的边权重。可以是一个序列或可迭代对象，甚至是边属性名称。使用边权重时，节点的度数将被视为其入射边的权重。
normalized	是否返回归一化拉普拉斯矩阵。
返回值
拉普拉斯矩阵。

def largest_cliques(): ¶

返回图的最大团，作为元组列表。

非常直观地，如果在整个图中没有具有更多顶点的团，则该团被认为是最大的。所有最大的团都是最大的（即不可扩展的），但并非所有最大的团都是最大的。

参见
`clique_number()` 用于最大团的大小，或者 `maximal_cliques()` 用于最大团

def largest_independent_vertex_sets(): ¶

返回图的最大独立顶点集，作为元组列表。

非常直观地，如果整个图中没有具有更多顶点的其他集合，则独立顶点集被认为是最大的。所有最大的集合都是最大的（即不可扩展的），但并非所有最大的集合都是最大的。

参见
`independence_number()` 用于最大独立顶点集的大小，或者 `maximal_independent_vertex_sets()` 用于最大（不可扩展）独立顶点集

def Lattice(dim, nei=1, directed=False, mutual=True, circular=True): ¶

生成一个规则晶格。

参数
暗淡	具有晶格尺寸的列表
内	值，给出两个顶点将被连接的距离（步数）。
有向	是否创建有向图。
相互	在有向图的情况下，是否将所有连接创建为相互连接。
循环	生成的晶格是否是周期性的。

def layout_bipartite(types='type', hgap=1, vgap=1, maxiter=100): ¶

将二分图的顶点放置在两层中。

通过根据顶点类型将顶点放置在两行中来创建布局。然后使用 Sugiyama 布局算法使用的启发式方法优化行内顶点的位置，以最大程度地减少边交叉的数量。

参数
types	包含顶点类型的 igraph 向量，或属性名称。任何评估为`False`的项都对应于第一种顶点，所有其他项都对应于第二种顶点。
hgap	同一层中顶点之间的最小水平间隙。
vgap	两层之间的垂直间隙。
最大迭代次数	交叉减少步骤中要执行的最大迭代次数。如果您觉得边交叉太多，请增加此值。
返回值
计算出的布局。

def layout_circle(dim=2, order=None): ¶

将图的顶点均匀地放置在圆或球面上。

参数
暗淡	布局所需的维数。 dim=2 表示 2D 布局，dim=3 表示 3D 布局。
顺序	顶点沿圆放置的顺序。当暗淡不等于 2 时不支持。
返回值
计算出的布局。

def layout_davidson_harel(seed=None, maxiter=10, fineiter=-1, cool_fact=0.75, weight_node_dist=1.0, weight_border=0.0, weight_edge_lengths=-1, weight_edge_crossings=-1, weight_node_edge_dist=-1): ¶

根据 Davidson-Harel 布局算法将顶点放置在 2D 平面上。

该算法使用模拟退火和复杂的能量函数，但不幸的是，很难为不同的图参数化。原始出版物未披露任何参数值，以下参数值是通过实验确定的。

该算法由两个阶段组成：退火阶段和微调阶段。第二阶段没有模拟退火。

参数
种子	如果`None`，为算法使用随机起始布局。如果是矩阵（列表的列表），则使用给定的矩阵作为起始位置。
最大迭代次数	在退火阶段要执行的迭代次数。
精细迭代次数	在微调阶段要执行的迭代次数。负数会从顶点数的以 2 为底的对数设置一个合理的默认值，上限为 10。
cool_fact	模拟退火阶段的冷却系数。
权重_节点_距离	能量函数中节点-节点距离的权重。
权重_边框	能量函数的边框组件的距离权重。零表示允许顶点位于指定用于布局的区域的边框上。
权重_边_长度	能量函数的边长组件的权重。负数将替换为图的密度除以 10。
权重_边_交叉	能量函数的边交叉组件的权重。负数将替换为 1 减去图密度的平方根。
权重_节点_边_距离	能量函数的节点-边距离组件的权重。负数将替换为 0.2 减去 0.2 倍的图密度。
返回值
计算出的布局。

def layout_drl(weights=None, fixed=None, seed=None, options=None, dim=2): ¶

根据 DrL 布局算法将顶点放置在 2D 平面或 3D 空间中。

这是一种适用于相当大的图的算法，但对于小型图来说可能非常慢（其中更简单的基于力的布局，例如layout_kamada_kawai()之一或layout_fruchterman_reingold()更有用）。

参数
weights	要使用的边权重。可以是序列或可迭代对象，甚至可以是边属性名称。
fixed	已忽略。我们过去认为 DrL 布局支持固定节点，但后来发现该参数在原始 DrL 代码中没有任何作用。我们保留了该参数以实现向后兼容性，但它不会对最终布局产生任何影响。
种子	如果`None`，为算法使用随机起始布局。如果是矩阵（列表的列表），则使用给定的矩阵作为起始位置。
选项	如果您在此处给出一个字符串参数，则可以从五个默认预设参数化中进行选择`默认`, `粗化`，用于更粗糙的布局，`最粗糙`，用于更粗糙的布局，`精炼`，用于优化现有布局，以及`最终`，用于完成布局。如果您提供一个不是字符串的对象，则将从该对象的相应键中检索 DrL 布局参数（因此它应该是一个字典或其他支持映射协议的对象）。可以使用以下键 `edge_cut`：在算法的后期阶段完成边切割，以便获得密度较低的布局。如果边上有很多压力（目标函数总和中的一个大值），则会切割边。边切割参数是一个介于 0 和 1 之间的值，其中 0 表示不切割边，1 表示最大边切割。 `init_iterations`：初始化阶段的迭代次数 `init_temperature`：初始化期间的起始温度 `init_attraction`：初始化期间的吸引力 `init_damping_mult`：初始化期间的阻尼乘数 `liquid_iterations`, `液体温度`, `液体吸引力`, `液体阻尼多重`：液体阶段的相同参数 `expansion_iterations`, `expansion_temperature`, `expansion_attraction`, `expansion_damping_mult`：扩展阶段的参数 `cooldown_...`：冷却阶段的参数 `crunch_...`：收缩阶段的参数 `simmer_...`：模拟阶段的参数您也可以在此处使用任意 Python 对象，而不是映射：如果该对象不支持映射协议，则将查找该对象具有相同名称的属性。如果无法找到作为键或属性的参数，则将使用`默认`预设中的默认值。
暗淡	布局所需的维数。 dim=2 表示 2D 布局，dim=3 表示 3D 布局。
返回值
计算出的布局。

def layout_fruchterman_reingold(weights=None, niter=500, seed=None, start_temp=None, minx=None, maxx=None, miny=None, maxy=None, minz=None, maxz=None, grid='auto'): ¶

根据 Fruchterman-Reingold 算法将顶点放置在 2D 平面上。

这是一种力导向布局，请参阅 Fruchterman, T. M. J. 和 Reingold, E. M.: Graph Drawing by Force-directed Placement. Software -- Practice and Experience, 21/11, 1129--1164, 1991

参数
weights	要使用的边权重。可以是序列或可迭代对象，甚至可以是边属性名称。
尼特	要执行的迭代次数。默认值为 500。
种子	如果`None`，为算法使用随机起始布局。如果是矩阵（列表的列表），则使用给定的矩阵作为起始位置。
start_temp	实数标量，起始温度。这是在一个步骤中允许沿一个轴移动的最大量，对于一个顶点。目前，它在迭代期间线性减小到零。默认值是顶点数除以 10 的平方根。
最小 x	如果不是`None`，它必须是一个向量，其中包含与图中顶点数量完全相同的元素。每个元素都是对布局中顶点的 X 值的最小约束。
最大 x	类似于最小 x，但具有最大约束
最小 y	类似于最小 x，但具有 Y 坐标
最大 y	类似于最大 x，但具有 Y 坐标
最小 z	类似于最小 x，但具有 Z 坐标。仅适用于 3D 布局（`暗淡`=3).
最大 z	类似于最大 x，但具有 Z 坐标。仅适用于 3D 布局（`暗淡`=3).
网格	是否使用算法的更快但准确性较低的基于网格的实现。`"auto"`根据图中的顶点数量来决定；如果至少有 1000 个顶点，将使用网格。`"网格"`等效于`True`, `"无网格"`等效于`False`.
返回值
计算出的布局。

def layout_graphopt(niter=500, node_charge=0.001, node_mass=30, spring_length=0, spring_constant=1, max_sa_movement=5, seed=None): ¶

这是 Michael Schmuhl 的 graphopt 布局算法的端口。 graphopt 版本 0.4.1 已用 C 重写，并且删除了对层的支持。

graphopt 使用物理类比来定义顶点之间吸引和排斥力，然后模拟物理系统直到达到平衡或达到最大迭代次数。

有关原始 graphopt，请参阅 http://www.schmuhl.org/graphopt/。

参数
尼特	要执行的迭代次数。通常应该是几百次。
节点_电荷	顶点的电荷，用于计算静电排斥力。
节点_质量	顶点的质量，用于弹簧力
弹簧_长度	弹簧的长度
弹簧_常数	弹簧常数
最大_萨_移动	单个步骤中沿单个轴允许的最大移动量。
种子	一个矩阵，其中包含将从其启动算法的种子布局。如果`None`，将使用随机布局。
返回值
计算出的布局。

def layout_grid(width=0, height=0, dim=2): ¶

将图的顶点放置在 2D 或 3D 网格中。

参数
宽度	布局中单行中的顶点数量。零或负数表示应自动确定宽度。
高度	布局中单列中的顶点数量。零或负数表示应自动确定高度。如果维数为 2，则不能给出它。
暗淡	布局所需的维数。 dim=2 表示 2D 布局，dim=3 表示 3D 布局。
返回值
计算出的布局。

def layout_kamada_kawai(maxiter=1000, epsilon=0, kkconst=None, seed=None, minx=None, maxx=None, miny=None, maxy=None, minz=None, maxz=None, dim=2): ¶

根据 Kamada-Kawai 算法将顶点放置在平面上。

这是一种力导向布局，请参阅 Kamada, T. 和 Kawai, S.: An Algorithm for Drawing General Undirected Graphs. Information Processing Letters, 31/1, 7--15, 1989.

参数
最大迭代次数	要执行的最大迭代次数。
epsilon	如果系统的能量变化小于 epsilon，则退出。有关详细信息，请参阅原始论文。
kkconst	Kamada-Kawai 顶点吸引常数。`None`表示顶点数的平方。
种子	如果`None`，为算法使用随机起始布局。如果是矩阵（列表的列表），则使用给定的矩阵作为起始位置。
最小 x	如果不是`None`，它必须是一个向量，其中包含与图中顶点数量完全相同的元素。每个元素都是对布局中顶点的 X 值的最小约束。
最大 x	类似于最小 x，但具有最大约束
最小 y	类似于最小 x，但具有 Y 坐标
最大 y	类似于最大 x，但具有 Y 坐标
最小 z	类似于最小 x，但具有 Z 坐标。仅适用于 3D 布局（`暗淡`=3).
最大 z	类似于最大 x，但具有 Z 坐标。仅适用于 3D 布局（`暗淡`=3).
暗淡	布局所需的维数。 dim=2 表示 2D 布局，dim=3 表示 3D 布局。
返回值
计算出的布局。

def layout_lgl(maxiter=150, maxdelta=-1, area=-1, coolexp=1.5, repulserad=-1, cellsize=-1, root=None): ¶

根据 Large Graph Layout 将顶点放置在 2D 平面上。

参数
最大迭代次数	要执行的迭代次数。
最大增量	顶点在一次迭代中移动的最大距离。如果为负，则默认为顶点数。
面积	将放置顶点的正方形的面积。如果为负，则默认为顶点数的平方。
冷却指数	模拟退火的冷却指数。
排斥半径	确定顶点-顶点排斥力抵消相邻顶点吸引力的半径。如果为负，则默认为 area 乘以顶点数。
单元格大小	网格单元格的大小。计算排斥力时，仅考虑同一网格单元格或相邻网格单元格中的顶点。默认为 area 的四次根。
根	根顶点，首先放置此顶点，然后在第一次迭代中放置其相邻顶点，在第二次迭代中放置其二阶相邻顶点，依此类推。`None`表示将选择一个随机顶点。
返回值
计算出的布局。

def layout_mds(dist=None, dim=2, arpack_options=None): ¶

使用多维缩放将顶点放置在具有给定维数的欧几里得空间中。

此布局需要一个距离矩阵，其中行 i 和列 j 的交点指定顶点 i 和顶点 j 之间的所需距离。该算法将尝试以一种近似于距离矩阵中规定的距离关系的方式放置顶点。 igraph 使用 Torgerson 的经典多维缩放（请参阅下面的参考资料）。

对于未连接的图，该方法将图分解为弱连接组件，然后使用距离矩阵的相应部分单独布局这些组件。

参数
距离	距离矩阵。它必须是对称的，并且不会检查对称性 - 当使用非对称距离矩阵时，结果是不确定的。如果此参数为`None`，则将最短路径长度用作距离。在计算最短路径长度以确保对称性时，有向图被视为无向图。
暗淡	维度数。对于 2D 布局，请在此处提供 2；对于 3D 布局，请提供 3。
arpack_options	一个 `ARPACKOptions` 对象，用于微调 ARPACK 特征向量计算。如果省略，则使用名为`arpack_options`。
返回值
计算出的布局。
未知字段：newfield
ref	参考
未知字段：ref
Cox & Cox: Multidimensional Scaling (1994), Chapman and Hall, London.

def layout_random(dim=2): ¶

随机放置图的顶点。

参数
暗淡	布局所需的维数。 dim=2 表示 2D 布局，dim=3 表示 3D 布局。
返回值
列表中的坐标对。

def layout_reingold_tilford(mode='out', root=None, rootlevel=None): ¶

根据 Reingold-Tilford 布局算法将顶点放置在 2D 平面上。

这是一种树布局。如果给定的图不是树，则首先执行广度优先搜索以获得可能的生成树。

参数
模式	指定在构建树时要考虑的边。如果是`输出`，则仅考虑传出的边，如果是`输入`，则仅考虑父顶点的传入边。如果是`全部`，则使用所有边（这是 igraph 0.5 及更早版本中的行为）。此参数还会影响在未给出根顶点时如何计算根顶点。请参阅根参数。
根	根顶点的索引或根顶点。如果这是一个非空向量，则提供的顶点 ID 用作树（或单个树，如果图已连接）的根。如果这是`None`或一个空列表，则将自动计算根顶点，以便所有其他顶点都可以从它们到达。目前，自动根选择更喜欢小型图（少于 500 个顶点）中的低偏心顶点和大型图中的高度顶点。此启发式方法可能会在以后的版本中更改。手动指定根以获得一致的输出。
根级别	此参数在绘制非树林时很有用。它指定森林中每棵树的根顶点的级别。
返回值
计算出的布局。
参见
layout_reingold_tilford_circular
未知字段：newfield
ref	参考
未知字段：ref
EM Reingold, JS Tilford: Tidier Drawings of Trees. IEEE Transactions on Software Engineering 7:22, 223-228, 1981.

def layout_reingold_tilford_circular(mode='out', root=None, rootlevel=None): ¶

树的圆形 Reingold-Tilford 布局。

此布局类似于 Reingold-Tilford 布局，但顶点以圆形方式放置，根顶点位于中心。

有关参数的说明，请参阅 layout_reingold_tilford。

返回值
计算出的布局。
参见
layout_reingold_tilford
未知字段：newfield
ref	参考
未知字段：ref
EM Reingold, JS Tilford: Tidier Drawings of Trees. IEEE Transactions on Software Engineering 7:22, 223-228, 1981.

def layout_star(center=0, order=None): ¶

计算图的星形布局。

参数
中心	要放在中心的顶点的 ID
顺序	一个数字向量，给出了顶点的顺序（包括中心顶点！）。如果是`None`，则顶点将按顶点 ID 递增的顺序放置。
返回值
计算出的布局。

def LCF(n, shifts, repeats): ¶

从 LCF 表示法生成图。

LCF 是 Lederberg-Coxeter-Frucht 的缩写，它是 3 正则哈密顿图的一种简明表示法。它由三个参数组成，即图中的顶点数、一个偏移列表，该列表提供了一个循环骨架的额外边，以及另一个整数，给出了应该执行偏移的次数。有关详细信息，请参阅 https://mathworld.net.cn/LCFNotation.html。

参数
n	顶点数
偏移	列表或元组中的偏移
重复次数	重复次数

def linegraph(): ¶

返回图的线图。

无向图的线图 L(G) 定义如下：L(G) 对于 G 中的每条边都有一个顶点，并且 L(G) 中的两个顶点是连接的，当且仅当它们在原始图中的相应边共享一个端点。

有向图的线图略有不同：当且仅当第一个顶点的相应边的目标与第二个顶点的相应边的源相同时，两个顶点通过有向边连接。

def maxdegree(vertices=None, mode='all', loops=False): ¶

返回图中顶点集的最大度数。

此方法接受单个顶点 ID 或顶点 ID 列表作为参数，并返回给定顶点的度数（以单个整数或列表的形式，具体取决于输入参数）。

参数
vertices	单个顶点 ID 或顶点 ID 列表，或者`None`表示图中的所有顶点。
模式	要返回的度的类型（`"out"`表示出度，`"in"`IN 表示入度或`"all"`表示它们的总和）。
循环	是否应计算自环。

def maxflow(source, target, capacity=None): ¶

在 igraph.Graph 中重写

返回源顶点和目标顶点之间的最大流量。

参数
来源	源顶点 ID
目标	目标顶点 ID
容量	边的容量。它必须是一个列表或一个有效的属性名称或`None`。在后一种情况下，每条边将具有相同的容量。
返回值
一个元组，其中包含以下内容：给定顶点之间的最大流量值、所有边上的流量值、作为相应最小切割的一部分的边 ID 以及切割一侧的顶点 ID。对于有向图，流量值向量给出每条边上的流量值。对于无向图，如果流量从较小的顶点 ID 流向较大的顶点 ID，则流量值为正；如果流量从较大的顶点 ID 流向较小的顶点 ID，则流量值为负。
未知字段：attention
此函数在类 `Graph` 中具有更方便的接口，它将结果包装在 `Flow` 对象中。建议使用该接口。

def maxflow_value(source, target, capacity=None): ¶

返回源顶点和目标顶点之间的最大流的值。

参数
来源	源顶点 ID
目标	目标顶点 ID
容量	边的容量。它必须是一个列表或一个有效的属性名称或`None`。在后一种情况下，每条边将具有相同的容量。
返回值
给定顶点之间的最大流量值

def maximal_cliques(min=0, max=0, file=None): ¶

返回图的最大团，作为元组列表。

最大团是一个无法通过向其添加任何其他顶点来扩展的团。最大团不一定是图中最大的团之一。

参数
min	要返回的最大团的最小大小。如果为零或负数，则不使用下限。
max	要返回的最大团的最大大小。如果为零或负数，则不使用上限。如果为非零，则会将找到的每个最大团的大小与此值进行比较，并且仅当其大小小于此限制时才会返回团。
文件	文件对象或要将结果写入到的文件的名称。当此参数为`None`时，最大团将作为列表的列表返回。
返回值
图的最大团，表示为列表的列表，或`None`（如果`文件`给出了参数）。@see: `largest_cliques()` 用于最大的团。

def maximal_independent_vertex_sets(): ¶

返回图的最大独立顶点集，作为元组列表。

最大独立顶点集是一个无法通过向其添加任何其他顶点来扩展的独立顶点集。最大独立顶点集不一定是图中最大的独立顶点集之一。

参见
`largest_independent_vertex_sets()` 用于最大独立顶点集
未知字段：newfield
ref	参考
未知字段：ref
S. Tsukiyama、M. Ide、H. Ariyoshi 和 I. Shirawaka: 一种生成所有最大独立集的新算法。 SIAM J Computing, 6:505--517, 1977.

def maximum_cardinality_search(): ¶

对图进行最大基数搜索。该函数计算每个顶点的秩 *alpha*，使得以递减秩顺序访问顶点对应于始终选择具有最多已访问邻居的顶点作为下一个要访问的顶点。

最大基数搜索在确定图的弦性方面很有用：当且仅当顶点的任何两个邻居在秩中高于原始顶点时，图才是弦图。

此函数的结果可以传递给 is_chordal()，以加快弦性计算速度，如果您还需要最大基数搜索的结果用于其他目的。

返回值
由秩向量及其逆向量组成的元组。

def mincut(source=None, target=None, capacity=None): ¶

在 igraph.Graph 中重写

计算源顶点和目标顶点之间或整个图中的最小割。

最小割是需要删除以分离源和目标（如果给出了源和目标）或断开图连接（如果未给出源和目标）的最小边集。使用边的权重（容量）计算最小值，因此计算具有最小总容量的切割。对于无向图且没有源和目标，该方法使用 Stoer-Wagner 算法。对于给定的源和目标，该方法使用推-重标记算法；请参阅下面的参考资料。

参数
来源	源顶点 ID。如果`None`，则目标也必须为 {None}，并且将对整个图（即所有可能的顶点对）进行计算。
目标	目标顶点 ID。如果`None`，则源也必须为 {None}，并且将对整个图（即所有可能的顶点对）进行计算。
容量	边的容量。它必须是一个列表或一个有效的属性名称或`None`。在后一种情况下，每条边将具有相同的容量。
返回值
最小割的值、第一个和第二个分区中的顶点的 ID 以及切割中的边的 ID，打包在一个 4 元组中
未知字段：attention
此函数在类 `Graph` 中具有更方便的接口，它将结果包装在 `Cut` 对象中。建议使用该接口。
未知字段：newfield
ref	参考
未知字段：ref
M. Stoer, F. Wagner: 一种简单的最小割算法。 Journal of the ACM 44(4):585-591, 1997.
A. V. Goldberg, R. E. Tarjan: 一种解决最大流问题的新方法。 Journal of the ACM 35(4):921-940, 1988.

def mincut_value(source=-1, target=-1, capacity=None): ¶

返回源顶点和目标顶点之间或整个图中的最小割。

参数
来源	源顶点 ID。如果为负数，则对除目标之外的每个顶点执行计算，并返回最小值。
目标	目标顶点 ID。如果为负数，则对除源之外的每个顶点执行计算，并返回最小值。
容量	边的容量。它必须是一个列表或一个有效的属性名称或`None`。在后一种情况下，每条边将具有相同的容量。
返回值
给定顶点之间的最小割的值

def minimum_size_separators(): ¶

返回一个列表，其中包含所有最小尺寸的分隔符顶点集。

如果顶点集的移除断开连接图，则该顶点集是一个分隔符。此方法列出了给定图中不存在较小分隔符集的所有分隔符。

返回值
一个列表，其中每个项目列出了给定最小大小分隔符的顶点索引。
未知字段：newfield
ref	参考
未知字段：ref
Arkady Kanevsky: 查找图中的所有最小大小分离顶点集。 Networks 23:533--541, 1993.

def modularity(membership, weights=None, resolution=1, directed=True): ¶

在 igraph.Graph 中重写

计算图相对于某些顶点类型的模块化。

图的模块度衡量了某种划分的好坏程度，或者说不同顶点类型之间的分离程度。它被定义为 Q = 1 ⁄ (2m)*sum(Aij − gamma*ki*kj ⁄ (2m)delta(ci, cj), i, j)。m 是边的数量， Aij 是 A 邻接矩阵中第 i 行和第 j 列的元素， ki 是节点 i 的度， kj 是节点 j 的度， Ci 和cj是两个顶点的类型（i 和 j），gamma 是一个分辨率参数，对于模块度的经典定义，默认为 1。delta(x, y) 当 x = y 时为 1，否则为 0。

如果给定了边权重，则模块度的定义修改如下：Aij 变为相应边的权重，ki 是顶点 i 上的边的总权重，kj 是顶点 j 上的边的总权重，m 是图中的总边权重。

参数
membership	成员向量，例如每个顶点的顶点类型索引。
weights	可选的边权重或`None`如果所有边的权重相同。
resolution	上述公式中的分辨率参数 gamma。当分辨率参数设置为 1 时，将检索到模块度的经典定义。
有向	如果图是有向图，是否考虑边的方向。`True`将使用模块度度量的有向变体，其中节点的入度和出度分别处理；`False`将有向图视为无向图。
返回值
模块度得分。大于 0.3 的分数通常表示较强的社区结构。
未知字段：attention
在 `Graph` 中重写的方法，允许 `VertexClustering` 对象作为参数。此方法不是严格必需的，因为 `VertexClustering` 类提供了一个名为`modularity`.
未知字段：newfield
ref	参考
未知字段：ref
MEJ Newman 和 M Girvan：Finding and evaluating community structure in networks。Phys Rev E 69 026113, 2004。

def motifs_randesu(size=3, cut_prob=None, callback=None): ¶

计算图中 motif 的数量

Motif 是图中给定结构的小子图。有人认为，motif 配置文件（即图中不同 motif 的数量）是不同类型的网络的特征，并且网络功能与图中的 motif 相关。

目前，我们支持有向图的大小为 3 和 4 的 motif，以及无向图的大小为 3、4、5 或 6 的 motif。

在一个大型网络中，motif 的总数可能非常大，因此找到所有 motif 需要很长时间。在这种情况下，可以使用抽样方法。此函数能够通过 cut_prob 参数进行抽样。此参数给出了 motif 搜索树的分支将不被探索的概率。

参数
size	motif 的大小
cut_prob	搜索树的不同级别的剪切概率。这必须是长度为 size 的列表或`None`找到所有 motif。
回调	`None`或者是一个可调用对象，它将为图中找到的每个 motif 调用。可调用对象必须接受三个参数：图本身，motif 中顶点的列表和 motif 的同构类（参见 `isoclass()`）。当回调返回具有非零真值的对象或引发异常时，搜索将停止。
返回值
如果 callback 为`None`，则为 motif 的列表`None`，否则
参见
Graph.motifs_randesu_no()
未知字段：newfield
ref	参考
未知字段：ref
S. Wernicke 和 F. Rasche：FANMOD：一种快速网络 motif 检测工具，Bioinformatics 22(9), 1152--1153, 2006。

def motifs_randesu_estimate(size=3, cut_prob=None, sample=None): ¶

计算图中 motif 的总数

Motif 是图中给定结构的小子图。此函数通过从顶点的随机样本中外推，来估计图中 motif 的总数，而不将同构类分配给它们。

目前，我们支持有向图的大小为 3 和 4 的 motif，以及无向图的大小为 3、4、5 或 6 的 motif。

参数
size	motif 的大小
cut_prob	搜索树的不同级别的剪切概率。这必须是长度为 size 的列表或`None`找到所有 motif。
样本	样本的大小或用于抽样的顶点的顶点 ID。
参见
Graph.motifs_randesu()
未知字段：newfield
ref	参考
未知字段：ref
S. Wernicke 和 F. Rasche：FANMOD：一种快速网络 motif 检测工具，Bioinformatics 22(9), 1152--1153, 2006。

def motifs_randesu_no(size=3, cut_prob=None): ¶

计算图中 motif 的总数

Motif 是图中给定结构的小子图。此函数计算图中 motif 的总数，而不将同构类分配给它们。

目前，我们支持有向图的大小为 3 和 4 的 motif，以及无向图的大小为 3、4、5 或 6 的 motif。

参数
size	motif 的大小
cut_prob	搜索树的不同级别的剪切概率。这必须是长度为 size 的列表或`None`找到所有 motif。
参见
Graph.motifs_randesu()
未知字段：newfield
ref	参考
未知字段：ref
S. Wernicke 和 F. Rasche：FANMOD：一种快速网络 motif 检测工具，Bioinformatics 22(9), 1152--1153, 2006。

def neighborhood(vertices=None, order=1, mode='all', mindist=0): ¶

对于 vertices 指定的每个顶点，返回最多 order 步可以从该顶点到达的顶点。如果 mindist 大于零，则排除少于 mindist 步可到达的顶点。

参数
vertices	单个顶点 ID 或顶点 ID 列表，或者`None`表示图中的所有顶点。
顺序	邻域的阶数，即从种子顶点开始的最大步数。
模式	指定如果分析有向图，如何考虑边的方向。`"out"`表示仅遵循传出的边，因此最多 order 步从源顶点可到达的所有顶点都会被计算在内。`"in"`表示仅遵循传入的边（当然是反方向），因此最多 order 步源顶点可到达的所有顶点都会被计算在内。`"all"`将有向边视为无向边。
mindist	将顶点包含在结果中所需的最小距离。如果这是一，则不包括种子顶点。如果这是二，则也不包括种子顶点的直接邻居，依此类推。
返回值
如果 vertices 是指定单个顶点索引的整数，则为指定邻域的单个列表，如果 vertices 是列表或`None`.

def neighborhood_size(vertices=None, order=1, mode='all', mindist=0): ¶

对于 vertices 指定的每个顶点，返回最多 order 步从该顶点可到达的顶点数。如果 mindist 大于零，则排除在小于 mindist 步内可到达的顶点。

参数
vertices	单个顶点 ID 或顶点 ID 列表，或者`None`表示图中的所有顶点。
顺序	邻域的阶数，即从种子顶点开始的最大步数。
模式	指定如果分析有向图，如何考虑边的方向。`"out"`表示仅遵循传出的边，因此最多 order 步从源顶点可到达的所有顶点都会被计算在内。`"in"`表示仅遵循传入的边（当然是反方向），因此最多 order 步源顶点可到达的所有顶点都会被计算在内。`"all"`将有向边视为无向边。
mindist	将顶点包含在结果中所需的最小距离。如果这是一，则不计算种子顶点。如果这是二，则也不计算种子顶点的直接邻居，依此类推。
返回值
如果 vertices 是指定单个顶点索引的整数，则为指定邻域大小的单个数字，如果 vertices 是列表或`None`.

def neighbors(vertex, mode='all'): ¶

返回给定顶点的相邻顶点。

参数
顶点	顶点 ID
模式	是否仅返回后继节点 (`"out"`)、前驱节点 (`"in"`) 或两者 (`"all"`）。对于无向图将被忽略。

def path_length_hist(directed=True): ¶

在 igraph.Graph 中重写

计算图的路径长度直方图

参数
有向	是否考虑有向路径
返回值
一个元组。元组的第一项是路径长度的列表，列表的第 i 个元素包含长度为 i + 1 的路径数。第二项包含未连接的顶点对的数量作为浮点数（因为它可能不适合整数）
未知字段：attention
此函数在派生类 `Graph` 中以更方便的语法包装。建议使用该版本而不是此版本。

def permute_vertices(permutation): ¶

根据给定的置换置换图的顶点并返回新图。

原始图的顶点 k 将成为新图中的顶点 permutation[k]。不对置换向量执行有效性检查。

返回值
新图

def personalized_pagerank(vertices=None, directed=True, damping=0.85, reset=None, reset_vertices=None, weights=None, arpack_options=None, implementation='prpack', niter=1000, eps=0.001): ¶

计算图的个性化 PageRank 值。

个性化 PageRank 计算类似于 PageRank 计算，但是随机游走以 1 − damping 的概率在每一步重置为顶点上的非均匀分布，而不是均匀分布。

参数
vertices	被查询的顶点的索引。`None`表示所有顶点。
有向	是否考虑有向路径。
damping	阻尼系数。1 − damping 是没有传入链接的顶点的 PageRank 值。
reset	重置随机游走时要使用的顶点上的分布。可以是序列，可迭代对象或顶点属性名称，只要它们返回一个浮点数列表，其长度等于顶点的数量。如果`None`，则假定为均匀分布，这使该方法等效于原始 PageRank 算法。
reset_vertices	指定重置随机游走时要使用的顶点上的分布的另一种方法。只需在此处提供顶点 ID 的列表，或者 `VertexSeq` 或 `Vertex`。重置将使用指定顶点上的均匀分布进行。
weights	要使用的边权重。可以是序列或可迭代对象，甚至可以是边属性名称。
arpack_options	一个 `ARPACKOptions` 对象，用于微调 ARPACK 特征向量计算。如果省略，则使用名为`arpack_options`被使用。如果未使用 ARPACK 实现，则忽略此参数，请参见 implementation 参数。
implementation	使用哪个实现来解决 PageRank 特征值问题。可能的值为 `"prpack"`：使用 PRPACK 库。这是 igraph 0.7 中的一个新实现 `"arpack"`：使用 ARPACK 库。此实现在版本 0.5 到版本 0.7 中使用。 `"power"`：使用简单的幂方法。这是在 igraph 版本 0.5 之前使用的实现。
尼特	在幂方法实现中使用的迭代次数。在其他实现中将被忽略。
eps	如果每次迭代之间 PageRank 值的差异对于每个节点都小于此值，则幂方法实现将认为计算已完成。其他实现将忽略它。
返回值
包含指定顶点的个性化 PageRank 值的列表。

def predecessors(vertex): ¶

返回给定顶点的前身。

等效于使用 type= 调用 neighbors() 方法"in".

def Preference(n, type_dist, pref_matrix, attribute=None, directed=False, loops=False): ¶

基于顶点类型和连接概率生成图。

这实际上是 Establishment 的非增长变体。生成给定数量的顶点。根据给定的类型概率将每个顶点分配给一个顶点类型。最后，评估每个顶点对，并且在它们之间创建一个边的概率取决于所涉及的顶点的类型。

参数
n	图中的顶点数
type_dist	列表，给出顶点类型的分布
pref_matrix	给出不同顶点类型的连接概率的矩阵。
attribute	用于存储顶点类型的顶点属性名称。如果`None`，则不存储顶点类型。
有向	是否生成有向图。
循环	是否允许环边。

def radius(mode='out'): ¶

计算图的半径。

图的半径定义为其顶点的最小离心率（参见 eccentricity()）。

参数
模式	对于有向图，在计算中考虑哪种路径。`输出`考虑遵循边方向的路径，`输入`考虑遵循相反边方向的路径，`全部`忽略边方向。该参数对于无向图将被忽略。
返回值
半径
参见
`eccentricity()`

def random_walk(start, steps, mode='out', stuck='return'): ¶

从给定节点执行给定长度的随机游走。

参数
开始	游走的起始顶点
steps	随机游走应采取的步数
模式	是否仅跟随出站边（`"out"`），仅跟随入站边（`"in"`) 或两者 (`"all"`）。对于无向图将被忽略。@param stuck: 当随机游走卡住时该怎么办。`"return"`返回部分随机游走；`"error"`抛出异常。
stuck	未归档
返回值
从给定顶点开始且最多具有给定长度的随机游走（如果随机游走卡住，则更短）

def Read_DIMACS(f, directed=False): ¶

在 igraph.Graph 中重写

从符合 DIMACS 最小成本流文件格式的文件中读取图。

有关格式的准确描述，请参见 http://lpsolve.sourceforge.net/5.5/DIMACS.htm

与格式的官方描述相比的限制

igraph 的 DIMACS 阅读器仅需要弧定义中的三个字段，描述了边的源节点和目标节点及其容量。
源顶点在 FLOW 字段中由“s”标识，目标顶点由“t”标识。
节点索引从 1 开始。仅允许单个源节点和目标节点。

参数
f	文件名或 Python 文件句柄
有向	生成的图是否应该是有向图。
返回值
生成的图，流的源和目标以及边容量在一个元组中

def Read_DL(f, directed=True): ¶

读取 UCINET DL 文件并基于它创建一个图。

参数
f	文件名或 Python 文件句柄
有向	生成的图是否应该是有向图。

def Read_Edgelist(f, directed=True): ¶

从文件中读取边列表并基于它创建一个图。

请注意，顶点索引是基于零的。将为范围内的每个整数创建一个零度顶点，但不会出现在边列表中。

参数
f	文件名或 Python 文件句柄
有向	生成的图是否应该是有向图。

def Read_GML(f): ¶

读取 GML 文件并基于它创建一个图。

参数
f	文件名或 Python 文件句柄

def Read_GraphDB(f, directed=False): ¶

读取 GraphDB 格式文件并基于它创建一个图。

GraphDB 是一种二进制格式，用于图数据库进行同构测试（参见 http://amalfi.dis.unina.it/graph/）。

参数
f	文件名或 Python 文件句柄
有向	生成的图是否应该是有向图。

def Read_GraphML(f, index=0): ¶

读取 GraphML 格式文件并基于它创建一个图。

参数
f	文件名或 Python 文件句柄
index	如果 GraphML 文件包含多个图，则指定应加载的图。图索引从零开始，因此如果要加载第一个图，请在此处指定 0。

def Read_Lgl(f, names=True, weights='if_present', directed=True): ¶

读取 LGL 使用的 .lgl 文件。

它也可用于从“命名”（和可选的加权）边列表创建图。

此格式由 Large Graph Layout 程序使用。有关准确的格式描述，请参见 LGL 的文档。

LGL 最初无法处理包含多个或环边的图，但是此处未检查此条件，因为 igraph 对此感到满意。

参数
f	文件名或 Python 文件句柄
names	如果`True`，顶点名称将作为名为“name”的顶点属性添加。
weights	如果为 True，则即使文件中没有权重，边权重也会添加为名为“weight”的边属性。如果为 False，则永远不会添加边权重，即使它们存在。`"auto"`之一或`"if_present"`表示如果输入文件中至少有一个加权边，则会添加权重，否则不会添加权重。
有向	正在创建的图是否应该是有向图

def Read_Ncol(f, names=True, weights='if_present', directed=True): ¶

读取 LGL 使用的 .ncol 文件。

它也可用于从“命名”（和可选的加权）边列表创建图。

此格式由 Large Graph Layout 程序使用。有关更多信息，请参见 LGL 的存储库。

LGL 最初无法处理包含多个或环边的图，但是此处未检查此条件，因为 igraph 对此感到满意。

参数
f	文件名或 Python 文件句柄
names	如果`True`，顶点名称将作为名为“name”的顶点属性添加。
weights	如果为 True，则即使文件中没有权重，边权重也会添加为名为“weight”的边属性。如果为 False，则永远不会添加边权重，即使它们存在。`"auto"`之一或`"if_present"`表示如果输入文件中至少有一个加权边，则会添加权重，否则不会添加权重。
有向	正在创建的图是否应该是有向图

def Read_Pajek(f): ¶

读取 Pajek 格式文件并基于它创建一个图。

参数
f	文件名或 Python 文件句柄

def Realize_Degree_Sequence(out, in_=None, allowed_edge_types='simple', method='smallest'): ¶

从度数序列生成图。

此方法从给定的度序列实现 Havel-Hakimi 风格的图构造。在每个步骤中，该算法以确定性的方式选择两个顶点并连接它们。顶点的选择方式由method参数定义。允许的边类型（即是否允许多重边或环边）在allowed_edge_types参数。

参数
out	未归档
in_	未归档
allowed_edge_types	控制在生成过程中是否允许环或多重边。请注意，并非所有组合都支持所有类型的图；对于不受支持的组合，将引发异常。可能的值为 `"simple"`：简单图（没有自环，没有多重边） `"loops"`：允许单个自环，但不允许多重边 `"multi"`：允许多重边，但不允许自环 `"all"`：允许多重边和自环
method	控制在生成过程中如何选择顶点。可能的值为 `smallest`：首先是剩余度最小的顶点。 `largest`：首先是剩余度最大的顶点。 `index`：顶点按照其索引的顺序选择。
outdeg	无向图的度序列（如果 indeg=None），或有向图的出度序列。
indeg	None 以生成无向图，入度序列以生成有向图。

def Recent_Degree(n, m, window, outpref=False, directed=False, power=1): ¶

基于随机模型生成图，其中边获得新节点的概率与给定时间窗口中获得的边成正比。

参数
n	顶点数
m	为每个顶点生成的传出边数或显式包含每个顶点的传出边数的列表。
window	时间步长中的窗口大小
outpref	`True`如果给定顶点的出度也应增加其引用概率（以及其入度），但默认为`False`.
有向	`True`生成的图是否应该是有向图（默认`False`).
power	非线性模型的功率常数。它可以省略，在这种情况下，将使用通常的线性模型。

def reciprocity(ignore_loops=True, mode='default'): ¶

互易性定义了有向图中互连的比例。它最常定义为有向边的相反对应物也包含在图中的概率。如果计算此度量模式是"default".

在 igraph 0.6 之前，实现了另一个度量，定义为顶点对之间的互连概率，如果我们知道它们之间存在（可能非互易）连接。换句话说，（无序）顶点对分为三组：（1）断开连接，（2）非互易连接和（3）互易连接。结果是组（3）的大小，除以组（2）和（3）的大小之和。如果计算此度量模式是"ratio".

参数
ignore_loops	是否应忽略环边。
模式	用于计算互易性的算法；有关更多详细信息，请参见上文。
返回值
图的互易性

def rewire(n=1000, mode='simple'): ¶

随机重新连接图，同时保留度数分布。

请注意，重布线是“就地”完成的，因此原始图将被修改。如果要保留原始图，请在使用前使用 copy 方法。

参数
n	重布线试验的次数。
模式	要使用的重布线算法。它可以是`"simple"`之一或`"loops"`；前者不会创建或破坏环边，而后者会。

def rewire_edges(prob, loops=False, multiple=False): ¶

以恒定概率重新连接图的边。

图的每个边的每个端点将以给定的恒定概率重新布线，该概率在第一个参数中给出。

请注意，重布线是“就地”完成的，因此原始图将被修改。如果要保留原始图，请在使用前使用 copy 方法。

参数
prob	重布线概率
循环	是否允许该算法创建环边
多个	是否允许该算法创建多重边。

def Ring(n, directed=False, mutual=False, circular=True): ¶

生成一个环图。

参数
n	环中顶点的数量
有向	是否创建有向环。
相互	是否在有向环中创建互边。
循环	是否创建一个闭环。

def SBM(n, pref_matrix, block_sizes, directed=False, loops=False): ¶

基于随机块模型生成图。

生成给定数量的顶点。根据给定的块大小将每个顶点分配给一个顶点类型。相同类型的顶点将被分配连续的顶点 ID。最后，评估每个顶点对，并且在它们之间创建一个边的概率取决于所涉及的顶点的类型。概率取自偏好矩阵。

参数
n	图中的顶点数
pref_matrix	给出不同顶点类型的连接概率的矩阵。
block_sizes	列表，给出每个块中的顶点数；总和必须达到 n。
有向	是否生成有向图。
循环	是否允许环边。

def shortest_paths(source=None, target=None, weights=None, mode='out'): ¶

计算图中给定顶点的最短路径长度。

用于计算的算法会自动选择：对于未加权图，使用简单的 BFS；当所有权重均为正时，使用 Dijkstra 算法。否则，如果请求的源顶点数大于 100，则使用 Bellman-Ford 算法，否则使用 Johnson 算法。

参数
来源	包含应包含在结果中的源顶点 ID 的列表。如果`None`，则将考虑所有顶点。
目标	包含应包含在结果中的目标顶点 ID 的列表。如果`None`，则将考虑所有顶点。
weights	包含边权重的列表。它也可以是属性名称（边权重从给定的属性中检索）或`None`（所有边的权重相等）。
模式	有向图中用于计算的最短路径的类型。`"out"`表示仅传出，`"in"`表示仅传入路径。`"all"`表示将有向图视为无向图。
返回值
矩阵中给定顶点的最短路径长度

def similarity_dice(vertices=None, pairs=None, mode='all', loops=True): ¶

顶点的 Dice 相似性系数。

两个顶点的 Dice 相似性系数是它们的公共邻居数的两倍，除以它们的度数之和。此系数与 Jaccard 系数非常相似，但是通常给出的相似度高于其对应系数。

参数
vertices	要分析的顶点。如果`None`，并且 pairs 也是`None`，则将考虑所有顶点。
对	要分析的顶点对。如果给出了这个，则 vertices 必须是`None`，并且相似度值仅针对给定的对计算。顶点对必须指定为顶点 ID 的元组。
模式	对于有向图，应考虑哪些邻居。可以是`"all"`, `"in"`之一或`"out"`，对于无向图将被忽略。
循环	是否应考虑顶点与其自身相邻。将此设置为`True`假设所有顶点都有一个环边，即使图中没有一个环边。将此设置为`False`可能会导致奇怪的结果：与在它们之间添加边的情况相比，非相邻顶点可能具有更大的相似度 - 但是，这可能正是您想要获得的结果。
返回值
如果`对`是`None`则为指定的顶点的成对相似性系数，以矩阵形式给出，如果`对`不是`None`.

def similarity_inverse_log_weighted(vertices=None, mode='all'): ¶

顶点的反向对数加权相似性系数。

每个顶点都被分配一个权重，该权重为 1 / log（度）。两个顶点的对数加权相似度是其公共邻居的权重之和。

参数
vertices	要分析的顶点。如果`None`，则将考虑所有顶点。
模式	对于有向图，应考虑哪些邻居。可以是`"all"`, `"in"`之一或`"out"`，对于无向图将被忽略。`"in"`表示权重由出度确定，`"out"`表示权重由入度确定。
返回值
指定的顶点的成对相似性系数，以矩阵形式（列表的列表）给出。

def similarity_jaccard(vertices=None, pairs=None, mode='all', loops=True): ¶

顶点的 Jaccard 相似性系数。

两个顶点的 Jaccard 相似性系数是它们的公共邻居数除以至少与其中一个相邻的顶点数。

参数
vertices	要分析的顶点。如果`None`，并且 pairs 也是`None`，则将考虑所有顶点。
对	要分析的顶点对。如果给出了这个，则 vertices 必须是`None`，并且相似度值仅针对给定的对计算。顶点对必须指定为顶点 ID 的元组。
模式	对于有向图，应考虑哪些邻居。可以是`"all"`, `"in"`之一或`"out"`，对于无向图将被忽略。
循环	是否应考虑顶点与其自身相邻。将此设置为`True`假设所有顶点都有一个环边，即使图中没有一个环边。将此设置为`False`可能会导致奇怪的结果：与在它们之间添加边的情况相比，非相邻顶点可能具有更大的相似度 - 但是，这可能正是您想要获得的结果。
返回值
如果`对`是`None`则为指定的顶点的成对相似性系数，以矩阵形式给出，如果`对`不是`None`.

def simplify(multiple=True, loops=True, combine_edges=None): ¶

通过删除自环和/或多条边来简化图。

例如，假设您有一个图，其边属性名为weight. graph.simplify(combine_edges=max)将采用多个边的权重的最大值，并将该权重分配给塌陷的边。graph.simplify(combine_edges=sum)将采用权重的总和。您也可以写graph.simplify(combine_edges=dict(weight="sum"))之一或graph.simplify(combine_edges=dict(weight=sum))，因为sum既被识别为 Python 内置函数，也被识别为字符串常量。

参数
多个	是否删除多重边。
循环	是否删除环。
combine_edges	指定如何将同一顶点对之间的多个边的属性组合为单个属性。如果是`None`，则只会保留其中一个边，并且所有属性将丢失。如果它是一个函数，则多个边的属性将被收集并传递给该函数，该函数将返回必须分配给单个塌陷边的新属性值。它也可以是以下字符串常量之一 `"ignore"`：所有边属性将被忽略。 `"sum"`：边属性值的总和将用于新边。 `"product"`：边属性值的乘积将用于新边。 `"mean"`：边属性值的平均值将用于新边。 `"median"`：边属性值的中位数将用于新边。 `"min"`：边属性值的最小值将用于新边。 `"max"`：边属性值的最大值将用于新边。 `"first"`：塌陷集中第一个边的属性值将用于新边。 `"last"`：塌陷集中最后一个边的属性值将用于新边。 `"random"`：将为新边使用随机选择的值 `"concat"`：属性值将被连接用于新边。如果要使简化过程的行为取决于属性的名称，也可以使用将边属性名称映射到函数或上述字符串常量的 dict。`None`是此 dict 中的一个特殊键，其值将用于字典中未明确指定的所有属性。

def st_mincut(source, target, capacity=None): ¶

在 igraph.Graph 中重写

计算图中源顶点和目标顶点之间的最小割。

参数
来源	源顶点 ID
目标	目标顶点 ID
容量	边的容量。它必须是一个列表或一个有效的属性名称或`None`。在后一种情况下，每条边将具有相同的容量。
返回值
最小割的值、第一个和第二个分区中的顶点的 ID 以及切割中的边的 ID，打包在一个 4 元组中
未知字段：attention
此函数在类 `Graph` 中具有更方便的接口，它将结果包装在 `Cut` 对象的列表中。建议使用该接口。

def Star(n, mode='undirected', center=0): ¶

生成一个星形图。

参数
n	图中的顶点数
模式	给出要创建的星形图的类型。应该为“in”，“out”，“mutual”或“undirected”
中心	星形图中中心顶点的顶点 ID。

def Static_Fitness(m, fitness_out, fitness_in=None, loops=False, multiple=False): ¶

生成一个非增长图，其边概率与节点适应度成正比。

该算法随机选择顶点对并将它们连接起来，直到创建给定数量的边。每个顶点的选择概率与其适应度成正比；对于有向图，选择顶点作为源与其出适应度成正比，选择顶点作为目标与其入适应度成正比。

参数
m	图中的边数
fitness_out	一个数值向量，具有非负条目，每个顶点对应一个。这些值表示适应度分数（有向图的出适应度分数）。fitness 是此关键字参数的别名。
fitness_in	一个数值向量，具有非负条目，每个顶点对应一个。这些值表示有向图的入适应度分数。对于无向图，此参数必须为`None`.
循环	是否允许环边。
多个	是否允许多重边。
返回值
一个具有规定的幂律度分布的有向图或无向图。

def Static_Power_Law(n, m, exponent_out, exponent_in=-1, loops=False, multiple=False, finite_size_correction=True): ¶

生成具有规定的幂律度数分布的非增长图。

参数
n	图中的顶点数
m	图中的边数
exponent_out	出度分布的指数，必须在 2 到无穷大之间（包括 2 和无穷大）。当未给出或为负数 exponent_in 时，该图将为无向图，并且此参数指定度分布。exponent 是此关键字参数的别名。
exponent_in	入度分布的指数，必须在 2 到无穷大之间（包括 2 和无穷大）。它也可以为负数，在这种情况下将生成一个无向图。
循环	是否允许环边。
多个	是否允许多重边。
finite_size_correction	是否对生成的适应度值应用有限大小校正，以使指数小于 3。有关更多详细信息，请参见 Cho 等人的论文。
返回值
一个具有规定的幂律度分布的有向图或无向图。
未知字段：newfield
ref	参考
未知字段：ref
Goh K-I, Kahng B, Kim D: Universal behaviour of load distribution in scale-free networks。Phys Rev Lett 87(27):278701, 2001。
Cho YS, Kim JS, Park J, Kahng B, Kim D: Percolation transitions in scale-free networks under the Achlioptas process。Phys Rev Lett 103:135702, 2009。

def strength(vertices, mode='all', loops=True, weights=None): ¶

从图中返回某些顶点的强度（加权度数）

此方法接受单个顶点 ID 或顶点 ID 的列表作为参数，并返回给定顶点的强度（即所有入射边的权重之和）（以单个整数或列表的形式，具体取决于输入参数）。

参数
vertices	单个顶点 ID 或顶点 ID 列表
模式	要返回的度的类型（`"out"`表示出度，`"in"`表示入度或`"all"`表示它们的总和）。
循环	是否应计算自环。
weights	要使用的边权重。可以是序列或可迭代对象，甚至是边属性名称。``None`` 表示将图视为未加权图，回退到普通度计算。

def subcomponent(v, mode='all'): ¶

确定与给定顶点位于同一组件中的顶点的索引。

参数
v	用作源/目标顶点的索引
模式	，如果等于`"in"`，则返回可以到达给定顶点的顶点 ID。如果等于`"out"`，则返回可以从给定顶点到达的顶点 ID。如果等于`"all"`，则返回与给定顶点位于同一组件内的所有顶点，忽略边方向。请注意，这不等于计算`"in"`和`"out"`.
返回值
与给定顶点位于同一组件中的顶点的索引。

def subgraph_edges(edges, delete_vertices=True): ¶

返回由给定边生成的子图。

参数
边	包含应包含在结果中的边 ID 的列表。
delete_vertices	如果`True`，不会关联到任何指定边的顶点将从结果中删除。如果`False`，则所有顶点都将被保留。
返回值
子图

def subisomorphic_lad(other, domains=None, induced=False, time_limit=0, return_mapping=False): ¶

检查图的子图是否与另一个图同构。

可选的domains参数可用于限制可能匹配的顶点。您还可以指定是否只对诱导子图感兴趣。

参数
other	我们在图中寻找的模式图。
domains	列表的列表，一个子列表属于模板图中的每个顶点。子列表 i 包含原始图中可能与模板图中的顶点 i 匹配的顶点的索引。`None`表示每个顶点都可能匹配每个其他顶点。
induced	是否仅考虑诱导子图。
time_limit	以秒为单位的最佳时间限制。仅考虑此数字的整数部分。如果超过时间限制，该方法将引发异常。
return_mapping	当`True`时，该函数将返回一个元组，其中第一个元素是一个布尔值，表示是否已找到子同构，第二个元素描述了从模板图到原始图的顶点映射。当`False`时，仅返回布尔值。
返回值
如果没有计算映射，则结果为`True`如果该图包含与给定模板同构的子图，`False`否则。如果计算了映射，则结果是一个元组，第一个元素是上述布尔值，第二个元素是从目标图到原始图的映射。

def subisomorphic_vf2(other, color1=None, color2=None, edge_color1=None, edge_color2=None, return_mapping_12=False, return_mapping_21=False, callback=None, node_compat_fn=None, edge_compat_fn=None): ¶

检查图的子图是否与另一个图同构。

顶点和边的颜色可用于限制同构，因为只允许具有相同颜色的顶点和边相互匹配。

参数
other	我们要与之比较的另一个图。
color1	可选向量，存储第一个图的顶点的着色。如果`None`，则所有顶点都具有相同的颜色。
color2	可选向量，存储第二个图的顶点的着色。如果`None`，则所有顶点都具有相同的颜色。
edge_color1	可选向量，存储第一个图的边的着色。如果`None`，则所有边都具有相同的颜色。
edge_color2	可选向量，存储第二个图的边的着色。如果`None`，则所有边都具有相同的颜色。
return_mapping_12	如果`True`，计算将第一个图的顶点映射到第二个图的映射。如果给定的节点未映射，则映射可以包含-1。
return_mapping_21	如果`True`，计算将第二个图的顶点映射到第一个图的映射。如果给定的节点未映射，则映射可以包含-1。
回调	如果不是`None`，子同构搜索不会在第一次匹配时停止；而是为找到的每个子同构调用此回调函数。回调函数必须接受四个参数：第一个图，第二个图，从第一个图的节点到第二个图的映射，以及从第二个图的节点到第一个图的映射。该函数必须返回`True`如果搜索应继续或`False`否则。
node_compat_fn	一个函数，接收两个图和两个节点索引（一个来自第一个图，一个来自第二个图）并返回`True`如果由两个索引给出的节点是兼容的（即，它们可以相互匹配）或`False`否则。这可以用于基于节点特定标准来限制同构的集合，这些标准太复杂而无法由节点颜色向量表示（即，`color1`和`color2`参数）。`None`表示每个节点与每个其他节点都兼容。
edge_compat_fn	一个函数，接收两个图和两个边索引（一个来自第一个图，一个来自第二个图）并返回`True`如果由两个索引给出的边是兼容的（即，它们可以相互匹配）或`False`否则。这可以用于基于边特定标准来限制同构的集合，这些标准太复杂而无法由边颜色向量表示（即，`edge_color1`和`edge_color2`参数）。`None`表示每条边与每个其他节点都兼容。
返回值
如果没有计算映射，则结果为`True`如果该图包含与给定图同构的子图，`False`否则。如果计算了任何一个或两个映射，则结果是一个 3 元组，第一个元素是上面提到的布尔值，第二个元素是 1 -> 2 映射，第三个元素是 2 -> 1 映射。如果未计算相应的映射，则`None`将在 3 元组的相应元素中返回。

def successors(vertex): ¶

返回给定顶点的后继者。

等效于使用 type= 调用 neighbors() 方法"out".

def to_directed(mode='mutual'): ¶

将无向图转换为有向图。

参数

模式指定如何将无向边转换为有向边。True之一或"mutual"（相互）为每个无向边创建一对相互边。False之一或"arbitrary"（任意）为每个边选择一个任意（但确定性）的边方向。"random"为每个边选择一个随机方向。"acyclic"（无环）以这样一种方式选择边的方向，使得如果原始图中没有自环，则生成的图将是无环的。

def to_prufer(): ¶

将树图转换为 Prufer 序列。

返回值
Prufer 序列作为列表

def to_undirected(mode='collapse', combine_edges=None): ¶

将有向图转换为无向图。

参数
模式	指定如何处理同一顶点对之间的多个有向边。`True`之一或`"collapse"（折叠）`表示应从多个有向边创建一个边。`False`之一或`"each"（每个）`表示将保留每个边（移除箭头）。`"mutual"（相互）`为每对相互有向边创建一个无向边。
combine_edges	指定如何将同一顶点对之间的多个边的属性组合成单个属性。有关更多详细信息，请参见`simplify()`。

def topological_sorting(mode='out'): ¶

计算图的可能拓扑排序。

如果图不是有向无环图，则返回部分排序并发出警告。

参数
模式	如果`"out"`，根据前向拓扑顺序返回顶点——所有顶点都在其后继节点之前。如果`"in"`，则所有顶点都在其祖先之前。
返回值
可能的拓扑排序作为列表

def transitivity_avglocal_undirected(mode='nan'): ¶

在 igraph.Graph 中重写

计算图的顶点传递性的平均值。

传递性度量了顶点的两个邻居连接的概率。就平均局部传递性而言，针对每个顶点计算此概率，然后取平均值。少于两个邻居的顶点需要特殊处理，它们将从计算中排除或被视为具有零传递性，具体取决于 _mode_ 参数。

请注意，此度量标准与全局传递性度量标准（请参见 transitivity_undirected()）不同，因为它仅取整个网络的平均局部传递性。

参数
模式	定义如何处理度数小于 2 的顶点。如果`TRANSITIVITT_ZERO`之一或`"zero"（零）`，这些顶点将具有零传递性。如果`TRANSITIVITY_NAN`之一或`"nan"`，这些顶点将从平均值中排除。
参见
`transitivity_undirected()`, `transitivity_local_undirected()`
未知字段：newfield
ref	参考
未知字段：ref
DJ Watts 和 S. Strogatz：_小世界网络的集体动力学_。Nature 393(6884):440-442, 1998。

def transitivity_local_undirected(vertices=None, mode='nan', weights=None): ¶

计算图中给定顶点的局部传递性（聚类系数）。

传递性衡量顶点的两个邻居相连的概率。对于局部传递性，此概率是为每个顶点单独计算的。

请注意，此度量标准与全局传递性度量标准（请参见 transitivity_undirected()）不同，因为它为每个顶点单独计算传递性值。

传统的局部传递性度量仅适用于无权重图。当weights给出参数时，此函数将计算 Barrat 等人提出的加权局部传递性（请参见参考文献）。

参数
vertices	一个列表，包含应包含在结果中的顶点 ID。`None`表示所有顶点。
模式	定义如何处理度数小于 2 的顶点。如果`TRANSITIVITT_ZERO`之一或`"zero"（零）`，这些顶点将具有零传递性。如果`TRANSITIVITY_NAN`之一或`"nan"`，这些顶点将具有`NaN`（非数字）作为其传递性。
weights	要使用的边权重。可以是序列或可迭代对象，甚至可以是边属性名称。
返回值
列表中给定顶点的传递性
参见
`transitivity_undirected()`, `transitivity_avglocal_undirected()`
未知字段：newfield
ref	参考
未知字段：ref
Watts DJ 和 Strogatz S：_小世界网络的集体动力学_。Nature 393(6884):440-442, 1998。
Barrat A, Barthelemy M, Pastor-Satorras R 和 Vespignani A：_复杂加权网络的架构_。PNAS 101, 3747 (2004)。http://arxiv.org/abs/cond-mat/0311416。

def transitivity_undirected(mode='nan'): ¶

计算图的全局传递性（聚类系数）。

传递性度量了顶点的两个邻居连接的概率。更准确地说，这是图中三角形和连接的三元组的比率。结果是一个实数。有向图被视为无向图。

请注意，此度量标准与局部传递性度量标准（请参见 transitivity_local_undirected()）不同，因为它为整个图计算一个值。

参数
模式	如果`TRANSITIVITY_ZERO`之一或`"zero"（零）`，如果图中没有任何三元组，则结果将为零。如果`"nan"`之一或`TRANSITIVITY_NAN`，则结果将为`NaN`（非数字）。
返回值
传递性
参见
`transitivity_local_undirected()`, `transitivity_avglocal_undirected()`
未知字段：newfield
ref	参考
未知字段：ref
S. Wasserman 和 K. Faust：_社会网络分析：方法和应用_。剑桥：剑桥大学出版社，1994 年。

def Tree(n, children, type='undirected'): ¶

生成一棵几乎所有顶点都具有相同数量子节点的树。

参数
n	图中的顶点数
children	图中一个顶点的子节点数
类型	确定树是否应为有向图，如果是，则确定其方向。必须是以下之一`"in"`, `"out"`和`"undirected"`.

def Tree_Game(n, directed=False, method='lerw'): ¶

通过从具有给定数量节点的标记树集中均匀采样来生成随机树。

参数
n	树中的顶点数
有向	图是否应为有向图
method	要使用的生成方法。以下之一 `"prufer"`-- 统一采样 Prufer 序列，然后将其转换为树 `"lerw"`-- 在完整图上执行循环擦除的随机游走，以统一采样其生成树（威尔逊算法）。这是默认选择，因为它支持有向图和无向图。

def triad_census(): ¶

在 igraph.Graph 中重写

Davis 和 Leinhardt 定义的三元统计

计算三元组普查意味着对有向图中的每个顶点三元组进行分类。三元组可以处于 16 种状态之一，这些状态在 igraph 的 C 接口文档中列出。

未知字段：attention
此函数在 `Graph` 类中具有更方便的界面，该类将结果包装在 `TriadCensus` 对象中。建议使用它。三元组类的名称也记录在那里。

def unfold_tree(sources=None, mode='out'): ¶

通过使用 BFS 展开图到一棵树，必要时复制顶点。

参数
来源	要开始展开的源顶点。它应该是顶点索引的列表，最好是来自每个连接组件的一个顶点。您可以使用 `topological_sorting()` 来确定合适的集合。也接受单个顶点索引。
模式	在 BFS 期间要遵循哪些边。`输出`跟随输出边，`输入`跟随输入边，`全部`两者都跟随。对于无向图，将被忽略。
返回值
展开的树图以及从新顶点索引到旧顶点的映射。

def vcount(): ¶

计算顶点数。

返回值
整数	图中的顶点数。

def vertex_attributes(): ¶

返回值
图的顶点的属性名称列表

def vertex_connectivity(source=-1, target=-1, checks=True, neighbors='error'): ¶

计算图的顶点连通性或某些顶点之间的顶点连通性。

两个给定顶点之间的顶点连通度是为了将两个顶点断开连接到两个单独的组件中而必须删除的顶点数。这也是顶点之间顶点不相交的定向路径的数量（当然，除了源顶点和目标顶点）。图的顶点连通度是所有顶点对的最小顶点连通度。

如果给出源顶点和目标顶点，则此方法将计算给定顶点对的顶点连通度。如果未给出它们中的任何一个（或者它们都为负），则将返回总体顶点连通度。

参数
来源	计算中涉及的源顶点。
目标	计算中涉及的目标顶点。
检查	如果计算整个图的连通性，并且这是`True`，igraph 在计算之前执行一些基本检查。如果图不是强连通的，那么连通性显然为零。如果最小度为 1，那么连通性也为 1。这些简单检查比检查整个图快得多，因此建议将其设置为`True`。如果计算两个给定顶点之间的连通性，则忽略该参数。
neighbors	告诉 igraph 当两个顶点连接时该怎么办。`"error"`引发异常，`"infinity"（无穷大）`返回无穷大，`"ignore"`忽略边缘。
返回值
顶点连通度

def Watts_Strogatz(dim, size, nei, p, loops=False, multiple=False): ¶

参数
暗淡	晶格的尺寸
size	沿所有尺寸的晶格尺寸
内	值，给出两个顶点将被连接的距离（步数）。
p	重布线概率
循环	指定是否允许循环边
多个	指定是否允许多个边
参见
如果需要更大的灵活性，请参阅 `Lattice()`, `rewire()`, `rewire_edges()`
未知字段：newfield
ref	参考
未知字段：ref
Duncan J Watts 和 Steven H Strogatz：_小世界网络的集体动力学_，Nature 393, 440-442, 1998

def Weighted_Adjacency(matrix, mode='directed', attr='weight', loops=True): ¶

在 igraph.Graph 中重写

从其邻接矩阵生成一个图。

参数
矩阵	邻接矩阵
模式	要使用的模式。可能的值为 `"directed"`- 图将是有向图，并且矩阵元素给出两个顶点之间的边数。 `"undirected"`- 别名为`"max"`为方便起见。 `"max"`- 将创建无向图，并且顶点 i 和 j 之间的边数为 max(A(i, j), A(j, i)) `"min"`- 类似于`"max"`，但使用 min(A(i, j), A(j, i)) `"plus"`- 类似于`"max"`，但使用 A(i, j) + A(j, i) `"upper"`- 具有矩阵右上三角形（包括对角线）的无向图 `"lower"`- 具有矩阵左下三角形（包括对角线）的无向图
attr	存储边权重的边属性的名称。
循环	是否包含循环边。当`False`时，将忽略邻接矩阵的对角线。

def write_dimacs(f, source, target, capacity=None): ¶

在 igraph.Graph 中重写

以 DIMACS 格式将图写入给定的文件。

参数
f	要写入的文件的名称或 Python 文件句柄
来源	源顶点 ID
目标	目标顶点 ID
容量	列表中边的容量。如果它不是列表，则将使用相应的边属性来检索容量。

def write_dot(f): ¶

以 DOT 格式将图写入给定文件。

DOT 是 GraphViz 软件包使用的格式。

参数
f	要写入的文件的名称或 Python 文件句柄

def write_edgelist(f): ¶

将图的边列表写入文件。

有向边以（从，到）顺序编写。

参数
f	要写入的文件的名称或 Python 文件句柄

def write_gml(f, creator=None, ids=None): ¶

以 GML 格式将图写入给定文件。

参数
f	要写入的文件的名称或 Python 文件句柄
creator	要写入文件的可选创建者信息。如果`None`，则添加当前日期和时间。
ids	要在文件中使用的可选数字顶点 ID。这必须是整数列表或`None`返回与给定`None`，顶点的`id`属性将被使用，如果它们不存在，则会自动生成数字顶点 ID。

def write_graphml(f): ¶

将图写入 GraphML 文件。

参数
f	要写入的文件的名称或 Python 文件句柄

def write_leda(f, names='name', weights='weights'): ¶

以 LEDA 本机格式将图写入文件。

LEDA 格式最多支持每个顶点和边一个属性。您可以指定要使用的顶点和边属性。请注意，属性的名称未保存在 LEDA 文件中。

参数
f	要写入的文件的名称或 Python 文件句柄
names	要与顶点一起存储的顶点属性的名称。它通常用于存储顶点名称（因此是关键字参数的名称），但您也可以使用数字属性。如果您不想存储任何顶点属性，请提供`None`在这里。
weights	要与边一起存储的边属性的名称。它通常用于存储边权重（因此是关键字参数的名称），但您也可以使用字符串属性。如果您不想存储任何边属性，请提供`None`在这里。

def write_lgl(f, names='name', weights='weights', isolates=True): ¶

以 .lgl 格式将图的边列表写入文件。

请注意，多个边和/或循环会破坏 LGL 软件，但 igraph 不会检查此条件。除非您知道该图没有多个边和/或循环，否则最好在保存之前调用 simplify()。

参数
f	要写入的文件的名称或 Python 文件句柄
names	包含顶点名称的顶点属性的名称。如果您不想存储顶点名称，请提供`None`在这里。
weights	包含顶点权重的边属性的名称。如果您不想存储权重，请提供`None`在这里。
isolates	是否在输出中包含孤立顶点。

def write_ncol(f, names='name', weights='weights'): ¶

以 .ncol 格式将图的边列表写入文件。

请注意，多个边和/或循环会破坏 LGL 软件，但 igraph 不会检查此条件。除非您知道该图没有多个边和/或循环，否则最好在保存之前调用 simplify()。

参数
f	要写入的文件的名称或 Python 文件句柄
names	包含顶点名称的顶点属性的名称。如果您不想存储顶点名称，请提供`None`在这里。
weights	包含顶点权重的边属性的名称。如果您不想存储权重，请提供`None`在这里。

def write_pajek(f): ¶

以 Pajek 格式将图写入给定文件。

参数
f	要写入的文件的名称或 Python 文件句柄

def __graph_as_capsule(...): ¶

__graph_as_capsule()

返回由 Python 对象封装的 igraph 图作为 PyCapsule

。PyCapsule 实际上是一个常规 C 指针，包装在 Python 对象中。igraph 用户不应直接使用此函数，仅在必须通过 Python 将底层 igraph 对象传递给其他 C 代码时才有用。

def __register_destructor(destructor): ¶

注册一个析构函数，以便在 Python 释放对象时调用。igraph 用户不应直接使用此函数。

def _Bipartite(types, edges, directed=False): ¶

内部函数，无文档。

参见
Graph.Bipartite()

def _Full_Bipartite(n1, n2, directed=False, loops=False): ¶

内部函数，无文档。

参见
Graph.Full_Bipartite()

def _get_all_simple_paths(v, to=None, cutoff=-1, mode='out'): ¶

内部函数，无文档。

参见
Graph.get_all_simple_paths()

def _GRG(n, radius, torus=False): ¶

内部函数，无文档。

参见
Graph.GRG()

def _Incidence(matrix, directed=False, mode='all', multiple=False): ¶

内部函数，无文档。

参见
Graph.Incidence()

def _is_matching(matching, types=None): ¶

内部函数，无文档。

def _is_maximal_matching(matching, types=None): ¶

内部函数，无文档。

请改用 igraph.Matching.is_maximal。

def _layout_sugiyama(...): ¶

内部函数，无文档。

参见
Graph.layout_sugiyama()

def _maximum_bipartite_matching(types, weights=None): ¶

内部函数，无文档。

参见
`igraph.Graph.maximum_bipartite_matching`

def _Random_Bipartite(n1, n2, p=None, m=None, directed=False, neimode='all'): ¶

内部函数，无文档。

参见
Graph.Random_Bipartite()

def _raw_pointer(): ¶

以普通 Python 整数形式返回 Python 对象封装的 igraph 图的内存地址。

igraph 用户不应直接使用此函数，仅当您想使用 ctypes 模块访问 igraph C 核心中的某些未包装函数时才有用。

def _spanning_tree(weights=None): ¶

内部函数，无文档。

参见
Graph.spanning_tree()

igraph._igraph.GraphBase

`igraph._igraph.GraphBase`