igraph.GraphBase - python-igraph 文档

类文档

class GraphBase

已知子类：igraph.Graph

构造函数：GraphBase(kwargs)

图的底层表示。

请勿直接使用，请改用 igraph.Graph。

方法	`__new__`	创建并返回一个新对象。有关准确签名，请参阅 help(type)。
方法	`add_edges`	向图中添加边。
方法	`add_vertices`	向图中添加顶点。
方法	`Adjacency`	从邻接矩阵生成图。
方法	`all_minimal_st_separators`	返回包含图中所有最小 s-t 分隔符的列表。
方法	`all_st_cuts`	返回有向图中源顶点和目标顶点之间的所有切割。
方法	`all_st_mincuts`	返回有向图中源顶点和目标顶点之间的所有最小割。
方法	`are_adjacent`	判断两个给定顶点是否直接连接。
方法	`articulation_points`	返回图中关节点的列表。
方法	`assortativity`	根据顶点的数值属性返回图的同配性。
方法	`assortativity_degree`	根据顶点度数返回图的同配性。
方法	`assortativity_nominal`	根据顶点类别返回图的同配性。
方法	`Asymmetric_Preference`	根据非对称顶点类型和连接概率生成图。
方法	`Atlas`	从图谱生成图。
方法	`attributes`	无摘要
方法	`authority_score`	计算图中顶点的 Kleinberg 权威分数
方法	`automorphism_group`	使用 BLISS 同构算法计算图的自同构群的生成器。
方法	`average_path_length`	计算图中的平均路径长度。
方法	`Barabasi`	基于 Barabási-Albert 模型生成图。
方法	`betweenness`	计算或估计图中顶点的中介性。
方法	`bfs`	对图执行广度优先搜索 (BFS)。
方法	`bfsiter`	构建图的广度优先搜索 (BFS) 迭代器。
方法	`bibcoupling`	计算图中给定顶点的文献耦合分数。
方法	`biconnected_components`	计算图的双连通分量。
方法	`bipartite_projection`	内部函数，无文档。
方法	`bipartite_projection_size`	内部函数，无文档。
方法	`bridges`	返回图中桥的列表。
方法	`canonical_permutation`	使用 BLISS 同构算法计算图的规范置换。
方法	`chordal_completion`	返回使图成为弦图所需添加的边列表。
方法	`Chung_Lu`	生成 Chung-Lu 随机图。
方法	`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`	查找网络顶点的核心度（壳指数）。
方法	`count_automorphisms`	使用 BLISS 同构算法计算图的自同构数量。
方法	`count_isomorphisms_vf2`	确定图与另一个图之间的同构数量
方法	`count_multiple`	计算给定边的重数。
方法	`count_subisomorphisms_vf2`	确定图与另一个图之间的子同构数量
方法	`De_Bruijn`	生成参数为 (m, n) 的德布鲁因图
方法	`decompose`	将图分解为子图。
方法	`degree`	返回图中的一些顶点度数。
方法	`Degree_Sequence`	生成具有给定度序列的图。
方法	`delete_edges`	从图中删除边。
方法	`delete_vertices`	从图中删除顶点及其所有边。
方法	`density`	计算图的密度。
方法	`dfsiter`	构建图的深度优先搜索 (DFS) 迭代器。
方法	`diameter`	计算图的直径。
方法	`difference`	从原始图中减去给定图
方法	`distances`	计算图中给定顶点的最短路径长度。
方法	`diversity`	计算顶点的结构多样性指数。
方法	`dominator`	返回给定根节点的支配树
方法	`dyad_census`	Holland 和 Leinhardt 定义的二元统计
方法	`eccentricity`	计算图中给定顶点的离心率。
方法	`ecount`	计算边数。
方法	`edge_attributes`	无摘要
方法	`edge_betweenness`	计算或估计图中边的中介性。
方法	`edge_connectivity`	计算图的边连通性或某些顶点之间的边连通性。
方法	`eigen_adjacency`	未文档化
方法	`eigenvector_centrality`	计算图中顶点的特征向量中心性。
方法	`Erdos_Renyi`	基于 Erdős-Rényi 模型生成图。
方法	`Establishment`	基于具有顶点类型的简单增长模型生成图。
方法	`Famous`	根据其名称生成著名的图。
方法	`farthest_points`	返回两个顶点 ID，其距离等于图的实际直径。
方法	`feedback_arc_set`	计算近似或精确的最小反馈弧集。
方法	`feedback_vertex_set`	计算最小反馈顶点集。
方法	`Forest_Fire`	基于森林火灾模型生成图
方法	`Full`	生成完整图（有向或无向，带或不带环）。
方法	`Full_Citation`	生成完整引用图
方法	`fundamental_cycles`	查找图的单个基本圈基
方法	`get_adjacency`	返回图的邻接矩阵。
方法	`get_all_shortest_paths`	计算图中从/到给定节点的所有最短路径。
方法	`get_biadjacency`	内部函数，无文档。
方法	`get_diameter`	返回具有图实际直径的路径。
方法	`get_edgelist`	返回图的边列表。
方法	`get_eid`	返回顶点 v1 和 v2 之间任意边的边 ID
方法	`get_eids`	返回某些顶点之间某些边的边 ID。
方法	`get_isomorphisms_vf2`	返回图与另一个图之间的所有同构
方法	`get_k_shortest_paths`	计算图中从/到给定节点的 k 条最短路径。
方法	`get_shortest_path`	计算图中从源顶点到目标顶点的最短路径。
方法	`get_shortest_path_astar`	使用 A-Star 算法和启发式函数计算图中从源顶点到目标顶点的最短路径。
方法	`get_shortest_paths`	计算图中从/到给定节点的最短路径。
方法	`get_subisomorphisms_lad`	使用 LAD 算法返回图与另一个图之间的所有子同构。
方法	`get_subisomorphisms_vf2`	返回图与另一个图之间的所有子同构
方法	`girth`	返回图的围长。
方法	`gomory_hu_tree`	内部函数，无文档。
方法	`Growing_Random`	生成一个增长随机图。
方法	`harmonic_centrality`	计算图中给定顶点的调和中心性。
方法	`has_multiple`	检查图是否有多条边。
方法	`Hexagonal_Lattice`	生成一个规则六边形晶格。
方法	`hub_score`	计算图中顶点的 Kleinberg 中枢分数
方法	`Hypercube`	生成一个 n 维超立方图。
方法	`incident`	返回给定顶点所关联的边。
方法	`independence_number`	返回图的独立数。
方法	`independent_vertex_sets`	以元组列表的形式返回图的部分或全部独立顶点集。
方法	`induced_subgraph`	返回由给定顶点构成的子图。
方法	`is_acyclic`	返回图是否是无环的（即不包含环）。
方法	`is_biconnected`	判断图是否是双连通的。
方法	`is_bipartite`	判断图是否是二分图。
方法	`is_chordal`	返回图是否是弦图。
方法	`is_clique`	判断一组顶点是否是团，即一个完全连接的子图。
方法	`is_complete`	检查图是否是完全图，即所有不同的顶点对之间是否存在至少一条连接。在有向图中，考虑有序对。
方法	`is_connected`	判断图是否是连通的。
方法	`is_dag`	检查图是否是 DAG（有向无环图）。
方法	`is_directed`	检查图是否是有向的。
方法	`is_independent_vertex_set`	判断集合中任意两个顶点是否不相邻。
方法	`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 布局算法将顶点放置在二维平面上。
方法	`layout_drl`	根据 DrL 布局算法将顶点放置在二维平面或三维空间中。
方法	`layout_fruchterman_reingold`	根据 Fruchterman-Reingold 算法将顶点放置在二维平面上。
方法	`layout_graphopt`	这是 Michael Schmuhl 的 graphopt 布局算法的移植版本。graphopt 0.4.1 版已用 C 重写，并移除了对层的支持。
方法	`layout_grid`	将图的顶点放置在二维或三维网格中。
方法	`layout_kamada_kawai`	根据 Kamada-Kawai 算法将顶点放置在平面上。
方法	`layout_lgl`	根据大型图布局将顶点放置在二维平面上。
方法	`layout_mds`	使用多维标度法将顶点放置在具有给定维数的欧几里得空间中。
方法	`layout_random`	随机放置图的顶点。
方法	`layout_reingold_tilford`	根据 Reingold-Tilford 布局算法将顶点放置在二维平面上。
方法	`layout_reingold_tilford_circular`	树的圆形 Reingold-Tilford 布局。
方法	`layout_star`	为图计算星形布局。
方法	`layout_umap`	统一流形逼近与投影 (UMAP)。
方法	`LCF`	从 LCF 符号生成图。
方法	`linegraph`	返回图的线图。
方法	`list_triangles`	列出图中的三角形
方法	`maxdegree`	返回图中顶点集的最大度数。
方法	`maxflow`	返回源顶点和目标顶点之间的最大流。
方法	`maxflow_value`	返回源顶点和目标顶点之间最大流的值。
方法	`maximal_cliques`	以元组列表的形式返回图的最大团。
方法	`maximal_independent_vertex_sets`	以元组列表的形式返回图的最大独立顶点集。
方法	`maximum_cardinality_search`	对图进行最大基数搜索。此函数为每个顶点计算一个秩 alpha，使得按降序访问顶点时，始终选择已访问邻居最多的顶点作为下一个访问对象。
方法	`mean_degree`	计算图的平均度。
方法	`mincut`	计算源顶点和目标顶点之间或整个图中的最小割。
方法	`mincut_value`	返回源顶点和目标顶点之间或整个图中的最小割。
方法	`minimum_cycle_basis`	计算图的最小圈基
方法	`minimum_size_separators`	返回包含所有最小大小分隔顶点集的列表。
方法	`modularity`	计算图相对于某些顶点类型的模块化。
方法	`modularity_matrix`	计算图的模块化矩阵。
方法	`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`	计算图的路径长度直方图。注意：此函数在派生类 `Graph` 中以更方便的语法封装。建议使用该版本而非此版本。
方法	`permute_vertices`	根据给定置换对图的顶点进行置换，并返回新图。
方法	`personalized_pagerank`	计算图的个性化 PageRank 值。
方法	`predecessors`	返回给定顶点的前驱。
方法	`Preference`	基于顶点类型和连接概率生成图。
方法	`Prufer`	从其 Prüfer 序列生成树。
方法	`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_Bipartite_Degree_Sequence`	从其分区度序列生成二分图。
方法	`Realize_Degree_Sequence`	从度序列生成图。
方法	`Recent_Degree`	基于随机模型生成图，其中边获得新节点的概率与给定时间窗口内获得的边成比例。
方法	`reciprocity`	互易性定义了有向图中相互连接的比例。它最常被定义为有向边的对立部分也包含在图中的概率...
方法	`reverse_edges`	反转图中一些边的方向。
方法	`rewire`	随机重连图，同时保留度分布。
方法	`rewire_edges`	以恒定概率重连图的边。
方法	`Ring`	生成一个环形图。
方法	`SBM`	基于随机块模型生成图。
方法	`similarity_dice`	顶点的 Dice 相似系数。
方法	`similarity_inverse_log_weighted`	顶点的逆对数加权相似系数。
方法	`similarity_jaccard`	顶点的 Jaccard 相似系数。
方法	`simple_cycles`	查找图中的简单环
方法	`simplify`	通过移除自环和/或多重边来简化图。
方法	`st_mincut`	计算图中源顶点和目标顶点之间的最小切割。
方法	`Star`	生成一个星形图。
方法	`Static_Fitness`	生成一个非增长图，其中边概率与节点适应度成比例。
方法	`Static_Power_Law`	生成一个具有预设幂律度分布的非增长图。
方法	`strength`	返回图中某些顶点的强度（加权度）
方法	`subcomponent`	确定与给定顶点在同一组件中的顶点索引。
方法	`subgraph_edges`	返回由给定边构成的子图。
方法	`subisomorphic_lad`	检查图的子图是否与另一个图同构。
方法	`subisomorphic_vf2`	检查图的子图是否与另一个图同构。
方法	`successors`	返回给定顶点的后继。
方法	`to_directed`	将无向图转换为有向图。
方法	`to_prufer`	将树图转换为 Prüfer 序列。
方法	`to_undirected`	将有向图转换为无向图。
方法	`topological_sorting`	计算图的可能拓扑排序。
方法	`transitivity_avglocal_undirected`	计算图的顶点传递性平均值。
方法	`transitivity_local_undirected`	计算图中给定顶点的局部传递性（聚类系数）。
方法	`transitivity_undirected`	计算图的全局传递性（聚类系数）。
方法	`Tree`	生成一个树，其中几乎所有顶点都具有相同数量的子节点。
方法	`Tree_Game`	通过从具有给定节点数的标记树集合中均匀抽样生成随机树。
方法	`triad_census`	Davis 和 Leinhardt 定义的三元组普查
方法	`Triangular_Lattice`	生成一个规则三角形晶格。
方法	`unfold_tree`	必要时通过复制顶点，使用 BFS 将图展开为树。
方法	`vcount`	计算顶点数。
方法	`vertex_attributes`	无摘要
方法	`vertex_coloring_greedy`	基于某些启发式算法为图计算贪婪顶点着色。
方法	`vertex_connectivity`	计算图的顶点连通性或某些顶点之间的顶点连通性。
方法	`Watts_Strogatz`	此函数基于 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`	以 PyCapsule 形式返回 Python 对象封装的 igraph 图
方法	`__invalidate_cache`	使 Python 对象封装的底层 C 图对象的内部缓存失效。此函数不应由 igraph 用户直接使用，但可能对基准测试或调试目的有用。
方法	`__register_destructor`	注册一个析构函数，当对象被 Python 释放时调用。此函数不应由 igraph 用户直接使用。
方法	`_Biadjacency`	内部函数，无文档。
方法	`_Bipartite`	内部函数，无文档。
方法	`_Full_Bipartite`	内部函数，无文档。
方法	`_get_all_simple_paths`	内部函数，无文档。
方法	`_GRG`	内部函数，无文档。
方法	`_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 中重写

从邻接矩阵生成图。

参数
matrix	邻接矩阵
mode	要使用的模式。可能的值有： `"directed"`- 图将是有向的，矩阵元素指定两个顶点之间的边数。 `"undirected"`- 图将是无向的，矩阵元素指定两个顶点之间的边数。输入矩阵必须是对称的。 `"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"`- 无向图，使用矩阵的左下三角形（包括对角线）
loops	指定如何处理矩阵的对角线 `"ignore"`- 忽略对角线中的自环边 `"once"`- 将对角线项视为自环边计数 `"twice"`- 将对角线项视为自环边数的两倍

def all_minimal_st_separators(): ¶

返回包含图中所有最小 s-t 分隔符的列表。

最小分隔符是一组顶点，移除它们会使图断开连接，而移除该集合的任何子集都会保持图的连通性。

参考文献：Anne Berry, Jean-Paul Bordat and Olivier Cogis: Generating all the minimal separators of a graph. In: Peter Widmayer, Gabriele Neyer and Stephan Eidenbenz (eds.): Graph-theoretic concepts in computer science, 1665, 167-172, 1999. Springer.

返回
一个列表，其中每个项列出给定最小 s-t 分隔符的顶点索引。

def all_st_cuts(source, target): ¶

在 igraph.Graph 中重写

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

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

注意：此函数在类 Graph 中有一个更方便的接口，它将结果封装在 Cut 对象列表中。建议使用该接口。

参数
source	源顶点 ID
target	目标顶点 ID

返回
一个元组，其中第一个元素是表示割的边 ID 列表的列表，第二个元素是表示被割分离的顶点集合的顶点 ID 列表的列表。

def all_st_mincuts(source, target): ¶

在 igraph.Graph 中重写

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

注意：此函数在类 Graph 中有一个更方便的接口，它将结果封装在 Cut 对象列表中。建议使用该接口。

参数
source	源顶点 ID
target	目标顶点 ID

def are_adjacent(v1, v2): ¶

判断两个给定顶点是否直接连接。

参数
v1	第一个顶点的 ID 或名称
v2	第二个顶点的 ID 或名称

返回
`True`如果存在从 v1 到 v2 的边，则为 True，`False`否则。

def articulation_points(): ¶

返回图中关节点的列表。

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

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

根据顶点的数值属性返回图的同配性。

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

有关准确定义，请参阅 Newman MEJ:《网络中的混合模式》，Phys Rev E 67:026126 (2003) 中的公式 (21)。实际计算是使用同一论文中针对有向图的公式 (26) 和 Newman MEJ:《网络中的同配混合》，Phys Rev Lett 89:208701 (2002) 中针对无向图的公式 (4) 进行的。

参考文献

Newman MEJ: Mixing patterns in networks, Phys Rev E 67:026126, 2003。
Newman MEJ: Assortative mixing in networks, Phys Rev Lett 89:208701, 2002。

参数
types1	列表中或保存顶点类型的顶点属性名称中的顶点类型。类型理想情况下用数值表示。
types2	在有向同配性计算中，每个顶点可以有一个出类型和一个入类型。在这种情况下，types1 包含出类型，此参数包含列表中的入类型或顶点属性的名称。如果`None`，则假定它等于 types1。
directed	是否考虑边的方向。
normalized	是否计算标准化协方差，即皮尔逊相关性。在此处提供 True 以计算标准同配性。

返回
同配性系数

另请参阅
当类型是顶点度数时，`assortativity_degree()`

def assortativity_degree(directed=True): ¶

根据顶点度数返回图的同配性。

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

参数
directed	是否考虑有向图的边方向。对于无向图，此参数将被忽略。

返回
同配性系数

另请参阅
`assortativity()`

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

根据顶点类别返回图的同配性。

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

有关正确定义，请参阅 Newman MEJ 的《网络中的混合模式》(Mixing patterns in networks)，Phys Rev E 67:026126 (2003) 中的公式 (2)。

参考文献：Newman MEJ：网络中的混合模式 (Mixing patterns in networks)，Phys Rev E 67:026126, 2003。

参数
类型	列表中包含的顶点类型，或者包含顶点类型的顶点属性名称。类型应由数值表示。
directed	是否考虑边的方向。
normalized	是否计算（通常的）归一化同配性。未归一化版本与模块度相同。在此处提供 True 以计算标准同配性。

返回
同配性系数

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

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

这是 `Preference()` 的非对称变体。生成给定数量的顶点。每个顶点根据给定的联合类型概率被分配一个“入站”和“出站”顶点类型。最后，评估每对顶点，并根据源顶点的“出站”类型和目标顶点的“入站”类型，以一定的概率在它们之间创建一条有向边。

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

def Atlas(idx): ¶

从图谱生成图。

参考文献：Ronald C. Read 和 Robin J. Wilson: An Atlas of Graphs. Oxford University Press, 1998。

参数

idx

要生成的图的索引。索引从零开始，图按以下方式列出

顶点数量递增顺序；
对于固定数量的顶点，按边数量递增顺序；
对于固定数量的顶点和边，按度序列递增顺序，例如 111223 < 112222；
对于固定度序列，按自同构数量递增顺序。

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	是否返回最大特征值

返回
列表中包含的权威分数，可选地，作为元组的第二个成员的最大特征值

另请参阅
hub_score()

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

使用 BLISS 同构算法计算图的自同构群的生成器。

生成器集可能不是最小的，并且可能取决于分裂启发式。生成器是使用零基索引表示的排列。

参数

图的分裂启发式，不区分大小写的字符串，可能的值如下

"f": 第一个非单例单元格
"fl": 第一个最大非单例单元格
"fs": 第一个最小非单例单元格
"fm": 第一个最大非平凡连接非单例单元格
"flm": 最大非平凡连接非单例单元格
"fsm": 最小非平凡连接非单例单元格

color 可选向量，存储顶点的着色，以此计算同构。如果None，则所有顶点具有相同的颜色。

返回
一个整数向量列表，每个向量代表图的一个自同构群。

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

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

参数
directed	在有向图的情况下，是否考虑有向路径。对于无向图忽略。
unconn	当图未连接时如何处理。如果`True`，则计算组件中测地线长度的平均值。否则，对于所有未连接的顶点对，使用等于顶点数量的路径长度。
weights	要使用的边权重。可以是序列、可迭代对象，甚至是边属性名称。

返回
图中的平均路径长度

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

基于 Barabási-Albert 模型生成图。

参考文献：Barabási, A-L and Albert, R. 1999. Emergence of scaling in random networks. Science, 286 509-512。

参数
n	顶点数量
m	为每个顶点生成的出边数量，或明确包含每个顶点出边数量的列表。
outpref	`True`如果给定顶点的出度也应增加其引用概率（以及其入度），但它默认为`False`.
directed	`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 版本之前对 power 不为 1 的情况使用此算法。
start_from	如果给定且不为`None`，这必须是另一个 `GraphBase` 对象。igraph 将使用此图作为优先连接模型的起点。

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

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

