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`	返回使图成为弦图需要添加到图中的边的列表。
方法	`clique_number`	返回图的团数。
方法	`cliques`	返回图的一些或所有团，作为元组列表。
方法	`closeness`	计算图中给定顶点的接近度中心性。
方法	`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`	返回两个图的组合。
方法	`connected_components`	计算给定图的（强或弱）连通分量。
方法	`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`	从原始图中减去给定的图
方法	`distances`	计算图中给定顶点的最短路径长度。
方法	`diversity`	计算顶点的结构多样性指数。
方法	`dominator`	从给定根节点返回支配树
方法	`dyad_census`	Dyad 人口普查，由 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`	生成一个完整的引用图
方法	`fundamental_cycles`	查找图的单个基本循环基
方法	`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_acyclic`	返回图是否是非循环的（即不包含循环）。
方法	`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`	计算图的星形布局。
方法	`layout_umap`	无摘要
方法	`LCF`	从 LCF 表示法生成图。
方法	`linegraph`	返回图的线图。
方法	`list_triangles`	列出图的三角形
方法	`maxdegree`	返回图中顶点集的最大度数。
方法	`maxflow`	返回源顶点和目标顶点之间的最大流。
方法	`maxflow_value`	返回源顶点和目标顶点之间的最大流的值。
方法	`maximal_cliques`	返回图的最大团，作为元组列表。
方法	`maximal_independent_vertex_sets`	返回图的最大独立顶点集，作为元组列表。
方法	`maximum_cardinality_search`	在图上进行最大基数搜索。该函数为每个顶点计算一个秩 alpha，使得以降序秩顺序访问顶点对应于始终选择具有最多已访问邻居的顶点作为下一个要访问的顶点。
方法	`mincut`	计算源顶点和目标顶点之间或整个图中的最小割。
方法	`mincut_value`	返回源顶点和目标顶点之间或整个图中的最小割。
方法	`minimum_cycle_basis`	计算图的最小循环基
方法	`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 格式的文件并基于它创建图。仅支持 Pajek 网络文件（.net 扩展名），不支持项目文件（.paj）。
方法	`Realize_Degree_Sequence`	从度数序列生成图。
方法	`Recent_Degree`	基于随机模型生成图，其中边获得新节点的概率与给定时间窗口中获得的边成正比。
方法	`reciprocity`	互易性定义了有向图中相互连接的比例。它最常定义为有向边的相反对应物也包含在图中的概率...
方法	`reverse_edges`	反转图中某些边的方向。
方法	`rewire`	随机重新连接图，同时保留度数分布。
方法	`rewire_edges`	以恒定概率重新连接图的边。
方法	`Ring`	生成一个环图。
方法	`SBM`	基于随机块模型生成图。
方法	`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`	Triad 人口普查，由 Davis 和 Leinhardt 定义
方法	`unfold_tree`	通过使用 BFS 展开图到一棵树，必要时复制顶点。
方法	`vcount`	计算顶点数。
方法	`vertex_attributes`	无摘要
方法	`vertex_connectivity`	计算图的顶点连通性或某些顶点之间的顶点连通性。
方法	`Watts_Strogatz`	无摘要
方法	`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`	返回由 Python 对象封装的 igraph 图作为 PyCapsule
方法	`__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`	内部函数，无文档。
方法	`_Weighted_Adjacency`	从其邻接矩阵生成一个图。

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', loops='once'): ¶

在 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"`- 具有矩阵左下三角形（包括对角线）的无向图
循环	指定应如何处理矩阵的对角线 `"ignore"`- 忽略对角线中的循环边 `"once"`- 将对角线条目视为循环边计数 `"twice"`- 将对角线条目视为循环边数的两倍

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 的边，则返回 True`False`否则。

def articulation_points(): ¶

返回图中铰接点的列表。

如果移除顶点会增加图中连通分量的数量，则该顶点是铰接点。

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

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

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

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

参数
types1	列表中的顶点类型或保存顶点类型的顶点属性的名称。理想情况下，类型用数值表示。
types2	在有向 assortativity 计算中，每个顶点都可以具有出类型和入类型。在这种情况下，types1 包含出类型，此参数包含列表或顶点属性名称中的入类型。如果`None`，则假定它等于 types1。
有向	是否考虑边方向。
normalized	是否计算归一化协方差，即 Pearson 相关性。在此处提供 True 以计算标准 assortativity。
返回值
assortativity 系数
参见
当类型是顶点度时，请使用 `assortativity_degree()`
未知字段：newfield
ref	参考
未知字段：ref
Newman MEJ：Networks 中的混合模式，Phys Rev E 67:026126, 2003。
Newman MEJ：Networks 中的 assortative 混合，Phys Rev Lett 89:208701,

