python-igraph API 参考 - igraph 网络分析库

类文档

class Graph(GraphBase)

通用图。

此类构建于 GraphBase 之上，因此生成的 API 文档中方法的顺序有点模糊：继承的方法在子类中直接实现的方法之后。Graph 提供了许多 GraphBase 没有的功能，主要是因为这些功能对速度要求不高，并且在 Python 中比在纯 C 中更容易实现。一个例子是构造函数中的属性处理：Graph 的构造函数接受三个字典，分别对应于图、顶点和边的属性，而 GraphBase 的构造函数则不接受。此扩展是使 Graph 可通过以下方式序列化所必需的pickle模块。Graph 还覆盖了 GraphBase 中的一些函数，以提供更方便的接口；例如，布局函数从 Graph 返回一个 Layout 实例，而不是坐标对列表。

图也可以通过字符串或顶点索引或顶点名称对进行索引。当图由字符串索引时，该操作将转换为图属性的检索、创建、修改或删除

>>> g = Graph.Full(3)
>>> g["name"] = "Triangle graph"
>>> g["name"]
'Triangle graph'
>>> del g["name"]

当图由一对顶点索引或名称索引时，图本身被视为邻接矩阵，并返回矩阵的相应单元格

>>> g = Graph.Full(3)
>>> g.vs["name"] = ["A", "B", "C"]
>>> g[1, 2]
1
>>> g["A", "B"]
1
>>> g["A", "B"] = 0
>>> g.ecount()
2

将与零或一不同的值分配给邻接矩阵将转换为一，除非图是加权的，在这种情况下，数字将被视为权重

>>> g.is_weighted()
False
>>> g["A", "B"] = 2
>>> g["A", "B"]
1
>>> g.es["weight"] = 1.0
>>> g.is_weighted()
True
>>> g["A", "B"] = 2
>>> g["A", "B"]
2
>>> g.es["weight"]
[1.0, 1.0, 2]

类方法	`邻接矩阵`	从其邻接矩阵生成一个图。
类方法	`Bipartite`	使用给定的顶点类型和边创建二分图。这类似于图的默认构造函数，唯一的区别是它检查所有边是否在两个顶点类之间，并将类型向量分配给 ...
类方法	`DataFrame`	从一个或两个数据帧生成一个图。
类方法	`DictDict`	从 dict-of-dicts 表示构造图。
类方法	`DictList`	从列表字典表示形式构造一个图。
类方法	`from_graph_tool`	从 graph-tool 转换图
类方法	`from_networkx`	从 networkx 转换图
类方法	`GRG`	生成一个随机几何图。
类方法	`Incidence`	从关联矩阵创建一个二分图。
类方法	`ListDict`	从 dict-of-lists 表示构造图。
类方法	`Read`	用于图的统一读取函数。
类方法	`Read_DIMACS`	从符合 DIMACS 最小成本流文件格式的文件中读取图。
类方法	`Read_GraphMLz`	从压缩的 GraphML 文件中读取图。
类方法	`Read_Pickle`	从 Python pickle 格式读取图
类方法	`Read_Picklez`	从压缩的 Python pickle 格式读取图，并即时解压缩。
类方法	`TupleList`	从元组列表表示形式构造一个图。
方法	`__add__`	复制图并根据给定的其他对象的类型扩展副本。
方法	`__and__`	图交集运算符。
方法	`__bool__`	如果图形至少有一个顶点，则返回 True，否则返回 False。
方法	`__coerce__`	强制规则。
方法	`__iadd__`	原地加法（不相交并集）。
方法	`__init__`	__init__(n=0, edges=None, directed=False, graph_attrs=None, vertex_attrs=None, edge_attrs=None)
方法	`__isub__`	原地减法（差集）。
方法	`__mul__`	任意次数复制原始图的精确副本。
方法	`__or__`	图并集运算符。
方法	`__plot__`	将图形绘制到给定的 Cairo 上下文或 matplotlib Axes。
方法	`__reduce__`	支持 pickle。
方法	`__str__`	返回图形的字符串表示形式。
方法	`__sub__`	从图中删除给定的对象
方法	`add_edge`	向图中添加单条边。
方法	`add_edges`	向图中添加一些边。
方法	`add_vertex`	向图中添加单个顶点。关键字参数将分配为顶点属性。请注意`name`作为关键字参数被特殊处理；如果一个图有`name`作为顶点属性，它允许人们在 igraph 期望顶点 ID 的大多数地方按名称引用顶点。
方法	`add_vertices`	向图中添加一些顶点。
方法	`all_st_cuts`	返回有向图中源顶点和目标顶点之间的所有割。
方法	`all_st_mincuts`	返回有向图中源顶点和目标顶点之间的所有最小割。
方法	`as_directed`	返回此图形的有向副本。参数传递给 `GraphBase.to_directed()`，该函数在副本上调用。
方法	`as_undirected`	返回此图形的无向副本。参数传递给 `GraphBase.to_undirected()`，该函数在副本上调用。
方法	`biconnected_components`	计算图的双连通分量。
方法	`bipartite_projection`	将二分图投影到两个单模图中。投影时忽略边的方向。
方法	`bipartite_projection_size`	根据指定的顶点类型计算此图形的双峰投影中的顶点和边数。如果您有一个双峰图，并且想要估计计算投影本身所需的内存量，这将非常有用。
方法	`blocks`	计算图的双连通分量。
方法	`clear`	清除图，删除所有顶点、边和属性。
方法	`clusters`	已弃用的 `Graph.connected_components()` 别名。
方法	`community_edge_betweenness`	基于网络中边的介数的社区结构。
方法	`community_fastgreedy`	基于模块化贪婪优化的社区结构。
方法	`community_infomap`	根据 Martin Rosvall 和 Carl T. Bergstrom 的 Infomap 方法查找网络的社区结构。
方法	`community_label_propagation`	根据 Raghavan 等人的标签传播方法查找图的社区结构。
方法	`community_leading_eigenvector`	纽曼的领先特征向量法，用于检测社区结构。
方法	`community_leading_eigenvector_naive`	纽曼特征向量社区结构检测的朴素实现。
方法	`community_leiden`	使用 Traag、van Eck 和 Waltman 的 Leiden 算法查找图的社区结构。
方法	`community_multilevel`	基于 Blondel 等人的多层算法的社区结构。
方法	`community_optimal_modularity`	计算图的最佳模块化分数和相应的社区结构。
方法	`community_spinglass`	根据 Reichardt & Bornholdt 的自旋玻璃社区检测方法查找图的社区结构。
方法	`community_walktrap`	Latapy & Pons 的社区检测算法，基于随机游走。
方法	`components`	计算给定图形的（强或弱）连通分量。
方法	`count_automorphisms_vf2`	返回图的自同构数。
方法	`degree_distribution`	计算图的度分布。
方法	`delete_edges`	从图中删除一些边。
方法	`dfs`	对图形进行深度优先搜索 (DFS)。
方法	`disjoint_union`	创建两个（或多个）图的不相交并集。
方法	`dyad_census`	计算图形的二元组普查。
方法	`get_adjacency`	返回图的邻接矩阵。
方法	`get_adjacency_sparse`	将图的邻接矩阵作为 SciPy CSR 矩阵返回。
方法	`get_adjlist`	返回图的邻接列表表示形式。
方法	`get_all_simple_paths`	计算图中从给定节点到某些其他节点（或所有节点）的所有简单路径。
方法	`get_automorphisms_vf2`	返回图的所有自同构
方法	`get_edge_dataframe`	将带有属性的边导出到 pandas.DataFrame
方法	`get_incidence`	返回二分图的关联矩阵。关联矩阵是一个 n 乘以 m 矩阵，其中 n 和 m 是两个顶点类中的顶点数。
方法	`get_inclist`	返回图的关联列表表示形式。
方法	`get_vertex_dataframe`	将带有属性的顶点导出到 pandas.DataFrame
方法	`gomory_hu_tree`	计算具有可选边容量的无向图的 Gomory-Hu 树。
方法	`indegree`	在列表中返回入度。
方法	`intersection`	创建两个（或多个）图的交集。
方法	`is_named`	返回图形是否已命名。
方法	`is_weighted`	返回图形是否已加权。
方法	`k_core`	返回图的一些 k 核。
方法	`layout`	根据布局算法返回图的布局。
方法	`layout_auto`	根据图的简单拓扑属性选择并运行合适的布局函数。
方法	`layout_sugiyama`	使用分层 Sugiyama 布局放置顶点。
方法	`maxflow`	返回图中给定源顶点和目标顶点之间的最大流量。
方法	`maximum_bipartite_matching`	在二分图中查找最大匹配。
方法	`mincut`	计算给定源顶点和目标顶点之间或整个图中的最小割。
方法	`modularity`	计算图相对于给定聚类的模块化分数。
方法	`outdegree`	在列表中返回出度。
方法	`pagerank`	计算图的 PageRank 值。
方法	`path_length_hist`	返回图形的路径长度直方图
方法	`shortest_paths`	已弃用的 `Graph.distances()` 别名。
方法	`spanning_tree`	计算图形的最小生成树。
方法	`summary`	返回图形的摘要。
方法	`to_dict_dict`	将图形导出到边属性的字典的字典
方法	`to_dict_list`	将图形导出为两个字典列表，分别用于顶点和边。
方法	`to_graph_tool`	将图转换为 graph-tool
方法	`to_list_dict`	将图形导出到列表（或其他序列）的字典。
方法	`to_networkx`	将图转换为 networkx 格式。
方法	`to_tuple_list`	将图形导出到边元组列表
方法	`transitivity_avglocal_undirected`	计算图的顶点传递性的平均值。
方法	`triad_census`	计算图形的三元组普查。
方法	`union`	创建两个（或多个）图的并集。
方法	`write`	用于图的统一写入函数。
方法	`write_adjacency`	将图的邻接矩阵写入给定的文件
方法	`write_dimacs`	以 DIMACS 格式将图写入给定的文件。
方法	`write_graphmlz`	将图写入压缩的 GraphML 文件。
方法	`write_pickle`	以 Python pickle 格式保存图
方法	`write_picklez`	以 Python pickle 格式保存图，并使用 gzip 压缩。
方法	`write_svg`	将图另存为 SVG（可缩放矢量图形）文件
类变量	`__hash__`	未归档
类变量	`__iter__`	未归档
类变量	`Formula`	未归档
属性	`es`	图形的边序列
属性	`vs`	图形的顶点序列
类方法	`_reconstruct`	从 Python 的 pickle 格式重建 Graph 对象。
属性	`_as_parameter_`	未归档

继承自 GraphBase

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

@classmethod
def Adjacency(cls, matrix, mode='directed', *args, **kwargs): ¶

覆盖 igraph.GraphBase.Adjacency

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

参数
矩阵	邻接矩阵。可能的类型是列表的列表 numpy 2D 数组或矩阵（将转换为列表的列表） scipy.sparse 矩阵（将转换为 COO 矩阵，而不是稠密矩阵）一个 pandas.DataFrame（列/行名称必须匹配，并将用作顶点名称）。
模式	要使用的模式。可能的值为 `"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"`- 具有矩阵左下三角形（包括对角线）的无向图
*args	未归档
**kwargs	未归档

@classmethod
def Bipartite(cls, types, edges, directed=False, *args, **kwds): ¶