还支持计算具有最短路径长度截止值或仅考虑从某些源顶点或到某些目标顶点的最短路径的介数。

关键字参数

参数
vertices	必须返回介数的顶点。如果`None`，则假定图中的所有顶点。
directed	是否考虑有向路径。
cutoff	如果它是一个整数，则只考虑小于或等于此长度的路径，从而有效估算给定顶点的介数。如果`None`，则返回精确介数。
weights	要使用的边权重。可以是序列、可迭代对象，甚至是边属性名称。
sources	计算最短路径时要考虑的源顶点集。
targets	计算最短路径时要考虑的目标顶点集。

返回
列表中给定顶点的（可能受截止限制的）介数

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 算法和规范排列的更多信息，请参阅 https://users.aalto.fi/~tjunttil/bliss/。

参数

图的分裂启发式，不区分大小写的字符串，可能的值如下

"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 Chung_Lu(out, in_=None, loops=True, variant='original'): ¶

生成 Chung-Lu 随机图。

在原始的 Chung-Lu 模型中，每对顶点 i 和 j 以独立的概率 p_ij = w_iw_j ⁄ S 连接，其中 w_i 是与顶点 i 关联的权重，S = ∑_kw_k 是权重的总和。在有向变体中，顶点同时具有出权重 w^out 和入权重 wⁱⁿ，且它们的总和相等，即 S = ∑_kw^out_k = ∑_kwⁱⁿ_k。顶点 i 和 j 之间的连接概率为 p_ij = w^out_iwⁱⁿ_j ⁄ S。

该模型通常用于创建具有固定预期度序列的随机图。顶点 i 的预期度近似等于权重 w_i。具体而言，如果图是有向的且允许自环，则预期出度和入度精确地为 w^out 和 wⁱⁿ。如果不允许自环，则预期出度和入度分别为 w^out(S − wⁱⁿ) ⁄ S 和 wⁱⁿ(S − w^out) ⁄ S。如果图是无向的，则包含和不包含自环的预期度分别为 w(S + w) ⁄ S 和 w(S − w) ⁄ S。

原始 Chung-Lu 模型的一个限制是，当某些权重很大时，p_ij 的公式会产生大于 1 的值。Chung 和 Lu 的原始论文排除了使用此类权重。当 p_ij > 1 时，此函数只会发出警告并在 i 和 j 之间创建连接。但是，在这种情况下，预期度将不再与上述权重相关。因此，原始 Chung-Lu 模型无法产生某些（大）预期度。

为了克服此限制，此函数实现了该模型的其他变体，并修改了顶点 i 和 j 之间连接概率 p_ij 的表达式。令 q_ij = w_iw_j ⁄ S，或在有向情况下为 q_ij = w^out_iwⁱⁿ_j ⁄ S。在稀疏图的极限下，当 q_ij 趋近于零时，所有模型变体都变得等效。在原始 Chung-Lu 模型中，通过设置以下参数可以选择：variant设置为"original"，p_ij = min(q_ij, 1)。该"maxent"变体，有时被称为广义随机图，使用 p_ij = q_ij ⁄ (1 + q_ij)，并且等效于具有预期度约束的最大熵模型（即指数随机图模型），参见 Park 和 Newman (2004) B 节，设置 exp( − Θ_ij) = w_iw_j ⁄ S。Britton、Deijfen 和 Martin-Löf (2006) 也讨论了该模型。由于它是一个受度约束的最大熵模型，它以相同的概率生成具有相同度序列的图。第三种变体可以通过以下方式请求："nr"，并使用 p_ij = 1 − exp( − q_ij)。这是 Norros 和 Reittu (2006) 提出的多重图模型的基础简单图。有关这三种模型变体的讨论，请参阅 Bollobás、Janson、Riordan (2007) 的 16.4 节以及 Van Der Hofstad (2013)。

参考文献

Chung F 和 Lu L: 给定度序列的随机图中的连通分量. Annals of Combinatorics 6, 125-145 (2002) https://doi.org/10.1007/PL00012580
Miller JC 和 Hagberg A: 具有给定预期度的网络的高效生成 (2011) https://doi.org/10.1007/978-3-642-21286-4_10
Park J 和 Newman MEJ: 网络的统计力学. Physical Review E 70, 066117 (2004). https://doi.org/10.1103/PhysRevE.70.066117
Britton T, Deijfen M, Martin-Löf A: 生成具有预定度分布的简单随机图. J Stat Phys 124, 1377–1397 (2006). https://doi.org/10.1007/s10955-006-9168-x
Norros I 和 Reittu H: 关于条件泊松图过程. Advances in Applied Probability 38, 59–75 (2006). https://doi.org/10.1239/aap/1143936140
Bollobás B, Janson S, Riordan O: 非均匀随机图中的相变. Random Struct Algorithms 31, 3–122 (2007). https://doi.org/10.1002/rsa.20168
Van Der Hofstad R: 非均匀随机图中的临界行为. Random Struct Algorithms 42, 480–508 (2013). https://doi.org/10.1002/rsa.20450

参数
out	顶点权重（或出度权重）。在稀疏图中，这些将近似等于预期（出）度。
in_	顶点入度权重，近似等于图的预期入度。如果省略，则生成的图将是无向的。
loops	是否允许生成自环。
variant	要使用的模型变体。令 q_ij = w_iw_j ⁄ S，其中 S = ∑_kw_k。可用变体如下 `"original"`-- 原始 Chung-Lu 模型，p_ij = min(1, q_ij)。 `"maxent"`-- 具有固定预期度的最大熵模型 p_ij = q_ij ⁄ (1 + q_ij) `"nr"`-- Norros 和 Reittu 的模型，p_ij = 1 − exp( − q_ij)

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`，则使用图中的所有顶点。
mode	必须是以下之一`"in"`, `"out"`和`"all"`. `"in"`意味着入站路径的长度，`"out"`意味着必须计算出站路径的长度。`"all"`意味着两者都必须计算。
cutoff	如果它是一个整数，则只考虑小于或等于此长度的路径，从而有效估算给定顶点的接近度（这总是对实际接近度的低估，因为某些顶点对即使已连接也会显示为未连接）。如果`None`，则返回精确接近度。
weights	要使用的边权重。可以是序列、可迭代对象，甚至是边属性名称。
normalized	是否通过乘以顶点数量减一来归一化原始接近度分数。

返回
列表中计算出的接近度

def cocitation(vertices=None): ¶

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

参数
vertices	要分析的顶点。如果`None`，则考虑所有顶点。

返回
矩阵中所有给定顶点的共引分数。

def cohesive_blocks(): ¶

在 igraph.Graph 中重写

计算图的凝聚块结构。

注意：此函数在 `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)。

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

注意：此函数在派生类 `Graph` 中以更方便的语法进行包装。建议使用该版本而不是此版本。