def assortativity_degree(directed=True): ¶

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

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

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

def assortativity_nominal(types, directed=True, normalized=True): ¶

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

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

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

参数
types	列表中的顶点类型或保存顶点类型的顶点属性的名称。类型应由数值表示。
有向	是否考虑边方向。
normalized	是否计算（通常的）归一化 assortativity。未归一化的版本与模块化相同。在此处提供 True 以计算标准 assortativity。
返回值
assortativity 系数
未知字段：newfield
ref	参考
未知字段：ref
Newman MEJ：Networks 中的混合模式，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 编写的图谱，牛津大学出版社，1998 年。

def attributes(): ¶

返回值
图的属性名称列表

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

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

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

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

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

参数
有向	在有向图中是否考虑有向路径。对于无向图，此参数将被忽略。
unconn	当图未连接时该怎么办。如果`True`，则计算组件中测地线长度的平均值。否则，对于所有未连接的顶点对，将使用等于顶点数的路径长度。
weights	要使用的边权重。可以是序列或可迭代对象，甚至可以是边属性名称。
返回值
图中的平均路径长度

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"`：0.6 之前的 igraph 中的默认算法。它的工作原理是将顶点的 ID 放入一个包（多集）中，次数正好等于它们的入度，再加上一次。然后从包中抽取所需数量的被引用顶点进行替换。它仅适用于 power=1 和 zero_appeal=1。 `"psumtree"`：此算法使用部分前缀和树来生成图。它不会生成多条边，并且适用于 power 和 zero_appeal 的任何值。 `"psumtree_multiple"`：类似于`"psumtree"`，但它也会生成多条边。0.6 之前的 igraph 对 1 以外的 power 使用此算法。
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	必须返回 betweenness 的顶点。如果`None`，则假定图中的所有顶点。
有向	是否考虑有向路径。
cutoff	如果它是一个整数，则仅考虑小于或等于此长度的路径，从而有效地估计给定顶点的 betweenness。如果`None`，则返回确切的 betweenness。
weights	要使用的边权重。可以是序列或可迭代对象，甚至可以是边属性名称。
返回值
列表中给定顶点的（可能估计的）betweenness

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 树中的父级。
返回值
作为 `igraph.BFSIter` 对象的 BFS 迭代器。

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(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 cocitation(vertices=None): ¶

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

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

def cohesive_blocks(): ¶

计算图的凝聚块结构。

未知字段：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。美国 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 and 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。

参数
边_权重	边属性的名称或包含边权重的列表。
顶点_权重	顶点属性的名称或包含顶点权重的列表。
试验	对网络进行分区的尝试次数。
返回值
元组中计算出的成员向量和相应的代码长度。
未知字段：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	边属性的名称或包含边权重的列表
初始	顶点属性的名称或包含初始顶点标签的列表。标签由从零到n − 1的整数标识，其中n是顶点的数量。此向量中也可能存在负数，它们表示未标记的顶点。
固定	每个顶点的布尔值列表。`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	用于微调 ARPACK 特征向量计算的 `ARPACKOptions` 对象。如果省略，将使用名为`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 算法查找图的社区结构。

参数
边_权重	要使用的边权重。可以是序列或可迭代对象，甚至可以是边属性名称。
节点_权重	Leiden算法中使用的节点权重。
分辨率_参数	要使用的分辨率参数。较高的分辨率会导致更多较小的社区，而较低的分辨率会导致较少较大的社区。
规范化_分辨率	如果设置为true，则分辨率参数将除以节点权重的总和。如果未提供此参数，则默认设置为节点度，或者如果提供了edge_weights，则设置为加权度。
贝塔	影响 Leiden 算法中随机性的参数。这仅影响算法的优化步骤。
初始_成员身份	如果提供，Leiden 算法将尝试改进此提供的成员资格。如果没有提供参数，则算法只从单例分区开始。
n_迭代	迭代Leiden算法的迭代次数。每次迭代都可能进一步改进分区。您也可以将此参数设置为负数，这意味着该算法将迭代直到迭代不再更改当前成员向量。
返回值
社区成员向量。

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

在 igraph.Graph 中重写

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

参数
weights	边属性的名称或包含边权重的列表
返回_级别	如果`True`，则返回多层结果。如果`False`，则仅返回最佳级别（对应于最佳模块化）。
分辨率	在模块化度量中使用的分辨率参数。较小的值会导致较少数量的较大聚类，而较大的值会导致大量的小聚类。经典模块化度量假设分辨率参数为 1。
返回值
描述每个顶点的社区成员身份的单个列表（如果`返回_级别`是`False`），或社区成员向量的列表，一个对应于每个级别，以及对应模块化的列表（如果`返回_级别`是`True`).
参见
modularity()
未知字段：attention
此函数在派生类`Graph`中以更方便的语法包装。建议使用该版本代替此版本。
未知字段：newfield
ref	参考
未知字段：ref
VD Blondel, J-L Guillaume, R Lambiotte and 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	要使用的边权重。可以是序列或可迭代对象，甚至可以是边属性名称。
自旋	整数，要使用的自旋数。这是社区数的上限。在这里提供（合理）大的数字没有问题，在这种情况下，某些自旋状态将不会被填充。
并行更新	是否并行（同步）更新顶点的自旋
开始_温度	起始温度
停止_温度	停止温度
冷却_系数	模拟退火的冷却因子
更新_规则	指定模拟的零模型。可能的值为`"config"`（具有与输入图相同的顶点度的随机图）或`"simple"`（具有相同数量边的随机图）
伽玛	算法的 gamma 参数，指定社区内存在边和缺失边之间的重要性平衡。默认值 1.0 为两者分配相同的重要性。
implementation	目前，igraph 包含 spinglass 社区检测算法的两种实现。更快的原始实现是默认设置。另一种实现能够考虑负权重，可以通过设置`implementation`到`"neg"`.
lambda_	该算法的 lambda 参数，指定社区内存在和缺失的负加权边之间的平衡。lambda 的较小值会导致负内部连接较少的社区。如果参数为零，则该算法会简化为图着色算法，使用自旋数作为颜色。如果使用原始实现，则会忽略此参数。
返回值
社区成员向量。

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