创建具有给定顶点类型和边的二分图。这类似于图的默认构造函数，唯一的区别是它检查所有边是否在两个顶点类之间，并将类型向量分配给type属性之后。

示例

>>> g = Graph.Bipartite([0, 1, 0, 1], [(0, 1), (2, 3), (0, 3)])
>>> g.is_bipartite()
True
>>> g.vs["type"]
[False, True, False, True]

参数
types	作为布尔列表的顶点类型。任何评估为`False`将表示第一种顶点，任何评估为`True`将表示第二种顶点。
边	边作为元组列表。
有向	是否创建有向图。二分图通常是无向图，因此默认为`False`
*args	未归档
**kwds	未归档
返回值
带有名为`"type"`的二进制顶点属性的图，该属性存储顶点类。

@classmethod
def DataFrame(cls, edges, directed=True, vertices=None, use_vids=True): ¶

从一个或两个数据帧生成一个图。

参数
边	包含边和元数据的 pandas DataFrame。此 DataFrame 的前两列包含每个边的源顶点和目标顶点。除非`use_vids`为 False，否则这些指示顶点 ID 为非负整数而不是顶点名称。其他列可能包含边属性。
directed:`bool`	图形是否为有向图
vertices	None（默认值）或包含顶点元数据的 pandas DataFrame。DataFrame 的索引必须包含顶点 ID 作为从 0 到`len(vertices) - 1`返回与给定`use_vids`是`False`的整数序列，第一列必须包含唯一的顶点名称。为了完全兼容，顶点名称应为字符串，但如果使用任何可哈希对象设置名称，许多函数都可以工作。所有其他列将按列名称添加为顶点属性。
use_vids:`bool`	是否将`边`参数的前两列解释为顶点 ID（从 0 开始的整数），而不是顶点名称。如果此参数设置为 True，并且`边`的前两列不是整数，则会引发错误。
返回值
图在设置为 NaN（非数字）的`边`之一或`vertices`参数中的顶点名称将设置为字符串“NA”。这可能会导致意外行为：在调用此函数之前使用值填充 NaN 以减轻这种情况。

@classmethod
def DictDict(cls, edges, directed=False, vertex_name_attr='name'): ¶

从 dict-of-dicts 表示构造图。

每个键可以是整数或字符串，并表示一个顶点。每个值是一个字典，表示从该顶点发出的边（如果图形是有向图）。每个字典键是目标顶点的整数/字符串，这样将在这两个顶点之间创建一条边。整数被解释为来自 0 的 vertex_ids（在 igraph 中使用），字符串被解释为顶点名称，在这种情况下，顶点被赋予单独的数字 ID。每个值是该边的边属性的字典。

示例

>>> {'Alice': {'Bob': {'weight': 1.5}, 'David': {'weight': 2}}}

创建一个具有三个顶点（Alice、Bob 和 David）和两条边的图形

Alice - Bob（权重为 1.5）
Alice - David（权重为 2）

参数
边	指定边及其属性的字典的字典的字典
directed:`bool`	是否创建有向图
vertex_name_attr:`str`	未归档
返回值
一个 Graph 对象
未知字段：vertex_name_attr
将存储名称的顶点属性

@classmethod
def DictList(cls, vertices, edges, directed=False, vertex_name_attr='name', edge_foreign_keys=('source', 'target'), iterative=False): ¶

从列表字典表示形式构造一个图。

当您有两个字典列表时，此函数非常有用，一个用于顶点，一个用于边，每个列表都包含它们的属性（例如，名称、权重）。当然，边字典还必须包含两个特殊键，用于指示由该边连接的源顶点和目标顶点。非列表可迭代对象应该可以工作，只要它们产生字典或类似字典的对象（它们应该具有“items”和“__getitem__”方法）。例如，数据库查询结果很可能适合，只要它是可迭代的，并且每次迭代都产生类似字典的对象。

参数
vertices	顶点的字典列表或`None`如果没有分配给顶点的特殊属性，我们应该简单地使用字典的边列表来推断顶点名称。
边	边的字典列表。每个字典必须至少具有 edge_foreign_keys 指定的两个键，以标记源顶点和目标顶点，而其他项将被视为边属性。
directed:`bool`	构造的图是否为有向图
vertex_name_attr:`str`	顶点数据源中字典中包含顶点名称的独特键的名称。如果`vertices`是`None`.
边_外键	元组指定每个边字典中包含源（第 1 个）和目标（第 2 个）顶点名称的属性。每个字典的这些项目也作为 edge_attributes 添加。
iterative:`bool`	是否以迭代方式逐个将边添加到图形中，或者先构建一个大型边列表并使用它来构造图形。后一种方法更快，但如果您的数据集很大，则可能不合适。默认是从边列表批量添加边。
返回值
构造的图示例 >>> vertices = [{'name': 'apple'}, {'name': 'pear'}, {'name': 'peach'}] >>> edges = [{'source': 'apple', 'target': 'pear', 'weight': 1.2}, ... {'source': 'apple', 'target': 'peach', 'weight': 0.9}] >>> g = Graph.DictList(vertices, edges) 图形具有三个具有名称的顶点和两个具有权重的边。

@classmethod
def from_graph_tool(cls, g): ¶

从 graph-tool 转换图

参数
g	graph-tool Graph

@classmethod
def from_networkx(cls, g, vertex_attr_hashable='_nx_name'): ¶

从 networkx 转换图

顶点名称将存储为 vertex_attr_hashable 属性（通常为“_nx_name”，但请参见下文）。由于 igraph 以有序方式存储顶点，因此顶点将从 0 开始获得新的 ID。对于多重图，每条边都有一个“_nx_multiedge_key”属性，用于区分连接相同两个顶点的边。

参数
g	networkx Graph 或 DiGraph
vertex_attr_hashable:`str`	用于存储 networkx 用于标识每个顶点的 Python 可哈希对象的属性。默认值“_nx_name”确保与 networkx 进行无损往返转换。另一种选择是“name”：在这种情况下，建议使用字符串作为顶点名称，并且如果将图形重新导出到 networkx，则必须使用 Graph.to_networkx(vertex_attr_hashable="name") 才能在导出的网络中恢复正确的顶点命名法。

@classmethod
def GRG(cls, n, radius, torus=False): ¶

生成一个随机几何图。

该算法将顶点随机放置在 2D 单位正方形上，如果它们彼此之间的距离小于给定的半径，则将它们连接起来。顶点的坐标存储在顶点属性中x和y.

参数
n	图中的顶点数
radius	给定半径
torus	这应该是`True`如果我们想使用圆环而不是正方形。

@classmethod
def Incidence(cls, matrix, directed=False, mode='out', multiple=False, weighted=None, *args, **kwds): ¶

从关联矩阵创建一个二分图。

示例

>>> g = Graph.Incidence([[0, 1, 1], [1, 1, 0]])

参数
矩阵	关联矩阵。
有向	是否创建有向图。
模式	定义图中边的方向。如果`"out"`，则边从第一种顶点（对应于矩阵的行）到第二种顶点（矩阵的列）。如果`"in"`，则使用相反的方向。`"all"`创建互边。对于无向图，忽略此参数。
multiple	定义如何处理矩阵中的非零条目。如果`False`，则无论值是什么，非零条目都将创建一条边。如果`True`，则非零条目将四舍五入到最接近的整数，这将是创建的多个边的数量。
weighted	定义是否从关联矩阵创建加权图。如果它是 c{None}，则创建一个未加权的图，并且使用 multiple 参数确定图形的边。如果它是一个字符串，则对于每个非零矩阵条目，都会创建一个边，并且该条目的值会添加为由 weighted 参数命名的边属性。如果是`True`，则创建一个加权图，并且边属性的名称将为“weight”。
*args	未归档
**kwds	未归档
返回值
带有名为`"type"`的二进制顶点属性的图，该属性存储顶点类。
引发
`ValueError`	如果 weighted 和 multiple 一起传递。

@classmethod
def ListDict(cls, edges, directed=False, vertex_name_attr='name'): ¶

从 dict-of-lists 表示构造图。

此函数用于从列表字典构造图形。接受其他非列表序列（例如，元组）和惰性迭代器。对于每个键 x，其对应的值必须是多个值 y 的序列：边 (x,y) 将在图形中创建。x 和 y 必须是以下之一

两个整数：具有这些 ID 的顶点将被连接
两个字符串：具有这些名称的顶点将被连接

如果使用名称，则不能保证顶点的顺序，并且每个顶点都将获得 vertex_name_attr 属性。

参数
边	描述边的序列字典
directed:`bool`	是否创建有向图
vertex_name_attr:`str`	未归档
返回值
一个 Graph 对象示例 >>> mydict = {'apple': ['pear', 'peach'], 'pear': ['peach']} >>> g = Graph.ListDict(mydict) # 该图形具有三个具有名称的顶点和连接 # 每对顶点的三条边。
未知字段：vertex_name_attr
将存储名称的顶点属性

@classmethod
def Read(cls, f, format=None, *args, **kwds): ¶

用于图的统一读取函数。

此方法尝试识别第一个参数中给出的图的格式，并调用相应的读取器方法。

剩余的参数将没有任何更改地传递给读取器方法。

参数
f	包含要加载的图的文件
format	文件的格式（如果事先已知）。`None`表示自动检测。可能的值是`"ncol"`（NCOL 格式），`"lgl"`（LGL 格式），`"graphdb"`（GraphDB 格式），`"graphml"`, `"graphmlz"`（GraphML 和 gzipped GraphML 格式），`"gml"`（GML 格式），`"net"`, `"pajek"`（Pajek 格式），`"dimacs"`（DIMACS 格式），`"edgelist"`, `"edges"`之一或`"edge"`（边列表），`"adjacency"`（邻接矩阵），`"dl"`（UCINET 使用的 DL 格式），`"pickle"`（Python pickle 格式），`"picklez"`（gzipped Python pickle 格式）
*args	未归档
**kwds	未归档
引发
`IOError`	如果无法识别文件格式，并且未给出任何格式。

@classmethod
def Read_DIMACS(cls, f, directed=False): ¶

覆盖 igraph.GraphBase.Read_DIMACS

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

有关格式的确切定义，请参见 http://lpsolve.sourceforge.net/5.5/DIMACS.htm。

与格式的官方描述相比，存在以下限制

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

参数
f	文件的名称或 Python 文件句柄
有向	生成的图是否应为有向图。
返回值
生成的图。源顶点和目标顶点的索引作为图属性附加`来源`和`目标`，边容量存储在`capacity`边属性。

@classmethod
def Read_GraphMLz(cls, f, index=0): ¶

从压缩的 GraphML 文件中读取图。

参数
f	文件的名称
index	如果 GraphML 文件包含多个图，则指定应加载的图。图索引从零开始，因此如果要加载第一个图，请在此处指定 0。
返回值
加载的图对象

@classmethod
def Read_Pickle(cls, fname=None): ¶

从 Python pickle 格式读取图

参数
fname	文件的名称、要从中读取的流或包含 pickle 数据的字符串。
返回值
创建的图对象。

@classmethod
def Read_Picklez(cls, fname): ¶

从压缩的 Python pickle 格式读取图，并即时解压缩。

参数
fname	文件的名称或要从中读取的流。
返回值
创建的图对象。

