igraph.GraphBase

class documentation

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的spinglass社区检测方法找到图的社区结构。
方法	`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布局算法将顶点放置在2D平面上。
方法	`layout_drl`	根据DrL布局算法将顶点放置在2D平面或3D空间中。
方法	`layout_fruchterman_reingold`	根据Fruchterman-Reingold算法将顶点放置在2D平面上。
方法	`layout_graphopt`	这是Michael Schmuhl的graphopt布局算法的一个移植版本。graphopt版本0.4.1被重写为C语言，并且移除了对层的支持。
方法	`layout_grid`	将图的顶点放置在2D或3D网格中。
方法	`layout_kamada_kawai`	根据Kamada-Kawai算法将顶点放置在平面上。
方法	`layout_lgl`	根据大图布局将顶点放置在2D平面上。
方法	`layout_mds`	使用多维缩放将顶点放置在具有给定维数的欧几里得空间中。
方法	`layout_random`	将图的顶点随机放置。
方法	`layout_reingold_tilford`	根据Reingold-Tilford布局算法将顶点放置在2D平面上。
方法	`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`	计算图中的模体数量
方法	`motifs_randesu_estimate`	计算图中所有主题的总数
方法	`motifs_randesu_no`	计算图中所有主题的总数
方法	`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相似系数。
方法	`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`	将Python对象封装的igraph图作为PyCapsule返回
方法	`__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对象封装的igraph图的内存地址，作为一个普通的Python整数。
方法	`_spanning_tree`	内部函数，未记录。
方法	`_Weighted_Adjacency`	从其邻接矩阵生成图。

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

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

def add_edges(es): ¶

overridden in igraph.Graph

向图中添加边。

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

def add_vertices(n): ¶

overridden in igraph.Graph

向图中添加顶点。

参数
n	要添加的顶点数量

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

overridden in 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 和 Olivier Cogis: 生成图的所有最小分隔符。载于: Peter Widmayer, Gabriele Neyer 和 Stephan Eidenbenz (编): 计算机科学中的图论概念, 1665, 167-172, 1999. Springer.

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

def all_st_cuts(source, target): ¶

overridden in igraph.Graph

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

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

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

参数
source	源顶点ID
target	目标顶点ID
返回
一个元组，其中第一个元素是表示切割的边ID列表的列表，第二个元素是表示被切割分隔的顶点集合的顶点ID列表的列表。

def all_st_mincuts(source, target): ¶

overridden in igraph.Graph

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

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

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

def are_adjacent(v1, v2): ¶

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

参数
v1	第一个顶点的ID或名称
v2	第二个顶点的ID或名称
返回
`True` 如果存在从 v1 到 v2 的边，否则为 `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): ¶

返回基于顶点类别的图的同配性。

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

请参见Newman MEJ: 网络中的混合模式, Phys Rev E 67:026126 (2003)中的方程(2)以获取正确定义。

参考文献: Newman MEJ: 网络中的混合模式, 物理评论 E 67:026126, 2003.

参数
types	顶点类型的列表或包含顶点类型的顶点属性的名称。类型应由数值表示。
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: 图集. 牛津大学出版社, 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同构算法计算图的自同构群的生成器。

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