在 igraph.Graph 中重写

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

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

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

def complementer(loops=False): ¶

返回图的补图

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

def compose(other): ¶

返回两个图的组合。

def connected_components(mode='strong'): ¶

计算给定图的（强或弱）连通分量。

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

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

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

如果自我拥有的联系人较少或相互之间关系更紧密（即更冗余），则Burt的约束较高。Burt的约束度量C[i]定义为顶点i的自我网络V[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): ¶

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

参数
映射	数字向量，给出旧顶点 ID 和新顶点 ID 之间的映射。在此向量中具有相同新顶点 ID 的顶点将被重新映射到单个新顶点中。可以安全地在此处传递`VertexClustering`对象的成员向量。
组合_属性	指定如何组合折叠为单个顶点的顶点的属性。如果是`None`，则所有属性都将丢失。如果它是一个函数，则将收集顶点的属性并传递给该函数，该函数将返回必须分配给单个折叠顶点的新属性值。它也可以是以下字符串常量之一，这些常量定义了内置的折叠函数`总和`, `产品`, `平均值`, `中位数`, `max`, `min`, `第一`, `最后`, `随机`。您还可以通过传递将属性名称映射到函数的字典，为不同的属性指定不同的组合函数。有关更多详细信息，请参见`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): ¶

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

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

参数
其他	另一个图。如果`None`，则将返回自同构的数量。
颜色 1	可选向量，用于存储第一个图的顶点的着色。如果`None`，则所有顶点都具有相同的颜色。
颜色 2	可选向量，用于存储第二个图的顶点的着色。如果`None`，则所有顶点都具有相同的颜色。
边_颜色 1	可选向量，用于存储第一个图的边的着色。如果`None`，则所有边都具有相同的颜色。
边_颜色 2	可选向量，用于存储第二个图的边的着色。如果`None`，则所有边都具有相同的颜色。
节点_兼容_fn	一个函数，接收两个图和两个节点索引（一个来自第一个图，一个来自第二个图），并返回`True`如果由两个索引给出的节点兼容（即，它们可以相互匹配），则返回，否则返回`False`。这可以用于基于节点特定的标准来限制同构集，这些标准太复杂而无法由节点颜色向量表示（即`颜色 1`和`颜色 2`参数）。`None`意味着每个节点都与每个其他节点兼容。
边_兼容_fn	一个函数，接收两个图和两个边索引（一个来自第一个图，一个来自第二个图），并返回`True`如果由两个索引给出的边兼容（即，它们可以相互匹配），则返回，否则返回`False`。这可以用于基于边特定的标准来限制同构集，这些标准太复杂而无法由边颜色向量表示（即`边_颜色 1`和`边_颜色 2`参数）。`None`）参数。意味着每条边都与每个其他节点兼容。
返回值
两个给定图之间的同构数量（或自同构数量，如果`其他`是`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): ¶

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

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

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