@classmethod
def TupleList(cls, edges, directed=False, vertex_name_attr='name', edge_attrs=None, weights=False): ¶

从元组列表表示形式构造一个图。

此表示形式假定图形的边编码在元组（或列表）列表中。列表中的每个项目必须至少有两个元素，这些元素指定边的源顶点和目标顶点。剩余元素（如果有）指定该边的边属性，其中边属性的名称来自边_属性列表。顶点的名称将存储在给定的顶点属性中顶点_名称_属性.

此函数的默认参数适用于从列表创建未加权的图形，其中每个项目包含源顶点和目标顶点。如果您有一个加权图，则可以通过设置边_属性到"weight"之一或["weight"]。如果您有更多的边属性，请将它们添加到边列表中的每个项目的末尾，并在边_属性中指定相应的边属性名称作为列表。

参数
边	边的数据源。这必须是一个列表，其中每个项目都是一个元组（或列表），其中包含至少两个项目：源顶点和目标顶点的名称。请注意，名称将被分配给`name`顶点属性（或者另一个顶点属性，如果`顶点_名称_属性`已指定），即使列表中的所有顶点名称实际上都是数字。
directed:`bool`	构造的图是否为有向图
vertex_name_attr:`str`	顶点属性的名称，该属性将包含顶点名称。
边_属性	使用其中第三个项目包含边的权重的项目，`None`或一个空序列，则只会提取源顶点和目标顶点，并且会忽略其他元组项。如果是字符串，则将其解释为单个边属性。
weights	指定图已加权的替代方法。如果您设置`weights`到`true`和`边_属性`未给出，则将假定`边_属性`是`["weight"]`，igraph 将从每个项目中解析第三个元素到边权重中。如果您设置`weights`为字符串，则将假定`边_属性`仅包含该字符串，igraph 会将边权重存储在该属性中。
返回值
构造的图

def __add__(graph, other): ¶

复制图并根据给定的其他对象的类型扩展副本。

参数
图	未归档
other	如果它是一个整数，则副本将扩展给定的顶点数。如果它是一个字符串，则副本将扩展单个顶点，其`name`属性将等于给定的字符串。如果它是一个包含两个元素的元组，则副本将通过一条边进行扩展。如果它是一个元组列表，则副本将通过多条边进行扩展。如果是 `Graph`，则执行不相交的并集。

def __and__(graph, other): ¶

图交集运算符。

参数
图	未归档
other	用于求交集的另一个图。
返回值
相交的图。

def __bool__(self): ¶

如果图形至少有一个顶点，则返回 True，否则返回 False。

def __coerce__(self, other): ¶

强制规则。

需要此方法才能允许图形对与列表、元组、整数、字符串、顶点、边等进行加法运算做出反应。

def __iadd__(graph, other): ¶

原地加法（不相交并集）。

参见
`__add__`

def __init__(self, *args, **kwds): ¶

__init__(n=0, edges=None, directed=False, graph_attrs=None, vertex_attrs=None, edge_attrs=None)

从头开始构造一个图形。

参数
*args	未归档
**kwds	未归档
n	顶点数。可以省略，默认值为零。请注意，如果边列表包含索引大于或等于 m 的顶点，则顶点数将相应调整。
边	边列表，其中每个列表项是一对整数。如果任何一个整数大于 n − 1，则顶点数将相应调整。`None`表示没有边。
有向	该图是否应该是有向图
graph_attrs	图形的属性，表示为字典。
vertex_attrs	顶点的属性，表示为字典。每个字典值必须是一个具有恰好 n 项的可迭代对象。
边_属性	边的属性，表示为字典。每个字典值必须是一个具有恰好 m 项的可迭代对象，其中 m 是边数。

def __isub__(graph, other): ¶

原地减法（差集）。

参见
`__sub__`

def __mul__(graph, other): ¶

任意次数复制原始图的精确副本。

参数
图	未归档
other	如果它是一个整数，则通过创建给定数量的相同副本并取它们的并集来乘以该图。

def __or__(graph, other): ¶

图并集运算符。

参数
图	未归档
other	用于求并集的另一个图。
返回值
并集图。

def __plot__(self, backend, context, *args, **kwds): ¶

将图形绘制到给定的 Cairo 上下文或 matplotlib Axes。

顶点和边的视觉样式可以在以下三个位置修改，优先级顺序如下（较低的索引会覆盖较高的索引）：

此函数的关键字参数（或 plot() 的关键字参数，该参数完整传递到Graph.__plot__().
顶点或边属性，在关键字参数列表中稍后指定。
igraph 范围内的绘图默认值（请参阅 igraph.config.Configuration）
内置默认值。

例如，如果vertex_size关键字属性不存在，但是存在一个名为size的顶点属性，则顶点的大小将由该属性指定。

除了通常的不言自明的绘图参数（context, bbox, palette）之外，它还接受以下关键字参数

autocurve：是否对图绘图上的多条边使用曲线而不是直线。此参数可以是True之一或False；省略时，对于边数少于 10.000 的图，假定为True，对于边数多于 10.000 的图，假定为False否则。
drawer_factory: AbstractCairoGraphDrawer 的一个子类，将用于绘制图形。您也可以在此处提供一个函数，该函数接受两个参数：要在其上绘制的 Cairo 上下文和一个边界框（BoundingBox 的一个实例）。如果缺少此关键字参数，igraph 将使用默认的图形绘制器，该绘制器应适用于大多数用途。除非您需要使用特定的图形绘制器，否则可以安全地省略此关键字参数。
keep_aspect_ratio：是否保持 igraph 计算以放置节点的布局的纵横比。True意味着布局将按比例缩放以适合要在其中绘制图的边界框，但纵横比将保持不变（可能会在图的旁边、下方或上方留下空白空间）。False意味着布局将沿 X 轴和 Y 轴独立缩放，以填充整个边界框。默认值为False.
layout: 要使用的布局。如果不是 Layout 的实例，它将传递给 layout 以计算布局。请注意，如果您想要一个不随每次绘图而变化的确定性布局，则必须使用确定性布局函数（例如 GraphBase.layout_circle）或提前计算布局并在此处传递一个 Layout 对象。
边距：顶部、右侧、底部、左侧边距，作为 4 元组。如果它的元素少于 4 个或者是一个浮点数，则将重复使用这些元素，直到长度至少为 4。
mark_groups：是否通过彩色多边形突出显示某些顶点组。此参数可以是以下之一
- False：不会突出显示任何组
- True: 仅当绘制的对象是 VertexClustering 或 VertexCover 时有效。聚类或覆盖中的顶点组将被突出显示，使得第 i 个组将由当前调色板中的第 i 种颜色着色。如果在绘制图形时使用，则会引发错误。
- 将顶点索引元组映射到颜色名称的字典。给定的顶点组将通过给定的颜色突出显示。
- 包含对的列表或生成对的可迭代对象，其中每对的第一个元素是顶点索引列表，第二个元素是一种颜色。
- 一个 VertexClustering 或 VertexCover 实例。聚类或覆盖中的顶点组将被突出显示，使得第 i 个组将由当前调色板中的第 i 种颜色着色。
您还可以使用 VertexSeq 实例代替顶点索引列表。

您还可以使用当前调色板中的颜色索引代替颜色名称。None作为颜色名称将意味着相应的组将被忽略。
vertex_size：顶点的大小。相应的顶点属性称为size。默认值为 10。顶点大小以 igraph 在其上绘制的 Cairo 上下文的单位进行测量。
vertex_color：顶点的颜色。相应的顶点属性是color，默认值为红色。颜色可以通过常见的 X11 颜色名称指定（请参阅 igraph.drawing.colors 的源代码以获取已知颜色的列表），通过浮点数的 3 元组指定（R、G 和 B 分量的值在 0 到 255 之间），通过 CSS 样式的字符串规范指定（#rrggbb）或指定调色板的整数颜色索引来指定颜色。
vertex_frame_color：顶点框架（即描边）的颜色。相应的顶点属性是frame_color，默认值为黑色。请参阅vertex_color以获取指定颜色的可能方法。
vertex_frame_width：顶点框架（即描边）的宽度。相应的顶点属性是frame_width。默认值为 1。顶点框架宽度以 igraph 在其上绘制的 Cairo 上下文的单位进行测量。
vertex_shape：顶点的形状。或者，可以通过shape顶点属性来指定。可能性是square、{circle}、{triangle}、{triangle-down} 或hidden。请参阅 igraph.drawing 的源代码，以获取也被接受并映射到这些形状的其他形状名称列表。
vertex_label：绘制在顶点旁边的标签。相应的顶点属性是label.
vertex_label_dist：顶点标签中点与相应顶点中心的距离。相应的顶点属性是label_dist.
vertex_label_color：标签的颜色。相应的顶点属性label_color。请参阅vertex_color以获取颜色指定语法。
vertex_label_size：标签的字体大小，以我们正在绘制的 Cairo 上下文的单位指定。相应的顶点属性label_size.
vertex_label_angle：连接顶点中点与标签中点的线的方向。这可以与vertex_label_dist结合使用，以相对于顶点本身定位标签。相应的顶点属性label_angle。默认是-math.pi/2.
vertex_order：顶点的绘制顺序。这必须是一个包含顶点索引的列表或元组；然后根据此顺序绘制顶点。
vertex_order_by: 指定顶点绘制顺序的另一种方法；此属性被解释为顶点属性的名称，并且绘制顶点的方式是首先绘制具有较小属性值的顶点。您也可以通过传递元组来反转顺序；元组的第一个元素应该是属性的名称，第二个元素指定顺序是否反转（True, False, "asc"和和"desc"
edge_coloredge_colorcolor：边的颜色。相应的边属性是vertex_color以获取颜色指定语法。
edge_curved：边是否应该是弯曲的。正数对应于逆时针方向弯曲的边，负数对应于顺时针方向弯曲的边。零表示直线边。True被解释为 0.5，False被解释为 0。默认值为 0，这会使所有边都变成直线。
edge_width：边在我们将要绘制的 Cairo 上下文的默认单位中的宽度。相应的边属性是width，默认值为 1。
edge_arrow_size：边的箭头大小。相应的边属性是arrow_size，默认值为 1。
edge_arrow_width：边上箭头的宽度。相应的边属性是arrow_width，默认值为 1。
edge_order：边的绘制顺序。这必须是一个包含边索引的列表或元组；然后根据此顺序绘制边。
edge_order_by: 指定边绘制顺序的另一种方法；此属性被解释为边属性的名称，并且绘制边的方式是首先绘制具有较小属性值的边。您也可以通过传递元组来反转顺序；元组的第一个元素应该是属性的名称，第二个元素指定顺序是否反转（True, False, "asc"和和"desc"

def __reduce__(self): ¶

支持 pickle。

def __str__(self): ¶

返回图形的字符串表示形式。

在幕后，此方法构造一个 GraphSummary 实例并调用其__str__方法，其中详细级别为 1，并且关闭属性打印。

有关输出的更多详细信息，请参见 GraphSummary 的文档。

def __sub__(graph, other): ¶

从图中删除给定的对象