参数
directed	在计算介数值时是否考虑边的方向性。
weights	边属性的名称或包含边权重的列表。

返回
一个元组，其中包含描述树状图的合并矩阵以及每次合并前的模块度分数。如果原始图是加权的，则模块度分数使用权重。

def community_fastgreedy(weights=None): ¶

在 igraph.Graph 中重写

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

这是一种自底向上的算法：最初每个顶点都属于一个独立的社区，然后社区逐一合并。在每一步中，合并的两个社区是那些导致模块度最大增益的社区。

注意：此函数在派生类 `Graph` 中以更方便的语法进行包装。建议使用该版本而不是此版本。

参考文献：A. Clauset, M. E. J. Newman and C. Moore: Finding community structure in very large networks. Phys Rev E 70, 066111 (2004)。

参数
weights	边属性的名称或包含边权重的列表

一个包含以下元素的元组

合并列表
每次合并前的模块度分数

另请参阅
modularity()

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

在 igraph.Graph 中重写

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

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

M. Rosvall 和 C. T. Bergstrom: 信息流图揭示复杂网络中的社区结构. PNAS 105, 1118 (2008). https://arxiv.org/abs/0707.0609
M. Rosvall, D. Axelsson 和 C. T. Bergstrom: 地图方程. Eur Phys J Special Topics 178, 13 (2009). https://arxiv.org/abs/0906.1405

参数
边权重（edge_weights）	边属性的名称或包含边权重的列表。
顶点权重（vertex_weights）	顶点属性名称或包含顶点权重的列表。
尝试次数（trials）	划分网络的尝试次数。

返回
一个元组，包含计算出的成员向量和相应的码长。

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

在 igraph.Graph 中重写

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

最初，每个顶点都被赋予一个不同的标签。之后，在每次迭代中，每个顶点选择其邻域中的主导标签。随机处理平局，并且在每次迭代之前随机化顶点的更新顺序。当顶点达成一致时，算法结束。

请注意，由于随机处理平局，因此无法保证算法在每次运行后都返回相同的社区结构。事实上，它们经常不同。有关如何得出聚合社区结构，请参阅 Raghavan 等人的论文。

参考文献: Raghavan, U.N. and Albert, R. and Kumara, S. Near linear time algorithm to detect community structures in large-scale networks. Phys Rev E 76:036106, 2007. https://arxiv.org/abs/0709.2938。

参数
weights	边属性的名称或包含边权重的列表
初始值（initial）	顶点属性的名称或包含初始顶点标签的列表。标签由从零到 n − 1 的整数标识，其中 n 是顶点数量。此向量中也可能存在负数，它们表示未标记的顶点。
固定（fixed）	每个顶点的布尔值列表。`True`对应于算法执行期间标签不应更改的顶点。仅当也提供了初始标签时才有意义。未标记的顶点无法固定。请注意，此处不接受顶点属性名称。

返回
结果成员向量

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

在 igraph.Graph 中重写

Newman 特征向量社区结构检测的正确实现。每次分裂都是通过最大化原始网络的模块化来进行的。有关详细信息，请参阅参考文献。

注意：此函数在派生类 `Graph` 中以更方便的语法进行包装。建议使用该版本而不是此版本。

参考文献: MEJ Newman: Finding community structure in networks using the eigenvectors of matrices, arXiv:physics/0605087

参数
n	所需的社区数量。如果为负数，算法会尝试进行尽可能多的分割。请注意，如果主导特征向量的符号全部相同，则算法不会进一步分割社区。
arpack_options	用于微调 ARPACK 特征向量计算的 `ARPACKOptions` 对象。如果省略，则使用模块级变量`arpack_options`指定的默认调色板。
weights	边属性的名称或包含边权重的列表

返回
一个元组，其中第一个元素是聚类的成员向量，第二个元素是合并矩阵。

def community_leiden(edge_weights=None, node_weights=None, resolution=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）	要使用的分辨率参数。更高的分辨率会导致更多更小的社区，而更低的分辨率会导致更少更大的社区。
normalize_resolution	如果设置为 true，分辨率参数将除以节点权重的总和。如果未提供，它将默认为节点度，或者在提供 `edge_weights` 时默认为加权度。
贝塔（beta）	影响 Leiden 算法随机性的参数。这仅影响算法的细化步骤。
初始成员（initial_membership）	如果提供，Leiden 算法将尝试改进此提供的成员关系。如果未提供参数，算法将简单地从单例分区开始。
迭代次数（n_iterations）	Leiden 算法的迭代次数。每次迭代都可能进一步改进分区。您也可以将此参数设置为负数，这意味着算法将一直迭代，直到某次迭代不再改变当前的成员向量为止。

返回
社区成员向量。

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

在 igraph.Graph 中重写

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

参考文献: VD Blondel, J-L Guillaume, R Lambiotte and E Lefebvre: Fast unfolding of community hierarchies in large networks. J Stat Mech P10008 (2008), https://arxiv.org/abs/0803.0476

注意：此函数在派生类 `Graph` 中以更方便的语法进行包装。建议使用该版本而不是此版本。

参数
weights	边属性的名称或包含边权重的列表
返回级别（return_levels）	如果`True`，返回多级结果。如果`False`，只返回最佳级别（对应于最佳模块化）。
分辨率（resolution）	模块度度量中使用的分辨率参数。较小的值会产生数量较少但规模较大的聚类，而较大的值会产生数量较多但规模较小的聚类。经典的模块度度量假定分辨率参数为 1。

返回
要么是一个描述每个顶点社区成员资格的单一列表（如果`return_levels`为`False`），或者是一个社区成员向量列表，每个级别对应一个，以及一个相应的模块化列表（如果`return_levels`为`True`).

另请参阅
modularity()

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 的随机游走方法查找图的社区结构。

该算法的基本思想是，短随机游走倾向于停留在同一个社区内。该方法提供了一个聚类树（dendrogram）。

注意：此函数在派生类 `Graph` 中以更方便的语法进行包装。建议使用该版本而不是此版本。

参考文献: Pascal Pons, Matthieu Latapy: Computing communities in large networks using random walks, https://arxiv.org/abs/physics/0512106。

参数
weights	边属性的名称或包含边权重的列表
步数（steps）	未文档化

返回
一个元组，包含合并列表和每个合并对应的模块化分数。

另请参阅
modularity()

def complementer(loops=False): ¶

返回图的补图

参数
loops	是否在补图中包含自环边。

返回
图的补图

def compose(other): ¶

返回两个图的组合。

def connected_components(mode='strong'): ¶

在 igraph.Graph 中重写

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

注意：此函数在 Graph 类中有一个更方便的接口，它将结果封装在 VertexClustering 对象中。建议使用该接口。

参数
mode	必须是以下之一：`“strong”`或`“weak”`，取决于所寻找的集群。可选，默认为`“strong”`.

返回
图中每个节点的连通分量索引。

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

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

如果自我（ego）的联系较少，或相互之间关系更强（即冗余更多），则 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] are elements of A and the latter being the graph adjacency matrix.

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

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

查找网络顶点的核心度（壳指数）。

图的 k-核是一个极大子图，其中每个顶点的度至少为 k。（此处度指的是子图中的度）。如果一个顶点是 k-核的成员但不是 k + 1-核的成员，则该顶点的核数（coreness）为 k。

参考文献: Vladimir Batagelj, Matjaz Zaversnik: An O(m) Algorithm for Core Decomposition of Networks.

参数
mode	是否计算入核数（`"in"`）、出核数（`"out"`）或无向核数（`"all"`）。对于无向图，此参数被忽略并假定为`"all"`适用于无向图。

返回
每个顶点的核数。

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

使用 BLISS 同构算法计算图的自同构数量。

有关 BLISS 算法和规范排列的更多信息，请参阅 https://users.aalto.fi/~tjunttil/bliss/。

参数

图的分裂启发式，不区分大小写的字符串，可能的值如下

"f": 第一个非单例单元格
"fl": 第一个最大非单例单元格
"fs": 第一个最小非单例单元格
"fm": 第一个最大非平凡连接非单例单元格
"flm": 最大非平凡连接非单例单元格
"fsm": 最小非平凡连接非单例单元格

color 可选向量，存储顶点的着色，以此计算同构。如果None，则所有顶点具有相同的颜色。

返回
图的自同构数量。

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

计算给定边的重数。

参数
edges	要计算其多重性的边索引。如果`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 图表示字符串之间的关系。使用包含 m 个字母的字母表，并考虑长度为 n 的字符串。每个可能的字符串对应一个顶点，如果顶点 v 的字符串可以通过移除其第一个字母并附加一个字母来转换为顶点 w 的字符串，则存在从 v 到 w 的有向边。

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

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

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

将图分解为子图。

参数
mode	必须是以下之一：`“strong”`或`“weak”`，取决于所寻找的集群。可选，默认为`“strong”`.
maxcompno	要返回的最大分量数量。`None`表示所有可能的分量。
minelements	一个分量中的最小顶点数量。将其设置为 2 时，孤立顶点不会作为单独的分量返回。

返回
子图列表。每个返回的子图都是原始图的副本。

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

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

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

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

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

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

参数
out	有向图的出度序列。如果省略入度序列，则生成的图将是无向图，因此这也将是入度序列。
in_	有向图的入度序列。如果省略，则生成的图将是无向图。
method	要使用的生成方法。以下之一： `“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。

def delete_edges(es): ¶

在 igraph.Graph 中重写

从图中删除边。

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

参数
es	要删除的边列表。边由边 ID 标识。此处也接受 `EdgeSeq` 对象。不提供任何参数将删除所有边。

def delete_vertices(vs): ¶

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

参数
vs	要删除的单个顶点 ID 或顶点 ID 列表。不提供任何参数将删除所有顶点。

def density(loops=False): ¶

计算图的密度。

参数
loops	是否考虑自环。如果`True`，算法假设图中可能存在一些自环并相应地计算密度。如果`False`，算法假设不存在任何自环。

返回
图的密度。

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

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

参数
vid	根顶点ID
mode	或`"in"`或`"out"`或`"all"`.
advanced	如果`False`，迭代器在每一步返回 DFS 顺序的下一个顶点。如果`True`，迭代器还会返回顶点到根的距离以及 DFS 树中顶点的父节点。

返回
DFS 迭代器，作为 `igraph.DFSIter` 对象。

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

计算图的直径。

参数
directed	是否考虑有向路径。
unconn	如果`True`并且图不连通，将返回分量内最长的测地线。如果`False`并且图不连通，如果没有权重，结果是顶点数量；如果有权重，结果是无穷大。
weights	要使用的边权重。可以是序列、可迭代对象，甚至是边属性名称。

返回
直径

def difference(other): ¶

从原始图中减去给定图

def distances(source=None, target=None, weights=None, mode='out', algorithm='auto'): ¶

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

用于计算的算法是自动选择的：无权图使用简单的 BFS，当所有权重非负时使用 Dijkstra 算法。否则，如果请求的源顶点数量小于 100，则使用 Bellman-Ford 算法；否则使用 Johnson 算法。

参数
source	包含应包含在结果中的源顶点 ID 的列表。如果`None`，则考虑所有顶点。
target	包含应包含在结果中的目标顶点 ID 的列表。如果`None`，则考虑所有顶点。
weights	包含边权重的列表。它也可以是属性名称（边权重从给定属性中检索）或`None`（所有边具有相同权重）。
mode	在有向图中用于计算的最短路径类型。`"out"`表示仅出度路径，`"in"`表示仅入度路径。`"all"`表示将有向图视为无向图。
algorithm	要使用的最短路径算法。`“auto”`根据图是否具有负权重自动选择算法。`“dijkstra”`使用 Dijkstra 算法。`“bellman_ford”`使用 Bellman-Ford 算法。`“johnson”`使用 Johnson 算法。对于无权图，此参数被忽略。

返回
矩阵中给定顶点的最短路径长度

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

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

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

该度量仅适用于无向图；边方向被忽略。

参考文献: Eagle N, Macy M and Claxton R: Network diversity and economic development, Science 328, 1029-1031, 2010。

参数
vertices	必须返回多样性指数的顶点。如果`None`，则使用图中的所有顶点。
weights	要使用的边权重。可以是序列、可迭代对象，甚至是边属性名称。

返回
列表中计算出的多样性指数，如果提供单个顶点则为单个数字。

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

返回给定根节点的支配树

参数
vid	根顶点ID
mode	或`"in"`或`"out"`

返回
包含当前图的支配树的列表。

def dyad_census(): ¶

在 igraph.Graph 中重写

Holland 和 Leinhardt 定义的二元统计

二元统计（Dyad census）是指将有向图中的每对顶点分为三类：互惠（mutual），即存在从 a 到 b 以及从 b 到 a 的边；不对称（asymmetric），即存在从 a 到 b 或从 b 到 a 的边，但不是双向的；空（null），即 a 和 b 之间没有边。

注意：此函数在 Graph 类中有一个更方便的接口，它将结果封装在 DyadCensus 对象中。建议使用该接口。

返回
一个 3 元组，包含互惠、不对称和空连接的数量。

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

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

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

参数
vertices	必须返回离心率分数的顶点。如果`None`，则使用图中的所有顶点。
mode	必须是以下之一`"in"`, `"out"`和`"all"`. `"in"`表示遵循边方向；`"out"`表示边方向反向遵循；`"all"`表示忽略方向。此参数对无向图无效。
weights	包含边权重的列表。它也可以是属性名称（边权重从给定属性中检索）或`None`（所有边具有相同权重）。

返回
列表中计算出的离心率，如果提供单个顶点则为单个数字。

def ecount(): ¶

计算边数。

返回
整数	图中的边数量。

def edge_attributes(): ¶

返回
图的边属性名称列表

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

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

还支持计算具有最短路径长度截止值的边介数，或仅考虑从特定源顶点到特定目标顶点的最短路径。