def De_Bruijn(m, n): ¶

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

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

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

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

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

将图分解为子图。

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

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

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

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

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

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

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

参数
出	有向图的出度序列。如果省略了入度序列，则生成的图将是无向的，因此这也将是入度序列
入_	有向图的入度序列。如果省略，则生成的图将是无向的。
方法	要使用的生成方法。以下之一 `"configuration"`-- 实现存根匹配配置模型的简单生成器。它可能会生成自环和多条边。此方法不均匀地采样多重图，但可以通过拒绝任何非简单的结果（即包含环或多条边）来用于实现简单图的均匀采样。 `"fast_heur_simple"`-- 类似于`"configuration"`，但避免了生成多条边和环边，代价是增加了时间复杂度。该方法将在每次卡在无法插入更多边而不创建环或多条边的配置中时重新启动生成，并且对迭代次数没有上限，但如果输入度序列是图形化的，则最终会成功，如果输入度序列不是图形化的，则会引发异常。此方法不均匀地采样简单图。 `"configuration_simple"`-- 类似于`"configuration"`，但如果生成的图不是简单的，则拒绝它们。此方法均匀地采样简单图。 `"edge_switching_simple"`-- 基于保留度的边交换的 MCMC 采样器。它生成简单的无向或有向图。该算法使用`Graph.Realize_Degree_Sequence()`构造初始图，然后使用`Graph.rewire()`重新连接它。 `"vl"`-- 一种更复杂的生成器，可以近似均匀地采样无向、连接的简单图。它使用边交换蒙特卡罗方法来随机化图。如果要生成无向和连接的图，并且执行时间不是问题，则应首选此生成器。igraph 使用 Fabien Viger 的原始实现；有关算法的详细信息，请参见以下 URL 和其中引用的论文：https://www-complexnetworks.lip6.fr/~latapy/FV/generation.html。 igraph 0.10 之前有效的旧名称也受支持，但可能会在不另行通知的情况下删除 `"simple"`-- 等效于`"configuration"` - `"no_multiple"`-- 等效于`"fast_heur_simple"` - `"no_multiple_uniform"`-- 等效于`"configuration_simple"`

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 distances(source=None, target=None, weights=None, mode='out'): ¶

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

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

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

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

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

顶点的结构多样性指数只是入射到顶点上的边的权重的（归一化）香农熵。

该度量仅为无向图定义；忽略边方向。

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

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

从给定根节点返回支配树

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

def dyad_census(): ¶

在 igraph.Graph 中重写

Dyad 人口普查，由 Holland 和 Leinhardt 定义

Dyad 人口普查意味着将有向图的每对顶点分为三个类别：互惠，从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	每步尝试的连接数
类型_dist	给出了顶点类型分布的列表
pref_matrix	一个矩阵（列表的列表），给出了不同顶点类型的连接概率
有向	是否生成有向图。

def Famous(name): ¶

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

几个著名的图在igraph中是已知的，包括（但不限于）Chvatal 图、Petersen 图或 Tutte 图。此方法基于其名称（不区分大小写）生成其中一个。请参阅igraph的 C 接口的文档，了解可用的名称：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	要使用的边权重。可以是序列或可迭代对象，甚至可以是边属性名称。给出时，算法将努力删除轻量级边，以尽量减少反馈弧集的总权重。
方法	要使用的算法。`"eades"`使用 Eades、Lin 和 Smyth 的贪婪循环中断启发式算法，该算法在边数上是线性的，但不一定是最佳的；但是，它可以保证要删除的边数小于 \|E\|/2 - \|V\|/6。`"ip"`使用整数规划公式，保证产生最佳结果，但对于大型图来说太慢。
返回值
要删除的边的 ID，以列表形式。
未知字段：newfield
ref	参考
未知字段：ref
Eades P, Lin X and Smyth WF: A fast and effective heuristic for the feedback arc set problem. 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 fundamental_cycles(start_vid=None, cutoff=None): ¶

查找图的单个基本循环基