参数
图	未归档
other	如果它是一个整数，则从图形中删除具有给定 ID 的顶点（请注意，剩余的顶点将被重新索引！）。如果它是一个元组，则删除给定的边。如果它是一个图形，则取两个图形的差。也接受整数列表或元组列表，但它们不能混合！也接受 `Edge` 和 `EdgeSeq` 对象。

def add_edge(graph, source, target, **kwds): ¶

向图中添加单条边。

关键字参数（源和目标参数除外）将作为属性分配给边。

向图中添加单条边或多条边的性能成本相似。因此，在添加多个边时，单次add_edges()调用比多次add_edge()调用更有效。

参数
图	未归档
来源	边的源顶点或其名称。
目标	边的目标顶点或其名称。
**kwds	未归档
返回值
作为 `Edge` 对象新添加的边。使用`add_edges([(source, target)])`如果你不需要 `Edge` 对象，并且想要避免创建它的开销。

def add_edges(graph, es, attributes=None): ¶

覆盖 igraph.GraphBase.add_edges

向图中添加一些边。

参数
图	未归档
es	要添加的边列表。每个边都用一个元组表示，该元组包含两个端点的顶点 ID 或名称。顶点从零开始枚举。
attributes	序列字典，所有序列的长度都等于要添加的边数，其中包含新边的属性。

def add_vertex(graph, name=None, **kwds): ¶

向图中添加单个顶点。关键字参数将分配为顶点属性。请注意name作为关键字参数被特殊处理；如果一个图有name作为顶点属性，它允许人们在 igraph 期望顶点 ID 的大多数地方按名称引用顶点。

返回值
新添加的顶点作为 `Vertex` 对象。使用`add_vertices(1)`如果你不需要 `Vertex` 对象，并且想要避免创建它的开销。

def add_vertices(graph, n, attributes=None): ¶

覆盖 igraph.GraphBase.add_vertices

向图中添加一些顶点。

请注意，如果n是一个字符串序列，指示新顶点的名称，并且 attributes 具有键name，则两者会冲突。在这种情况下，将应用该属性。

参数
图	未归档
n	要添加的顶点数，或要添加的单个顶点的名称，或一个字符串序列，每个字符串对应于要添加的顶点的名称。名称将分配给`name`vertex 属性。
attributes	序列的字典，所有序列的长度等于要添加的顶点的数量，包含新顶点的属性。如果 n 是一个字符串（因此添加单个顶点），那么该字典的值就是属性本身，但如果 n=1，则它们必须是长度为 1 的列表。

def all_st_cuts(graph, source, target): ¶

覆盖 igraph.GraphBase.all_st_cuts

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

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

参数
图	未归档
来源	源顶点 ID
目标	目标顶点 ID
返回值
一个 `Cut` 对象的列表。
未知字段：newfield
参考	参考
未知字段：ref
JS Provan and DR Shier: A paradigm for listing (s,t)-cuts in graphs. Algorithmica 15, 351--372, 1996.

def all_st_mincuts(graph, source, target, capacity=None): ¶

覆盖 igraph.GraphBase.all_st_mincuts

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

此函数列出源顶点和目标顶点之间的所有最小割边。

参数
图	未归档
来源	源顶点 ID
目标	目标顶点 ID
capacity	边的容量（权重）。如果`None`，则所有边都具有相同的权重。也可以是属性名称。
返回值
一个 `Cut` 对象的列表。
未知字段：newfield
参考	参考
未知字段：ref
JS Provan and DR Shier: A paradigm for listing (s,t)-cuts in graphs. Algorithmica 15, 351--372, 1996.

def as_directed(graph, *args, **kwds): ¶

返回此图形的有向副本。参数传递给 GraphBase.to_directed()，该函数在副本上调用。

def as_undirected(graph, *args, **kwds): ¶

返回此图形的无向副本。参数传递给 GraphBase.to_undirected()，该函数在副本上调用。

def biconnected_components(graph, return_articulation_points=False): ¶

覆盖 igraph.GraphBase.biconnected_components

计算图的双连通分量。

参数
图	未归档
return_articulation_points	是否也返回割点
返回值
一个 `VertexCover` 对象，描述双连通分量，还可以选择关节点的列表

def bipartite_projection(graph, types='type', multiplicity=True, probe1=-1, which='both'): ¶

覆盖 igraph.GraphBase.bipartite_projection

将二分图投影到两个单模图中。投影时忽略边的方向。

示例

>>> g = Graph.Full_Bipartite(10, 5)
>>> g1, g2 = g.bipartite_projection()
>>> g1.isomorphic(Graph.Full(10))
True
>>> g2.isomorphic(Graph.Full(5))
True

参数
图	未归档
types	一个 igraph 向量，包含顶点类型，或一个属性名称。任何评估为`False`的内容都对应于第一种顶点，其他所有内容都对应于第二种顶点。
multiplicity	如果`True`，则 igraph 会将投影中边的多重性保存在名为`"weight"`的边属性中。例如，如果二分图中存在 A-C-B 和 A-D-B 三元组，并且不存在其他 X（除了 X=B 和 X=D）对于它 A-X-B 三元组会存在于二分图中，则投影中 A-B 边的多重性将为 2。
probe1	此参数可用于指定结果列表中投影的顺序。如果给定且非负，则将其视为顶点 ID；包含该顶点的投影将是结果中的第一个。
which	此参数可用于指定如果只需要两个投影之一，则应返回哪个投影。在此处传递 0 意味着仅返回第一个投影，而 1 意味着仅返回第二个投影。（请注意，我们使用 0 和 1 是因为 Python 索引从零开始）。`False`等效于 0，`True`等效于 1。任何其他值都意味着两个投影都将在元组中返回。
返回值
如果`which`不是 1 或 2，或者是由`which`参数指定的投影一对一图（如果其值为 0、1、`False`之一或`True`.

def bipartite_projection_size(graph, types='type', *args, **kwds): ¶

覆盖 igraph.GraphBase.bipartite_projection_size

根据指定的顶点类型计算此图形的双峰投影中的顶点和边数。如果您有一个双峰图，并且想要估计计算投影本身所需的内存量，这将非常有用。

参数
图	未归档
types	一个 igraph 向量，包含顶点类型，或一个属性名称。任何评估为`False`的内容都对应于第一种顶点，其他所有内容都对应于第二种顶点。
*args	未归档
**kwds	未归档
返回值
一个 4 元组，包含第一个投影中的顶点数和边数，后跟第二个投影中的顶点数和边数。

def blocks(graph, return_articulation_points=False): ¶

计算图的双连通分量。

参数
图	未归档
return_articulation_points	是否也返回割点
返回值
一个 `VertexCover` 对象，描述双连通分量，还可以选择关节点的列表

def clear(graph): ¶

清除图，删除所有顶点、边和属性。

参见
`GraphBase.delete_vertices` 和 `Graph.delete_edges`。

def clusters(graph, mode='strong'): ¶

已弃用的 Graph.connected_components() 别名。

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

覆盖 igraph.GraphBase.community_edge_betweenness

基于网络中边的介数的社区结构。

这个想法是，连接两个社区的边的介数通常很高，因为单独社区中节点之间的许多最短路径都通过它们。因此，我们逐渐删除介数最高的边，并在每次删除后重新计算介数。这样，网络迟早会分解为单独的组件。聚类的结果将由树状图表示。

参数
图	未归档
clusters	我们希望看到的聚类数量。这实际上定义了我们“切割”树状图以获得顶点成员向量的“级别”。如果`None`，当图未加权时，树状图在最大化模块化级别处被切割；否则，树状图在单个群集处被切割（因为如果不是所有权重都相等，则基于模块性的群集计数选择对于此方法没有意义）。
有向	是否应考虑边的方向性。
weights	边属性的名称或包含边权重的列表。
返回值
一个 `VertexDendrogram` 对象，最初在最大模块化或所需数量的群集处被切割。

def community_fastgreedy(graph, weights=None): ¶

覆盖 igraph.GraphBase.community_fastgreedy

基于模块化贪婪优化的社区结构。

该算法以贪婪的方式最大化图的模块化得分，将单个节点合并到社区中。可以证明，如果没有合并可以增加当前的模块化得分，则可以停止该算法，因为无法实现进一步的增加。

据说此算法在稀疏图上几乎以线性时间运行。

参数
图	未归档
weights	边属性名称或包含边权重的列表
返回值
一个合适的 `VertexDendrogram` 对象。
未知字段：newfield
参考	参考
未知字段：ref
A Clauset、MEJ Newman 和 C Moore：在非常大的网络中查找社区结构。Phys Rev E 70, 066111 (2004)。

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

覆盖 igraph.GraphBase.community_infomap

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

参数
图	未归档
edge_weights	边属性的名称或包含边权重的列表。
vertex_weights	顶点属性的名称或包含顶点权重的列表。
trials	对网络进行分区的尝试次数。
返回值
一个合适的 `VertexClustering` 对象，带有一个名为`codelength`的额外属性，该属性存储由算法确定的代码长度。
未知字段：newfield
参考	参考
未知字段：ref
M. Rosvall and C. T. Bergstrom: Maps of information flow reveal community structure in complex networks, PNAS 105, 1118 (2008). http://dx.doi.org/10.1073/pnas.0706851105, 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://dx.doi.org/10.1140/epjst/e2010-01179-1, http://arxiv.org/abs/0906.1405.

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

覆盖 igraph.GraphBase.community_label_propagation

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

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

请注意，由于随机中断了关系，因此无法保证该算法在每次运行后都返回相同的社区结构。实际上，它们经常不同。请参阅 Raghavan 等人的论文，了解如何提出聚合的社区结构。

另请注意，社区_标签_（数字）没有语义含义，igraph 可以自由地重新编号社区。如果你使用固定的标签，igraph 仍然可以重新编号社区，但会遵守共同社区成员约束：如果你有两个具有固定标签的顶点属于同一个社区，它们仍然会在最后属于同一个社区。类似地，如果你有两个具有固定标签的顶点属于不同的社区，它们仍然会在最后属于不同的社区。

参数
图	未归档
weights	边属性的名称或包含边权重的列表
initial	顶点属性的名称或包含初始顶点标签的列表。标签由从零到 n − 1 的整数标识，其中 n 是顶点的数量。此向量中也可能存在负数，它们表示未标记的顶点。
fixed	每个顶点的布尔值列表。`True`对应于在算法期间不应更改其标签的顶点。只有在也给出初始标签的情况下才有意义。未标记的顶点无法固定。它也可以是顶点属性的名称；每个属性值将被解释为布尔值。
返回值
一个合适的 `VertexClustering` 对象。
未知字段：newfield
参考	参考
未知字段：ref
Raghavan, U.N. and Albert, R. and Kumara, S. Near linear time algorithm to detect community structures in large-scale networks. Phys Rev E 76:036106, 2007. http://arxiv.org/abs/0709.2938.

def community_leading_eigenvector(graph, clusters=None, weights=None, arpack_options=None): ¶

覆盖 igraph.GraphBase.community_leading_eigenvector

纽曼的领先特征向量法，用于检测社区结构。

这是递归、分裂算法的正确实现：每次拆分都是通过最大化关于原始网络的模块性来完成的。