参数
directed	是否考虑有向路径。
cutoff	如果它是一个整数，则只考虑小于或等于此长度的路径，从而有效地估计介数。如果`None`，则返回精确的介数。
weights	要使用的边权重。可以是序列、可迭代对象，甚至是边属性名称。
sources	计算最短路径时要考虑的源顶点集。
targets	计算最短路径时要考虑的目标顶点集。

返回
包含所有边的（精确或估计的）边介数列表。

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

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

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

如果同时给定源顶点和目标顶点，此方法将计算给定顶点对的边连通度。如果未给定它们（或它们都为负数），则返回整体边连通度。

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

返回
边连通度

def eigen_adjacency(algorithm=None, which=None, arpack_options=None): ¶

未文档化

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

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

特征向量中心性是衡量网络中节点重要性的指标。它根据“来自高分节点的连接对目标节点分数的贡献大于来自低分节点的相同连接”的原则，为网络中的所有节点分配相对分数。实际上，中心性是通过计算邻接矩阵的最大正特征值所对应的特征向量来确定的。在无向图情况下，此函数将邻接矩阵的对角线元素视为相应顶点上自环数量的两倍。

在有向图情况下，计算邻接矩阵的左特征向量。换句话说，顶点的中心性与其指向该顶点的所有顶点的中心性之和成比例。

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

参数
directed	是否考虑有向图中的边方向。对于无向图则忽略。
scale	是否对中心性进行归一化，使最大值始终为1。
weights	边权重，以列表形式或边属性给出。如果`None`，所有边具有相等权重。
return_eigenvalue	是否返回实际的最大特征值以及中心性
arpack_options	一个 `ARPACKOptions` 对象，可用于微调计算。如果省略，则使用名为模块级变量`arpack_options`指定的默认调色板。

返回
以列表形式返回特征向量中心性，并可选地返回最大特征值（作为元组的第二个元素）

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

基于 Erdős-Rényi 模型生成图。

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

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

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

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

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

def Famous(name): ¶

根据其名称生成著名的图。

一些著名的图表已知igraph包括（但不限于）Chvatal 图、Petersen 图或 Tutte 图。此方法根据其名称（不区分大小写）生成其中之一。请参阅 C 接口的文档igraph获取可用名称：https://igraph.cn/c/doc。

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

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

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

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

参数
directed	是否考虑有向路径。
unconn	如果`True`并且图不连通，将返回分量内最长的测地线。如果`False`且图不连通，如果无权重，结果包含顶点数量；如果有权重，则结果为无穷大。
weights	要使用的边权重。可以是序列、可迭代对象，甚至是边属性名称。

返回
一个包含两个顶点 ID 及其距离的三元组。ID 为`None`如果图不连通且`unconn`为`False`.

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

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

反馈弧集是一组边的集合，移除这些边可使图成为无环图。由于移除所有边总能使其成为无环图，我们通常感兴趣的是移除尽可能少的边，或总权重尽可能小的边集。此方法计算一个这样的边集。请注意，对于无向图，此任务是微不足道的，因为只需找到一棵生成树，然后移除所有不在生成树中的边即可。当然，对于有向图，这更复杂。

参考文献：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.

参数
weights	要使用的边权重。可以是序列、可迭代对象，甚至是边属性名称。给出时，算法将努力移除轻量级边，以最小化反馈弧集的总权重。
method	要使用的算法。`"eades"`使用 Eades、Lin 和 Smyth 的贪婪循环打破启发式算法，该算法的复杂度与边数呈线性关系，但不一定是最优解；但是，它保证移除的边数小于 \|E\|/2 - \|V\|/6。`"ip"`使用最有效的整数规划公式，保证产生最优结果。可以使用以下方法选择特定的整数规划公式`"ip_ti"`（使用三角不等式）和`"ip_cg"`（使用增量约束生成的最小集合覆盖公式）。请注意，最小反馈弧集问题是 NP 难问题，因此所有获得精确最优解的方法在大型图上都慢得不切实际。

返回
要移除的边的 ID，以列表形式。

def feedback_vertex_set(weights=None, method='ip'): ¶

计算最小反馈顶点集。

反馈顶点集是一组顶点的集合，移除这些顶点可使图成为无环图。寻找最小反馈顶点集在有向图和无向图中都是 NP 难问题。

参数
weights	要使用的顶点权重。可以是序列、可迭代对象，甚至是顶点属性名称。给出时，算法将努力移除轻量级顶点，以最小化反馈顶点集的总权重。
method	要使用的算法。`"ip"`使用精确的整数规划方法，并且是目前唯一可用的方法。

返回
要移除的顶点的 ID，以列表形式。

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	每步选择的“大使”数量
directed	图是否为有向图

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

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

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

def Full_Citation(n, directed=False): ¶

生成完整引用图

完整引用图是指顶点从 0 到 n − 1 编号，且顶点 i 有一个指向所有索引小于 i 的顶点的有向边的图。

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

def fundamental_cycles(start_vid=None, cutoff=None): ¶

查找图的单个基本圈基

参数
start_vid	当`None`或负数时，返回一个完整的基循环基。当它是一个顶点或顶点 ID 时，将返回与以该顶点为根的 BFS 树相关的基循环，仅针对包含该顶点的弱连通分量
cutoff	当`None`或负数时，返回一个完整的循环基。否则 BFS 将在此步数后停止，因此结果将有效地只包括长度为 2*cutoff + 1 或更短的循环。

返回
循环基，以包含边 ID 的元组列表形式。

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

在 igraph.Graph 中重写

返回图的邻接矩阵。

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

返回
邻接矩阵。

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

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

参数
v	计算路径的来源
设置为	一个描述计算路径目标的顶点选择器。这可以是一个顶点 ID、一个顶点 ID 列表、一个顶点名称、一个顶点名称列表或一个 `VertexSeq` 对象。`None`意味着所有顶点。
weights	边权重以列表形式，或持有边权重的边属性名称。如果`None`，假设所有边具有相等权重。
mode	路径的方向性。`"in"`意味着计算传入路径，`"out"`意味着计算传出路径，`"all"`意味着计算两种路径。

返回
以列表形式返回从给定节点到图中每个可达节点的所有最短路径。请注意，在模式为`"in"`时，路径中的顶点以反向顺序返回！

def get_biadjacency(types): ¶

在 igraph.Graph 中重写

内部函数，无文档。

另请参阅
Graph.get_biadjacency()

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

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

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

参数
directed	是否考虑有向路径。
unconn	如果`True`并且图不连通，将返回分量内最长的测地线。如果`False`并且图不连通，如果没有权重，结果是顶点数量；如果有权重，结果是无穷大。
weights	要使用的边权重。可以是序列、可迭代对象，甚至是边属性名称。

返回
路径中的顶点按顺序。

def get_edgelist(): ¶

返回图的边列表。

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

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

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

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

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

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

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

参数
pairs	一个整数对列表。每个整数对被视为一个源-目标顶点对；在图中查找相应的边，并为每对返回边 ID。
directed	在有向图中是否应考虑边方向。默认值为`True`。对于无向图则忽略。
error	如果`True`，如果给定边不存在将引发异常。如果`False`，在这种情况下将返回 -1。

返回
边 ID 以列表形式

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_k_shortest_paths(v, to, k=1, weights=None, mode='out', output='vpath'): ¶

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

参数
v	计算路径来源顶点的 ID 或名称。
设置为	计算路径目标顶点的 ID 或名称。
k	所需的最短路径数量
weights	边权重以列表形式，或持有边权重的边属性名称。如果`None`，假设所有边具有相等权重。
mode	路径的方向性。`"in"`意味着计算传入路径，`"out"`意味着计算传出路径，`"all"`意味着计算两种路径。
output	决定返回什么。如果是`"vpath"`，将返回一个顶点 ID 列表，每个目标顶点一条路径。对于非连通图，列表中的某些元素可能为空。请注意，在模式为`"in"`时，路径中的顶点以反向顺序返回。如果`output="epath"`，返回边 ID 而不是顶点 ID。

返回
以顶点或边 ID 列表形式返回从给定源节点到给定目标节点的 k 条最短路径（取决于`output`参数的值）。请注意，在模式为`"in"`时，路径中的顶点以反向顺序返回！

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

计算图中从源顶点到目标顶点的最短路径。

此函数只返回一条最短路径。请考虑使用 get_shortest_paths() 查找源和多个目标顶点之间的所有最短路径。

参数
v	路径的源顶点
设置为	路径的目标顶点
weights	边权重以列表形式，或持有边权重的边属性名称。如果`None`，假设所有边具有相等权重。
mode	路径的方向性。`"out"`意味着计算从源到目标的路径，遵循边的自然方向。`"in"`意味着计算从目标到源的路径，动态翻转每条边的方向。`"all"`意味着忽略边方向。
output	决定返回什么。如果是`"vpath"`，将返回一个顶点 ID 列表。如果这是`"epath"`，返回边 ID 而不是顶点 ID。
algorithm	要使用的最短路径算法。`“auto”`根据图是否具有负权重自动选择算法。`“dijkstra”`使用 Dijkstra 算法。`“bellman_ford”`使用 Bellman-Ford 算法。对于无权重图则忽略。

返回
参见`output`参数的文档。

另请参阅
`get_shortest_paths()`

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

使用 A-Star 算法和启发式函数计算图中从源顶点到目标顶点的最短路径。

参数
v	路径的源顶点
设置为	路径的目标顶点
heuristics	一个函数，将使用图和两个顶点调用，并且必须返回从第一个顶点到第二个顶点路径成本的估计值。如果启发式是可接受的（即，它从不高估从给定源顶点到给定目标节点的最短路径的成本），则 A* 算法保证返回最优解。
weights	边权重以列表形式，或持有边权重的边属性名称。如果`None`，假设所有边具有相等权重。
mode	路径的方向性。`"out"`意味着计算从源到目标的路径，遵循边的自然方向。`"in"`意味着计算从目标到源的路径，动态翻转每条边的方向。`"all"`意味着忽略边方向。
output	决定返回什么。如果是`"vpath"`，将返回一个顶点 ID 列表。如果这是`"epath"`，返回边 ID 而不是顶点 ID。

返回
参见`output`参数的文档。

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

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

参数
v	计算路径的源/目标
设置为	一个描述计算路径的目标/源的顶点选择器。这可以是一个顶点 ID、一个顶点 ID 列表、一个顶点名称、一个顶点名称列表或一个 `VertexSeq` 对象。`None`意味着所有顶点。
weights	边权重以列表形式，或持有边权重的边属性名称。如果`None`，假设所有边具有相等权重。
mode	路径的方向性。`"in"`意味着计算传入路径，`"out"`意味着计算传出路径，`"all"`意味着计算两种路径。
output	决定返回什么。如果是`"vpath"`，将返回一个顶点 ID 列表，每个目标顶点一条路径。对于非连通图，列表中的某些元素可能为空。请注意，在模式为`"in"`时，路径中的顶点以反向顺序返回。如果`output="epath"`，返回边 ID 而不是顶点 ID。
algorithm	要使用的最短路径算法。`“auto”`根据图是否具有负权重自动选择算法。`“dijkstra”`使用 Dijkstra 算法。`“bellman_ford”`使用 Bellman-Ford 算法。对于无权重图则忽略。

返回
参见`output`参数的文档。

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

返回图的围长。

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

参数
return_shortest_circle	是否返回图中找到的最短环之一。

返回
最短环的长度，或（如果`return_shortest_circle`为真），最短环本身以列表形式。

def gomory_hu_tree(capacity=None): ¶

在 igraph.Graph 中重写

内部函数，无文档。

另请参阅
Graph.gomory_hu_tree()

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

生成一个增长随机图。

参数
n	图中顶点的数量
m	每步要添加的边数（添加新顶点后）
directed	图是否应为有向图。
citation	新边是否应起源于最近添加的顶点。

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

计算图中给定顶点的调和中心性。

顶点的调和中心性衡量从该顶点到达其他顶点的容易程度（或反之：其他顶点到达该顶点的容易程度）。它被定义为到所有其他顶点的平均逆距离。

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

参数
vertices	必须返回调和中心性的顶点。如果`None`，则使用图中的所有顶点。
mode	必须是以下之一`"in"`, `"out"`和`"all"`. `"in"`意味着入站路径的长度，`"out"`意味着必须计算出站路径的长度。`"all"`意味着两者都必须计算。
cutoff	如果不是`None`，只考虑小于或等于此长度的路径。
weights	要使用的边权重。可以是序列、可迭代对象，甚至是边属性名称。
normalized	是否对结果进行归一化。如果为 True，结果是到其他顶点的平均逆路径长度，即，它通过顶点数量减一进行归一化。如果为 False，结果是到其他顶点的逆路径长度之和。

返回
计算出的调和中心性以列表形式

def has_multiple(): ¶

检查图是否有多条边。

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

def Hexagonal_Lattice(dim, directed=False, mutual=True): ¶

生成一个规则六边形晶格。

参数
dim	包含晶格维度的列表
directed	是否创建有向图。
mutual	在有向图的情况下，是否将所有连接创建为互惠的。

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

计算图中顶点的 Kleinberg 中枢分数

参数
weights	要使用的边权重。可以是序列、可迭代对象，甚至是边属性名称。
scale	是否将分数归一化，使最大值为 1。
arpack_options	用于微调 ARPACK 特征向量计算的 `ARPACKOptions` 对象。如果省略，则使用模块级变量`arpack_options`指定的默认调色板。
return_eigenvalue	是否返回最大特征值

返回
以列表形式返回中心枢纽分数，并可选地返回最大特征值（作为元组的第二个元素）

另请参阅
authority_score()

def Hypercube(n, directed=False): ¶

生成一个 n 维超立方图。