参数
sh	用于图的分割启发式方法，作为不区分大小写的字符串，可能的值如下： `"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 和 Albert, R. 1999. 随机网络中的标度涌现. 科学, 286 509-512.

参数
n	顶点的数量
m	每个顶点生成的出边数量，或者明确包含每个顶点出边数量的列表。
outpref	`True` 如果给定顶点的出度也应增加其引用概率（以及其入度），但默认值为 `False`。
directed	`True` 如果生成的图应该是有向的（默认：`False`）。
power	非线性模型的幂常数。可以省略，在这种情况下将使用通常的线性模型。
zero_appeal	度数为零的顶点的吸引力。
implementation	用于生成网络的算法。可能的值为： `"bag"`: 在0.6版本之前，igraph中默认使用的算法。它通过将顶点的ID放入一个袋子（多重集）中，次数等于它们的入度加一次。然后从袋子中抽取所需的引用顶点数量，允许重复抽取。它仅适用于power=1和zero_appeal=1的情况。 `"psumtree"`: 该算法使用部分前缀和树来生成图。它不会生成多重边，并且适用于任何power和zero_appeal的值。 `"psumtree_multiple"`: 类似于`"psumtree"`，但它也会生成多重边。在0.6版本之前，igraph对于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树中的父节点。
返回
BFS迭代器作为一个`igraph.BFSIter`对象。

def bibcoupling(vertices=None): ¶

计算图中给定顶点的文献耦合分数。

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

def biconnected_components(return_articulation_points=True): ¶

overridden in igraph.Graph

计算图的双连通组件。

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

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

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

overridden in igraph.Graph

内部函数，未记录。

另请参阅
Graph.bipartite_projection()

def bipartite_projection_size(types): ¶

overridden in igraph.Graph

内部函数，未记录。

另请参阅
Graph.bipartite_projection_size()

def bridges(): ¶

返回图中的桥梁列表。

如果移除一条边会增加图中（弱）连通分量的数量，那么这条边就是一座桥。

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

使用BLISS同构算法计算图的规范排列。

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

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

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

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

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

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

图的弦补全是为了使图成为弦图而需要添加的边的列表。如果图已经是弦图，则它是一个空列表。

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

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

def Chung_Lu(out, in_=None, loops=True, variant='original'): ¶

生成一个Chung-Lu随机图。

In the original Chung-Lu model, each pair of vertices i and j is connected with independent probability p_ij = w_iw_j ⁄ S, where w_i is a weight associated with vertex i and S = ∑_kw_k is the sum of weights. In the directed variant, vertices have both out-weights, w^out, and in-weights, wⁱⁿ, with equal sums, S = ∑_kw^out_k = ∑_kwⁱⁿ_k. The connection probability between i and j is 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模型无法产生某些（较大的）预期度数。

The overcome this limitation, this function implements additional variants of the model, with modified expressions for the connection probability p_ij between vertices i and j. Let q_ij = w_iw_j ⁄ S, or q_ij = w^out_iwⁱⁿ_j ⁄ S in the directed case. All model variants become equivalent in the limit of sparse graphs where q_ij approaches zero. In the original Chung-Lu model, selectable by setting variant to "original", p_ij = min(q_ij, 1). The "maxent" variant, sometimes referred to as the generalized random graph, uses p_ij = q_ij ⁄ (1 + q_ij), and is equivalent to a maximum entropy model (i.e. exponential random graph model) with a constraint on expected degrees, see Park and Newman (2004), Section B, setting exp( − Θ_ij) = w_iw_j ⁄ S. This model is also discussed by Britton, Deijfen and Martin-Löf (2006). By virtue of being a degree-constrained maximum entropy model, it generates graphs having the same degree sequence with the same probability. A third variant can be requested with "nr", and uses p_ij = 1 − exp( − q_ij). This is the underlying simple graph of a multigraph model introduced by Norros and Reittu (2006). For a discussion of these three model variants, see Section 16.4 of Bollobás, Janson, Riordan (2007), as well as Van Der Hofstad (2013).

参考文献:

Chung F and Lu L: Connected components in a random graph with given degree sequences. Annals of Combinatorics 6, 125-145 (2002) https://doi.org/10.1007/PL00012580
Miller JC and Hagberg A: Efficient Generation of Networks with Given Expected Degrees (2011) https://doi.org/10.1007/978-3-642-21286-4_10
Park J and Newman MEJ: Statistical mechanics of networks. Physical Review E 70, 066117 (2004). https://doi.org/10.1103/PhysRevE.70.066117
Britton T, Deijfen M, Martin-Löf A: Generating Simple Random Graphs with Prescribed Degree Distribution. J Stat Phys 124, 1377–1397 (2006). https://doi.org/10.1007/s10955-006-9168-x
Norros I and Reittu H: On a conditionally Poissonian graph process. Advances in Applied Probability 38, 59–75 (2006). https://doi.org/10.1239/aap/1143936140
Bollobás B, Janson S, Riordan O: The phase transition in inhomogeneous random graphs. Random Struct Algorithms 31, 3–122 (2007). https://doi.org/10.1002/rsa.20168
Van Der Hofstad R: Critical behavior in inhomogeneous random graphs. 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(): ¶

overridden in igraph.Graph

计算图的凝聚块结构。

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

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

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

overridden in igraph.Graph

根据Clauset等人的算法，通过贪婪优化模块性来找到图的社区结构。

这是一种自底向上的算法：最初每个顶点属于一个独立的社区，然后社区一个接一个地合并。在每一步中，被合并的两个社区是那些能够导致模块性最大增加的社区。

注意：此函数在派生类 Graph 中被封装为更便捷的语法。建议使用该版本而不是此版本。

参考文献: A. Clauset, M. E. J. Newman 和 C. Moore: 在非常大的网络中寻找社区结构。 物理评论 E 70, 066111 (2004).

参数
weights	边属性的名称或包含边权重的列表
返回
一个包含以下元素的元组：合并的列表每次合并前的模块化分数
另请参阅
模块化()

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

overridden in igraph.Graph

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

请参阅http://www.mapequation.org以查看算法的可视化或下面提供的参考文献之一。参考文献

M. Rosvall and C. T. Bergstrom: Maps of information flow reveal community structure in complex networks. PNAS 105, 1118 (2008). http://arxiv.org/abs/0707.0609
M. Rosvall, D. Axelsson and C. T. Bergstrom: The map equation. Eur Phys J Special Topics 178, 13 (2009). http://arxiv.org/abs/0906.1405

参数
edge_weights	边属性的名称或包含边权重的列表。
vertex_weights	顶点属性的名称或包含顶点权重的列表。
trials	尝试划分网络的次数。
返回
计算出的成员向量和相应的代码长度在一个元组中。

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

overridden in igraph.Graph

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

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

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

参考文献: Raghavan, U.N. 和 Albert, R. 以及 Kumara, S. 近线性时间算法检测大规模网络中的社区结构。 Phys Rev E 76:036106, 2007. http://arxiv.org/abs/0709.2938.

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

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

overridden in igraph.Graph

Newman的特征向量社区结构检测的正确实现。每次分割都是通过最大化原始网络的模块性来完成的。详情请参阅参考文献。

注意：此函数在派生类 Graph 中被封装为更便捷的语法。建议使用该版本而不是此版本。

参考: MEJ Newman: 使用矩阵的特征向量在网络中寻找社区结构, 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): ¶

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

overridden in igraph.Graph

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

参考: VD Blondel, J-L Guillaume, R Lambiotte 和 E Lefebvre: 大型网络中社区层次的快速展开。J Stat Mech P10008 (2008), http://arxiv.org/abs/0803.0476

注意：此函数在派生类 Graph 中被封装为更便捷的语法。建议使用该版本而不是此版本。

参数
weights	边属性的名称或包含边权重的列表
return_levels	如果 `True`，返回多层次结果。如果 `False`，只返回最佳层次（对应于最佳模块性）。
resolution	用于模块化度量的分辨率参数。较小的值会导致较少的较大集群，而较高的值会产生大量的小集群。经典的模块化度量假设分辨率参数为1。
返回
要么是一个描述每个顶点社区成员资格的单一列表（如果`return_levels`是`False`），要么是一个社区成员资格向量的列表，每个级别对应一个向量，以及一个对应的模块性列表（如果`return_levels`是`True`）。
另请参阅
模块化()

def community_optimal_modularity(weights=None): ¶

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

overridden in igraph.Graph

根据Reichardt & Bornholdt的spinglass社区检测方法，找到图的社区结构。

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

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

overridden in igraph.Graph

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

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

注意：此函数在派生类 Graph 中被封装为更便捷的语法。建议使用该版本而不是此版本。

参考: Pascal Pons, Matthieu Latapy: 使用随机游走计算大型网络中的社区, http://arxiv.org/abs/physics/0512106.

参数
weights	边属性的名称或包含边权重的列表
steps	未记录
返回
一个包含合并列表和每个合并对应的模块化分数的元组
另请参阅
模块化()

def complementer(loops=False): ¶

返回图的补图

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

def compose(other): ¶

返回两个图的组合。

def connected_components(mode='strong'): ¶

overridden in igraph.Graph

计算给定图的（强或弱）连通组件。

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

参数
mode	必须是 `"strong"` 或 `"weak"`，取决于所寻找的集群。可选，默认为 `"strong"`。
返回
图中每个节点的组件索引。

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

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

如果自我拥有较少或相互之间关系更强（即更冗余）的联系，Burt的约束度会更高。Burt对顶点i的自我网络V[i]的约束度C[i]的度量，针对有向和有值图定义如下：

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

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

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

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

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

def contract_vertices(mapping, combine_attrs=None): ¶

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

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

def convergence_degree(): ¶

尚未记录。

def convergence_field_size(): ¶

未记录（尚未）。

def copy(): ¶

创建图的副本。

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

def coreness(mode='all'): ¶

找到网络顶点的核心度（壳层索引）。

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

参考: Vladimir Batagelj, Matjaz Zaversnik: 一个O(m)算法用于网络的核心分解。

参数
mode	是否计算核心度（`"in"`）、出核心度（`"out"`）或无向核心度（`"all"`）。对于无向图，此参数被忽略并假定为`"all"`。
返回
每个顶点的核心度。

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

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

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

参数
sh	用于图的分割启发式方法，作为不区分大小写的字符串，可能的值如下： `"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) 的德布鲁因图