参数
图	未归档
clusters	所需的社区数量。如果`None`，则算法尝试尽可能多地拆分。请注意，如果前导特征向量的符号都相同，则该算法不会进一步拆分社区，因此发现的社区的实际数量可能少于所需的数量。
weights	边属性的名称或包含边权重的列表。
arpack_options	用于微调 ARPACK 特征向量计算的 `ARPACKOptions` 对象。如果省略，将使用名为`arpack_options`。
返回值
一个合适的 `VertexClustering` 对象。
未知字段：newfield
参考	参考
未知字段：ref
MEJ Newman：使用矩阵的特征向量在网络中寻找社区结构，arXiv:physics/0605087

def community_leading_eigenvector_naive(graph, clusters=None, return_merges=False): ¶

纽曼特征向量社区结构检测的朴素实现。

此函数根据模块化矩阵的主要特征向量将网络分成两个组件，然后通过将社区拆分为单个网络，以递归方式执行给定的步数。但是，这不是正确的方法，请参阅参考资料以了解解释。考虑改用正确的 Graph.community_leading_eigenvector 方法。

参数
图	未归档
clusters	所需的社区数量。如果`None`，则算法尝试尽可能多地拆分。请注意，如果前导特征向量的符号都相同，则该算法不会进一步拆分社区，因此发现的社区的实际数量可能少于所需的数量。
return_merges	返回的对象是否应该是一个树状图而不是单个聚类。
返回值
一个合适的 `VertexClustering` 或 `VertexDendrogram` 对象。
未知字段：newfield
参考	参考
未知字段：ref
MEJ Newman：使用矩阵的特征向量在网络中寻找社区结构，arXiv:physics/0605087

def community_leiden(graph, objective_function='CPM', weights=None, resolution_parameter=1.0, beta=0.01, initial_membership=None, n_iterations=2, node_weights=None): ¶

覆盖 igraph.GraphBase.community_leiden

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

参数
图	未归档
objective_function	是使用恒定 Potts 模型 (CPM) 还是模块性。必须是`"CPM"`之一或`"modularity"`.
weights	要使用的边权重。可以是序列或可迭代对象，甚至可以是边属性名称。
resolution_parameter	要使用的分辨率参数。较高的分辨率会导致更多较小的社区，而较低的分辨率会导致较少较大的社区。
beta	影响 Leiden 算法中随机性的参数。这仅影响算法的优化步骤。
initial_membership	如果提供，Leiden 算法将尝试改进此提供的成员资格。如果没有提供参数，则算法只从单例分区开始。
n_iterations	迭代 Leiden 算法的次数。每次迭代都可能进一步改进分区。使用负数的迭代次数将运行直到遇到稳定的迭代（即，在该迭代期间质量没有提高）。
node_weights	Leiden 算法中使用的节点权重。如果未提供，将根据您是否要使用 CPM 或模块化自动确定。如果您确实提供了此参数，请确保您了解自己在做什么。
返回值
一个合适的 `VertexClustering` 对象。
未知字段：newfield
参考	参考
未知字段：ref
Traag, V. A., Waltman, L., & van Eck, N. J. (2019). From Louvain to Leiden: guaranteeing well-connected communities. Scientific reports, 9(1), 5233. doi: 10.1038/s41598-019-41695-z

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

覆盖 igraph.GraphBase.community_multilevel

基于 Blondel 等人的多层算法的社区结构。

这是一种自下而上的算法：最初，每个顶点都属于一个单独的社区，并且顶点以一种最大化顶点对总体模块化得分的局部贡献的方式在社区之间迭代地移动。当达成共识（即，没有单次移动会增加模块化得分）时，原始图中的每个社区都会缩小为一个顶点（同时保持相邻边的总权重），并且该过程在下一层继续。当无法通过将社区缩小为顶点来进一步增加模块化时，算法停止。

据说此算法在稀疏图上几乎以线性时间运行。

参数
图	未归档
weights	边属性名称或包含边权重的列表
return_levels	如果`True`，每个级别的社群都将以列表形式返回。如果`False`，则仅返回具有最佳模块化的社群结构。
返回值
一个 `VertexClustering` 对象的列表，每个对象对应于每个级别（如果`return_levels`是`True`），或者一个对应于最佳模块化的 `VertexClustering`。
未知字段：newfield
参考	参考
未知字段：ref
VD Blondel, J-L Guillaume, R Lambiotte and E Lefebvre: Fast unfolding of community hierarchies in large networks, J Stat Mech P10008 (2008), http://arxiv.org/abs/0803.0476

def community_optimal_modularity(graph, *args, **kwds): ¶

覆盖 igraph.GraphBase.community_optimal_modularity

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

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

返回值
计算出的成员向量和元组中相应的模块化。

def community_spinglass(graph, *args, **kwds): ¶

覆盖 igraph.GraphBase.community_spinglass

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

参数
图	未归档
*args	未归档
**kwds	未归档
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 值越小，社区的负内部连接性越小。如果参数为零，则该算法将简化为图着色算法，使用自旋数作为颜色。如果使用原始实现，则忽略此参数。请注意参数名称末尾的下划线；这是因为 lambda 是 Python 中的保留关键字。
返回值
一个合适的 `VertexClustering` 对象。
未知字段：newfield
参考	参考
未知字段：ref
Reichardt J and Bornholdt S: Statistical mechanics of community detection. Phys Rev E 74:016110 (2006). http://arxiv.org/abs/cond-mat/0603718.
Traag VA and Bruggeman J: Community detection in networks with positive and negative links. Phys Rev E 80:036115 (2009). http://arxiv.org/abs/0811.2329.

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

覆盖 igraph.GraphBase.community_walktrap

Latapy & Pons 的社区检测算法，基于随机游走。

该算法的基本思想是，短随机游走往往会停留在同一个社群中。聚类的结果将表示为树状图。

参数
图	未归档
weights	边属性的名称或包含边权重的列表
steps	要执行的随机游走的长度
返回值
一个 `VertexDendrogram` 对象，最初在最大模块化处被切割。
未知字段：newfield
参考	参考
未知字段：ref
Pascal Pons, Matthieu Latapy：使用随机游走计算大型网络中的社区，http://arxiv.org/abs/physics/0512106。

def components(graph, mode='strong'): ¶

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

参数
图	未归档
模式	必须是`"strong"`之一或`"weak"`，具体取决于要寻找的连通分量。可选，默认为`"strong"`.
返回值
一个 `VertexClustering` 对象

def count_automorphisms_vf2(graph, color=None, edge_color=None, node_compat_fn=None, edge_compat_fn=None): ¶

返回图的自同构数。

此函数只是简单地调用count_isomorphisms_vf2带有图 itgraph。请参阅count_isomorphisms_vf2以获取参数的解释。

返回值
图的自同构的数量
参见
Graph.count_isomorphisms_vf2

def degree_distribution(graph, bin_width=1, *args, **kwds): ¶

计算图的度分布。

未知的关键字参数直接传递给 GraphBase.degree。

参数
图	未归档
bin_width	直方图的 bin 宽度
*args	未归档
**kwds	未归档
返回值
表示图的度分布的直方图。

def delete_edges(graph, *args, **kwds): ¶

覆盖 igraph.GraphBase.delete_edges

从图中删除一些边。

要删除的边集由位置和关键字参数确定。如果在没有任何参数的情况下调用该函数，则删除所有边。如果存在任何关键字参数，或者第一个位置参数是可调用的，则通过使用相同的位置和关键字参数调用 EdgeSeq.select 来导出边序列。将删除导出的边序列中的边。否则，第一个位置参数被视为如下

None- 删除所有边（自 0.8.3 起已弃用）
单个整数 - 删除具有给定 ID 的边
整数列表 - 删除由给定 ID 表示的边
2 元组列表 - 删除由给定的源-目标顶点对表示的边。当给定源-目标顶点对之间存在多个边时，只会删除一个边。

未知字段: deprecated
`delete_edges(None)`已被替换为`delete_edges()`- 没有参数 - 自 igraph 0.8.3 起。

def dfs(self, vid, mode=OUT): ¶

对图形进行深度优先搜索 (DFS)。

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

def disjoint_union(graph, other): ¶

创建两个（或多个）图的不相交并集。

参数
图	未归档
other	要与当前图联合的图或图列表。
返回值
互斥并集图

def dyad_census(self, *args, **kwds): ¶

覆盖 igraph.GraphBase.dyad_census

计算图形的二元组普查。

Dyad 普查意味着将有向图的每一对顶点分为三个类别：互惠（从 a 到 b 有一条边，从 b 到 a 也有一条边），不对称（从 a 到 b 或从 b 到 a 有一条边，但反之则没有）和空（a 和 b 之间没有连接）。

返回值
一个 `DyadCensus` 对象。
未知字段：newfield
参考	参考
未知字段：ref
Holland, P.W. 和 Leinhardt, S. (1970). A Method for Detecting Structure in Sociometric Data. American Journal of Sociology, 70, 492-513.

def get_adjacency(self, type=GET_ADJACENCY_BOTH, attribute=None, default=0, eids=False): ¶

覆盖 igraph.GraphBase.get_adjacency

返回图的邻接矩阵。

参数
type	mode`GET_ADJACENCY_LOWER`（使用矩阵的下三角）或`GET_ADJACENCY_UPPER`（使用上三角）或`GET_ADJACENCY_BOTH`（使用两个部分）。对于有向图将被忽略。
attribute	如果`None`，返回普通的邻接矩阵。当在此处给出有效边属性的名称时，返回的矩阵将在没有边的地方包含默认值，或者在有边的地方包含给定属性的值。不支持多重边，在这种情况下写入矩阵的值将是不可预测的。如果 eids 是`True`
default	在具有属性的邻接矩阵的情况下，写入单元格的默认值。
eids	指定是否应在邻接矩阵中返回边 ID。由于零是一个有效的边 ID，因此如果eids是`True`，则矩阵中对应于未连接顶点对的单元格将包含 -1 而不是 0。如果eids是`False`，则将在矩阵中返回每个顶点对的边数。
返回值
邻接矩阵，作为 `Matrix`。

def get_adjacency_sparse(self, attribute=None): ¶

将图的邻接矩阵作为 SciPy CSR 矩阵返回。

参数
attribute	如果`None`，返回普通的邻接矩阵。当在此处给出有效边属性的名称时，返回的矩阵将在没有边的地方包含默认值，或者在有边的地方包含给定属性的值。
返回值
邻接矩阵，作为`scipy.sparse.csr_matrix`.

def get_adjlist(self, mode='out'): ¶

返回图的邻接列表表示形式。

邻接列表表示是一个列表的列表。外部列表的每个项目都属于图的单个顶点。内部列表包含给定顶点的邻居。

参数
模式	如果`"out"`，返回顶点的后继顶点。如果`"in"`，返回顶点的前驱顶点。如果`"all""`，则将返回前驱顶点和后继顶点。对于无向图将被忽略。

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

计算图中从给定节点到某些其他节点（或所有节点）的所有简单路径。

如果路径的顶点是唯一的，则该路径是简单的，即没有顶点被访问多次。

请注意，在图的两个顶点之间可能存在指数级的路径，特别是如果你的图是格子状的。在这种情况下，使用此函数可能会耗尽内存。