超立方体图 Q_n 具有 2ⁿ 个顶点和 2^n − 1n 条边。当两个顶点的二进制表示恰好在一个位上不同时，它们是连接的。

参数
n	超立方体图的维度。
directed	是否创建有向图；边将从索引较低的顶点指向索引较高的顶点。

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

返回给定顶点所关联的边。

参数
vertex	一个顶点 ID。
mode	是否只返回后继（`"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_biconnected(): ¶

判断图是否是双连通的。

如果移除任何一个顶点后图仍然保持连通，则该图是双连通的。

请注意，关于是否将由两个连通顶点组成的图视为双连通图，目前存在不同的约定。igraph 确实将其视为双连通图。

返回
布尔值	`True`如果它是双连通的，`False`否则。

def is_bipartite(return_types=False): ¶

判断图是否是二分图。

二分图的顶点可以划分为 A 和 B 两个组，使得所有边都连接这两个组之间。

参数
return_types	如果`False`，该方法将简单地返回`True`或`False`取决于图是否为二分图。如果`True`，实际的组分配也会作为布尔值列表返回。（请注意，组分配不是唯一的，特别是当图包含多个连通分量时，因为各分量的分配彼此独立）。

返回
`True`如果图是二分图，`False`否则为 `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_clique(vertices=None, directed=False): ¶

判断一组顶点是否是团，即一个完全连接的子图。

参数
vertices	一个顶点 ID 列表。
directed	是否要求有向图中顶点对之间存在相互连接。

返回
`True`给定的顶点集合是否为团，`False`否则为 `False`。

def is_complete(): ¶

检查图是否是完全图，即所有不同的顶点对之间是否存在至少一条连接。在有向图中，考虑有序对。

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

def is_connected(mode='strong'): ¶

判断图是否是连通的。

参数
mode	是否应该计算强连通性或弱连通性。

返回
`True`如果图是连通的，`False`否则。

def is_dag(): ¶

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

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

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

def is_directed(): ¶

检查图是否是有向的。

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

def is_independent_vertex_set(vertices=None): ¶

判断集合中任意两个顶点是否不相邻。

参数
vertices	一个顶点 ID 列表。

返回
`True`给定的顶点是否构成独立集，`False`否则为 `False`。

def is_loop(edges=None): ¶

检查特定边集是否包含自环边

参数
edges	我们要检查的边索引。如果`None`，则检查所有边。

返回
一个布尔值列表，每个给定边对应一个

def is_minimal_separator(vertices): ¶

判断给定顶点集是否是最小分离器。

最小分隔符是一组顶点，移除它们会使图断开连接，而移除该集合的任何子集都会保持图的连通性。

参数
vertices	单个顶点 ID 或顶点 ID 列表

返回
`True`给定的顶点集合是否是最小分离集，`False`否则。

def is_multiple(edges=None): ¶

检查边是否是多重边。

也适用于边集——在这种情况下，每条边都会被逐一检查。请注意，如果一对顶点之间存在多条边，其中总有一条边不会被报告为多重边（只有其他边会被报告）。这使得用户可以轻松检测出必须删除哪些边才能使图没有多重边。

参数
edges	我们要检查的边索引。如果`None`，则检查所有边。

返回
一个布尔值列表，每个给定边对应一个

def is_mutual(edges=None, loops=True): ¶

检查边是否有反向对。

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

参数
edges	我们要检查的边索引。如果`None`，则检查所有边。
loops	指定在有向图中是否将自环边视为相互的。

返回
一个布尔值列表，每个给定边对应一个

def is_separator(vertices): ¶

判断移除给定顶点是否会使图断开连接。

参数
vertices	单个顶点 ID 或顶点 ID 列表

返回
`True`给定的顶点集合是否是分离集，`False`否则为 `False`。

def is_simple(): ¶

检查图是否是简单的（无自环或多重边）。

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

def is_tree(mode='out'): ¶

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

对于有向树，该函数可能要求边的方向是从根向外还是向内，这取决于mode参数的值。

参数
mode	对于有向图，指定如何考虑边的方向。`"all"`意味着必须忽略边的方向，`"out"`意味着边必须是远离根的方向，`"in"`意味着边必须是朝向根的方向。对于无向图，此参数被忽略。

返回
布尔值	`True`如果图是树，`False`否则。

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

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

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

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

def isoclass(vertices): ¶

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

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

参数
vertices	如果只想计算顶点子集的同构类，则为顶点列表。`None`意味着使用整个图。

返回
（子）图的同构类

def isomorphic(other): ¶

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

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

如果一个图是有向的而另一个是无向的，则抛出异常。
如果两个图的顶点数和边数不同，则返回 `False`。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 算法的更多信息，请参阅 https://users.aalto.fi/~tjunttil/bliss/。

参数
other	想要与当前图比较的另一个图。
return_mapping_12	如果`True`，计算将第一个图的顶点映射到第二个图的映射。
return_mapping_21	如果`True`，计算将第二个图的顶点映射到第一个图的映射。
sh1	第一个图的分裂启发式算法，作为不区分大小写的字符串，可能的值如下： `"f"`: 第一个非单例单元格 `"fl"`: 第一个最大非单例单元格 `"fs"`: 第一个最小非单例单元格 `"fm"`: 第一个最大非平凡连接非单例单元格 `"flm"`: 最大非平凡连接非单例单元格 `"fsm"`: 最小非平凡连接非单例单元格
sh2	用于第二个图的分裂启发式算法。必须与`sh1`相同；或者，它可以是 `None``None`，在这种情况下，它将自动使用与 `sh1``sh1`相同的值。目前仅为向后兼容性而存在。
color1	可选向量，存储第一个图的顶点着色。如果`None`，则所有顶点具有相同的颜色。
color2	可选向量，存储第二个图的顶点着色。如果`None`，则所有顶点具有相同的颜色。

返回
如果没有计算映射，结果为 `False``True`如果图是同构的，`False`否则为 `True`。如果计算了任一或两个映射，结果将是一个 3 元组，第一个元素是上述布尔值，第二个元素是 1 -> 2 映射，第三个元素是 2 -> 1 映射。如果没有计算相应的映射，`None`则在 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 同构算法检查图是否与另一个图同构。

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

参数
other	想要与当前图比较的另一个图。如果为 `None``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`意味着每条边都与所有其他节点兼容。
callback	如果不是 `None``None`，同构搜索将不会在第一次匹配时停止；它将为找到的每个同构调用此回调函数。回调函数必须接受四个参数：第一个图、第二个图、从第一个图节点到第二个图的映射，以及从第二个图节点到第一个图的映射。该函数必须返回 `True``True`如果搜索应该继续，则返回 `True`，否则返回 `False`。`False`否则。

返回
如果没有计算映射，结果为 `False``True`如果图是同构的，`False`否则为 `True`。如果计算了任一或两个映射，结果将是一个 3 元组，第一个元素是上述布尔值，第二个元素是 1 -> 2 映射，第三个元素是 2 -> 1 映射。如果没有计算相应的映射，`None`则在 3 元组的相应元素中返回 `None`。

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

生成 k-正则随机图

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

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

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``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`或`"unnormalized"`返回未归一化的拉普拉斯矩阵。`True`或`"symmetric"`返回拉普拉斯矩阵的对称归一化。`"left"`返回左归一化，`"right"`返回右归一化拉普拉斯矩阵。
mode	对于有向图，指定在拉普拉斯矩阵中使用出度还是入度。`"all"`意味着必须忽略边的方向，`"out"``"out"` 意味着应使用出度，`"in"``"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	表示两个顶点之间连接距离（步数）的值。
directed	是否创建有向图。
mutual	在有向图的情况下，是否将所有连接创建为互惠的。
circular	生成的格是否是周期性的。也可以是可迭代对象；在这种情况下，迭代器应生成布尔值，指定格在每个维度上是否是周期性的。

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

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

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

参数
类型	一个包含顶点类型的 igraph 向量，或一个属性名称。任何求值为`False`都对应于第一种类型的顶点，其他所有值则对应于第二种类型的顶点。
hgap	同一层中顶点之间的最小水平间距。
vgap	两层之间的垂直间隙。
maxiter	在交叉减少步骤中进行的最大迭代次数。如果您觉得边的交叉过多，请增加此值。

返回
计算出的布局。

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

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

参数
dim	布局所需的维度数量。dim=2 表示 2D 布局，dim=3 表示 3D 布局。
order	顶点沿圆形排列的顺序。当 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 布局算法将顶点放置在二维平面上。

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

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

参数
seed	如果`None`如果为 `None`，算法将使用随机起始布局。如果是矩阵（列表的列表），则使用给定矩阵作为起始位置。
maxiter	退火阶段要执行的迭代次数。
fineiter	微调阶段要执行的迭代次数。负数将根据顶点计数的以 2 为底的对数设置一个合理的默认值，上限为 10。
冷却因子（cool_fact）	模拟退火阶段的冷却因子。
weight_node_dist	能量函数中节点间距离的权重。
weight_border	能量函数中与边界分量距离的权重。零表示允许顶点位于指定布局区域的边界上。
weight_edge_lengths	能量函数中边长度分量的权重。负数会被替换为图的密度除以 10。
weight_edge_crossings	能量函数中边交叉分量的权重。负数会被替换为 1 减去图的密度的平方根。
weight_node_edge_dist	能量函数中节点-边距离分量的权重。负数会被替换为 0.2 减去 0.2 乘以图的密度。

返回
计算出的布局。

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

根据 DrL 布局算法将顶点放置在二维平面或三维空间中。

这是一种适用于大型图的算法，但对于小型图来说可能出奇地慢（对于小型图，更简单的基于力的布局算法，例如layout_kamada_kawai()或layout_fruchterman_reingold()更为有用）。

参数
weights	要使用的边权重。可以是序列、可迭代对象，甚至是边属性名称。
固定（fixed）	被忽略。我们曾认为 DrL 布局支持固定节点，但后来发现该参数在原始 DrL 代码中不起作用。我们保留了该参数以实现向后兼容性，但它对最终布局没有影响。
seed	如果`None`如果为 `None`，算法将使用随机起始布局。如果是矩阵（列表的列表），则使用给定矩阵作为起始位置。
options	如果在此处提供字符串参数，则可以从五种默认预设参数化中选择`default`, `coarsen`用于更粗糙的布局，`coarsest`用于更粗糙的布局，`refine`用于细化现有布局，以及`final`用于最终确定布局。如果您提供一个非字符串对象，DrL 布局参数将从该对象的相应键中检索（因此它应该是一个字典或支持映射协议的其他对象）。可以使用以下键： `edge_cut`：算法后期会进行边切割，以实现稀疏布局。如果边上有很大压力（目标函数和中的值较大），则会切割边。边切割参数是一个介于 0 和 1 之间的值，其中 0 表示不进行边切割，1 表示最大程度的边切割。 `init_iterations`：初始化阶段的迭代次数 `init_temperature`：初始化期间的起始温度 `init_attraction`：初始化期间的吸引力 `init_damping_mult`：初始化期间的阻尼乘数 `liquid_iterations`, `liquid_temperature`, `liquid_attraction`, `liquid_damping_mult`：液态阶段的相同参数 `expansion_iterations`, `expansion_temperature`, `expansion_attraction`, `expansion_damping_mult`：扩展阶段的参数 `cooldown_...`：冷却阶段的参数 `crunch_...`：紧缩阶段的参数 `simmer_...`：慢煮阶段的参数在这里，您也可以使用任意 Python 对象而不是映射：如果该对象不支持映射协议，则会查找该对象中具有相同名称的属性。如果参数既不能作为键也不能作为属性找到，则使用 `default``default`预设值。
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 算法将顶点放置在二维平面上。

这是一种力导向布局算法，参见 Fruchterman, T. M. J. 和 Reingold, E. M. 的论文《Graph Drawing by Force-directed Placement. Software -- Practice and Experience, 21/11, 1129--1164, 1991》。