德布鲁因图表示字符串之间的关系。使用一个包含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	the generation method to be used. One of the following: `"configuration"` -- simple generator that implements the stub-matching configuration model. It may generate self-loops and multiple edges. This method does not sample multigraphs uniformly, but it can be used to implement uniform sampling for simple graphs by rejecting any result that is non-simple (i.e. contains loops or multi-edges). `"fast_heur_simple"` -- similar to `"configuration"` but avoids the generation of multiple and loop edges at the expense of increased time complexity. The method will re-start the generation every time it gets stuck in a configuration where it is not possible to insert any more edges without creating loops or multiple edges, and there is no upper bound on the number of iterations, but it will succeed eventually if the input degree sequence is graphical and throw an exception if the input degree sequence is not graphical. This method does not sample simple graphs uniformly. `"configuration_simple"` -- similar to `"configuration"` but rejects generated graphs if they are not simple. This method samples simple graphs uniformly. `"edge_switching_simple"` -- an MCMC sampler based on degree-preserving edge switches. It generates simple undirected or directed graphs. The algorithm uses `Graph.Realize_Degree_Sequence()` to construct an initial graph, then rewires it using `Graph.rewire()`. `"vl"` -- a more sophisticated generator that can sample undirected, connected simple graphs approximately uniformly. It uses edge-switching Monte-Carlo methods to randomize the graphs. This generator should be favoured if undirected and connected graphs are to be generated and execution time is not a concern. igraph uses the original implementation of Fabien Viger; see the following URL and the paper cited on it for the details of the algorithm: https://www-complexnetworks.lip6.fr/~latapy/FV/generation.html.

def delete_edges(es): ¶

overridden in 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的列表，这些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 和 Claxton R: 网络多样性与经济发展, 科学 328, 1029-1031, 2010.

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

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

返回从给定根节点开始的支配树

参数
vid	根顶点ID
mode	可以是 `"in"` 或 `"out"`
返回
包含当前图的支配树列表。

def dyad_census(): ¶

overridden in igraph.Graph

由Holland和Leinhardt定义的二元组普查