参数
v	计算路径的源
到	描述计算路径的目的地的顶点选择器。这可以是单个顶点 ID、顶点 ID 列表、单个顶点名称、顶点名称列表或 `VertexSeq` 对象。`None`表示所有顶点。
cutoff	要考虑的路径的最大长度。如果为负数，则考虑所有长度的路径。
模式	路径的方向性。`"in"`表示计算传入路径，`"out"`表示计算传出路径，`"all"`表示计算两者。
返回值
从给定节点到图中每个其他可到达节点的所有简单路径的列表。请注意，在 mode= 的情况下`"in"`的情况下，路径中的顶点以相反的顺序返回！

def get_automorphisms_vf2(graph, color=None, edge_color=None, node_compat_fn=None, edge_compat_fn=None): ¶

返回图的所有自同构

此函数只是简单地调用get_isomorphisms_vf2带有图 itgraph。请参阅get_isomorphisms_vf2以获取参数的解释。

返回值
列表的列表，每个项目包含根据自同构将图顶点映射到 itgraph 的可能映射
参见
Graph.get_isomorphisms_vf2

def get_edge_dataframe(graph): ¶

将带有属性的边导出到 pandas.DataFrame

如果想使用源顶点和目标顶点 ID 作为索引，可以执行

>>> from string import ascii_letters
>>> graph = Graph.GRG(25, 0.4)
>>> graph.vs["name"] = ascii_letters[:graph.vcount()]
>>> df = graph.get_edge_dataframe()
>>> df.set_index(['source', 'target'], inplace=True)

索引将是一个 pandas.MultiIndex。可以使用drop=False选项来保留来源和目标列。

如果想在源列和目标列中使用顶点名称

>>> df = graph.get_edge_dataframe()
>>> df_vert = graph.get_vertex_dataframe()
>>> df['source'].replace(df_vert['name'], inplace=True)
>>> df['target'].replace(df_vert['name'], inplace=True)
>>> df_vert.set_index('name', inplace=True)  # Optional

返回值
一个 pandas.DataFrame，表示边及其属性。索引使用边 ID，从 0 到 M - 1，其中 M 是边的数量。数据帧的前两列表示每条边的源顶点和目标顶点的 ID。这些列的名称为“source”和“target”。如果你的边具有相同名称的属性，它们将出现在数据帧中，但不会出现在前两列中。

def get_incidence(graph, types='type', *args, **kwds): ¶

覆盖 igraph.GraphBase.get_incidence

返回二分图的关联矩阵。关联矩阵是一个 n 乘以 m 矩阵，其中 n 和 m 是两个顶点类中的顶点数。

参数
图	未归档
types	一个 igraph 向量，包含顶点类型，或一个属性名称。任何评估为`False`的内容都对应于第一种顶点，其他所有内容都对应于第二种顶点。
*args	未归档
**kwds	未归档
返回值
关联矩阵和三元组中的两个列表。第一个列表定义矩阵的行索引和原始顶点 ID 之间的映射。第二个列表对于列索引是相同的。

def get_inclist(graph, mode='out'): ¶

返回图的关联列表表示形式。

关联列表表示是一个列表的列表。外部列表的每个项目都属于图的单个顶点。内部列表包含给定顶点的入射边的 ID。

参数
图	未归档
模式	如果`"out"`，返回顶点的后继顶点。如果`"in"`，返回顶点的前驱顶点。如果`"all"`，则将返回前驱顶点和后继顶点。对于无向图将被忽略。

def get_vertex_dataframe(graph): ¶

将带有属性的顶点导出到 pandas.DataFrame

如果想使用顶点名称作为索引，可以执行

>>> from string import ascii_letters
>>> graph = Graph.GRG(25, 0.4)
>>> graph.vs["name"] = ascii_letters[:graph.vcount()]
>>> df = graph.get_vertex_dataframe()
>>> df.set_index('name', inplace=True)

返回值
一个 pandas.DataFrame，表示顶点及其属性。索引使用顶点 ID，从 0 到 N - 1，其中 N 是顶点数。

def gomory_hu_tree(graph, capacity=None, flow='flow'): ¶

覆盖 igraph.GraphBase.gomory_hu_tree

计算具有可选边容量的无向图的 Gomory-Hu 树。

Gomory-Hu 树是图中所有最大流量（或最小割）值的简明表示。树的顶点与原始图中具有相同顺序的顶点完全对应。Gomory-Hu 树的边由流量值注释。原始图中任意 (u,v) 顶点对之间的最大流量（或最小割）的值由 Gomory-Hu 树中 u 和 v 之间的最短路径上的最小流量值（即边注释）给出。

参数
图	未归档
capacity	边的容量（权重）。如果`None`，则所有边都具有相同的权重。也可以是属性名称。
flow	流量值将存储在返回的图中的边属性的名称。
返回值
Gomory-Hu 树作为 `Graph` 对象。

def indegree(graph, *args, **kwds): ¶

在列表中返回入度。

有关可能的参数，请参阅 GraphBase.degree。

def intersection(graph, other, byname='auto'): ¶

创建两个（或多个）图的交集。

参数
图	未归档
other	要与当前图相交的图或图列表。
byname	是否使用顶点名称而不是 ID。有关详细信息，请参阅 `igraph.operators.intersection`。
返回值
交集图

def is_named(self): ¶

返回图形是否已命名。

当且仅当图具有"name"vertex 属性。

def is_weighted(self): ¶

返回图形是否已加权。

当且仅当图具有"weight"边属性。

def k_core(graph, *args): ¶

返回图的一些 k 核。

该方法接受任意数量的参数，这些参数表示要返回的 k-核的所需索引。参数也可以是列表或元组。如果仅给出一个整数参数，则结果是单个 Graph 对象，否则结果是 Graph 对象的列表，表示按参数指定顺序排列的所需 k-核。如果没有给出参数，则返回所有 k-核，按 k 递增的顺序排列。

def layout(graph, layout=None, *args, **kwds): ¶

根据布局算法返回图的布局。

此处未指定的参数和关键字参数直接传递给布局算法。有关这些参数的说明，请参阅布局算法的文档。

此方法理解的已注册布局名称是

auto, automatic：自动布局（请参阅 Graph.layout_auto）
bipartite：二分图布局（请参阅 GraphBase.layout_bipartite）
circle, circular：圆形布局（请参阅 GraphBase.layout_circle）
dh, davidson_harel：Davidson-Harel 布局（请参阅 GraphBase.layout_davidson_harel）
drl：大型图的 DrL 布局（请参阅 GraphBase.layout_drl）
drl_3d：大型图的 3D DrL 布局（请参阅 GraphBase.layout_drl）
fr, fruchterman_reingold：Fruchterman-Reingold 布局（请参阅 GraphBase.layout_fruchterman_reingold）。
fr_3d, fr3d, fruchterman_reingold_3d：3D Fruchterman- Reingold 布局（请参阅 GraphBase.layout_fruchterman_reingold）。
grid：2D 中的规则网格布局（请参阅 GraphBase.layout_grid）
grid_3d：3D 中的规则网格布局（请参阅 GraphBase.layout_grid）
graphopt：graphopt 算法（请参阅 GraphBase.layout_graphopt）
kk, kamada_kawai：Kamada-Kawai 布局（请参阅 GraphBase.layout_kamada_kawai）
kk_3d, kk3d, kamada_kawai_3d：3D Kamada-Kawai 布局（请参阅 GraphBase.layout_kamada_kawai）
lgl, large, large_graph：大型图布局（请参阅 GraphBase.layout_lgl）
mds：多维缩放布局（请参阅 GraphBase.layout_mds）
random：随机布局（请参阅 GraphBase.layout_random）
random_3d：随机 3D 布局（请参阅 GraphBase.layout_random）
rt, tree, reingold_tilford：Reingold-Tilford 树布局（请参阅 GraphBase.layout_reingold_tilford）
rt_circular, reingold_tilford_circular：圆形 Reingold-Tilford 树布局（请参阅 GraphBase.layout_reingold_tilford_circular）
sphere, spherical, circle_3d, circular_3d：球形布局（请参阅 GraphBase.layout_circle）
star：星形布局（请参阅 GraphBase.layout_star）
sugiyama：Sugiyama 布局（请参阅 Graph.layout_sugiyama）

参数
图	未归档
layout	要使用的布局。这可以是注册的布局名称之一，也可以是返回 `Layout` 对象或包含坐标的列表的列表的可调用对象。如果`None`, 使用`plotting.layout`配置键的值。
*args	未归档
**kwds	未归档
返回值
一个 `Layout` 对象。

def layout_auto(graph, *args, **kwds): ¶

根据图的简单拓扑属性选择并运行合适的布局函数。

此函数尝试使用以下规则为图选择合适的布局函数

如果图具有名为layout，则将使用它。它可以是 Layout 实例、坐标对列表、布局函数的名称或可调用函数，该函数在以图作为参数调用时生成布局。
否则，如果图具有名为x和y的顶点属性，这些属性将用作布局中的坐标。当请求 3D 布局时（通过设置dim为 3），还需要一个名为z的顶点属性。
否则，如果图已连接且最多有 100 个顶点，则将使用 Kamada-Kawai 布局（请参阅 GraphBase.layout_kamada_kawai()）。
否则，如果图最多有 1000 个顶点，则将使用 Fruchterman-Reingold 布局（请参阅 GraphBase.layout_fruchterman_reingold()）。
如果以上所有操作都失败，则将使用 DrL 布局算法（请参阅 GraphBase.layout_drl()）。

此函数的所有参数，除了dim都传递给所选的布局函数（以防我们需要调用某些布局函数）。

参数
图	未归档
*args	未归档
**kwds	未归档
dim	指定我们是否要获取 2D 或 3D 布局。
返回值
一个 `Layout` 对象。

def layout_sugiyama(graph, layers=None, weights=None, hgap=1, vgap=1, maxiter=100, return_extended_graph=False): ¶

使用分层 Sugiyama 布局放置顶点。

这是一种分层布局，最适合有向无环图，尽管它也适用于无向或循环图。

每个顶点都被分配到一个层，每个层都放置在一条水平线上。然后使用重心启发法对同一层内的顶点进行置换，该启发法尝试最小化边交叉。

将在跨越多个层的边上添加虚拟顶点。因此，返回的布局包含的行数多于原始图中节点的数量；额外的行对应于虚拟顶点。

参数
图	未归档
layers	一个向量，指定每个顶点的非负整数层索引，或者指定包含层索引的数字顶点属性的名称。如果`None`，将自动确定分层。对于无向图，将提取生成树，并使用从具有最大度的节点开始的广度优先搜索将顶点分配到层。对于有向图，使用 Eades、Lin 和 Smyth 的启发式算法反转近似反馈弧集中的边的方向来打破循环，然后使用最长路径分层将顶点放置在层中。
weights	要使用的边权重。可以是序列或可迭代对象，甚至可以是边属性名称。
hgap	同一层中顶点之间的最小水平间隙。
vgap	层之间的垂直间隙。层索引将乘以 vgap 以获得 Y 坐标。
maxiter	减少交叉步骤中要执行的最大迭代次数。如果您觉得您获得的边交叉太多，请增加此值。
return_extended_graph	指定还应返回带有添加的虚拟顶点的扩展图。当这是`True`，结果将是一个包含布局和扩展图的元组。扩展图的前 \|V\| 个节点将对应于原始图的节点，其余节点是虚拟节点。使用返回的布局和隐藏的虚拟节点绘制扩展图将生成类似于原始图的布局，但添加了边弯曲。扩展图还包含一个名为的边属性`_original_eid`的边属性，该属性指定从中创建扩展图的边的原始图中的边的 ID。
返回值
计算出的布局，它可能（并且通常会）具有比顶点数更多的行；其余行对应于分层步骤中引入的虚拟节点。当`return_extended_graph`是`True`, 它还将包含扩展图。
未知字段：newfield
参考	参考
未知字段：ref
K Sugiyama, S Tagawa, M Toda: Methods for visual understanding of hierarchical system structures. IEEE Systems, Man and Cybernetics 11(2):109-125, 1981.
P Eades, X Lin and WF Smyth: A fast effective heuristic for the feedback arc set problem. Information Processing Letters 47:319-323, 1993.

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