参数
weights	要使用的边权重。可以是序列、可迭代对象，甚至是边属性名称。
niter	要执行的迭代次数。默认值为 500。
seed	如果`None`如果为 `None`，算法将使用随机起始布局。如果是矩阵（列表的列表），则使用给定矩阵作为起始位置。
起始温度（start_temp）	实数标量，起始温度。这是顶点在一个步骤内沿一个轴允许的最大移动量。当前，它在迭代过程中线性减小到零。默认值是顶点数平方根除以 10。
minx	如果不是 `None``None`如果不是 `None`，它必须是一个向量，其元素数量与图中的顶点数量完全相同。每个元素都是布局中顶点 X 值的最小约束。
maxx	类似于 minx，但带有最大约束
miny	类似于 minx，但用于 Y 坐标
maxy	类似于 maxx，但用于 Y 坐标
minz	类似于 minx，但用于 Z 坐标。仅用于 3D 布局（`dim=3`）。`dim`=3).
maxz	类似于 maxx，但用于 Z 坐标。仅用于 3D 布局（`dim=3`）。`dim`=3).
grid	是否使用更快但精度较低的基于网格的算法实现。`“auto”``"auto"` 根据图中的顶点数量决定；如果至少有 1000 个顶点，则将使用网格。`"grid"`等效于 `True`，`True`, `"nogrid"` 等效于 `False`。等效于 `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 的信息，请参见 https://web.archive.org/web/20220611030748/http://www.schmuhl.org/graphopt/ 和 https://sourceforge.net/projects/graphopt/。

参数
niter	要执行的迭代次数。通常应为几百次。
node_charge	顶点的电荷，用于计算电斥力。
node_mass	顶点的质量，用于弹簧力
spring_length	弹簧的长度
spring_constant	弹簧常数
max_sa_movement	在单个步骤中沿单个轴允许的最大移动量。
seed	一个包含种子布局的矩阵，算法将从该布局开始。如果为 `None``None`，将使用随机布局。

返回
计算出的布局。

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

将图的顶点放置在二维或三维网格中。

参数
width	布局中单行顶点数。零或负数表示宽度应自动确定。
height	布局中单列顶点数。零或负数表示高度应自动确定。如果维度数为 2，则不得给定此参数。
dim	布局所需的维度数量。dim=2 表示 2D 布局，dim=3 表示 3D 布局。

返回
计算出的布局。

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

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

这是一种力导向布局算法，参见 Kamada, T. 和 Kawai, S. 的论文《An Algorithm for Drawing General Undirected Graphs. Information Processing Letters, 31/1, 7--15, 1989》。

参数
maxiter	要执行的最大迭代次数。`None``None` 选择一个合理的默认值，该值基于顶点数量。
epsilon	如果系统能量变化小于 epsilon，则退出。有关详细信息，请参阅原始论文。
kkconst	Kamada-Kawai 顶点吸引常数。`None``None` 意味着顶点数。
seed	当`None`如果为 `None`，当未给定边界时，算法将使用圆形布局作为起始点；当为坐标指定边界时，则使用随机布局。当参数是矩阵（列表的列表）时，它使用给定矩阵作为初始布局。
minx	如果不是 `None``None`如果不是 `None`，它必须是一个向量，其元素数量与图中的顶点数量完全相同。每个元素都是布局中顶点 X 值的最小约束。
maxx	类似于 minx，但带有最大约束
miny	类似于 minx，但用于 Y 坐标
maxy	类似于 maxx，但用于 Y 坐标
minz	类似于 minx，但用于 Z 坐标。仅用于 3D 布局（`dim=3`）。`dim`=3).
maxz	类似于 maxx，但用于 Z 坐标。仅用于 3D 布局（`dim=3`）。`dim`=3).
dim	布局所需的维度数量。dim=2 表示 2D 布局，dim=3 表示 3D 布局。
weights	要使用的边权重。可以是序列、可迭代对象，甚至是边属性名称。

返回
计算出的布局。

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

根据大型图布局将顶点放置在二维平面上。

参数
maxiter	要执行的迭代次数。
maxdelta	在一次迭代中移动顶点的最大距离。如果为负数，则默认为顶点数。
area	顶点将被放置的方形区域的面积。如果为负数，则默认为顶点数的平方。
coolexp	模拟退火的冷却指数。
repulserad	决定了顶点-顶点斥力抵消相邻顶点吸引力的半径。如果为负数，则默认为 area 乘以顶点数。
cellsize	网格单元格的大小。计算斥力时，只考虑相同或相邻网格单元格中的顶点。默认为 area 的四次方根。
root	根顶点，它首先被放置，然后是它的邻居在第一次迭代中，其次是第二次迭代中的第二邻居，依此类推。`None``None` 意味着将选择一个随机顶点。

返回
计算出的布局。

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

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

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

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

参考文献: Cox & Cox: Multidimensional Scaling (1994), Chapman and Hall, London.

参数
dist	距离矩阵。它必须是对称的，并且不对称性进行检查——当使用非对称距离矩阵时，结果是未定义的。如果此参数为`None`，则最短路径长度将用作距离。在计算最短路径长度时，有向图被视为无向图以确保对称性。
dim	维度数。对于二维布局，此处提供 2；对于三维布局，提供 3。
arpack_options	用于微调 ARPACK 特征向量计算的 `ARPACKOptions` 对象。如果省略，则使用模块级变量`arpack_options`指定的默认调色板。

返回
计算出的布局。

def layout_random(dim=2): ¶

随机放置图的顶点。

参数
dim	布局所需的维度数量。dim=2 表示 2D 布局，dim=3 表示 3D 布局。

返回
列表中坐标对。

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

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

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

参考文献: EM Reingold, JS Tilford: Tidier Drawings of Trees. IEEE Transactions on Software Engineering 7:22, 223-228, 1981.

参数
mode	指定在构建树时要考虑哪些边。如果是`OUT`则只考虑出边，如果是`IN`则只考虑父节点的入边。如果是`ALL`则使用所有边（这是 igraph 0.5 及之前版本的行为）。此参数还会影响在未给出根顶点时如何计算它们。请参阅 root 参数。
root	根顶点或根顶点的索引。如果这是一个非空向量，则提供的顶点 ID 将用作树的根（如果图是连通的，则为单个树的根）。如果此为`None`或空列表，根顶点将自动计算，使得所有其他顶点都可以从它们到达。当前，自动根选择在小型图（少于 500 个顶点）中偏好低离心率的顶点，在大型图中偏好高度的顶点。这种启发式算法在未来版本中可能会改变。手动指定根以获得一致的输出。
rootlevel	此参数在绘制非树状森林时很有用。它指定了森林中每棵树的根顶点级别。

返回
计算出的布局。

另请参阅
layout_reingold_tilford_circular

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

树的圆形 Reingold-Tilford 布局。

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

请参阅 layout_reingold_tilford 以获取参数说明。

参考文献: EM Reingold, JS Tilford: Tidier Drawings of Trees. IEEE Transactions on Software Engineering 7:22, 223-228, 1981.

返回
计算出的布局。

另请参阅
layout_reingold_tilford

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

为图计算星形布局。

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

返回
计算出的布局。

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

统一流形逼近与投影 (UMAP)。

这种布局是一种概率算法，它将相互连接且距离较近的顶点放置在嵌入空间中彼此靠近的位置。

参考文献: L McInnes, J Healy, J Melville: UMAP: Uniform Manifold Approximation and Projection for Dimension Reduction. arXiv:1802.03426.

参数
dist	与图边关联的距离。如果为 None，则所有边将被假定在顶点之间传达相同的距离。此参数或`weights`参数可以设置，但不能同时设置两者。两者都不设置也行。
weights	如果您有预计算的边权重，可以替代设置`dist`参数。如果设置了此参数，零权重将被忽略，例如，如果您通过 igraph.umap_compute_weights() 计算了权重。
dim	布局所需的维度数量。dim=2 表示 2D 布局，dim=3 表示 3D 布局。
seed	如果`None`如果为 `None`，算法将使用随机起始布局。如果是矩阵（列表的列表），则使用给定矩阵作为起始位置。
min_dist	嵌入空间中的最小距离，超出该距离后，彼此靠近的概率会降低。
epochs	算法将迭代的 epoch（迭代）次数。更多 epoch 会提高准确性，但代价是运行时间更长。50 到 1000 之间的值是典型的。请注意，由于对称性原因，UMAP 在技术上不会收敛，但更多的 epoch 通常会提供等效或更好的布局。

计算出的布局。

请注意，如果设置了距离，则图通常是有向的；而如果预计算了权重，则图将被视为无向的。一种特殊情况是，当图是有向的，但预计算的权重以一种方式对称化，使得每对相反的边中只有一条具有非零权重，例如通过 igraph.umap_compute_weights() 计算得出的。例如weights = igraph.umap_compute_weights(graph, dist) layout = graph.layout_umap(weights=weights)

另请参阅
igraph.umap_compute_weights()

def LCF(n, shifts, repeats): ¶

从 LCF 符号生成图。

LCF 是 Lederberg-Coxeter-Frucht 的缩写，它是一种简洁的 3-正则哈密顿图表示法。它由三个参数组成：图中顶点的数量，一个移位列表（为循环骨架提供附加边），以及另一个整数（表示移位应执行的次数）。详情请参阅 https://mathworld.net.cn/LCFNotation.html 。

参数
n	顶点数量
shifts	列表或元组中的移位
repeats	重复次数

def linegraph(): ¶

返回图的线图。

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

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

原始图中的边 i 将映射到线图的顶点 i。

def list_triangles(): ¶

列出图中的三角形

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

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

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

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

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

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

在 igraph.Graph 中重写

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

注意：此函数在 Graph 类中有一个更方便的接口，它将结果封装在 Flow 对象中。建议使用该接口。

参数
source	源顶点 ID
target	目标顶点 ID
capacity	边的容量。它必须是一个列表、有效的属性名或`None`。在后一种情况下，每条边将具有相同的容量。

返回
一个包含以下内容的元组：给定顶点之间的最大流值、所有边上的流值、构成相应最小割的边 ID，以及割的一侧的顶点 ID。对于有向图，流值向量给出每条边上的流值。对于无向图，如果流从较小的顶点 ID 流向较大的顶点 ID，则流值为正；如果流从较大的顶点 ID 流向较小的顶点 ID，则流值为负。

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

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

参数
source	源顶点 ID
target	目标顶点 ID
capacity	边的容量。它必须是一个列表、有效的属性名或`None`。在后一种情况下，每条边将具有相同的容量。

返回
给定顶点之间的最大流值

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

以元组列表的形式返回图的最大团。

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

参数
min	要返回的最大团的最小大小。如果为零或负数，则不使用下限。
max	要返回的最大团的最大大小。如果为零或负数，则不使用上限。如果非零，则会将找到的每个最大团的大小与此值进行比较，并且仅当其大小小于此限制时才返回该团。
file	文件对象或要写入结果的文件名。当此参数为`None`时，最大团将作为列表的列表返回。

返回
图的最大团，作为列表的列表，或`None`如果`file`参数已给出。另请参阅：`largest_cliques()` 以获取最大的团。

def maximal_independent_vertex_sets(): ¶

以元组列表的形式返回图的最大独立顶点集。

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

参考文献: S. Tsukiyama, M. Ide, H. Ariyoshi and I. Shirawaka: A new algorithm for generating all the maximal independent sets. SIAM J Computing, 6:505-517, 1977.

另请参阅
`largest_independent_vertex_sets()` 获取最大独立顶点集

def maximum_cardinality_search(): ¶

对图进行最大基数搜索。此函数为每个顶点计算一个秩 alpha，使得按降序访问顶点时，始终选择已访问邻居最多的顶点作为下一个访问对象。

最大基数搜索有助于判断图的弦性：当且仅当一个顶点的任意两个邻居（其秩高于原始顶点）彼此连接时，该图才是弦图。

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

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

def mean_degree(loops=True): ¶

计算图的平均度。

参数
loops	计算期间是否考虑自环。

返回
图的平均度。

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

在 igraph.Graph 中重写

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

最小割是需要移除以分离源和目标（如果给出）或断开图（如果未给出源和目标）的最小边集。最小割是使用边的权重（容量）计算的，因此计算的是总容量最小的割。对于无向图且未指定源和目标的情况，该方法使用 Stoer-Wagner 算法。对于给定的源和目标，该方法使用推重标记算法；参见下方参考文献。

注意：此函数在 Graph 类中有一个更方便的接口，它将结果封装在 Cut 对象中。建议使用该接口。

参考文献

M. Stoer, F. Wagner: A simple min-cut algorithm. Journal of the ACM 44(4):585-591, 1997.
A. V. Goldberg, R. E. Tarjan: A new approach to the maximum-flow problem. Journal of the ACM 35(4):921-940, 1988.

参数
source	源顶点ID。如果`None`，目标也必须是 {None}，并且将对整个图（即所有可能的顶点对）进行计算。
target	目标顶点ID。如果`None`，源也必须是 {None}，并且将对整个图（即所有可能的顶点对）进行计算。
capacity	边的容量。它必须是一个列表、有效的属性名或`None`。在后一种情况下，每条边将具有相同的容量。

返回
最小割的值、第一和第二分区中顶点的ID以及割中边的ID，打包为一个四元组。

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

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

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

返回
给定顶点之间的最小割值

def minimum_cycle_basis(cutoff=None, complete=True, use_cycle_order=True): ¶

计算图的最小圈基

参数
cutoff	当`None`或负数，则返回完整的最小循环基。否则，结果中只有那些长度为 2*cutoff + 1 或更短的循环会成为某个最小循环基的一部分。长度超过此限制的循环可能不是最小可能大小。此参数有效地限制了计算候选循环时 BFS 树的深度，并可能显著加快计算速度。
complete	仅当指定了截止值时使用，在这种情况下，它指定是否返回完整基（`True`）或结果将仅限于长度为 2*cutoff + 1 或更短的循环。这限制了计算时间，但结果可能不会覆盖整个循环空间。
use_cycle_order	如果`True`，每个循环都按自然顺序返回：边 ID 将沿循环有序出现。如果`False`，则不保证循环内边 ID 的顺序。

返回
循环基，以包含边 ID 的元组列表形式。

def minimum_size_separators(): ¶

返回包含所有最小大小分隔顶点集的列表。

如果移除一个顶点集会使图断开连接，则该顶点集是一个分离器。此方法列出给定图中不存在更小分离器集的所有分离器。

参考文献: Arkady Kanevsky: Finding all minimum-size separating vertex sets in a graph. 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 是图中的总边权重。

注意：此方法在 Graph 中被覆盖，以允许 VertexClustering 对象作为参数。此方法并非严格必要，因为 VertexClustering 类提供了一个名为modularity.

参考文献: MEJ Newman and M Girvan: Finding and evaluating community structure in networks. Phys Rev E 69 026113, 2004。

参数
membership	成员向量，例如每个顶点的顶点类型索引。
weights	可选的边权重或`None`如果所有边的权重相等。
分辨率（resolution）	上述公式中的分辨率参数 gamma。当分辨率参数设置为 1 时，即得到模块度的经典定义。
directed	如果图是有向的，是否考虑边的方向。`True`将使用模块度度量的有向变体，其中节点的入度和出度分别处理；`False`将有向图视为无向图。

返回
模块度分数。

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

计算图的模块化矩阵。

参数
weights	可选的边权重或`None`如果所有边的权重相等。
分辨率（resolution）	模块度公式的分辨率参数 gamma。当分辨率参数设置为 1 时，即为模块度的经典定义。
directed	如果图是有向的，是否考虑边的方向。`True`将使用模块度度量的有向变体，其中节点的入度和出度分别处理；`False`将有向图视为无向图。

返回
模块度矩阵，作为列表的列表。

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

计算图中的motif数量

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

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

在大型网络中，模式的总数可能非常大，因此查找所有模式需要大量时间。在这种情况下，可以使用采样方法。此函数能够通过 cut_prob 参数进行采样。此参数给出模式搜索树的某个分支不会被探索的概率。

参考文献: S. Wernicke and F. Rasche: FANMOD: a tool for fast network motif detection, Bioinformatics 22(9), 1152--1153, 2006.

参数
size	模式的大小
cut_prob	搜索树不同级别的剪枝概率。这必须是一个长度为 size 的列表，或者`None`以查找所有模式。
callback	`None`或者是一个可调用对象，对于图中找到的每个模式都会调用它。该可调用对象必须接受三个参数：图本身、模式中的顶点列表以及模式的同构类（参见 `isoclass()`）。当回调返回一个具有非零真值或引发异常的对象时，搜索将停止。

返回
如果 callback 为，则为模式列表`None`，或`None`否则

另请参阅
Graph.motifs_randesu_no()

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

计算图中的motif总数

模式是图中给定结构的小型子图。此函数通过从顶点的随机样本中外推，估计图中模式的总数，而不为其分配同构类。

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

参考文献: S. Wernicke and F. Rasche: FANMOD: a tool for fast network motif detection, Bioinformatics 22(9), 1152--1153, 2006.

参数
size	模式的大小
cut_prob	搜索树不同级别的剪枝概率。这必须是一个长度为 size 的列表，或者`None`以查找所有模式。
sample	样本大小或用于采样的顶点 ID。

另请参阅
Graph.motifs_randesu()

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

计算图中的motif总数

模式是图中给定结构的小型子图。此函数计算图中模式的总数，而不为其分配同构类。

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

参考文献: S. Wernicke and F. Rasche: FANMOD: a tool for fast network motif detection, Bioinformatics 22(9), 1152--1153, 2006.

参数
size	模式的大小
cut_prob	搜索树不同级别的剪枝概率。这必须是一个长度为 size 的列表，或者`None`以查找所有模式。

另请参阅
Graph.motifs_randesu()

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

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

参数
vertices	单个顶点 ID 或顶点 ID 列表，或`None`表示图中的所有顶点。
order	邻域的阶数，即从种子顶点出发的最大步数。负值被解释为无限阶，即步数没有限制。
mode	指定在分析有向图时如何考虑边的方向。`"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`表示图中的所有顶点。
order	邻域的阶数，即从种子顶点出发的最大步数。负值被解释为无限阶，即步数没有限制。
mode	指定在分析有向图时如何考虑边的方向。`"out"`意味着只跟随出边，因此最多在 order 步内可从源顶点到达的所有顶点都被计数。`"in"`意味着只跟随入边（当然是反向），因此最多在 order 步内可从源顶点到达的所有顶点都被计数。`"all"`将有向边视为无向边。
mindist	将顶点包含在结果中所需的最小距离。如果为一，则不计数种子顶点。如果为二，则也不计数种子顶点的直接邻居，依此类推。