二元组普查意味着将有向图的每对顶点分类为三种类型：互惠的，存在从a到b的边，同时也存在从b到a的边；非对称的，存在从a到b或从b到a的边，但不是双向的；以及空的，a和b之间没有边。

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

返回
三元组中相互、不对称和空连接的数量。

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

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

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

参数
vertices	必须返回偏心度分数的顶点。如果 `None`，则使用图中的所有顶点。
mode	必须是 `"in"`, `"out"` 和 `"all"` 中的一个。`"in"` 表示遵循边的方向；`"out"` 表示遵循边的相反方向；`"all"` 表示忽略方向。该参数对无向图没有影响。
weights	一个包含边权重的列表。它也可以是一个属性名称（边权重从给定的属性中获取）或`None`（所有边的权重相等）。
返回
计算出的偏心度列表，如果提供了单个顶点，则为单个数字。

def ecount(): ¶

计算边的数量。

返回
integer	图中的边数。

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图。此方法根据其名称（不区分大小写）生成其中一个。有关可用名称，请参阅igraph的C接口文档：https://igraph.org/c/doc。

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

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

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

如果存在许多长度等于直径的最短路径，则返回找到的第一个。

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

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

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

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

参考文献: Eades P, Lin X 和 Smyth WF: 一种快速有效的反馈弧集问题启发式算法。发表于: 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'): ¶

overridden in igraph.Graph

返回图的邻接矩阵。

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

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

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

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

def get_biadjacency(types): ¶

overridden in 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或名称。
to	计算路径的目标顶点的ID或名称。
k	所需的最短路径数量
weights	边权重在一个列表中或持有边权重的边属性的名称。如果 `None`，则假定所有边的权重相等。
mode	路径的方向性。`"in"` 表示计算传入路径，`"out"` 表示计算传出路径，`"all"` 表示计算两者。
output	决定应返回的内容。如果这是`"vpath"`，将返回顶点ID的列表，每个目标顶点一个路径。对于未连接的图，某些列表元素可能为空。请注意，在mode=`"in"`的情况下，路径中的顶点以相反的顺序返回。如果`output="epath"`，则返回边ID而不是顶点ID。
返回
从给定的源节点到给定的目标节点的k条最短路径，以顶点或边ID的列表形式返回（取决于`output`参数的值）。请注意，在mode=`"in"`的情况下，路径中的顶点将以相反的顺序返回！

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

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

此函数仅返回单个最短路径。考虑使用get_shortest_paths()来查找源顶点与一个或多个目标顶点之间的所有最短路径。

参数
v	路径的源顶点
to	路径的目标顶点
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	路径的源顶点
to	路径的目标顶点
heuristics	一个函数，它将与图和两个顶点一起调用，并且必须返回从第一个顶点到第二个顶点的路径成本的估计值。如果启发式是可接受的，即如果它从不高估从给定源顶点到给定目标顶点的最短路径的成本，则A-Star算法保证返回最优解。
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	计算路径的源/目标
to	一个顶点选择器，描述计算路径的目标/源。这可以是单个顶点ID、顶点ID列表、单个顶点名称、顶点名称列表或一个`VertexSeq`对象。`None`表示所有顶点。
weights	边权重在一个列表中或持有边权重的边属性的名称。如果 `None`，则假定所有边的权重相等。
mode	路径的方向性。`"in"` 表示计算传入路径，`"out"` 表示计算传出路径，`"all"` 表示计算两者。
output	决定应返回的内容。如果这是`"vpath"`，将返回顶点ID的列表，每个目标顶点一个路径。对于未连接的图，某些列表元素可能为空。请注意，在mode=`"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): ¶

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

检查图是否有多条边。

返回
boolean	`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 条边。当两个顶点的ID的二进制表示恰好有一位不同时，这两个顶点是相连的。

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

返回图是否是无环的（即不包含任何循环）。

返回
boolean	`True` 如果图是无环的，`False` 否则。

def is_biconnected(): ¶

决定图是否是双连通的。

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

请注意，关于是否将包含两个连接顶点的图视为双连通图，存在不同的惯例。igraph确实将其视为双连通的。

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

def is_bipartite(return_types=False): ¶

判断图是否为二分图。

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

参数
return_types	如果 `False`，该方法将简单地返回 `True` 或 `False`，取决于图是否是二分图。如果 `True`，实际的组分配也将作为布尔值列表返回。（请注意，组分配不是唯一的，特别是如果图由多个组件组成，因为组件的分配是相互独立的）。
返回
`True` 如果图是二分图，`False` 如果不是。如果 `return_types` 是 `True`，则还会返回组分配。

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

返回图是否为弦图。

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

def is_clique(vertices=None, directed=False): ¶

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

参数
vertices	顶点ID的列表。
directed	在有向图中是否需要顶点对之间的相互连接。
返回
`True` 表示给定的顶点集是一个团，`False` 表示不是。

def is_complete(): ¶

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

返回
boolean	`True` 如果它是完整的，`False` 否则。

def is_connected(mode='strong'): ¶

决定图是否连通。

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

def is_dag(): ¶

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

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

返回
boolean	`True` 如果它是一个有向无环图（DAG），否则为 `False`。

def is_directed(): ¶

检查图是否为有向图。

返回
boolean	`True` 如果是有向的，`False` 否则。

def is_independent_vertex_set(vertices=None): ¶