重写 igraph.GraphBase.maxflow

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

从源到目标的最大流量是将非负实数分配给图的边的过程，满足以下两个属性

对于每条边，流量（即分配的数字）不大于边的容量（参见capacity参数）
对于除源和目标之外的每个顶点，流入的流量与流出的流量相同。

流量的值是目标的流入流量或源的流出流量（两者相等）。最大流量是最大可能的此类值。

参数
图	未归档
来源	未归档
目标	未归档
capacity	边的容量（权重）。如果`None`，则所有边都具有相同的权重。也可以是属性名称。
返回值
一个描述最大流量的`Flow`对象

def maximum_bipartite_matching(graph, types='type', weights=None, eps=None): ¶

在二分图中查找最大匹配。

最大匹配是一组边，使得每个顶点最多入射到一个匹配边上，并且该集合中此类边的数量（或权重）尽可能大。

参数
图	未归档
types	列表中顶点的类型或保存顶点类型的顶点属性的名称。类型应由零和一表示（或`False`和`True`）表示二分图的两侧。如果省略，则默认为`type`，这是二分图的默认顶点类型属性。
weights	要使用的边权重。可以是序列或可迭代对象，甚至可以是边属性名称。
eps	，是在加权二分匹配算法中用于相等性测试的小实数。如果两个实数之差小于此值，则在算法中认为它们相等。这是避免数值误差累积所必需的。如果您传递`None`，igraph 将尝试自动确定适当的值。
返回值
`Matching`的一个实例。

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

重写 igraph.GraphBase.mincut

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

最小割是需要移除以分离源和目标（如果给定）或断开图（如果既未给定源也未给定目标）的最小边集。最小值是使用边的权重（容量）计算的，因此计算的是具有最小总容量的割。

对于无向图且没有源和目标，该方法使用 Stoer-Wagner 算法。对于给定的源和目标，该方法使用 push-relabel 算法；请参阅下面的参考文献。

参数
图	未归档
来源	源顶点 ID。如果`None`，目标也必须是`None`，并且将对整个图（即所有可能的顶点对）进行计算。
目标	目标顶点 ID。如果`None`，源也必须是`None`，并且将对整个图（即所有可能的顶点对）进行计算。
capacity	边的容量（权重）。如果`None`，则所有边都具有相同的权重。也可以是属性名称。
返回值
一个描述最小割的`Cut`对象

def modularity(self, membership, weights=None): ¶

重写 igraph.GraphBase.modularity

计算图相对于给定聚类的模块化分数。

相对于某种划分，图的模块度衡量了划分的好坏，或者不同的顶点类型彼此分离的程度。它被定义为 Q = 1 ⁄ (2m)*sum(Aij − ki*kj ⁄ (2m)delta(ci, cj), i, j)。m 是边的数量，Aij 是 A 邻接矩阵中第 i 行和第 j 列的元素，ki 是节点 i 的度，kj 是节点 j 的度，并且 Ci 和cj是两个顶点的类型（i 和 j）。如果 x = y，则 delta(x, y) 为 1，否则为 0。

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

参数
membership	一个成员列表或一个`VertexClustering`对象
weights	可选的边权重或`None`如果所有边的权重相等。也允许属性名称。
返回值
模块度得分
未知字段：newfield
参考	参考
未知字段：ref
MEJ Newman 和 M Girvan： Finding and evaluating community structure in networks. Phys Rev E 69 026113, 2004.

def outdegree(graph, *args, **kwds): ¶

在列表中返回出度。

有关可能的参数，请参阅 GraphBase.degree。

def pagerank(graph, vertices=None, directed=True, damping=0.85, weights=None, arpack_options=None, implementation='prpack'): ¶

计算图的 PageRank 值。

参数
图	未归档
vertices	正在查询的顶点的索引。`None`表示所有顶点。
有向	是否考虑有向路径。
damping	，阻尼因子。1 − damping 是没有传入链接的节点的 PageRank 值。它也是在每个步骤中将随机游走重置为均匀分布的概率。
weights	要使用的边权重。可以是序列或可迭代对象，甚至可以是边属性名称。
arpack_options	用于微调 ARPACK 特征向量计算的 `ARPACKOptions` 对象。如果省略，将使用名为`arpack_options`使用。如果未使用 ARPACK 实现，则忽略此参数，请参阅 implementation 参数。
implementation	用于解决 PageRank 特征问题的实现方式。可能的值包括 `"prpack"`：使用 PRPACK 库。这是 igraph 0.7 中的一个新实现 `"arpack"`：使用 ARPACK 库。此实现从 0.5 版本一直使用到 0.7 版本。
返回值
，包含指定顶点的 PageRank 值的列表。

def path_length_hist(self, directed=True): ¶

重写 igraph.GraphBase.path_length_hist

返回图形的路径长度直方图

参数
有向	是否考虑有向路径。对于无向图，此参数将被忽略。
返回值
一个`Histogram`对象。该对象还将具有一个`unconnected`属性，该属性存储未连接的顶点对的数量（其中无法从第一个顶点到达第二个顶点）。后者将是 long 类型（而不是简单的整数），因为这可能非常大。

def shortest_paths(graph, *args, **kwds): ¶

已弃用的 Graph.distances() 别名。

def spanning_tree(self, weights=None, return_tree=True): ¶

计算图形的最小生成树。

参数
weights	一个包含图中每条边的权重的向量。`None`表示该图是未加权的。
return_tree	是否返回最小生成树（当`return_tree`是`True`时）还是返回最小生成树中的边的 ID（当`return_tree`是`False`时）。默认值为`True`，这是因为此参数是在 igraph 0.6 中引入的。
返回值
如果`return_tree`是`True`，则将生成树作为`Graph`对象返回；如果`return_tree`是`False`.
未知字段：newfield
参考	参考
未知字段：ref
Prim, R.C.: Shortest connection networks and some generalizations. Bell System Technical Journal 36:1389-1401, 1957.

def summary(self, verbosity=0, width=None, *args, **kwds): ¶

返回图形的摘要。

此方法的输出类似于__str__方法的输出。如果 verbosity 为零，则仅返回标题行（请参见__str__了解更多详细信息），否则将打印标题行和边列表。

在幕后，此方法构造一个GraphSummary对象并调用其__str__方法。

参数
verbosity	，如果为零，则仅返回标题行（请参见`__str__`了解更多详细信息），否则将打印标题行和完整边列表。
width	，一行中要使用的字符数。如果`None`，则不会对行长度强制执行任何限制。
*args	未归档
**kwds	未归档
返回值
图的摘要。

def to_dict_dict(graph, use_vids=True, edge_attrs=None, skip_none=False, vertex_name_attr='name'): ¶

将图形导出到边属性的字典的字典

此函数是 Graph.DictDict 的反函数。

示例

>>> g = Graph.Full(3)
>>> g.es['name'] = ['first_edge', 'second', 'third']
>>> g.to_dict_dict()
{0: {1: {'name': 'first_edge'}, 2: {'name': 'second'}}, 1: {2: {'name': 'third'}}}

参数
图	未归档
use_vids:`bool`	是否通过顶点 ID 或 vertex_name_attr 属性标记输出数据结构中的顶点。如果 use_vids=False 但顶点缺少 vertex_name_attr 属性，则会引发 AttributeError。
edge_attrs:`Union[str, Sequence[str]]`	要导出的边属性列表。None（默认）表示所有属性（与 Graph.to_tuple_list 不同）。字符串可以接受，表示单个属性，并且将在内部包装在列表中。
skip_none:`bool`	是否跳过每个边中值为 None 的属性。如果预期只有某些边具有某个属性，这将非常有用。
vertex_name_attr:`str`	未归档
返回值
字典的字典的字典，其中外层键是顶点 ID/名称，中间键是它们的邻居的 ID/名称，最内层字典表示该边的属性。
未知字段：vertex_name_attr
仅与 use_vids=False 一起使用，用于选择在输出数据结构中使用哪个顶点属性来命名顶点。

def to_dict_list(graph, use_vids=True, skip_none=False, vertex_name_attr='name'): ¶

将图形导出为两个字典列表，分别用于顶点和边。

此函数是 Graph.DictList 的反函数。

示例

>>> g = Graph([(0, 1), (1, 2)])
>>> g.vs["name"] = ["apple", "pear", "peach"]
>>> g.es["name"] = ["first_edge", "second"]