返回
如果 vertices 是指定单个顶点索引的整数，则为指定邻域大小的单个数字；如果 vertices 是列表，则为大小列表，或者`None`.

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

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

参数
vertex	一个顶点 ID。
mode	是否只返回后继（`"out"`），前驱（`"in"`）或两者（`"all"`）。对于无向图则忽略。

def path_length_hist(directed=True): ¶

在 igraph.Graph 中重写

计算图的路径长度直方图。注意：此函数在派生类 Graph 中以更方便的语法封装。建议使用该版本而非此版本。

参数
directed	是否考虑有向路径。

返回
一个元组。元组的第一个项是路径长度列表，列表的第 i 个元素包含长度为 i + 1 的路径数量。第二个项包含不连通顶点对的数量，为一个浮点数（因为可能无法放入整数）。

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

计算图的个性化 PageRank 值。

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

参数
vertices	查询的顶点索引。`None`表示所有顶点。
directed	是否考虑有向路径。
阻尼	阻尼因子。
重置	重置随机游走时要使用的顶点分布。可以是序列、可迭代对象或顶点属性名称，只要它们返回一个长度等于顶点数量的浮点数列表。如果`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 版本。

返回
包含指定顶点的个性化PageRank值的列表。

def predecessors(vertex): ¶

返回给定顶点的前驱。

等同于调用 neighbors() 方法并设置 type="in".

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

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

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

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

def Prufer(seq): ¶

从其 Prüfer 序列生成树。

普吕弗序列是与带标签树相关联的唯一整数序列。一个具有 n 个顶点的树可以用一个包含 n − 2 个整数的序列表示，每个整数介于 0 和 n − 1 之间（包括两端）。

参数
seq	普吕弗序列，作为整数的可迭代对象

def radius(mode='out', weights=None): ¶

计算图的半径。

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

参数
mode	在有向图的情况下，计算应考虑哪种路径。`OUT`考虑沿边方向的路径，`IN`考虑沿相反边方向的路径，`ALL`忽略边的方向。对于无向图，该参数将被忽略。
weights	包含边权重的列表。它也可以是属性名称（边权重从给定属性中检索）或`None`（所有边具有相同权重）。

返回
半径

另请参阅
`eccentricity()`

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

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

参数
起始	游走的起始顶点
步数（steps）	随机游走应采取的步数
mode	是否仅遵循出边（`"out"`），仅遵循入边（`"in"`）或两者（`"all"`）。对于无向图则忽略。@param stuck: 随机游走受阻时如何处理。`"return"`返回部分随机游走；`"error"`抛出异常。
受阻	未文档化
weights	要使用的边权重。可以是序列、可迭代对象，甚至是边属性名称。
return_type	返回什么。可以是`"vertices"`（默认），则函数返回访问过的顶点ID列表；`"edges"`，则函数返回访问过的边ID列表；或者`"both"`，则函数返回一个带有键的字典`"vertices"`和`"edges"`.

返回
从给定顶点开始，长度至多为给定长度（如果随机游走受阻则更短）的随机游走。

def Read_DIMACS(f, directed=False): ¶

在 igraph.Graph 中重写

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

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

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

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

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

返回
生成的图，流的源和目标，以及边的容量，以元组形式表示

def Read_DL(f, directed=True): ¶

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

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

def Read_Edgelist(f, directed=True): ¶

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

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

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

def Read_GML(f): ¶

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

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

def Read_GraphDB(f, directed=False): ¶

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

GraphDB是一种二进制格式，用于图数据库中的同构测试（参见 https://mivia.unisa.it/datasets/graph-database/arg-database/）。

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

def Read_GraphML(f, index=0): ¶

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

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

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

读取 LGL 使用的 .lgl 文件。

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

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

LGL最初无法处理包含多重边或自环的图，但此处未对此条件进行检查，因为igraph可以处理这些。

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

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

读取 LGL 使用的 .ncol 文件。

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

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

LGL最初无法处理包含多重边或自环的图，但此处未对此条件进行检查，因为igraph可以处理这些。

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

def Read_Pajek(f): ¶

读取 Pajek 格式文件并基于它创建图。仅支持 Pajek 网络文件（.net 扩展名），不支持项目文件（.paj）。

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

def Realize_Bipartite_Degree_Sequence(degrees1, degrees2, allowed_edge_types='simple', method='smallest'): ¶

从其分区度序列生成二分图。

此方法为二分图实现了Havel-Hakimi风格的图构造。在每一步中，算法以确定性方式选择两个顶点并将它们连接起来。选择顶点的方式由method参数定义。允许的边类型（即是否允许多重边）在allowed_edge_types参数中指定。永远不会创建自环，因为包含自环的图不是二分图。

参数
degrees1	第一部分的度数。
degrees2	第二部分的度数。
allowed_edge_types	控制在生成过程中是否允许多重边。可能的值为 `“simple”`：简单图（无多重边） `"multi"`：允许多重边
method	控制在生成过程中如何选择顶点。可能的值为 `smallest`：优先选择剩余度数最小的顶点。 `largest`：优先选择剩余度数最大的顶点。 `索引`：按索引顺序选择顶点。最小`smallest`方法保证生成连通图（如果存在）。

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

从度序列生成图。

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

参考文献

V. Havel, Poznámka o existenci konečných grafů (有限图存在性的一点说明), Časopis pro pěstování matematiky 80, 477-480 (1955)。 http://eudml.org/doc/19050
S. L. Hakimi, On Realizability of a Set of Integers as Degrees of the Vertices of a Linear Graph (关于一组整数作为线性图顶点度数的可实现性), Journal of the SIAM 10, 3 (1962)。 https://www.jstor.org/stable/2098770
D. J. Kleitman and D. L. Wang, Algorithms for Constructing Graphs and Digraphs with Given Valences and Factors (给定价数和因子的图和有向图构造算法), Discrete Mathematics 6, 1 (1973)。 https://doi.org/10.1016/0012-365X%2873%2990037-X
Sz. Horvát and C. D. Modes, Connectedness matters: construction and exact random sampling of connected networks (连通性很重要：连通网络的构建和精确随机采样) (2021)。 https://doi.org/10.1088/2632-072X/abced5

参数
out	无向图的度序列（如果 in_=None），或有向图的出度序列。
in_	None 用于生成无向图，入度序列用于生成有向图。
allowed_edge_types	控制在生成过程中是否允许自环或多重边。请注意，并非所有组合都支持所有类型的图；对于不支持的组合将抛出异常。可能的值为 `“simple”`：简单图（无自环，无多重边） `"loops"`：允许单个自环，但不允许多重边 `"multi"`：允许多重边，但不允许自环 `"all"`：允许多重边和自环
method	控制在生成过程中如何选择顶点。可能的值为 `smallest`：优先选择剩余度数最小的顶点。 `largest`：优先选择剩余度数最大的顶点。 `索引`：按索引顺序选择顶点。在无向情况下，`smallest`保证生成连通图。详情请参见 Horvát 和 Modes (2021)。

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

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

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

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

互惠性定义了有向图中相互连接的比例。它最常见的定义是，有向边的相反对应边也包含在图中的概率。如果mode为"default".

在igraph 0.6之前，实现了另一种度量，定义为如果已知顶点对之间存在（可能是非相互的）连接，则它们之间相互连接的概率。换句话说，（无序）顶点对分为三组：(1) 不连通，(2) 非互惠连通，(3) 互惠连通。结果是第(3)组的大小，除以第(2)组和第(3)组大小之和。如果mode为"ratio".

参数
ignore_loops	是否应忽略自环边。
mode	用于计算互惠性的算法；详见上文。

返回
图的互惠性

def reverse_edges(es): ¶

反转图中一些边的方向。

此函数对无向图无效。

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

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

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

重新布线是“就地”进行的，因此原始图将被修改。如果想保留原始图，请在重新布线前使用 copy 方法。

参数
n	重新布线尝试的次数。默认值为边数的10倍。
mode	要使用的重新布线算法。可以是`“simple”`或`"loops"`；前者不创建或销毁自环边，而后者会。

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

以恒定概率重连图的边。

图中每条边的每个端点都将以第一个参数中给定的常数概率进行重新布线。

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

参数
概率	重新布线概率
loops	算法是否允许创建自环边
multiple	算法是否允许创建多重边。

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

生成一个环形图。

参数
n	环中的顶点数量
directed	是否创建有向环。
mutual	是否在有向环中创建相互边。
circular	是否创建闭环。

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

基于随机块模型生成图。

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

参数
n	图中的顶点数量
pref_matrix	给出不同顶点类型连接概率的矩阵。
block_sizes	一个列表，给出每个块中的顶点数量；所有块的顶点数量之和必须等于 n。
directed	是否生成有向图。
loops	是否允许环边。

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

顶点的 Dice 相似系数。

两个顶点的Dice相似系数是它们共同邻居数量的两倍除以它们的度数之和。该系数与Jaccard系数非常相似，但通常比后者给出更高的相似性。

参数
vertices	要分析的顶点。如果`None`且 pairs 也是`None`，则考虑所有顶点。
pairs	要分析的顶点对。如果给出此参数，则 vertices 必须是`None`，并且相似性值将仅针对给定的对计算。顶点对必须指定为顶点ID的元组。
mode	对于有向图，应考虑哪些邻居。可以是`"all"`, `"in"`或`"out"`，对于无向图忽略。
loops	顶点是否应被视为与其自身相邻。将其设置为`True`假定所有顶点都存在自环边，即使图中没有自环边。将其设置为`False`可能会导致奇怪的结果：非相邻顶点与在它们之间添加边的情况相比，可能具有更大的相似性——然而，这可能正是你想要得到的结果。

返回
指定顶点的成对相似系数，如果`pairs`为`None`否则以列表形式返回，如果`pairs`不是`None`.

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

顶点的逆对数加权相似系数。

每个顶点被分配一个权重，该权重为 1 / log(度数)。两个顶点的对数加权相似度是它们共同邻居的权重之和。

请注意，自环边的存在可能会产生反直觉的结果。具有自环边的节点被认为是它自己的两次邻居（因为有两个边柄入射到该节点）。向节点添加自环边可能会降低它与其他节点的相似性，但也可能增加相似性。例如，如果节点A和B已连接但没有共同邻居，则它们的相似度为零。然而，如果向B添加自环边，则B本身成为A和B的共同邻居，从而A和B的相似度将增加。在使用 Graph.simplify() 调用此函数之前，请考虑明确移除自环边。

参数
vertices	要分析的顶点。如果`None`，则考虑所有顶点。
mode	对于有向图，应考虑哪些邻居。可以是`"all"`, `"in"`或`"out"`，对于无向图忽略。`"in"`表示权重由出度决定，`"out"`表示权重由入度决定。

返回
指定顶点的成对相似系数，以矩阵形式（列表的列表）返回。

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

顶点的 Jaccard 相似系数。

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

参数
vertices	要分析的顶点。如果`None`且 pairs 也是`None`，则考虑所有顶点。
pairs	要分析的顶点对。如果给出此参数，则 vertices 必须是`None`，并且相似性值将仅针对给定的对计算。顶点对必须指定为顶点ID的元组。
mode	对于有向图，应考虑哪些邻居。可以是`"all"`, `"in"`或`"out"`，对于无向图忽略。
loops	顶点是否应被视为与其自身相邻。将其设置为`True`假定所有顶点都存在自环边，即使图中没有自环边。将其设置为`False`可能会导致奇怪的结果：非相邻顶点与在它们之间添加边的情况相比，可能具有更大的相似性——然而，这可能正是你想要得到的结果。

返回
指定顶点的成对相似系数，如果`pairs`为`None`否则以列表形式返回，如果`pairs`不是`None`.

def simple_cycles(mode=None, min=-1, max=-1, output='epath'): ¶

查找图中的简单环

参数
mode	对于有向图，指定如何考虑边的方向。`"all"`意味着必须忽略边的方向，`"out"`意味着边必须是远离根的方向，`"in"`意味着边必须是朝向根的方向。对于无向图，此参数被忽略。
min	要返回的循环中顶点的最小数量。
max	要考虑的循环中顶点的最大数量。
output	决定返回什么。如果是`"vpath"`，将返回一个顶点ID元组列表。如果这是`"epath"`，返回边 ID 而不是顶点 ID。

返回
参见`output`参数的文档。

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内置函数，也被识别为字符串常量。

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

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

在 igraph.Graph 中重写

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

注意：此函数在类 Graph 中有一个更方便的接口，它将结果封装在 Cut 对象列表中。建议使用该接口。

参数
source	源顶点 ID
target	目标顶点 ID
capacity	边的容量。它必须是一个列表、有效的属性名或`None`。在后一种情况下，每条边将具有相同的容量。

返回
最小割的值、第一和第二分区中顶点的ID以及割中边的ID，打包为一个四元组。

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

生成一个星形图。

参数
n	图中的顶点数量
mode	指定要创建的星形图的类型。应为 "in"、"out"、"mutual" 或 "undirected" 之一。
center	星形图中中心顶点的顶点ID。

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

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

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

参数
m	图中的边数
fitness_out	一个具有非负项的数值向量，每个顶点一项。这些值代表适应度分数（对于有向图为出适应度分数）。fitness 是此关键字参数的别名。
fitness_in	一个具有非负项的数值向量，每个顶点一项。这些值代表有向图的入适应度分数。对于无向图，此参数必须为`None`.
loops	是否允许环边。
multiple	是否允许多重边。

返回
具有规定幂律度分布的有向图或无向图。

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

生成一个具有预设幂律度分布的非增长图。

参考文献

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 (Achlioptas过程下无标度网络的渗流相变). Phys Rev Lett 103:135702, 2009。

参数
n	图中的顶点数量
m	图中的边数
exponent_out	出度分布的指数，必须介于2和无穷大之间（包括两端）。当未给出 exponent_in 或其为负值时，图将是无向的，此参数指定度分布。exponent 是此关键字参数的别名。
exponent_in	入度分布的指数，必须介于2和无穷大之间（含）。它也可以是负数，在这种情况下将生成无向图。
loops	是否允许环边。
multiple	是否允许多重边。
finite_size_correction	对于指数小于3的生成适应度值是否应用有限尺寸校正。详情请参见Cho等人的论文。

返回
具有规定幂律度分布的有向图或无向图。

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

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

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

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

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

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

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

返回
与给定顶点在同一组件中的顶点索引。

def subgraph_edges(edges, delete_vertices=True): ¶

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

参数
edges	包含应包含在结果中的边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`时，只返回布尔值。