决定集合内是否没有两个顶点是相邻的。

参数
vertices	顶点ID的列表。
返回
`True` 表示给定的顶点形成一个独立集，`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): ¶

检查一条边是否有相反的对。

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

参数
edges	我们想要检查的边的索引。如果 `None`，则检查所有边。
loops	指定在有向图中是否应将循环边视为相互的。
返回
一个布尔值列表，每个给定的边对应一个

def is_separator(vertices): ¶

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

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

def is_simple(): ¶

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

返回
boolean	`True` 如果是简单的，`False` 否则。

def is_tree(mode='out'): ¶

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

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

参数
mode	对于有向图，指定应如何考虑边的方向。`"all"` 表示必须忽略边的方向，`"out"` 表示边必须远离根节点，`"in"` 表示边必须朝向根节点。对于无向图则忽略此参数。
返回
boolean	`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): ¶

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

使用的算法是通过一个简单的启发式方法选择的：

If one graph is directed and the other undirected, an exception is thrown.
If the two graphs does not have the same number of vertices and edges, it returns with False
If the graphs have three or four vertices, then an O(1) algorithm is used with precomputed data.
Otherwise if the graphs are directed, then the VF2 isomorphism algorithm is used (see isomorphic_vf2).
Otherwise the BLISS isomorphism algorithm is used, see isomorphic_bliss.

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

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

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

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