参数
开始_vid	当`None`或负数时，返回一个完整的基本环基。当它是一个顶点或顶点 ID 时，将返回与以该顶点为根的 BFS 树相关联的基本环，仅适用于包含该顶点的弱连通分量
cutoff	当`None`或负数时，返回一个完整的环基。否则，BFS 将在此步骤之后停止，因此结果将仅有效地包括长度为 2*cutoff + 1 或更短的环。
返回值
环基，表示为包含边 ID 的元组列表

def get_adjacency(type='both', loops='twice'): ¶

在 igraph.Graph 中重写

返回图的邻接矩阵。

参数
类型	之一`"lower"`（使用矩阵的下三角），`"upper"`（使用上三角）或`"both"`（使用两个部分）。对于有向图将被忽略。
循环	指定如何处理环边。`False`之一或`"ignore"`忽略环边。`"once"`在对角线上计算每个环边一次。`"twice"`计算每个环边两次（即，它计算环边的端点，而不是边本身）。
返回值
邻接矩阵。

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。

此方法可以在两种不同的模式下运行，具体取决于给出了哪个关键字参数对和路径。

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

参数
对	整数对的列表。每个整数对都被视为一个源-目标顶点对；在图中查找相应的边，并返回每对的边 ID。
路径	顶点 ID 的列表。该列表被视为从第一个顶点到最后一个顶点的连续路径，途经中间顶点。查找图中第一个和第二个顶点之间、第二个和第三个顶点之间等等的相应边 ID，并返回边 ID。如果同时给出了`路径`和`对`，则将两个列表连接起来。
有向	是否应在有向图中考虑边的方向。默认为`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): ¶

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

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

参数
其他	另一个图。如果`None`，则将返回自同构。
颜色 1	可选向量，用于存储第一个图的顶点的着色。如果`None`，则所有顶点都具有相同的颜色。
颜色 2	可选向量，用于存储第二个图的顶点的着色。如果`None`，则所有顶点都具有相同的颜色。
边_颜色 1	可选向量，用于存储第一个图的边的着色。如果`None`，则所有边都具有相同的颜色。
边_颜色 2	可选向量，用于存储第二个图的边的着色。如果`None`，则所有边都具有相同的颜色。
节点_兼容_fn	一个函数，接收两个图和两个节点索引（一个来自第一个图，一个来自第二个图），并返回`True`如果由两个索引给出的节点兼容（即，它们可以相互匹配），则返回，否则返回`False`。这可以用于基于节点特定的标准来限制同构集，这些标准太复杂而无法由节点颜色向量表示（即`颜色 1`和`颜色 2`参数）。`None`意味着每个节点都与每个其他节点兼容。
边_兼容_fn	一个函数，接收两个图和两个边索引（一个来自第一个图，一个来自第二个图），并返回`True`如果由两个索引给出的边兼容（即，它们可以相互匹配），则返回，否则返回`False`。这可以用于基于边特定的标准来限制同构集，这些标准太复杂而无法由边颜色向量表示（即`边_颜色 1`和`边_颜色 2`参数）。`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 算法返回图与另一个图之间的所有子同构。

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

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

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

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

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

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

def girth(return_shortest_circle=False): ¶

返回图的 girth。

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

参数
返回_最短_圈	是否返回图中找到的最短圈之一。
返回值
最短圈的长度，或者（如果`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	用于微调 ARPACK 特征向量计算的 `ARPACKOptions` 对象。如果省略，将使用名为`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_acyclic(): ¶

返回图是否是非循环的（即不包含循环）。

返回值
布尔值	`True`如果图是无环的，则为`False`否则。

def is_bipartite(return_types=False): ¶

确定图是否为二分图。

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