返回
如果没有计算映射，结果为 `False``True`如果图包含与给定模板同构的子图，则为True，`False`否则为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。
callback	如果不是 `None``None`，子同构搜索不会在第一次匹配时停止；相反，它会为每个找到的子同构调用此回调函数。回调函数必须接受四个参数：第一个图、第二个图、从第一个图的节点到第二个图的映射、以及从第二个图的节点到第一个图的映射。函数必须返回`True`如果搜索应该继续，则返回 `True`，否则返回 `False`。`False`否则。
node_compat_fn	一个函数，接收两个图和两个节点索引（一个来自第一个图，一个来自第二个图），并返回`True`如果两个索引给定的节点兼容（即它们可以相互匹配），否则返回`False`。这可用于根据节点特定条件限制同构集，这些条件过于复杂，无法通过节点颜色向量（即`color1`和`color2`参数）表示。`None`意味着每个节点都与所有其他节点兼容。
edge_compat_fn	一个函数，接收两个图和两个边索引（一个来自第一个图，一个来自第二个图），并返回`True`如果两个索引给定的边兼容（即它们可以相互匹配），否则返回`False`。这可用于根据边特定条件限制同构集，这些条件过于复杂，无法通过边颜色向量（即`edge_color1`和`edge_color2`参数）表示。`None`意味着每条边都与所有其他节点兼容。

如果没有计算映射，结果为 `False`True如果图包含与给定图同构的子图，则返回True，False否则为 `True`。如果计算了任一或两个映射，结果将是一个 3 元组，第一个元素是上述布尔值，第二个元素是 1 -> 2 映射，第三个元素是 2 -> 1 映射。如果没有计算相应的映射，None则在 3 元组的相应元素中返回 `None`。

def successors(vertex): ¶

返回给定顶点的后继。

等同于调用 neighbors() 方法并设置 type="out".

def to_directed(mode='mutual'): ¶

将无向图转换为有向图。

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

def to_prufer(): ¶

将树图转换为 Prüfer 序列。

返回
Prüfer序列作为列表

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

将有向图转换为无向图。

参数
mode	指定如何处理在同一顶点对之间连接的多条有向边。`True`或`"collapse"`表示应从多条有向边中只创建一条边。`False`或`"each"`表示每条边都将保留（箭头已移除）。`"mutual"`为每个相互有向边对创建一条无向边。
combine_edges	指定如何将同一对顶点之间的多条边的属性合并为单个属性。有关详细信息，请参见`simplify()`。

def topological_sorting(mode='out'): ¶

计算图的可能拓扑排序。

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

参数
mode	如果`"out"`，顶点按前向拓扑顺序返回——所有顶点都在其后继之前。如果`"in"`，所有顶点都在其祖先之前。

返回
一个可能的拓扑排序列表

def transitivity_avglocal_undirected(mode='nan'): ¶

在 igraph.Graph 中重写

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

传递性衡量一个顶点的两个邻居连接的概率。在平均局部传递性中，此概率针对每个顶点计算，然后取平均值。邻居少于两个的顶点需要特殊处理，它们将被排除在计算之外，或者根据mode参数被视为传递性为零。

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

参考：D. J. Watts和S. Strogatz：《小世界网络的集体动力学》。Nature 393(6884):440-442, 1998。

参数
mode	定义如何处理度数小于2的顶点。如果`TRANSITIVITT_ZERO`或`"zero"`，这些顶点的传递性将为零。如果`TRANSITIVITY_NAN`或`"nan"`，这些顶点将被排除在平均值计算之外。

另请参阅
`transitivity_undirected()`, `transitivity_local_undirected()`

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

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

传递性衡量一个顶点的两个邻居连接的概率。在局部传递性中，此概率针对每个顶点单独计算。

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

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

参考文献:

D. J. Watts和S. Strogatz：《小世界网络的集体动力学》。Nature 393(6884):440-442, 1998。
Barrat A, Barthelemy M, Pastor-Satorras R and Vespignani A: 复杂加权网络的架构。PNAS 101, 3747 (2004)。 https://arxiv.org/abs/cond-mat/0311416。

参数
vertices	一个包含应包含在结果中的顶点 ID 的列表。`None`表示所有顶点。
mode	定义如何处理度数小于2的顶点。如果`TRANSITIVITT_ZERO`或`"zero"`，这些顶点的传递性将为零。如果`TRANSITIVITY_NAN`或`"nan"`，这些顶点的传递性将是`NaN`（非数字）。
weights	要使用的边权重。可以是序列、可迭代对象，甚至是边属性名称。

返回
给定顶点的传递性列表

另请参阅
`transitivity_undirected()`, `transitivity_avglocal_undirected()`

def transitivity_undirected(mode='nan'): ¶

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

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

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

参考：S. Wasserman和K. Faust：《社会网络分析：方法与应用》。剑桥：剑桥大学出版社，1994年。

参数
mode	如果`TRANSITIVITY_ZERO`或`"zero"`，如果图没有任何三元组，结果将为零。如果`"nan"`或`TRANSITIVITY_NAN`，结果将是`NaN`（非数字）。

返回
传递性

另请参阅
`transitivity_local_undirected()`, `transitivity_avglocal_undirected()`

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

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

参数
n	图中的顶点数量
children	图中一个顶点的子节点数量
mode	决定树是否应该是有向的，如果是，也决定其方向。必须是以下之一：`"in"`, `"out"`和`"undirected"`.

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

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

参数
n	树中的顶点数量
directed	图是否应有向
method	要使用的生成方法。以下之一： `"prufer"`-- 均匀采样Prüfer序列，然后将其转换为树 `"lerw"`-- 在完全图上执行无环随机游走，以均匀采样其生成树（Wilson算法）。这是默认选择，因为它支持有向图和无向图。

def triad_census(): ¶

在 igraph.Graph 中重写

Davis 和 Leinhardt 定义的三元组普查

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

注意：此函数在Graph类中有一个更方便的接口，它将结果封装在TriadCensus对象中。建议使用该接口。三元组类的名称也记录在那里。

def Triangular_Lattice(dim, directed=False, mutual=True): ¶

生成一个规则三角形晶格。

参数
dim	包含晶格维度的列表
directed	是否创建有向图。
mutual	在有向图的情况下，是否将所有连接创建为互惠的。

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

必要时通过复制顶点，使用 BFS 将图展开为树。

参数
sources	开始展开的源顶点。它应该是一个顶点索引列表，最好是每个连通分量中有一个顶点。您可以使用`topological_sorting()`来确定一个合适的集合。也接受单个顶点索引。
mode	在BFS期间要跟踪的边。`OUT`跟踪出边，`IN`跟踪入边，`ALL`同时跟踪两者。对于无向图则忽略。

返回
展开的树图以及从新顶点索引到旧顶点索引的映射。

def vcount(): ¶

计算顶点数。

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

def vertex_attributes(): ¶

返回
图顶点属性名称列表

def vertex_coloring_greedy(method='colored_neighbors'): ¶

基于某些启发式算法为图计算贪婪顶点着色。

参数
method	要使用的启发式算法。`colored_neighbors`总是选择具有最多着色邻居的顶点作为下一个要着色的顶点。`dsatur`选择其邻域中具有最多唯一颜色的顶点；这也被称为DSatur启发式算法（因此得名）。

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

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

两个给定顶点之间的顶点连通性是指必须移除的顶点数量，以便将这两个顶点断开为两个独立的组件。这也是顶点之间顶点不相交有向路径的数量（当然，源顶点和目标顶点除外）。图的顶点连通性是所有顶点对之间最小的顶点连通性。

如果同时给定源顶点和目标顶点，此方法计算给定顶点对的顶点连通性。如果两者均未给定（或均为负数），则返回总体顶点连通性。

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

返回
顶点连通性

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

此函数基于Watts-Strogatz模型的一种变体生成具有小世界特性的网络。通过首先创建一个周期性无向格，然后以概率p重新连接每条边的两个端点，同时避免创建多重边来获得网络。

此过程与Watts和Strogatz的原始模型（参见参考文献）不同之处在于，它重新连接了边的两个端点。因此，当p=1时，我们得到一个与原始格具有相同顶点数和边数的G(n,m)随机图。相比之下，原始的Watts-Strogatz模型只重新连接每条边的一个端点，因此即使在p=1时，网络也不会完全随机。

对于适当的p选择，两种模型都表现出同时具有短路径长度和高聚类性的特性。

参考文献：Duncan J Watts和Steven H Strogatz：《小世界网络的集体动力学》，Nature 393, 440-442, 1998

参数
dim	格的维度
size	格沿所有维度的尺寸
nei	表示两个顶点之间连接距离（步数）的值。
p	重新布线概率
loops	指定是否允许自环边
multiple	指定是否允许多重边

另请参阅
`Lattice()`, `rewire()`, `rewire_edges()` 如果需要更大的灵活性

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

在 igraph.Graph 中重写

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

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

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, prefixattr=True): ¶

将图写入 GraphML 文件。

参数
f	要写入的文件名或Python文件句柄
prefixattr	写入文件中的属性名称是否应分别以`g_`, `v_`和`e_`作为图、顶点和边属性的前缀。这可能需要确保写入的GraphML文件中属性标识符的唯一性。

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

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

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

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

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

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

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

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

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

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

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

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

def write_pajek(f): ¶

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

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

def __graph_as_capsule(): ¶

以 PyCapsule 形式返回 Python 对象封装的 igraph 图

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

def __invalidate_cache(): ¶

使 Python 对象封装的底层 C 图对象的内部缓存失效。此函数不应由 igraph 用户直接使用，但可能对基准测试或调试目的有用。

def __register_destructor(destructor): ¶

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

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

内部函数，无文档。

另请参阅
Graph.Biadjacency()

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

从邻接矩阵生成图。

参数
matrix	邻接矩阵
mode	要使用的模式。可能的值有： `"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"`- 无向图，使用矩阵的左下三角形（包括对角线）
loops	指定如何处理环边。当为`False`或`"ignore"`时，邻接矩阵的对角线将被忽略。当为`True`或`"once"`时，对角线被假定包含相应环边的权重。当为`"twice"`时，对角线被假定包含相应环边权重的两倍。

返回
一个由图本身及其边权重向量组成的对