参数
other	我们想要与之比较的另一个图。
return_mapping_12	如果 `True`，计算将第一个图的顶点映射到第二个图的映射。
return_mapping_21	如果 `True`，计算将第二个图的顶点映射到第一个图的映射。
sh1	第一个图的分割启发式方法，作为不区分大小写的字符串，可能的值如下： `"f"`: 第一个非单例单元 `"fl"`: 第一个最大的非单例单元 `"fs"`: 第一个最小的非单例单元 `"fm"`: 第一个最大非平凡连接的非单例单元 `"flm"`: 最大非平凡连接的非单例单元 `"fsm"`: 最小非平凡连接的非单例单元
sh2	用于第二个图的分割启发式方法。这必须与`sh1`相同；或者，它可以是`None`，在这种情况下，它将自动使用与`sh1`相同的值。目前它仅用于向后兼容。
color1	可选的向量，存储第一个图顶点的着色。如果为`None`，则所有顶点具有相同的颜色。
color2	可选的向量，存储第二个图顶点的着色。如果为`None`，则所有顶点具有相同的颜色。
返回
如果没有计算映射，如果图是同构的，则结果为 `True`，否则为 `False`。如果计算了任一或两个映射，则结果是一个三元组，第一个元素是上述布尔值，第二个元素是 1 -> 2 的映射，第三个元素是 2 -> 1 的映射。如果未计算相应的映射，则在三元组的相应元素中返回 `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`，将测试图的自同构。
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`，同构搜索不会在第一个匹配处停止；相反，它会为每个找到的同构调用此回调函数。回调函数必须接受四个参数：第一个图，第二个图，从第一个图的节点到第二个图的映射，以及从第二个图的节点到第一个图的映射。如果搜索应继续，函数必须返回`True`，否则返回`False`。
返回
如果没有计算映射，如果图是同构的，则结果为 `True`，否则为 `False`。如果计算了任一或两个映射，则结果是一个三元组，第一个元素是上述布尔值，第二个元素是 1 -> 2 的映射，第三个元素是 2 -> 1 的映射。如果未计算相应的映射，则在三元组的相应元素中返回 `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` 表示所有顶点。
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"` 表示应使用出度，`"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布局算法所使用的启发式方法优化顶点在行中的位置，以最小化边的交叉数量。

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

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

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

参数
dim	布局所需的维度数。dim=2 表示二维布局，dim=3 表示三维布局。
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布局算法将顶点放置在2D平面上。

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

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

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

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

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

这是一种适用于非常大的图的算法，但对于小图来说可能会出奇地慢（在这种情况下，像layout_kamada_kawai()或layout_fruchterman_reingold()这样更简单的基于力的布局更有用。

参数
weights	要使用的边权重。可以是序列、可迭代对象，甚至是边属性名称。
fixed	忽略。我们曾经假设DrL布局支持固定节点，但后来发现该参数在原始DrL代码中没有效果。为了向后兼容，我们保留了该参数，但它不会对最终布局产生影响。
seed	如果为 `None`，则使用随机起始布局进行算法。如果是一个矩阵（列表的列表），则使用给定的矩阵作为起始位置。
options	if you give a string argument here, you can select from five default preset parameterisations: `default`, `coarsen` for a coarser layout, `coarsest` for an even coarser layout, `refine` for refining an existing layout and `final` for finalizing a layout. If you supply an object that is not a string, the DrL layout parameters are retrieved from the respective keys of the object (so it should be a dict or something else that supports the mapping protocol). The following keys can be used: `edge_cut`: edge cutting is done in the late stages of the algorithm in order to achieve less dense layouts. Edges are cut if there is a lot of stress on them (a large value in the objective function sum). The edge cutting parameter is a value between 0 and 1 with 0 representing no edge cutting and 1 representing maximal edge cutting. `init_iterations`: number of iterations in the initialization phase `init_temperature`: start temperature during initialization `init_attraction`: attraction during initialization `init_damping_mult`: damping multiplier during initialization `liquid_iterations`, `liquid_temperature`, `liquid_attraction`, `liquid_damping_mult`: same parameters for the liquid phase `expansion_iterations`, `expansion_temperature`, `expansion_attraction`, `expansion_damping_mult`: parameters for the expansion phase `cooldown_...`: parameters for the cooldown phase `crunch_...`: parameters for the crunch phase `simmer_...`: parameters for the simmer phase Instead of a mapping, you can also use an arbitrary Python object here: if the object does not support the mapping protocol, an attribute of the object with the same name is looked up instead. If a parameter cannot be found either as a key or an attribute, the default from the `default` preset will be used.
dim	布局所需的维度数。dim=2 表示二维布局，dim=3 表示三维布局。
返回
计算出的布局。

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

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

这是一个力导向布局，参见 Fruchterman, T. M. J. 和 Reingold, E. M.: 通过力导向布局绘制图形。软件 -- 实践与经验，21/11，1129--1164，1991

参数
weights	要使用的边权重。可以是序列、可迭代对象，甚至是边属性名称。
niter	执行的迭代次数。默认值为500。
seed	如果 `None`，则使用随机起始布局进行算法。如果是一个矩阵（列表的列表），则使用给定的矩阵作为起始位置。
start_temp	实数标量，起始温度。这是在一个步骤内，顶点沿一个轴允许的最大移动量。目前它在迭代过程中线性减少到零。默认值是顶点数的平方根除以10。
minx	如果不是`None`，它必须是一个向量，其元素数量与图中的顶点数量完全相同。每个元素都是布局中顶点X值的最小约束。
maxx	类似于 minx，但具有最大约束
miny	类似于 minx，但是针对 Y 坐标
maxy	类似于 maxx，但用于 Y 坐标
minz	类似于 minx，但用于 Z 坐标。仅用于 3D 布局 (`dim`=3)。
maxz	类似于 maxx，但用于 Z 坐标。仅用于 3D 布局 (`dim`=3)。
grid	是否使用更快但精度较低的基于网格的算法实现。`"auto"` 根据图中的顶点数量决定；如果顶点数量至少为1000，则使用网格。`"grid"` 等同于 `True`，`"nogrid"` 等同于 `False`。
返回
计算出的布局。

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

这是由Michael Schmuhl开发的graphopt布局算法的移植版本。graphopt版本0.4.1被重写为C语言，并且移除了对图层的支持。

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

查看原始graphopt，请访问http://www.schmuhl.org/graphopt/。

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

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

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

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

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.: 绘制一般无向图的算法。信息处理快报，31/1，7--15，1989年。

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

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

根据大图布局将顶点放置在2D平面上。

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

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

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

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

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

参考: Cox & Cox: 多维尺度分析 (1994), Chapman and Hall, 伦敦.

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

def layout_random(dim=2): ¶

将图的顶点随机放置。

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

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

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

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

参考文献: EM Reingold, JS Tilford: 更整洁的树形图绘制. IEEE软件工程汇刊 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: 更整洁的树形图绘制方法. IEEE软件工程学报 7:22, 223-228, 1981.

返回
计算出的布局。
另请参阅
布局_雷因戈尔德_蒂尔福德

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: 均匀流形逼近与投影用于降维. arXiv:1802.03426.

参数
dist	与图边相关联的距离。如果为None，则所有边将被假定为在顶点之间传递相同的距离。可以设置此参数或`weights`参数，但不能同时设置两者。不设置两者也是可以的。
weights	如果你有预计算的边权重，可以使用它们作为设置`dist`参数的替代方案。如果设置了此参数，零权重将被忽略，例如，如果你通过igraph.umap_compute_weights()计算了权重。
dim	布局所需的维度数。dim=2 表示二维布局，dim=3 表示三维布局。
seed	如果为 `None`，则使用随机起始布局进行算法。如果是一个矩阵（列表的列表），则使用给定的矩阵作为起始位置。
min_dist	嵌入空间中的最小距离，超过此距离后，位于附近的可能性会降低。
epochs	算法将迭代的轮数（迭代次数）。随着轮数的增加，准确性会提高，但运行时间也会更长。通常在50到1000之间。请注意，由于对称性原因，UMAP在技术上不会收敛，但更多的轮数通常会给出等效或更好的布局。
返回
计算出的布局。请注意，如果设置了距离，图通常是有向的，而如果权重是预先计算的，图将被视为无向的。一个特殊情况是图是有向的，但预先计算的权重以某种方式对称化，使得每对相反边中只有一条具有非零权重，例如由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-正则哈密顿图的简洁符号。它由三个参数组成：图中的顶点数、一个给出循环骨架额外边的移位列表，以及另一个整数，表示应执行移位的次数。详情请参见http://mathworld.wolfram.com/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"` 表示入度, 或 `"all"` 表示它们的总和).
loops	是否应该计算自环。

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