参数
返回_类型	如果`False`，该方法只会返回`True`之一或`False`，具体取决于图是否为二分图。如果`True`，实际的组分配也将作为布尔值列表返回。（请注意，组分配不是唯一的，特别是如果图由多个组件组成，因为组件的分配彼此独立）。
返回值
`True`如果图是二分图，则为`False`，否则为`。如果`是`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, loops=True): ¶

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

也适用于一组边 - 在这种情况下，逐一检查每条边。结果将是布尔值列表（或者如果只提供一个边索引，则为单个布尔值），每个布尔值对应于提供的边集中的一条边。True如果原始图中存在另一条边 b --> a（不是给定的边集！），则为给定的边 a --> b 返回。无向图中的所有边都是互连的。如果在 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。

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

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 同构算法检查图是否与另一个图同构。

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

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

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='unnormalized', mode='out'): ¶

返回图的拉普拉斯矩阵。

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

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

左归一化和右归一化拉普拉斯矩阵是通过缩放行或列总和以等于 1 从非归一化拉普拉斯矩阵导出的。

参数
weights	要使用的边权重。可以是序列或可迭代对象，甚至是边属性名称。当使用边权重时，节点的度数被认为是其入射边的权重的总和。
normalized	是否返回归一化拉普拉斯矩阵。`False`之一或`"未归一化"`返回未归一化拉普拉斯矩阵。`True`之一或`"对称"`返回拉普拉斯矩阵的对称归一化。`"左"`返回左-，`"右"`返回右归一化拉普拉斯矩阵。
模式	对于有向图，指定在拉普拉斯矩阵中使用出度还是入度。`"all"`表示必须忽略边的方向，`"out"`表示应使用出度，`"in"`表示应使用入度。对于无向图，将被忽略。
返回值
拉普拉斯矩阵。

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): ¶

生成一个规则晶格。

参数
dim	具有晶格维度的列表
nei	给出一个距离（步数）的值，在该距离内两个顶点将被连接。
有向	是否创建有向图。
相互的	在有向图的情况下，是否将所有连接创建为相互连接。
循环	生成的晶格是否是周期性的。也可以是可迭代的；在这种情况下，假定迭代器产生布尔值，这些布尔值指定晶格是否沿每个维度是周期性的。

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

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

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

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

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

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

参数
dim	布局所需的维数。dim=2 表示 2D 布局，dim=3 表示 3D 布局。
顺序	顶点沿圆放置的顺序。当 dim 不等于 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`，为算法使用随机起始布局。如果是一个矩阵（列表的列表），则使用给定的矩阵作为起始位置。
maxiter	在退火阶段执行的迭代次数。
fineiter	在微调阶段执行的迭代次数。负数从顶点计数的以 2 为底的对数设置合理的默认值，上限为 10。
冷却_系数	模拟退火阶段的冷却系数。
权重_节点_dist	能量函数中节点间距离的权重。
权重_边框	能量函数的边框组件的距离权重。零表示允许顶点位于为布局指定的区域的边框上。
权重_边_长度	能量函数的边长组件的权重。负数将替换为图的密度除以 10。
权重_边_交叉	能量函数的边交叉组件的权重。负数将替换为 1 减去图密度的平方根。
权重_节点_边_dist	能量函数的节点-边距离组件的权重。负数将替换为 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	要使用的边权重。可以是序列或可迭代对象，甚至可以是边属性名称。
固定	已忽略。我们过去常常假设 DrL 布局支持固定节点，但后来发现该参数在原始 DrL 代码中不起作用。为了向后兼容，我们保留了该参数，但它对最终布局没有影响。
种子	如果`None`，为算法使用随机起始布局。如果是一个矩阵（列表的列表），则使用给定的矩阵作为起始位置。
选项	如果你在这里给出一个字符串参数，你可以从五个默认预设参数化中进行选择`默认`, `粗化`用于更粗糙的布局，`最粗糙`用于更粗糙的布局，`细化`用于细化现有布局，以及`最终`用于最终确定布局。如果你提供一个不是字符串的对象，则 DrL 布局参数将从该对象的相应键中检索（因此它应该是一个字典或其他支持映射协议的对象）。可以使用以下键 `edge_cut`：在算法的后期阶段进行边切割，以实现更稀疏的布局。如果边承受很大的压力（目标函数总和中的一个大值），则会切割边。边切割参数是一个介于 0 和 1 之间的值，其中 0 表示不进行边切割，1 表示最大边切割。 `init_iterations`：初始化阶段的迭代次数 `init_temperature`：初始化期间的起始温度 `init_attraction`：初始化期间的吸引力 `init_damping_mult`：初始化期间的阻尼乘数 `liquid_iterations`, `液态温度`, `液态吸引力`, `液态阻尼_多`：液相的相同参数 `膨胀_迭代`, `膨胀温度`, `膨胀吸引力`, `膨胀阻尼_多`：膨胀阶段的参数 `冷却_...`：冷却阶段的参数 `脆_...`：紧缩阶段的参数 `文火_...`：文火阶段的参数除了映射，你也可以在这里使用任意 Python 对象：如果该对象不支持映射协议，则将查找具有相同名称的对象的属性。如果找不到参数作为键或属性，则将使用`默认`预设中的默认值。
dim	布局所需的维数。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。软件 -- 实践与经验，21/11, 1129--1164, 1991