>>> g.to_dict_list()
([{"name": "apple"}, {"name": "pear"}, {"name": "peach"}],
 [{"source": 0, "target": 1, "name": "first_edge"},
  {"source" 0, "target": 2, name": "second"}])

>>> g.to_dict_list(use_vids=False)
([{"name": "apple"}, {"name": "pear"}, {"name": "peach"}],
 [{"source": "apple", "target": "pear", "name": "first_edge"},
  {"source" "apple", "target": "peach", name": "second"}])

参数
图	未归档
use_vids:`bool`	是否通过顶点 ID 或 vertex_name_attr 属性标记输出数据结构中的顶点。如果 use_vids=False 但顶点缺少 vertex_name_attr 属性，则会引发 AttributeError。
skip_none:`bool`	是否跳过每个边中值为 None 的属性。如果预期只有某些边具有某个属性，这将非常有用。
vertex_name_attr:`str`	未归档
返回值
一个包含两个字典列表的元组，分别表示顶点和边及其属性。
未知字段：vertex_name_attr
仅与 use_vids=False 一起使用，用于选择在输出数据结构中使用哪个顶点属性来命名顶点。

def to_graph_tool(graph, graph_attributes=None, vertex_attributes=None, edge_attributes=None): ¶

将图转换为 graph-tool

数据类型：graph-tool 仅接受特定的数据类型。有关列表，请参见以下网页

https://graph-tool.skewed.de/static/doc/quickstart.html

注意：由于 graph-tool 中受限的数据类型，顶点和边属性需要在所有顶点或边上类型一致。如果仅为某些顶点/边设置了属性，则其他顶点/边将在 igraph 中标记为 None，因此它们只能使用“object”类型转换为 graph-tool，任何其他转换都将失败。

参数
图	未归档
graph_attributes	要传输的图属性的字典。键是来自图的属性，值是数据类型（请参见下文）。`None`表示不传输图属性。
vertex_attributes	要传输的顶点属性的字典。键是来自顶点的属性，值是数据类型（请参见下文）。`None`表示不传输顶点属性。
edge_attributes	要传输的边属性的字典。键是来自边的属性，值是数据类型（请参见下文）。`None`表示不传输顶点属性。

def to_list_dict(graph, use_vids=True, sequence_constructor=list, vertex_name_attr='name'): ¶

将图形导出到列表（或其他序列）的字典。

此函数是 Graph.ListDict 的反函数。

示例

>>> g = Graph.Full(3)
>>> g.to_sequence_dict() -> {0: [1, 2], 1: [2]}
>>> g.to_sequence_dict(sequence_constructor=tuple) -> {0: (1, 2), 1: (2,)}
>>> g.vs['name'] = ['apple', 'pear', 'peach']
>>> g.to_sequence_dict(use_vids=False)
{'apple': ['pear', 'peach'], 'pear': ['peach']}

参数
图	未归档
use_vids:`bool`	是否通过顶点 ID 或 vertex_name_attr 属性标记输出数据结构中的顶点。如果 use_vids=False 但顶点缺少 vertex_name_attr 属性，则会引发 AttributeError。
sequence_constructor:`callable`	用作字典值的的数据结构的构造函数。默认值 (list) 创建一个列表字典，其中每个列表表示相应字典键中指定的顶点的邻居。
vertex_name_attr:`str`	未归档
返回值
序列字典，以顶点为键，每个值包含该顶点的邻居。
未知字段：vertex_name_attr
仅与 use_vids=False 一起使用，用于选择在输出数据结构中使用哪个顶点属性来命名顶点。

def to_networkx(graph, create_using=None, vertex_attr_hashable='_nx_name'): ¶

将图转换为 networkx 格式。

igraph 具有有序的顶点和边，但 networkx 没有。为了跟踪原始顺序，“_igraph_index”顶点属性已添加到顶点和边。

参数
图	未归档
create_using	指定构造图时要使用的 NetworkX 图类。`None`表示让 igraph 根据图是否是有向图以及是否具有多重边来推断最合适的类。
vertex_attr_hashable:`str`	用于命名导出网络中顶点的顶点属性。默认值 "_nx_name" 确保与 networkx 的往返转换是无损的。

def to_tuple_list(graph, use_vids=True, edge_attrs=None, vertex_name_attr='name'): ¶

将图形导出到边元组列表

此函数是 Graph.TupleList 的反函数。

示例

>>> g = Graph.Full(3)
>>> g.vs["name"] = ["apple", "pear", "peach"]
>>> g.es["name"] = ["first_edge", "second", "third"]

>>> # Get name of the edge
>>> g.to_tuple_list(edge_attrs=["name"])
[(0, 1, "first_edge"), (0, 2, "second"), (1, 2, "third")]

>>> # Use vertex names, no edge attributes
>>> g.to_tuple_list(use_vids=False)
[("apple", "pear"), ("apple", "peach"), ("pear", "peach")]

参数
图	未归档
use_vids:`bool`	是否通过顶点 ID 或 vertex_name_attr 属性标记输出数据结构中的顶点。如果 use_vids=False 但顶点缺少 vertex_name_attr 属性，则会引发 AttributeError。
edge_attrs:`Union[str, Sequence[str]]`	除了源顶点和目标顶点之外，要导出的边属性列表，它们始终是每个元组的前两个元素。None（默认）等效于空列表。字符串可以接受，表示单个属性，并且将在内部包装在列表中。
vertex_name_attr:`str`	未归档
返回值
元组列表，每个元组表示图的一条边。
未知字段：vertex_name_attr
仅与 use_vids=False 一起使用，用于选择在输出数据结构中使用哪个顶点属性来命名顶点。

def transitivity_avglocal_undirected(self, mode='nan', weights=None): ¶

重写 igraph.GraphBase.transitivity_avglocal_undirected

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

在未加权的情况下，传递性衡量顶点的两个邻居之间连接的概率。在平均局部传递性的情况下，为每个顶点计算此概率，然后取平均值。邻居数少于两个的顶点需要特殊处理，它们要么从计算中排除，要么被认为具有零传递性，具体取决于 mode 参数。对于加权图，计算稍微复杂一些；在这种情况下，权重会根据 Barrat 等人的公式考虑在内（请参阅参考文献）。

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

参数
模式	定义如何处理度数小于 2 的顶点。如果`TRANSITIVITY_ZERO`之一或`"zero"`，这些顶点将具有零传递性。如果`TRANSITIVITY_NAN`之一或`"nan"`，这些顶点将被排除在平均值之外。
weights	要使用的边权重。可以是序列或可迭代对象，甚至可以是边属性名称。
参见
`transitivity_undirected()`, `transitivity_local_undirected()`
未知字段：newfield
参考	参考
未知字段：ref
Watts DJ and Strogatz S: 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.

def triad_census(self, *args, **kwds): ¶

重写 igraph.GraphBase.triad_census

计算图形的三元组普查。

返回值
一个`TriadCensus`对象。
未知字段：newfield
参考	参考
未知字段：ref
Davis, J.A. and Leinhardt, S. (1972). The Structure of Positive Interpersonal Relations in Small Groups. In: J. Berger (Ed.), Sociological Theories in Progress, Volume 2, 218-251. Boston: Houghton Mifflin.

def union(graph, other, byname='auto'): ¶

创建两个（或多个）图的并集。

参数
图	未归档
other	要与当前图联合的图或图列表。
byname	是否使用顶点名称而不是 ID。有关详细信息，请参见`igraph.operators.union`。
返回值
并集图

def write(graph, f, format=None, *args, **kwds): ¶

用于图的统一写入函数。

此方法尝试根据第一个参数中给定的图的格式（基于扩展名）来识别它，并调用相应的写入方法。

其余参数将传递给写入方法，没有任何更改。

参数
图	未归档
f	包含要保存的图的文件
format	文件的格式（如果要覆盖从文件名扩展名确定的格式，或者文件名本身是一个流）。`None`表示自动检测。可能的值是 `"adjacency"`：邻接矩阵格式 `"dimacs"`：DIMACS 格式 `"dot"`, `"graphviz"`：GraphViz DOT 格式 `"edgelist"`, `"edges"`之一或`"edge"`：数字边列表格式 `"gml"`：GML 格式 `"graphml"`和`"graphmlz"`：标准和 gzip 压缩的 GraphML 格式 `"gw"`, `"leda"`, `"lgr"`：LEDA 本机格式 `"lgl"`：LGL 格式 `"ncol"`：NCOL 格式 `"net"`, `"pajek"`：Pajek 格式 `"pickle"`, `"picklez"`：标准和 gzip 压缩的 Python pickle 格式 `"svg"`：SVG 格式
*args	未归档
**kwds	未归档
引发
`IOError`	如果无法识别文件格式，并且未给出任何格式。

def write_adjacency(graph, f, sep=' ', eol='\n', *args, **kwds): ¶

将图的邻接矩阵写入给定的文件

此处未提及的所有剩余参数都将完整地传递给Graph.get_adjacency。

参数
图	未归档
f	要写入的文件的名称。
sep	分隔行中矩阵元素的字符串
eol	分隔矩阵行的字符串。请注意，当且仅当这是一个换行符时，igraph 才能读回写入的邻接矩阵
*args	未归档
**kwds	未归档

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

重写 igraph.GraphBase.write_dimacs

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

参数
图	未归档
f	要写入的文件的名称或 Python 文件句柄。
来源	源顶点 ID。如果`None`，igraph 将尝试从`来源`图属性中推断它。
目标	目标顶点 ID。如果`None`，igraph 将尝试从`目标`图属性中推断它。
capacity	列表中边的容量或保存容量的边属性的名称。如果没有这样的边属性，则每条边的容量为 1。

def write_graphmlz(graph, f, compresslevel=9): ¶

将图写入压缩的 GraphML 文件。

该库使用 gzip 压缩算法，因此可以使用常规 gzip 解压缩（例如gunzip之一或zcat来自 Unix 命令行）或 Pythongzip模块解压缩生成的文件。

使用临时文件来存储中间 GraphML 数据，因此请确保您有足够的可用空间来存储解压缩的 GraphML 文件。

参数
图	未归档
f	要写入的文件的名称。
compresslevel	压缩级别。1 最快并且产生的压缩最少，而 9 最慢并且产生的压缩最多。

def write_pickle(graph, fname=None, version=-1): ¶

以 Python pickle 格式保存图

参数
图	未归档
fname	要保存到的文件的名称或流。如果`None`，则将图保存到字符串并返回该字符串。
version	要使用的 pickle 协议版本。如果为 -1，则使用最高可用协议
返回值
`None`如果图已成功保存到给定文件，或者如果`fname`为字符串。`None`.

def write_picklez(graph, fname=None, version=-1): ¶

以 Python pickle 格式保存图，并使用 gzip 压缩。

以这种格式保存比以没有压缩的 Python pickle 格式保存慢一些，但最终文件占用的硬盘空间要少得多。

参数
图	未归档
fname	要保存到的文件的名称或流。
version	要使用的 pickle 协议版本。如果为 -1，则使用最高可用协议
返回值
`None`如果图已成功保存到给定文件。

def write_svg(graph, fname, layout='auto', width=None, height=None, labels='label', colors='color', shapes='shape', vertex_size=10, edge_colors='color', edge_stroke_widths='width', font_size=16, *args, **kwds): ¶

将图另存为 SVG（可缩放矢量图形）文件

该文件将与 Inkscape (http://inkscape.org) 兼容。在 Inkscape 中，随着节点的重新排列，边会自动更新。

参数
图	未归档
fname	文件的名称或 Python 文件句柄
layout	图的布局。可以是显式指定的布局（使用坐标对列表）或布局算法的名称（应引用`Graph`对象中的方法，但不包含`layout_`前缀。
width	首选的宽度（以像素为单位）（默认值：400）
height	首选的高度（以像素为单位）（默认值：400）
labels	顶点标签。可以是要使用的顶点属性的名称，也可以是显式指定标签的列表。它也可以是`None`.
colors	顶点颜色。可以是要使用的顶点属性的名称，也可以是显式指定颜色的列表。颜色可以是 SVG 文件中可接受的任何内容。
shapes	顶点形状。它可以是要使用的顶点属性的名称，也可以是显式指定形状为整数的列表。形状 0 表示隐藏（不绘制任何内容），形状 1 是一个圆，形状 2 是一个矩形，形状 3 是一个自动调整大小以适应内部文本的矩形。
vertex_size	顶点大小（以像素为单位）
edge_colors	边颜色。可以是要使用的边属性的名称，也可以是显式指定颜色的列表。颜色可以是 SVG 文件中可接受的任何内容。
edge_stroke_widths	边的笔画宽度。可以是要使用的边属性的名称，也可以是显式指定笔画宽度的列表。笔画宽度可以是 SVG 文件中可接受的任何内容。
font_size	字体大小。如果它是一个字符串，它将按原样写入 SVG 文件（因此您可以指定任何作为`font-size`样式的有效值）。如果它是一个数字，它将被解释为像素大小并相应地转换为正确的属性值。
*args	未归档
**kwds	未归档

__hash__ = ¶

未归档

__iter__ = ¶

未归档

Formula = ¶

未归档

@property
es = ¶

图形的边序列

@property
vs = ¶

图形的顶点序列

@classmethod
def _reconstruct(cls, attrs, *args, **kwds): ¶

从 Python 的 pickle 格式重建 Graph 对象。

此方法仅供内部使用，不应直接调用。

@property
_as_parameter_ = ¶

未归档