overridden in 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`时，最大团将作为列表的列表返回。
返回
图的最大团作为一个列表的列表，如果给出了`file`参数，则为`None`。@see: `largest_cliques()` 用于获取最大团。

def maximal_independent_vertex_sets(): ¶

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

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

参考文献: S. Tsukiyama, M. Ide, H. Ariyoshi 和 I. Shirawaka: 一种生成所有最大独立集的新算法。 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): ¶

overridden in 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`，则source也必须为{None}，并且计算将在整个图上进行（即所有可能的顶点对）。
capacity	边的容量。它必须是一个列表或有效的属性名称或`None`。在后一种情况下，每条边将具有相同的容量。
返回
最小割的值，第一个和第二个分区中的顶点ID，以及割中的边ID，打包在一个4元组中

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: 在图中找到所有最小尺寸的分离顶点集。网络 23:533-541, 1993.

返回
一个列表，其中每个项目列出了最小尺寸给定分隔符的顶点索引。

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

overridden in 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 和 M Girvan: 在网络中寻找和评估社区结构。 物理评论 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): ¶

计算图中主题的数量

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

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

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

参考文献: S. Wernicke 和 F. Rasche: FANMOD: 一种用于快速网络模体检测的工具, 生物信息学 22(9), 1152--1153, 2006.

参数
size	主题的大小
cut_prob	搜索树不同层次的切割概率。这必须是一个长度为size的列表，或者为`None`以找到所有主题。
callback	`None` 或一个可调用对象，该对象将在图中找到每个主题时被调用。可调用对象必须接受三个参数：图本身、主题中的顶点列表以及主题的同构类（参见 `isoclass()`）。当回调返回一个具有非零真值的对象或引发异常时，搜索将停止。
返回
如果callback是`None`，则返回motifs列表，否则返回`None`
另请参阅
Graph.motifs_randesu_no()

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

计算图中主题的总数

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

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

参考文献: S. Wernicke 和 F. Rasche: FANMOD: 一种用于快速网络模体检测的工具, 生物信息学 22(9), 1152--1153, 2006.

参数
size	主题的大小
cut_prob	搜索树不同层次的切割概率。这必须是一个长度为size的列表，或者为`None`以找到所有主题。
sample	样本的大小或用于采样的顶点ID。
另请参阅
Graph.motifs_randesu()

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

计算图中主题的总数

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

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

参考文献: S. Wernicke 和 F. Rasche: FANMOD: 一种用于快速网络模体检测的工具, 生物信息学 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): ¶

overridden in 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	是否考虑有向路径。
damping	阻尼因子。
reset	重置随机游走时使用的顶点分布。可以是一个序列、可迭代对象或顶点属性名称，只要它们返回一个长度等于顶点数量的浮点数列表。如果`None`，则假定为均匀分布，这使得该方法等同于原始的PageRank算法。
reset_vertices	一种指定在重置随机游走时使用的顶点分布的替代方法。只需在此处提供一个顶点ID列表，或者一个`VertexSeq`或一个`Vertex`。重置将使用指定顶点上的均匀分布进行。
weights	要使用的边权重。可以是序列、可迭代对象，甚至是边属性名称。
arpack_options	一个用于微调ARPACK特征向量计算的`ARPACKOptions`对象。如果省略，则使用名为`arpack_options`的模块级变量。如果未使用ARPACK实现，则忽略此参数，请参阅implementation参数。
implementation	用于解决PageRank特征问题的实现方式。可能的值为： `"prpack"`: 使用PRPACK库。这是igraph 0.7版本中的新实现。 `"arpack"`: 使用ARPACK库。该实现从0.5版本开始使用，直到0.7版本。
返回
一个包含指定顶点的个性化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序列生成一棵树。

Prüfer序列是与标记树相关联的唯一整数序列。一个具有n个顶点的树可以用一个长度为n − 2的整数序列表示，每个整数在0到n − 1之间（包括两端）。

参数
seq	作为整数可迭代的Prüfer序列

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

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

参数
start	行走的起始顶点
steps	随机游走应采取的步数
mode	是否仅跟随出边（`"out"`），仅跟随入边（`"in"`）或两者都跟随（`"all"`）。对于无向图忽略此参数。@param stuck: 当随机游走卡住时该怎么做。`"return"` 返回部分随机游走；`"error"` 抛出异常。
stuck	未记录
weights	要使用的边权重。可以是序列、可迭代对象，甚至是边属性名称。
return_type	返回的内容。可以是 `"vertices"`（默认），此时函数返回访问的顶点ID列表；`"edges"`，此时函数返回访问的边ID列表；或者 `"both"`，此时函数返回一个包含 `"vertices"` 和 `"edges"` 键的字典。
返回
从给定顶点开始的随机游走，其长度最多为给定长度（如果随机游走卡住则更短）。

def Read_DIMACS(f, directed=False): ¶

overridden in igraph.Graph

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

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

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

igraph's DIMACS reader requires only three fields in an arc definition, describing the edge's source and target node and its capacity.
Source vertices are identified by 's' in the FLOW field, target vertices are identified by 't'.
Node indices start from 1. Only a single source and target node is allowed.

参数
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 是一种二进制格式，用于图数据库中的同构测试（参见 http://amalfi.dis.unina.it/graph/）。

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

def Read_GraphML(f, index=0): ¶

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

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

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

读取LGL使用的.lgl文件。

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

此格式由大型图形布局程序使用。有关确切格式描述，请参阅LGL的文档。

LGL 最初无法处理包含多重边或环边的图，但这里没有检查这种情况，因为 igraph 可以很好地处理这些情况。

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

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

读取LGL使用的.ncol文件。

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