参数
weights	要使用的边权重。可以是序列或可迭代对象，甚至可以是边属性名称。
niter	要执行的迭代次数。默认为 500。
种子	如果`None`，为算法使用随机起始布局。如果是一个矩阵（列表的列表），则使用给定的矩阵作为起始位置。
开始_温度	实标量，起始温度。这是在一个步骤中，顶点沿一个轴允许的最大移动量。目前，它在线性减少到零的迭代过程中。默认值为顶点数的平方根除以 10。
minx	如果不是`None`，它必须是一个向量，其元素数量与图中的顶点数完全相同。每个元素都是对布局中顶点的 X 值的最小约束。
maxx	类似于 minx，但具有最大约束
miny	类似于 minx，但具有 Y 坐标
maxy	类似于 maxx，但具有 Y 坐标
minz	类似于 minx，但具有 Z 坐标。仅用于 3D 布局（`dim`=3).
maxz	类似于 maxx，但具有 Z 坐标。仅用于 3D 布局（`dim`=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/。

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

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

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

参数
宽度	布局中单行中的顶点数。零或负数表示应自动确定宽度。
高度	布局中单列中的顶点数。零或负数表示应自动确定高度。如果维数为 2，则不能给定。
dim	布局所需的维数。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。信息处理快报，31/1, 7--15, 1989。

参数
maxiter	要执行的最大迭代次数。
epsilon	如果系统能量的变化小于 epsilon，则退出。有关详细信息，请参见原始论文。
kkconst	Kamada-Kawai 顶点吸引常数。`None`表示顶点数的平方。
种子	如果`None`，为算法使用随机起始布局。如果是一个矩阵（列表的列表），则使用给定的矩阵作为起始位置。
minx	如果不是`None`，它必须是一个向量，其元素数量与图中的顶点数完全相同。每个元素都是对布局中顶点的 X 值的最小约束。
maxx	类似于 minx，但具有最大约束
miny	类似于 minx，但具有 Y 坐标
maxy	类似于 maxx，但具有 Y 坐标
minz	类似于 minx，但具有 Z 坐标。仅用于 3D 布局（`dim`=3).
maxz	类似于 maxx，但具有 Z 坐标。仅用于 3D 布局（`dim`=3).
dim	布局所需的维数。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 平面上。

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

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

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

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

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

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

def layout_random(dim=2): ¶

随机放置图的顶点。

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

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

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

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

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

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

计算图的星形布局。

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

def layout_umap(dist=None, dim=2, seed=None, min_dist=0.01, epochs=500, sampling_prob=0.3): ¶

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 list_triangles(): ¶

列出图的三角形

返回值
图中三角形的列表；每个三角形由长度为 3 的元组表示，其中包含相应的顶点 ID。

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 算法。对于给定的源和目标，该方法使用 push-relabel 算法；请参见下面的参考。

参数
来源	源顶点 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_cycle_basis(cutoff=None, complete=True, use_cycle_order=True): ¶

计算图的最小循环基

参数
cutoff	当`None`或负数，将返回一个完整的最小循环基。否则，结果中只有那些属于长度为 2*cutoff + 1 或更短的最小循环基的循环。长于此限制的循环可能不是最小的可能大小。此参数有效地限制了在计算候选循环时 BFS 树的深度，并且可以大大加快计算速度。
完成	仅当指定截止时使用，并且在这种情况下，它指定是返回完整的基（`True`），还是结果将仅限于长度为 2*cutoff + 1 或更短的循环。这限制了计算时间，但结果可能无法跨越整个循环空间。
使用_循环_顺序	如果`True`，每个循环都以自然顺序返回：边 ID 将沿循环有序显示。如果是`False`，则不保证循环中边 ID 的顺序。
返回值
环基，表示为包含边 ID 的元组列表

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 和抄送是两个顶点（i 和 j）的类型，gamma 是分辨率参数，对于模块化的经典定义，默认为 1。delta(x, y) 当且仅当 x = y 时为 1，否则为 0。

如果给出边权重，则模块化的定义修改如下：Aij 变为对应边的权重，ki 是事件发生在顶点 i 上的边的总权重，kj 是事件发生在顶点 j 上的边的总权重，m 是图中边的总权重。