此格式由大型图形布局程序使用。有关更多信息，请参阅LGL的存储库。

LGL 最初无法处理包含多重边或环边的图，但这里没有检查这种情况，因为 igraph 可以很好地处理这些情况。

参数
f	文件名或Python文件句柄
names	如果 `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`: 首先选择剩余度数最大的顶点。 `index`: 按顶点的索引顺序选择顶点。最小的 `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ů (A remark on the existence of finite graphs), Č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`: 首先选择剩余度数最大的顶点。 `index`: 按顶点索引顺序选择顶点。在无向图的情况下，`smallest` 保证生成一个连通图。详情请参见 Horvát 和 Modes (2021)。

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

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

参数
n	顶点的数量
m	每个顶点生成的出边数量，或者明确包含每个顶点出边数量的列表。
window	窗口的大小，以时间步长为单位
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方法。

参数
prob	重连概率
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 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	specifies how to combine the attributes of multiple edges between the same pair of vertices into a single attribute. If it is `None`, only one of the edges will be kept and all the attributes will be lost. If it is a function, the attributes of multiple edges will be collected and passed on to that function which will return the new attribute value that has to be assigned to the single collapsed edge. It can also be one of the following string constants: `"ignore"`: all the edge attributes will be ignored. `"sum"`: the sum of the edge attribute values will be used for the new edge. `"product"`: the product of the edge attribute values will be used for the new edge. `"mean"`: the mean of the edge attribute values will be used for the new edge. `"median"`: the median of the edge attribute values will be used for the new edge. `"min"`: the minimum of the edge attribute values will be used for the new edge. `"max"`: the maximum of the edge attribute values will be used for the new edge. `"first"`: the attribute value of the first edge in the collapsed set will be used for the new edge. `"last"`: the attribute value of the last edge in the collapsed set will be used for the new edge. `"random"`: a randomly selected value will be used for the new edge `"concat"`: the attribute values will be concatenated for the new edge. You can also use a dict mapping edge attribute names to functions or the above string constants if you want to make the behaviour of the simplification process depend on the name of the attribute. `None` is a special key in this dict, its value will be used for all the attributes not specified explicitly in the dictionary.

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

overridden in igraph.Graph

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

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

参数
source	源顶点ID
target	目标顶点ID
capacity	边的容量。它必须是一个列表或有效的属性名称或`None`。在后一种情况下，每条边将具有相同的容量。
返回
最小割的值，第一个和第二个分区中的顶点ID，以及割中的边ID，打包在一个4元组中

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. Phys Rev Lett 103:135702, 2009.

参数
n	图中的顶点数量
m	图中的边数
exponent_out	出度分布的指数，必须在2到无穷大（包括）之间。当未给出或为负数时，图将是无向的，此参数指定度分布。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` 时，只返回布尔值。
返回
如果没有计算映射，如果图包含与给定模板同构的子图，则结果为 `True`，否则为 `False`。如果计算了映射，结果是一个元组，第一个元素是上述布尔值，第二个元素是从目标图到原始图的映射。

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

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

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

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

overridden in igraph.Graph

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

传递性衡量了一个顶点的两个邻居之间连接的概率。在平均局部传递性的情况下，这个概率是为每个顶点计算的，然后取平均值。邻居少于两个的顶点需要特殊处理，根据mode参数，它们要么被排除在计算之外，要么被视为具有零传递性。

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

参考文献: D. J. Watts 和 S. Strogatz: 小世界网络的集体动力学. 自然 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 and S. Strogatz: Collective dynamics of small-world networks. Nature 393(6884):440-442, 1998.
Barrat A, Barthelemy M, Pastor-Satorras R and Vespignani A: The architecture of complex weighted networks. PNAS 101, 3747 (2004). http://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(): ¶

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

计算顶点的数量。

返回
integer	图中的顶点数量。

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: 小世界网络的集体动力学, 自然 393, 440-442, 1998

参数
dim	晶格的维度
size	沿所有维度的晶格大小
nei	值表示两个顶点将在多少步数内连接的距离。
p	重新连接概率
loops	指定是否允许循环边
multiple	指定是否允许多条边
另请参阅
`Lattice()`, `rewire()`, `rewire_edges()` 如果需要更多灵活性

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

overridden in 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文件句柄
names	要随顶点一起存储的顶点属性的名称。通常用于存储顶点名称（因此关键字参数的名称），但您也可以使用数字属性。如果您不想存储任何顶点属性，请在此处提供`None`。
weights	要存储的边属性的名称。它通常用于存储边的权重（因此关键字参数的名称），但您也可以使用字符串属性。如果您不想存储任何边属性，请在此处提供`None`。

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

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

请注意，多重边和/或环会破坏LGL软件，但igraph不会检查这种情况。除非您确定图中没有多重边和/或环，否则在保存之前调用simplify()是明智的。

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

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

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

请注意，多重边和/或环会破坏LGL软件，但igraph不会检查这种情况。除非您确定图中没有多重边和/或环，否则在保存之前调用simplify()是明智的。

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

def write_pajek(f): ¶

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

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

def __graph_as_capsule(): ¶

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

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

def __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对象封装的igraph图的内存地址，作为一个普通的Python整数。

此函数不应由 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"`时，对角线被认为包含相应循环边权重的两倍。
返回
一对由图本身及其边权重向量组成