参数
会员	成员向量，例如，每个顶点的顶点类型索引。
weights	可选的边权重或`None`如果所有边的权重相等。
分辨率	上面公式中的分辨率参数 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	搜索树不同级别的 cut 概率。这必须是长度为 size 的列表，或者`None`以查找所有 motif。
回调	`None`或一个可调用对象，它将为图中找到的每个 motif 调用。可调用对象必须接受三个参数：图本身、motif 中的顶点列表和 motif 的同构类（请参阅 `isoclass()`）。当回调返回具有非零真值的对象或引发异常时，搜索将停止。
返回值
如果 callback 是，则为 motif 列表`None`，或者`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	搜索树不同级别的 cut 概率。这必须是长度为 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	搜索树不同级别的 cut 概率。这必须是长度为 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	用于微调 ARPACK 特征向量计算的 `ARPACKOptions` 对象。如果省略，将使用名为`arpack_options`使用。如果未使用 ARPACK 实现，则忽略此参数，请参阅 implementation 参数。
implementation	用于解决 PageRank 特征问题的实现方式。可能的值包括 `"prpack"`：使用 PRPACK 库。这是 igraph 0.7 中的一个新实现 `"arpack"`：使用 ARPACK 库。此实现从 0.5 版本一直使用到 0.7 版本。
niter	未使用，为了向后兼容而保留。它将在 igraph 0.10 中删除。
eps	未使用，为了向后兼容而保留。它将在 igraph 0.10 中删除。
返回值
具有指定顶点的个性化 PageRank 值的列表。

def predecessors(vertex): ¶

返回给定顶点的前身。

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

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

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

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

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

def radius(mode='out'): ¶

计算图的半径。

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

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

def random_walk(start, steps, mode='out', stuck='return', weights=None, return_type='vertices'): ¶

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

参数
开始	游走的起始顶点
步骤	随机游走应采取的步数
模式	是否仅遵循出站边（`"out"`），仅遵循入站边（`"in"`）或两者（`"all"`）。无向图忽略。@param stuck：当随机游走卡住时该怎么办。`"return"`返回部分随机游走；`"error"`抛出异常。
stuck	未归档
weights	要使用的边权重。可以是序列或可迭代对象，甚至可以是边属性名称。
return_type	返回什么。它可以是`"vertices"`（默认），然后该函数返回访问的顶点 ID 列表；`"edges"`，然后该函数返回访问的边 ID 列表；或者`"both"`，然后该函数返回带有键的字典`"vertices"`和`"edges"`.
返回值
从给定顶点开始并且最多具有给定长度的随机游走（如果随机游走卡住，则更短）。

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 格式的文件并基于它创建图。仅支持 Pajek 网络文件（.net 扩展名），不支持项目文件（.paj）。

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

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

从度数序列生成图。

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

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

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 reverse_edges(es): ¶

反转图中某些边的方向。

此函数对于无向图是空操作。

参数
es	要反转的边列表。边通过边 ID 标识。此处也接受 `EdgeSeq` 对象。省略时，将反转所有边。

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 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))，因为总和被识别为 Python 内置函数和字符串常量。

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

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

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

参数
来源	源顶点 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): ¶

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

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

参数
其他	我们在图中寻找的模式图。
域	列表的列表，一个子列表属于模板图中的每个顶点。子列表 i 包含原始图中可能匹配模板图中顶点 i 的顶点的索引。`None`意味着每个顶点都可以匹配其他每个顶点。
导出的	是否仅考虑导出的子图。
时间_限制	最佳时间限制，以秒为单位。仅考虑此数字的整数部分。如果超过时间限制，该方法将引发异常。
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): ¶

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

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

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

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
D. J. 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	树中的顶点数
有向	该图是否应该是有向图
方法	要使用的生成方法。以下之一 `"prufer"`-- 均匀地采样 Prufer 序列，然后将它们转换为树 `"lerw"`-- 在完整图上执行循环擦除的随机游走以均匀地采样其生成树（Wilson 算法）。这是默认选择，因为它支持有向图和无向图。

def triad_census(): ¶

在 igraph.Graph 中重写

Triad 人口普查，由 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): ¶

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

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): ¶

将图的边列表写入文件。

有向边按（from，to）顺序写入。

参数
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(): ¶

返回由 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()

def _Weighted_Adjacency(matrix, mode='directed', loops='once'): ¶

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

参数
矩阵	邻接矩阵
模式	要使用的模式。可能的值为 `"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"`- 具有矩阵左下三角形（包括对角线）的无向图
循环	指定如何处理环边。当`False`之一或`"ignore"`时，将忽略邻接矩阵的对角线。当`True`之一或`"once"`时，假定对角线包含相应环边的权重。当`"twice"`时，假定对角线包含相应环边的权重的两倍。
返回值
由图本身及其边权重向量组成的一对

igraph.GraphBase

`igraph.GraphBase`