igraph.Graph

class documentation

class Graph(GraphBase): (source)

构造函数: Graph(kwargs)

查看层次结构

通用图。

该类建立在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]
类方法 Adjacency 从其邻接矩阵生成图。
类方法 Biadjacency 从二分邻接矩阵创建二分图。
类方法 Bipartite 创建一个具有给定顶点类型和边的二分图。这与图的默认构造函数类似，唯一的区别是它检查所有边是否在两个顶点类之间，并将类型向量分配给...
类方法 DataFrame 从一个或两个数据框生成图。
类方法 DictDict 从字典的字典表示中构造一个图。
类方法 DictList 从字典列表表示中构造图。
类方法 from_graph_tool 将图从graph-tool转换
类方法 from_networkx 将图从networkx转换
类方法 Full_Bipartite 生成一个完全二分图（有向或无向，带或不带循环）。
类方法 GRG 生成一个随机几何图。
类方法 Incidence 已弃用的别名，指向 Graph.Biadjacency()。
类方法 ListDict 从列表字典表示构造图。
类方法 Random_Bipartite 生成一个具有给定顶点数和边数（如果提供了m）的随机二分图，或者具有给定顶点数和连接概率（如果提供了p）的随机二分图。
类方法 Read 图的统一读取函数。
类方法 Read_Adjacency 根据给定文件中的邻接矩阵构建图。
类方法 Read_DIMACS 从符合DIMACS最小成本流文件格式的文件中读取图。
类方法 Read_GraphMLz 从压缩的GraphML文件中读取图。
类方法 Read_Pickle 从Python的pickle格式读取图
类方法 Read_Picklez 从压缩的Python pickle格式读取图，并在读取时解压缩。
类方法 TupleList 从元组列表表示中构造图。
类方法 Weighted_Adjacency 从其加权邻接矩阵生成图。
方法 __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__ 支持序列化。
方法 __str__ 返回图的字符串表示。
方法 __sub__ 从图中移除给定的对象
方法 add_edge 向图中添加一条边。
方法 add_edges 向图中添加一些边。
方法 add_vertex 向图中添加一个顶点。关键字参数将被分配为顶点属性。请注意，name 作为关键字参数会被特殊处理；如果图具有 name 作为顶点属性，它允许在大多数期望顶点ID的地方通过名称引用顶点。
方法 add_vertices 向图中添加一些顶点。
方法 all_st_cuts 返回有向图中源顶点和目标顶点之间的所有切割。
方法 all_st_mincuts 返回有向图中源顶点和目标顶点之间的所有最小割。
方法 are_connected 已弃用的别名，指向 Graph.are_adjacent()。
方法 as_directed 返回此图的有向副本。参数传递给在副本上调用的GraphBase.to_directed()。
方法 as_undirected 返回此图的无向副本。参数传递给在副本上调用的GraphBase.to_undirected()。
方法 biconnected_components 计算图的双连通组件。
方法 bipartite_projection 将二分图投影为两个单模图。在投影过程中忽略边的方向。
方法 bipartite_projection_size 根据指定的顶点类型计算此图的二分投影中的顶点和边的数量。如果您有一个二分图并且想要估计计算投影本身所需的内存量，这将非常有用。
方法 blocks 计算图的双连通组件。
方法 clear 清除图，删除所有顶点、边和属性。
方法 clusters 已弃用的别名，指向 Graph.connected_components()。
方法 cohesive_blocks 计算图的凝聚块结构。
方法 community_edge_betweenness 基于网络中边的介数来划分社区结构。
方法 community_fastgreedy 基于模块度贪婪优化的社区结构。
方法 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社区检测算法。
方法 components 计算给定图的（强或弱）连通组件。
方法 connected_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_biadjacency 返回二分图的二分邻接矩阵。二分邻接矩阵是一个n乘以m的矩阵，其中n和m是两个顶点类中的顶点数量。
方法 get_edge_dataframe 将带有属性的边导出到pandas.DataFrame
方法 get_incidence 已弃用的别名，指向 Graph.get_biadjacency()。
方法 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 计算图的最小生成树。
方法 st_mincut 计算图中源顶点和目标顶点之间的最小割。
方法 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的pickled格式重建Graph对象。
属性 _as_parameter_ 未记录

继承自 GraphBase:

方法 __new__ 创建并返回一个新对象。有关准确的签名，请参见 help(type)。
方法 all_minimal_st_separators 返回包含图中所有最小s-t分隔符的列表。
方法 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 计算图中给定顶点的文献耦合分数。
方法 bridges 返回图中的桥列表。
方法 canonical_permutation 使用BLISS同构算法计算图的规范排列。
方法 chordal_completion 返回需要添加到图中以使其成为弦图的边列表。
方法 Chung_Lu 生成一个Chung-Lu随机图。
方法 clique_number 返回图的团数。
方法 cliques 返回图中部分或所有团，作为一个元组列表。
方法 closeness 计算图中给定顶点的接近中心性。
方法 cocitation 计算图中给定顶点的共引分数。
方法 complementer 返回图的补图
方法 compose 返回两个图的组合。
方法 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_vertices 从图中删除顶点及其所有边。
方法 density 计算图的密度。
方法 dfsiter 构造图的深度优先搜索（DFS）迭代器。
方法 diameter 计算图的直径。
方法 difference 从原始图中减去给定的图
方法 distances 计算图中给定顶点的最短路径长度。
方法 diversity 计算顶点的结构多样性指数。
方法 dominator 返回从给定根节点开始的支配树
方法 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_all_shortest_paths 计算图中从/到给定节点的所有最短路径。
方法 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 返回图的周长。
方法 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_value 返回源顶点和目标顶点之间的最大流量的值。
方法 maximal_cliques 返回图的最大团作为一个元组列表。
方法 maximal_independent_vertex_sets 返回图的最大独立顶点集作为元组列表。
方法 maximum_cardinality_search 在图上执行最大基数搜索。该函数为每个顶点计算一个等级alpha，使得按递减等级顺序访问顶点对应于始终选择具有最多已访问邻居的顶点作为下一个要访问的顶点。
方法 mean_degree 计算图的平均度数。
方法 mincut_value 返回源顶点和目标顶点之间或整个图中的最小割。
方法 minimum_cycle_basis 计算图的最小环基
方法 minimum_size_separators 返回包含所有最小大小的分隔顶点集的列表。
方法 modularity_matrix 计算图的模块化矩阵。
方法 motifs_randesu 计算图中的模体数量
方法 motifs_randesu_estimate 计算图中所有主题的总数
方法 motifs_randesu_no 计算图中所有主题的总数
方法 neighborhood 对于由vertices指定的每个顶点，返回在最多order步内可从该顶点到达的顶点。如果mindist大于零，则在少于mindist步内可到达的顶点将被排除。
方法 neighborhood_size 对于由vertices指定的每个顶点，返回在最多order步内可以从该顶点到达的顶点数量。如果mindist大于零，则在少于mindist步内可到达的顶点...
方法 neighbors 返回给定顶点的相邻顶点。
方法 permute_vertices 根据给定的排列对图的顶点进行排列，并返回新的图。
方法 personalized_pagerank 计算图的个性化PageRank值。
方法 predecessors 返回给定顶点的前驱。
方法 Preference 基于顶点类型和连接概率生成图。
方法 Prufer 从其Prüfer序列生成树。
方法 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_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 通过移除自环和/或多重边来简化图。
方法 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_local_undirected 计算图中给定顶点的局部传递性（聚类系数）。
方法 transitivity_undirected 计算图的全局传递性（聚类系数）。
方法 Tree 生成一个几乎所有顶点都有相同数量子节点的树。
方法 Tree_Game 通过从具有给定节点数的标记树集合中均匀采样生成随机树。
方法 Triangular_Lattice 生成一个规则的三角网格。
方法 unfold_tree 通过必要的顶点复制，使用广度优先搜索（BFS）将图展开为树。
方法 vcount 计算顶点的数量。
方法 vertex_attributes 无摘要
方法 vertex_coloring_greedy 基于一些启发式方法计算图的贪婪顶点着色。
方法 vertex_connectivity 计算图的顶点连通性或某些顶点之间的连通性。
方法 Watts_Strogatz 此函数基于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返回
方法 __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 从其邻接矩阵生成图。
@classmethod
def Adjacency(cls, matrix, mode='directed', loops='once'): (source)
overrides igraph.GraphBase.Adjacency

从其邻接矩阵生成图。

参数
matrix

邻接矩阵。可能的类型有：

  • 列表的列表
  • numpy 2D 数组或矩阵（将被转换为列表的列表）
  • scipy.sparse 矩阵（将被转换为 COO 矩阵，但不会转换为密集矩阵）
  • pandas.DataFrame（列/行名称必须匹配，并将用作顶点名称）。
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指定如何处理循环边。当False或"ignore"时，邻接矩阵的对角线将被忽略。当True或"once"时，对角线被认为包含相应循环边的多重性。当"twice"时，对角线被认为包含相应循环边多重性的两倍。
@classmethod
def Biadjacency(cls, matrix, directed=False, mode='out', multiple=False, weighted=None, *args, **kwds): (source)

从二分邻接矩阵创建一个二分图。

示例：

>>> g = Graph.Biadjacency([[0, 1, 1], [1, 1, 0]])
参数
matrix二分邻接矩阵。
directed是否创建有向图。
mode定义图中边的方向。如果为"out"，则边从第一种类型的顶点（对应于矩阵的行）指向第二种类型的顶点（矩阵的列）。如果为"in"，则使用相反的方向。"all"创建相互的边。对于无向图则忽略此参数。
multiple定义如何处理矩阵中的非零条目。如果False，无论值是多少，非零条目都会创建一个边。如果True，非零条目将四舍五入到最接近的整数，这将是创建的多个边的数量。
weighted定义是否从邻接矩阵创建加权图。如果它是c{None}，则创建一个未加权的图，并使用multiple参数来确定图的边。如果它是一个字符串，则对于每个非零矩阵条目，将创建一条边，并将条目的值添加为由weighted参数命名的边属性。如果它是True，则创建一个加权图，并且边属性的名称将是"weight"。
*args未记录
**kwds未记录
返回
具有名为"type"的二进制顶点属性的图，该属性存储顶点类别。
引发
ValueError如果同时传递了加权和多个参数。
@classmethod
def Bipartite(cls, types, edges, directed=False, *args, **kwds): (source)

使用给定的顶点类型和边创建一个二分图。这与图的默认构造函数类似，唯一的区别是它会检查所有边是否在两个顶点类之间，并在之后将类型向量分配给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的将表示第二种类型的顶点。
edges边作为元组列表。
directed是否创建有向图。二分网络通常是无向的，因此默认值为 False
*args未记录
**kwds未记录
返回
具有名为"type"的二进制顶点属性的图，该属性存储顶点类别。
@classmethod
def DataFrame(cls, edges, directed: bool = True, vertices=None, use_vids: bool = True): (source)

从一个或两个数据框生成图表。

参数
edges包含边和元数据的pandas DataFrame。此DataFrame的前两列包含每条边的源顶点和目标顶点。这些顶点ID表示为非负整数，而不是顶点名称，除非use_vids为False。其他列可能包含边属性。
directed:bool图是否为有向图
vertices无（默认）或包含顶点元数据的pandas DataFrame。DataFrame的索引必须包含顶点ID，作为从0到len(vertices) - 1的整数序列。如果use_vids为False，则第一列必须包含唯一的顶点名称。顶点名称应为字符串以确保完全兼容性，但如果您使用任何可哈希对象设置名称，许多函数仍将正常工作。所有其他列将按列名添加为顶点属性。
use_vids:bool是否将edges参数的前两列解释为顶点ID（基于0的整数）而不是顶点名称。如果此参数设置为True且edges的前两列不是整数，则会抛出错误。
返回

图表

在edges或vertices参数中设置为NaN（非数字）的顶点名称将被设置为字符串"NA"。这可能会导致意外行为：在调用此函数之前，请用值填充您的NaN以避免这种情况。

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

从字典的字典表示中构建一个图。

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

示例：

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

创建一个包含三个顶点（Alice、Bob 和 David）和两条边的图：

  • Alice - Bob (with weight 1.5)
  • Alice - David (with weight 2)
参数
edges指定边及其属性的字典的字典
directed:bool是否创建有向图
vertex_name_attr:str将存储名称的顶点属性
返回
一个图形对象
@classmethod
def DictList(cls, vertices, edges, directed: bool = False, vertex_name_attr: str = 'name', edge_foreign_keys=('source', 'target'), iterative: bool = False): (source)

从字典列表表示中构建图。

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

参数
vertices顶点的字典列表，如果没有为顶点分配特殊属性并且我们应该简单地使用边的字典列表来推断顶点名称，则为 None。
edges边的字典列表。每个字典必须至少包含由edge_foreign_keys指定的两个键来标记源顶点和目标顶点，而其他项将被视为边属性。
directed:bool构建的图是否是有向的
vertex_name_attr:str顶点数据源中包含顶点名称的字典中的区分键的名称。如果vertices为None，则忽略。
edge_foreign_keys指定每个边字典中包含源（第一个）和目标（第二个）顶点名称的属性的元组。每个字典的这些项也会作为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): (source)

将图形从graph-tool转换

参数
ggraph-tool 图
@classmethod
def from_networkx(cls, g, vertex_attr_hashable: str = '_nx_name'): (source)

将图形从networkx转换

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

参数
gnetworkx 图或有向图
vertex_attr_hashable:str用于存储Python可哈希对象的属性，networkx使用它来识别每个顶点。默认值'_nx_name'确保与networkx之间的无损往返转换。另一个选择是'name'：在这种情况下，建议使用字符串作为顶点名称，并且如果图重新导出到networkx，必须使用Graph.to_networkx(vertex_attr_hashable="name")来恢复导出网络中的正确顶点命名。
@classmethod
def Full_Bipartite(cls, n1, n2, directed=False, mode='all', *args, **kwds): (source)

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

>>> g = Graph.Full_Bipartite(2, 3)
>>> g.is_bipartite()
True
>>> g.vs["type"]
[False, False, True, True, True]
参数
n1第一种顶点的数量。
n2第二种类型的顶点数量。
directed是否生成有向图。
mode如果 "out"，则第一种类型的所有顶点都连接到其他顶点；"in" 指定相反的方向，"all" 创建相互的边。对于无向图忽略此参数。
*args未记录
**kwds未记录
返回
具有名为"type"的二进制顶点属性的图，该属性存储顶点类别。
@classmethod
def GRG(cls, n, radius, torus=False): (source)

生成一个随机几何图。

该算法将顶点随机放置在二维单位正方形上，并在它们之间的距离小于给定半径时连接它们。顶点的坐标存储在顶点属性x和y中。

参数
n图中的顶点数量
radius给定的半径
torus如果我们想使用环面而不是正方形，这应该是 True。
@classmethod
def Incidence(cls, *args, **kwds): (source)

已弃用的别名，指向 Graph.Biadjacency()。

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

从列表字典表示中构建图。

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

  • two integers: the vertices with those ids will be connected
  • two strings: the vertices with those names will be connected

如果使用名称，顶点的顺序不能保证，并且每个顶点将被赋予vertex_name_attr属性。

参数
edges描述边的序列字典
directed:bool是否创建有向图
vertex_name_attr:str将存储名称的顶点属性
返回

一个Graph对象

示例：

>>> mydict = {'apple': ['pear', 'peach'], 'pear': ['peach']}
>>> g = Graph.ListDict(mydict)

# 该图有三个顶点和三条边，每条边连接一对顶点。

@classmethod
def Random_Bipartite(cls, n1, n2, p=None, m=None, directed=False, neimode='all', *args, **kwds): (source)

生成一个具有给定顶点数和边数（如果给出了m）的随机二分图，或者具有给定顶点数和给定连接概率（如果给出了p）的随机二分图。

如果给出了m但没有给出p，生成的图将有n1个类型1的顶点，n2个类型2的顶点，并且它们之间有m条随机选择的边。如果给出了p但没有给出m，生成的图将有n1个类型1的顶点和n2个类型2的顶点，并且每条边将以概率p存在于它们之间。

参数
n1类型1的顶点数量。
n2类型2的顶点数量。
p边的概率。如果给定，m 必须缺失。
m边的数量。如果给定，p 必须缺失。
directed是否生成有向图。
neimode如果图是有向的，指定如何生成边。如果是"all"，边将在两个方向上独立生成（从类型1到类型2，反之亦然）。如果是"out"，边将始终从类型1指向类型2。如果是"in"，边将始终从类型2指向类型1。对于无向图，此参数将被忽略。
*args未记录
**kwds未记录
@classmethod
def Read(cls, f, format=None, *args, **kwds): (source)

图的统一读取功能。

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

其余的参数将原封不动地传递给读取器方法。

参数
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_Adjacency(cls, f, sep=None, comment_char='#', attribute=None, *args, **kwds): (source)

根据给定文件中的邻接矩阵构建图。

此处未提及的其他位置参数和关键字参数将原封不动地传递给 Graph.Adjacency。

参数
f要读取的文件名或文件对象
sep用于分隔矩阵行中元素的字符串。None 表示任意的空白字符序列。
comment_char以该字符串开头的行被视为注释。
attribute一个边属性名称，用于在加权邻接矩阵的情况下存储边的权重。如果为None，则不存储权重，大于1的值被视为边的多重性。
*args未记录
**kwds未记录
返回
创建的图表
@classmethod
def Read_DIMACS(cls, f, directed=False): (source)
overrides igraph.GraphBase.Read_DIMACS

从符合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生成的图是否应该是有向的。
返回
生成的图。源顶点和目标顶点的索引作为图属性 source 和 target 附加，边的容量存储在 capacity 边属性中。
@classmethod
def Read_GraphMLz(cls, f, index=0): (source)

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

参数
f文件的名称
index如果GraphML文件包含多个图形，指定应加载的图形。图形索引从零开始，因此如果要加载第一个图形，请在此处指定0。
返回
加载的图形对象
@classmethod
def Read_Pickle(cls, fname=None): (source)

从Python的pickled格式读取图形

参数
fname文件的名称、要读取的流或包含pickled数据的字符串。
返回
创建的图形对象。
@classmethod
def Read_Picklez(cls, fname): (source)

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

参数
fname文件名或要读取的流。
返回
创建的图形对象。
@classmethod
def TupleList(cls, edges, directed: bool = False, vertex_name_attr: str = 'name', edge_attrs=None, weights=False): (source)

从元组列表表示中构建图。

这种表示法假设图的边被编码在一个元组（或列表）的列表中。列表中的每个项目必须至少有两个元素，这两个元素指定了边的源顶点和目标顶点。其余的元素（如果有的话）指定了该边的边属性，其中边属性的名称来源于edge_attrs列表。顶点的名称将存储在由vertex_name_attr给出的顶点属性中。

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

参数
edges边的数据源。这必须是一个列表，其中每个项目是一个包含至少两个项目的元组（或列表）：源顶点和目标顶点的名称。请注意，名称将被分配给name顶点属性（或如果指定了vertex_name_attr，则为另一个顶点属性），即使列表中的所有顶点名称实际上都是数字。
directed:bool构建的图是否是有向的
vertex_name_attr:str将包含顶点名称的顶点属性的名称。
edge_attrs边列表中额外项填充的边属性名称（从索引2开始，因为前两项是源顶点和目标顶点）。如果为None或空序列，则仅提取源顶点和目标顶点，并忽略额外的元组项。如果是字符串，则解释为单个边属性。
weights指定图是加权的另一种方式。如果你将weights设置为true并且没有给出edge_attrs，则会假定edge_attrs为["weight"]，并且igraph会将每个项目的第三个元素解析为边的权重。如果你将weights设置为一个字符串，则会假定edge_attrs仅包含该字符串，并且igraph会将边的权重存储在该属性中。
返回
构建的图表
@classmethod
def Weighted_Adjacency(cls, matrix, mode='directed', attr='weight', loops='once'): (source)

从其加权邻接矩阵生成图形。

仅创建具有非零权重的边。

参数
matrix

邻接矩阵。可能的类型有：

  • 列表的列表
  • numpy 2D 数组或矩阵（将被转换为列表的列表）
  • scipy.sparse 矩阵（将被转换为 COO 矩阵，但不会转换为密集矩阵）
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" - 使用矩阵的左下三角形（包括对角线）创建无向图

这些值也可以作为字符串给出，不带 ADJ 前缀。

attr存储边权重的边属性的名称。
loops指定如何处理循环边。当False或"ignore"时，邻接矩阵的对角线将被忽略。当True或"once"时，对角线被认为包含相应循环边的权重。当"twice"时，对角线被认为包含相应循环边权重的两倍。
def __add__(graph, other): (source)

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

参数
graph未记录
other如果它是一个整数，副本将扩展给定的顶点数。如果它是一个字符串，副本将扩展一个顶点，其name属性将等于给定的字符串。如果它是一个包含两个元素的元组，副本将扩展一条边。如果它是一个元组列表，副本将扩展多条边。如果它是一个Graph，则执行不相交的联合。
def __and__(graph, other): (source)

图交集操作符。

参数
graph未记录
other与之相交的另一个图。
返回
相交的图形。
def __bool__(self): (source)

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

def __coerce__(self, other): (source)

强制转换规则。

此方法允许图形对列表、元组、整数、字符串、顶点、边等的添加做出反应。

def __iadd__(graph, other): (source)

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

另请参阅
__add__
def __init__(self, *args, **kwds): (source)

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

从零开始构建一个图。

参数
*args未记录
n顶点的数量。可以省略，默认值为零。请注意，如果边列表包含索引大于或等于n的顶点，则顶点数量将相应调整。
edges边列表，其中每个列表项都是一对整数。如果任何整数大于n − 1，则顶点数会相应调整。None 表示没有边。
directed图是否应该是有向的
graph_attrs图的属性，以字典形式表示。
vertex_attrs顶点的属性作为字典。字典的键必须是属性的名称；值必须是具有恰好 n 个项目的可迭代对象，其中 n 是顶点的数量。
edge_attrs边的属性作为字典。字典的键必须是属性的名称；值必须是具有恰好 m 个项目的可迭代对象，其中 m 是边的数量。
def __isub__(graph, other): (source)

原地减法（差值）。

另请参阅
__sub__
def __mul__(graph, other): (source)

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

参数
graph未记录
other如果它是一个整数，则通过创建给定数量的相同副本并取它们的并集来乘以图形。
def __or__(graph, other): (source)

图联合操作符。

参数
graph未记录
other与之进行并集操作的其他图。
返回
联合图。
def __plot__(self, backend, context, *args, **kwds): (source)

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

顶点和边的视觉样式可以在以下三个地方按照优先顺序进行修改（较低的索引会覆盖较高的索引）：

  1. Keyword arguments of this function (or of plot() which is passed intact to Graph.__plot__().
  2. Vertex or edge attributes, specified later in the list of keyword arguments.
  3. igraph-wide plotting defaults (see igraph.config.Configuration)
  4. Built-in defaults.

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

除了通常的自解释绘图参数（context, bbox, palette），它还接受以下关键字参数：

  • autocurve: 是否在图形绘图中使用曲线而不是直线来表示多条边。此参数可以是True或False；当省略时，对于边数少于10,000的图形，默认为True，否则为False。

  • drawer_factory: AbstractCairoGraphDrawer 的一个子类，用于绘制图形。你也可以在这里提供一个函数，该函数接受两个参数：用于绘制的Cairo上下文和一个边界框（BoundingBox 的实例）。如果缺少此关键字参数，igraph 将使用默认的图形绘制器，该绘制器应适用于大多数用途。除非你需要使用特定的图形绘制器，否则可以安全地省略此关键字参数。

  • keep_aspect_ratio: 是否保持igraph计算出的节点布局的宽高比。True 表示布局将按比例缩放以适应绘制图形的边界框，但宽高比将保持不变（可能会在图形旁边、下方或上方留下空白空间）。False 表示布局将沿X和Y轴独立缩放以填充整个边界框。默认值为 False。

  • layout: 要使用的布局。如果不是Layout的实例，它将被传递给layout来计算布局。请注意，如果你想要一个不随每次绘图变化的确定性布局，你必须使用一个确定性布局函数（如GraphBase.layout_circle）或提前计算布局并在此处传递一个Layout对象。

  • margin: 上、右、下、左边距作为一个4元组。如果元素少于4个或者是单个浮点数，元素将被重复使用，直到长度至少为4。

  • mark_groups: 是否通过彩色多边形突出显示某些顶点组。此参数可以是以下之一：

    • False: no groups will be highlighted
    • True: only valid if the object plotted is a VertexClustering or VertexCover. The vertex groups in the clutering or cover will be highlighted such that the i-th group will be colored by the i-th color from the current palette. If used when plotting a graph, it will throw an error.
    • A dict mapping tuples of vertex indices to color names. The given vertex groups will be highlighted by the given colors.
    • A list containing pairs or an iterable yielding pairs, where the first element of each pair is a list of vertex indices and the second element is a color.
    • A VertexClustering or VertexCover instance. The vertex groups in the clustering or cover will be highlighted such that the i-th group will be colored by the i-th color from the current palette.

    代替顶点索引列表，你也可以使用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_color: 边的颜色。对应的边属性是 color，默认是红色。有关颜色规范语法，请参见 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): (source)

支持序列化。

def __str__(self): (source)

返回图的字符串表示。

在幕后，此方法构建了一个GraphSummary实例，并以详细程度为1且关闭属性打印的方式调用其__str__方法。

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

def __sub__(graph, other): (source)

从图中移除给定的对象

参数
graph未记录
other如果它是一个整数，从图中移除具有给定ID的顶点（注意剩余的顶点将会被重新索引！）。如果它是一个元组，移除给定的边。如果它是一个图，取两个图的差集。也接受整数列表或元组列表，但它们不能混合！还接受Edge和EdgeSeq对象。
def add_edge(graph, source, target, **kwds): (source)

向图中添加一条边。

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

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

参数
graph未记录
source边的源顶点或其名称。
target边的目标顶点或其名称。
**kwds未记录
返回
新添加的边作为一个Edge对象。如果你不需要Edge对象并希望避免创建它的开销，请使用add_edges([(source, target)])。
def add_edges(graph, es, attributes=None): (source)
overrides igraph.GraphBase.add_edges

向图中添加一些边。

参数
graph未记录
es要添加的边的列表。每条边用一个包含两个端点的顶点ID或名称的元组表示。顶点从零开始编号。
attributes序列的字典，每个序列的长度等于要添加的边的数量，包含新边的属性。
def add_vertex(graph, name=None, **kwds): (source)

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

返回
新添加的顶点作为一个Vertex对象。如果你不需要Vertex对象并希望避免创建的开销，请使用add_vertices(1)。
def add_vertices(graph, n, attributes=None): (source)
overrides igraph.GraphBase.add_vertices

向图中添加一些顶点。

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

参数
graph未记录
n要添加的顶点数量，或要添加的单个顶点的名称，或一系列字符串，每个字符串对应要添加的顶点的名称。名称将被分配给name顶点属性。
attributes序列的字典，每个序列的长度等于要添加的顶点数，包含新顶点的属性。如果n是字符串（即添加单个顶点），则此字典的值是属性本身，但如果n=1，则它们必须是长度为1的列表。
def all_st_cuts(graph, source, target): (source)
overrides igraph.GraphBase.all_st_cuts

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

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

参考文献: JS Provan 和 DR Shier: 图中列出(s,t)-割的范例. 算法学 15, 351-372, 1996.

参数
graph未记录
source源顶点ID
target目标顶点ID
返回
一个Cut对象的列表。
def all_st_mincuts(graph, source, target, capacity=None): (source)
overrides igraph.GraphBase.all_st_mincuts

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

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

参考文献: JS Provan 和 DR Shier: 图中列出(s,t)-割的范例. 算法学 15, 351-372, 1996.

参数
graph未记录
source源顶点ID
target目标顶点ID
capacity边的容量（权重）。如果 None，所有边的权重相等。也可以是属性名称。
返回
一个Cut对象的列表。
def are_connected(self, *args, **kwds): (source)

已弃用的别名，指向 Graph.are_adjacent()。

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

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

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

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

def biconnected_components(graph, return_articulation_points=False): (source)
overrides igraph.GraphBase.biconnected_components

计算图的双连通组件。

参数
graph未记录
return_articulation_points是否也返回关节点
返回
一个 VertexCover 对象，描述双连通组件，并可选择性地描述关节点列表
def bipartite_projection(graph, types='type', multiplicity=True, probe1=-1, which='both'): (source)
overrides 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
参数
graph未记录
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的索引是从0开始的）。False等同于0，True等同于1。任何其他值意味着两个投影将以元组形式返回。
返回
一个包含两个投影的一模图的元组，如果which不是1或2，或者由which参数指定的投影的一模图，如果其值为0、1、False或True。
def bipartite_projection_size(graph, types='type', *args, **kwds): (source)
overrides igraph.GraphBase.bipartite_projection_size

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

参数
graph未记录
types一个包含顶点类型的igraph向量，或一个属性名称。任何评估为False的内容对应于第一种顶点，其他所有内容对应于第二种顶点。
*args未记录
**kwds未记录
返回
一个包含第一个投影中的顶点和边数的4元组，后面跟着第二个投影中的顶点和边数。
def blocks(graph, return_articulation_points=False): (source)

计算图的双连通组件。

参数
graph未记录
return_articulation_points是否也返回关节点
返回
一个 VertexCover 对象，描述双连通组件，并可选择性地描述关节点列表
def clear(graph): (source)

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

另请参阅
GraphBase.delete_vertices 和 Graph.delete_edges。
def clusters(graph, mode='strong'): (source)

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

def cohesive_blocks(graph): (source)
overrides igraph.GraphBase.cohesive_blocks

计算图的凝聚块结构。

凝聚块是一种基于图顶点的结构凝聚力（即顶点连通性）来确定图顶点层次子集的方法。对于给定的图G，如果不存在顶点连通性大于或等于k的S的超集，则称其顶点子集S是最大k凝聚的。凝聚块是一个过程，通过该过程，给定一个k凝聚的顶点集，递归地识别出l > k的最大l凝聚子集。因此，最终获得了一个顶点子集的层次结构，整个图G位于其根部。

返回
CohesiveBlocks 的一个实例。有关更多信息，请参阅 CohesiveBlocks 的文档。
另请参阅
CohesiveBlocks
def community_edge_betweenness(graph, clusters=None, directed=True, weights=None): (source)
overrides igraph.GraphBase.community_edge_betweenness

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

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

参数
graph未记录
clusters我们想要看到的聚类数量。这实际上定义了我们在“切割”树状图以获取顶点成员向量时的“级别”。如果None，则在图未加权时，树状图在最大化模块性的级别处被切割；否则，树状图在单个聚类处被切割（因为如果并非所有权重都相等，基于模块性的聚类数量选择对于此方法没有意义）。
directed是否应考虑边的方向性。
weights边的属性名称或包含边权重的列表。
返回
一个 VertexDendrogram 对象，最初在最大模块度或所需聚类数处切割。
def community_fastgreedy(graph, weights=None): (source)
overrides igraph.GraphBase.community_fastgreedy

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

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

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

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

参数
graph未记录
weights边属性名称或包含边权重的列表
返回
一个适当的 VertexDendrogram 对象。
def community_infomap(graph, edge_weights=None, vertex_weights=None, trials=10): (source)
overrides igraph.GraphBase.community_infomap

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

参考文献

参数
graph未记录
edge_weights边属性的名称或包含边权重的列表。
vertex_weights顶点属性的名称或包含顶点权重的列表。
trials尝试划分网络的次数。
返回
一个适当的 VertexClustering 对象，带有一个额外的属性 codelength，该属性存储由算法确定的代码长度。
def community_label_propagation(graph, weights=None, initial=None, fixed=None): (source)
overrides igraph.GraphBase.community_label_propagation

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

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

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

还要注意，社区的_labels_（数字）没有语义意义，igraph可以自由地重新编号社区。如果您使用固定标签，igraph可能仍然会重新编号社区，但会尊重共同社区成员资格约束：如果您有两个具有固定标签的顶点属于同一个社区，它们最终仍将在同一个社区中。同样，如果您有两个具有固定标签的顶点属于不同的社区，它们最终仍将在不同的社区中。

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

参数
graph未记录
weights边属性的名称或包含边权重的列表
initial顶点属性的名称或包含初始顶点标签的列表。标签由从零到n − 1的整数标识，其中n是顶点的数量。此向量中也可能存在负数，它们表示未标记的顶点。
fixed每个顶点的布尔值列表。True 对应于在算法期间不应更改标签的顶点。只有在初始标签也给定的情况下才有意义。未标记的顶点不能被固定。它也可以是顶点属性的名称；每个属性值将被解释为布尔值。
返回
一个适当的 VertexClustering 对象。
def community_leading_eigenvector(graph, clusters=None, weights=None, arpack_options=None): (source)
overrides igraph.GraphBase.community_leading_eigenvector

Newman的领先特征向量方法用于检测社区结构。

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

参考: MEJ Newman: 使用矩阵的特征向量在网络中寻找社区结构, arXiv:physics/0605087

参数
graph未记录
clusters期望的社区数量。如果为None，算法会尽可能多地进行分割。请注意，如果前导特征向量的符号都相同，算法将不会进一步分割社区，因此实际发现的社区数量可能少于期望的数量。
weights边的属性名称或包含边权重的列表。
arpack_options一个用于微调ARPACK特征向量计算的ARPACKOptions对象。如果省略，则使用名为arpack_options的模块级变量。
返回
一个适当的 VertexClustering 对象。
def community_leiden(graph, objective_function='CPM', weights=None, resolution=1.0, beta=0.01, initial_membership=None, n_iterations=2, node_weights=None, **kwds): (source)
overrides igraph.GraphBase.community_leiden

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

参考文献: Traag, V. A., Waltman, L., & van Eck, N. J. (2019). 从Louvain到Leiden：保证良好连接的社区。 科学报告, 9(1), 5233. doi: 10.1038/s41598-019-41695-z

参数
graph未记录
objective_function是否使用常数Potts模型（CPM）或模块度。必须是"CPM"或"modularity"。
weights要使用的边权重。可以是序列、可迭代对象，甚至是边属性名称。
resolution使用的分辨率参数。较高的分辨率会导致更多的小社区，而较低的分辨率会导致较少的大社区。
beta影响Leiden算法中随机性的参数。这仅影响算法的细化步骤。
initial_membership如果提供了此参数，Leiden算法将尝试改进此提供的成员资格。如果没有提供参数，算法将简单地从单例分区开始。
n_iterationsLeiden算法的迭代次数。每次迭代可能会进一步改善分区。使用负数的迭代次数将运行直到遇到稳定的迭代（即在该迭代期间质量没有提高）。
node_weightsLeiden算法中使用的节点权重。如果未提供此参数，将根据您是否希望使用CPM或模块性自动确定。如果您确实提供了此参数，请确保您理解自己在做什么。
**kwds未记录
返回
一个适当的VertexClustering对象，带有一个名为quality的额外属性，该属性存储了算法优化的内部质量函数的值。
def community_multilevel(graph, weights=None, return_levels=False, resolution=1): (source)
overrides igraph.GraphBase.community_multilevel

基于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。
返回
一个VertexClustering对象的列表，每个对象对应一个级别（如果return_levels为True），或者是一个对应最佳模块度的VertexClustering。
def community_optimal_modularity(graph, *args, **kwds): (source)
overrides igraph.GraphBase.community_optimal_modularity

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

此函数使用GNU线性编程工具包来解决大型整数优化问题，以找到最佳模块化分数和相应的社区结构，因此对于超过几百个顶点的图可能无法工作。如果你有如此大的图，请考虑使用启发式方法之一。

返回
计算出的成员向量和相应的模块化在一个元组中。
def community_spinglass(graph, *args, **kwds): (source)
overrides igraph.GraphBase.community_spinglass

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

参考文献

参数
graph未记录
*args未记录
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 对象。
def community_walktrap(graph, weights=None, steps=4): (source)
overrides igraph.GraphBase.community_walktrap

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

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

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

参数
graph未记录
weights边属性的名称或包含边权重的列表
steps执行随机游走的长度
返回
一个 VertexDendrogram 对象，最初在最大模块性处切割。
def components(graph, mode='strong'): (source)

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

参数
graph未记录
mode必须是 "strong" 或 "weak"，取决于所寻找的连接组件。可选，默认为 "strong"。
返回
一个 VertexClustering 对象
def connected_components(graph, mode='strong'): (source)
overrides igraph.GraphBase.connected_components

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

参数
graph未记录
mode必须是 "strong" 或 "weak"，取决于所寻找的连接组件。可选，默认为 "strong"。
返回
一个 VertexClustering 对象
def count_automorphisms_vf2(graph, color=None, edge_color=None, node_compat_fn=None, edge_compat_fn=None): (source)

返回图的自同构数量。

此函数简单地使用itgraph调用count_isomorphisms_vf2。有关参数的说明，请参见count_isomorphisms_vf2。

返回
图的自动态数量
另请参阅
Graph.count_isomorphisms_vf2
def degree_distribution(graph, bin_width=1, *args, **kwds): (source)

计算图的度分布。

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

参数
graph未记录
bin_width直方图的箱宽
*args未记录
**kwds未记录
返回
表示图度分布的直方图。
def delete_edges(graph, *args, **kwds): (source)
overrides igraph.GraphBase.delete_edges

从图中删除一些边。

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

弃用通知：自 igraph 0.8.3 起，delete_edges(None) 已被替换为 delete_edges() - 不带参数。

  • None - deletes all edges (deprecated since 0.8.3)
  • a single integer - deletes the edge with the given ID
  • a list of integers - deletes the edges denoted by the given IDs
  • a list of 2-tuples - deletes the edges denoted by the given source-target vertex pairs. When multiple edges are present between a given source-target vertex pair, only one is removed.
def dfs(self, vid, mode=OUT): (source)

在图上进行深度优先搜索（DFS）。

参数
vid根顶点ID
mode可以是 "in" 或 "out" 或 "all"，对于无向图忽略。
返回

一个包含以下项目的元组：

  • 访问的顶点ID（按顺序）
  • DFS中每个顶点的父节点
def disjoint_union(graph, other): (source)

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

参数
graph未记录
other要与当前图合并的图或图列表。
返回
不相交的并集图
def dyad_census(self, *args, **kwds): (source)
overrides igraph.GraphBase.dyad_census

计算图的二元组普查。

二元组普查意味着将有向图的每对顶点分类为三种类型：互惠的（存在从a到b的边，也存在从b到a的边）、不对称的（存在从a到b的边或从b到a的边，但不是双向的）和无连接的（a和b之间没有连接）。

参考文献: Holland, P.W. 和 Leinhardt, S. 一种检测社会计量数据中结构的方法。 美国社会学杂志, 70, 492-513, 1970.

返回
一个 DyadCensus 对象。
def get_adjacency(self, type=GET_ADJACENCY_BOTH, attribute=None, default=0, eids=False): (source)
overrides igraph.GraphBase.get_adjacency

返回图的邻接矩阵。

参数
type可以是 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): (source)

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

参数
attribute如果 None，返回普通的邻接矩阵。当给定一个有效的边属性名称时，返回的矩阵将在没有边的地方包含默认值，在有边的地方包含给定属性的值。
返回
邻接矩阵作为 scipy.sparse.csr_matrix。
def get_adjlist(self, mode='out'): (source)

返回图的邻接表表示。

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

参数
mode如果 "out"，返回顶点的后继。如果 "in"，返回顶点的前驱。如果 "all"，将返回前驱和后继。对于无向图忽略此参数。
def get_all_simple_paths(self, v, to=None, cutoff=-1, mode='out'): (source)

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

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

请注意，图中两个顶点之间可能存在指数级数量的路径，尤其是在图形类似格子的情况下。在这种情况下，使用此函数时可能会耗尽内存。

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

返回图的所有自同构

此函数简单地使用itgraph调用get_isomorphisms_vf2。有关参数的说明，请参见get_isomorphisms_vf2。

返回
一个列表的列表，每个项目包含图顶点根据自同构到其图的可能映射
另请参阅
Graph.get_isomorphisms_vf2
def get_biadjacency(graph, types='type', *args, **kwds): (source)
overrides igraph.GraphBase.get_biadjacency

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

参数
graph未记录
types一个包含顶点类型的向量，或一个属性名称。任何评估为False的内容对应于第一种顶点，其他所有内容对应于第二种顶点。
*args未记录
**kwds未记录
返回
二分邻接矩阵和三元组中的两个列表。第一个列表定义了矩阵的行索引与原始顶点ID之间的映射。第二个列表对列索引也是如此。
def get_edge_dataframe(graph): (source)

将带有属性的边导出到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选项来保留source和target列。

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

>>> 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(self, *args, **kwds): (source)

已弃用的别名，指向 Graph.get_biadjacency()。

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

返回图的邻接表表示。

邻接表表示法是一个列表的列表。外部列表的每个项属于图的单个顶点。内部列表包含给定顶点的关联边的ID。

参数
graph未记录
mode如果 "out"，返回顶点的后继。如果 "in"，返回顶点的前驱。如果 "all"，将返回前驱和后继。对于无向图忽略此参数。
def get_vertex_dataframe(graph): (source)

将带有属性的顶点导出到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'): (source)
overrides igraph.GraphBase.gomory_hu_tree

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

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

参数
graph未记录
capacity边的容量（权重）。如果 None，所有边的权重相等。也可以是属性名称。
flow返回的图中存储流值的边属性的名称。
返回
Gomory-Hu 树作为一个 Graph 对象。
def indegree(graph, *args, **kwds): (source)

返回列表中的入度。

请参阅 GraphBase.degree 以获取可能的参数。

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

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

参数
graph未记录
other要与当前图形相交的图形或图形列表。
byname是否使用顶点名称而不是ID。详情请参见igraph.operators.intersection。
返回
交集图
def is_named(self): (source)

返回图是否被命名。

一个图被命名当且仅当它有一个"name"顶点属性。

def is_weighted(self): (source)

返回图是否加权。

一个图是加权的，当且仅当它具有一个"weight"边属性。

def k_core(graph, *args): (source)

返回图的一些k-核心。

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

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

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

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

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

参数
graph未记录
layout要使用的布局。这可以是已注册的布局名称之一，也可以是一个可调用对象，该对象返回一个Layout对象或包含坐标的列表的列表。如果None，则使用plotting.layout配置键的值。
*args未记录
**kwds未记录
返回
一个 Layout 对象。
def layout_auto(graph, *args, **kwds): (source)

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

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

  1. If the graph has an attribute called layout, it will be used. It may either be a Layout instance, a list of coordinate pairs, the name of a layout function, or a callable function which generates the layout when called with the graph as a parameter.
  2. Otherwise, if the graph has vertex attributes called x and y, these will be used as coordinates in the layout. When a 3D layout is requested (by setting dim to 3), a vertex attribute named z will also be needed.
  3. Otherwise, if the graph is connected and has at most 100 vertices, the Kamada-Kawai layout will be used (see GraphBase.layout_kamada_kawai()).
  4. Otherwise, if the graph has at most 1000 vertices, the Fruchterman-Reingold layout will be used (see GraphBase.layout_fruchterman_reingold()).
  5. If everything else above failed, the DrL layout algorithm will be used (see GraphBase.layout_drl()).

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

参数
graph未记录
*args未记录
dim指定我们是否希望获得2D或3D布局。
返回
一个 Layout 对象。
def layout_sugiyama(graph, layers=None, weights=None, hgap=1, vgap=1, maxiter=100, return_extended_graph=False): (source)

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

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

每个顶点被分配到一个层，并且每一层被放置在一个水平线上。然后使用重心启发式算法对同一层内的顶点进行排列，以尽量减少边的交叉。

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

参考文献:

  • 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.
参数
graph未记录
layers一个向量，指定每个顶点的非负整数层索引，或包含层索引的数值顶点属性的名称。如果为None，将自动确定分层。对于无向图，将提取一个生成树，并使用从度数最大的节点开始的广度优先搜索将顶点分配到层。对于有向图，通过使用Eades、Lin和Smyth的启发式方法反转近似反馈弧集中的边来打破循环，然后使用最长路径分层将顶点放置在层中。
weights要使用的边权重。可以是序列、可迭代对象，甚至是边属性名称。
hgap同一层顶点之间的最小水平间距。
vgap层之间的垂直间隙。层索引将乘以vgap以获得Y坐标。
maxiter在交叉减少步骤中执行的最大迭代次数。如果您觉得得到的边交叉过多，请增加此值。
return_extended_graph指定是否还应返回添加了虚拟顶点的扩展图。当此参数为True时，结果将是一个包含布局和扩展图的元组。扩展图的前|V|个节点将对应于原始图的节点，其余的是虚拟节点。使用返回的布局和隐藏的虚拟节点绘制扩展图将产生一个与原始图相似的布局，但增加了边弯曲。扩展图还包含一个名为_original_eid的边属性，该属性指定了扩展图中边的原始图中边的ID。
返回
计算出的布局，可能（通常也会）比顶点的数量有更多的行；剩余的行对应于分层步骤中引入的虚拟节点。当return_extended_graph为True时，它还将包含扩展图。
def maxflow(graph, source, target, capacity=None): (source)
overrides igraph.GraphBase.maxflow

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

从源到目标的最大流是对图的边分配非负实数，满足两个属性：

  1. For each edge, the flow (i.e. the assigned number) is not more than the capacity of the edge (see the capacity argument)
  2. For every vertex except the source and the target, the incoming flow is the same as the outgoing flow.

流量的值是目标的流入流量或源的流出流量（它们是相等的）。最大流量是可能的最大值。

参数
graph未记录
source未记录
target未记录
capacity边的容量（权重）。如果 None，所有边的权重相等。也可以是属性名称。
返回
一个 Flow 对象，描述最大流
def maximum_bipartite_matching(graph, types='type', weights=None, eps=None): (source)

在二分图中找到一个最大匹配。

最大匹配是一组边，使得每个顶点最多与一条匹配边相连，并且该组中的边数（或权重）尽可能大。

参数
graph未记录
types顶点类型的列表或包含顶点类型的顶点属性的名称。类型应由零和一（或False和True）表示，用于二分图的两侧。如果省略，则默认为type，这是二分图的默认顶点类型属性。
weights要使用的边权重。可以是序列、可迭代对象，甚至是边属性名称。
eps用于加权二分图匹配算法中相等性测试的一个小实数。如果两个实数的差值小于此值，则在算法中认为它们相等。这是为了避免数值误差的累积。如果在此处传递None，igraph将尝试自动确定一个合适的值。
返回
Matching 的一个实例。
def mincut(graph, source=None, target=None, capacity=None): (source)
overrides igraph.GraphBase.mincut

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

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

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

参数
graph未记录
source源顶点ID。如果为None，则目标也必须为None，并且计算将针对整个图进行（即所有可能的顶点对）。
target目标顶点ID。如果为None，则源也必须为None，并且计算将针对整个图进行（即所有可能的顶点对）。
capacity边的容量（权重）。如果 None，所有边的权重相等。也可以是属性名称。
返回
一个 Cut 对象，描述最小割
def modularity(self, membership, weights=None, resolution=1, directed=True): (source)
overrides igraph.GraphBase.modularity

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

图的模块化程度相对于某种划分，衡量了该划分的好坏，或者不同顶点类型之间的分离程度。它被定义为 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 是图中所有边的总权重。

参考文献: MEJ Newman 和 M Girvan: 在网络中寻找和评估社区结构。 物理评论 E 69 026113, 2004.

参数
membership一个成员列表或一个VertexClustering对象
weights可选的边权重，如果所有边的权重相等则为None。也允许使用属性名称。
resolution上述公式中的分辨率参数 gamma。当分辨率参数设置为1时，将恢复模块化的经典定义。
directed如果图是有向的，是否考虑边的方向。True 将使用模块度测量的有向变体，其中节点的入度和出度分别处理；False 将将有向图视为无向图。
返回
模块化得分
def outdegree(graph, *args, **kwds): (source)

返回列表中的出度。

请参阅 GraphBase.degree 以获取可能的参数。

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

计算图的PageRank值。

参数
graph未记录
vertices被查询的顶点的索引。None 表示所有顶点。
directed是否考虑有向路径。
damping阻尼因子。1 − damping 是在每一步中将随机游走重置为均匀分布的概率。
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): (source)
overrides igraph.GraphBase.path_length_hist

返回图的路径长度直方图

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

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

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

计算图的最小生成树。

参考文献: Prim, R.C. 最短连接网络及其一些推广。 贝尔系统技术杂志 36:1389-1401, 1957.

参数
weights一个包含图中每条边权重的向量。None 表示该图是无权重的。
return_tree是否返回最小生成树（当return_tree为True时）或返回最小生成树中的边的ID（当return_tree为False时）。默认值为True，这是出于历史原因，因为此参数是在igraph 0.6中引入的。
返回
如果 return_tree 为 True，则生成树作为 Graph 对象返回；如果 return_tree 为 False，则返回构成生成树的边的 ID。
def st_mincut(graph, source, target, capacity=None): (source)
overrides igraph.GraphBase.st_mincut

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

参数
graph未记录
source源顶点ID
target目标顶点ID
capacity边的容量。它必须是一个列表或有效的属性名称或None。在后一种情况下，每条边将具有相同的容量。
返回
最小割的值，第一个和第二个分区中的顶点ID，以及割中的边ID，打包在一个4元组中
def summary(self, verbosity=0, width=None, *args, **kwds): (source)

返回图的摘要。

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

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

参数
verbosity如果为零，则只返回标题行（有关更多详细信息，请参见__str__），否则将打印标题行和完整的边列表。
width每行使用的字符数。如果为None，则不会对行长度进行限制。
*args未记录
**kwds未记录
返回
图表的摘要。
def to_dict_dict(graph, use_vids: bool = True, edge_attrs: Union[str, Sequence[str]] = None, skip_none: bool = False, vertex_name_attr: str = 'name'): (source)

将图导出为边属性字典的字典

此函数是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'}}}
参数
graph未记录
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仅在use_vids=False时使用，用于选择在输出数据结构中使用哪个顶点属性来命名顶点。
返回
字典的字典的字典，外层键为顶点ID/名称，中间键为其邻居的ID/名称，最内层的字典表示该边的属性。
def to_dict_list(graph, use_vids: bool = True, skip_none: bool = False, vertex_name_attr: str = 'name'): (source)

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

此函数是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"}])
参数
graph未记录
use_vids:bool是否在输出数据结构中使用顶点的ID或它们的vertex_name_attr属性来标记顶点。如果use_vids=False但顶点缺少vertex_name_attr属性，则会引发AttributeError。
skip_none:bool是否跳过每条边中值为None的属性。如果只有部分边预计拥有某个属性，这将非常有用。
vertex_name_attr:str仅在use_vids=False时使用，用于选择在输出数据结构中使用哪个顶点属性来命名顶点。
返回
一个包含两个字典列表的元组，分别表示顶点和边及其属性。
def to_graph_tool(graph, graph_attributes=None, vertex_attributes=None, edge_attributes=None): (source)

将图转换为graph-tool

数据类型：graph-tool 只接受特定的数据类型。请查看以下网页以获取列表：

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

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

参数
graph未记录
graph_attributes要传输的图形属性的字典。键是图形中的属性，值是数据类型（见下文）。None 表示不传输任何图形属性。
vertex_attributes要传输的顶点属性的字典。键是顶点的属性，值是数据类型（见下文）。None 表示不传输任何顶点属性。
edge_attributes要传输的边属性字典。键是边的属性，值是数据类型（见下文）。None 表示不传输任何顶点属性。
def to_list_dict(graph, use_vids: bool = True, sequence_constructor: callable = list, vertex_name_attr: str = 'name'): (source)

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

此函数是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']}
参数
graph未记录
use_vids:bool是否在输出数据结构中使用顶点的ID或它们的vertex_name_attr属性来标记顶点。如果use_vids=False但顶点缺少vertex_name_attr属性，则会引发AttributeError。
sequence_constructor:callable用于作为字典值的数据结构的构造函数。默认值（list）会创建一个列表字典，每个列表表示相应字典键中指定的顶点的邻居。
vertex_name_attr:str仅在use_vids=False时使用，用于选择在输出数据结构中使用哪个顶点属性来命名顶点。
返回
序列的字典，由顶点键控，每个值包含该顶点的邻居。
def to_networkx(graph, create_using=None, vertex_attr_hashable: str = '_nx_name'): (source)

将图转换为networkx格式。

igraph 有有序的顶点和边，但 networkx 没有。为了跟踪原始顺序，'_igraph_index' 顶点属性被添加到顶点和边中。

参数
graph未记录
create_using指定在构建图时使用哪个NetworkX图类。None 表示让igraph根据图是否有向以及是否有多重边来推断最合适的类。
vertex_attr_hashable:str用于命名导出网络中顶点的顶点属性。默认值 "_nx_name" 确保与 networkx 之间的往返转换是无损的。
def to_tuple_list(graph, use_vids: bool = True, edge_attrs: Union[str, Sequence[str]] = None, vertex_name_attr: str = 'name'): (source)

将图导出为边元组列表

此函数是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")]
参数
graph未记录
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仅在use_vids=False时使用，用于选择在输出数据结构中使用哪个顶点属性来命名顶点。
返回
一个元组列表，每个元组代表图的一条边。
def transitivity_avglocal_undirected(self, mode='nan', weights=None): (source)
overrides igraph.GraphBase.transitivity_avglocal_undirected

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

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

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

参考文献

  • 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.
参数
mode定义如何处理度数小于2的顶点。如果为TRANSITIVITY_ZERO或"zero"，这些顶点的传递性将为零。如果为TRANSITIVITY_NAN或"nan"，这些顶点将被排除在平均值之外。
weights要使用的边权重。可以是序列、可迭代对象，甚至是边属性名称。
另请参阅
transitivity_undirected(), transitivity_local_undirected()
def triad_census(self, *args, **kwds): (source)
overrides igraph.GraphBase.triad_census

计算图的三元组普查。

参考文献: Davis, J.A. 和 Leinhardt, S. 小群体中积极人际关系的结构。载于：J. Berger (编), 《进展中的社会学理论》, 第2卷, 218-251. 波士顿: Houghton Mifflin (1972).

返回
一个 TriadCensus 对象。
def union(graph, other, byname='auto'): (source)

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

参数
graph未记录
other要与当前图合并的图或图列表。
byname是否使用顶点名称而不是ID。详情请参见igraph.operators.union。
返回
联合图
def write(graph, f, format=None, *args, **kwds): (source)

图的统一写入功能。

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

其余的参数将原封不动地传递给写入方法。

参数
graph未记录
f包含要保存的图形的文件
format

文件的格式（如果想要覆盖从文件扩展名确定的格式，或者文件名本身是一个流）。None 表示自动检测。可能的值为：

  • "adjacency": 邻接矩阵格式
  • "dimacs": DIMACS 格式
  • "dot", "graphviz": GraphViz DOT 格式
  • "edgelist", "edges" 或 "edge": 数字边列表格式
  • "gml": GML 格式
  • "graphml" 和 "graphmlz": 标准和压缩的 GraphML 格式
  • "gw", "leda", "lgr": LEDA 原生格式
  • "lgl": LGL 格式
  • "ncol": NCOL 格式
  • "net", "pajek": Pajek 格式
  • "pickle", "picklez": 标准和压缩的 Python pickle 格式
  • "svg": SVG 格式
*args未记录
**kwds未记录
引发
IOError如果无法识别文件格式且未提供格式。
def write_adjacency(graph, f, sep=' ', eol='\n', *args, **kwds): (source)

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

所有未在此提及的剩余参数都原封不动地传递给 Graph.get_adjacency。

参数
graph未记录
f要写入的文件名。
sep分隔矩阵行中元素的字符串
eol用于分隔矩阵行的字符串。请注意，igraph只有在这是一个单独的换行符时才能读取回写入的邻接矩阵
*args未记录
**kwds未记录
def write_dimacs(graph, f, source=None, target=None, capacity='capacity'): (source)
overrides igraph.GraphBase.write_dimacs

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

参数
graph未记录
f要写入的文件名或Python文件句柄。
source源顶点ID。如果None，igraph将尝试从source图属性中推断它。
target目标顶点ID。如果为None，igraph将尝试从target图属性中推断它。
capacity边的容量列表或保存容量的边属性的名称。如果没有这样的边属性，每条边的容量将为1。
def write_graphmlz(graph, f, compresslevel=9): (source)

将图写入一个压缩的GraphML文件。

该库使用gzip压缩算法，因此生成的文件可以使用常规的gzip解压缩工具（如Unix命令行中的gunzip或zcat）或Python的gzip模块进行解压。

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

参数
graph未记录
f要写入的文件名。
compresslevel压缩级别。1 是最快的，压缩效果最差，9 是最慢的，压缩效果最好。
def write_pickle(graph, fname=None, version=-1): (source)

将图保存为Python的pickle格式

参数
graph未记录
fname文件名或要保存到的流。如果为None，则将图形保存到字符串并返回该字符串。
version使用的pickle协议版本。如果为-1，则使用可用的最高协议版本
返回
None 如果图形成功保存到给定文件，或者如果 fname 是 None，则返回一个字符串。
def write_picklez(graph, fname=None, version=-1): (source)

将图保存为Python的pickle格式，并使用gzip进行压缩。

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

参数
graph未记录
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): (source)

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

该文件将与Inkscape（http://inkscape.org）兼容。在Inkscape中，当节点重新排列时，边会自动更新。

参数
graph未记录
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__ = (source)

未记录

__iter__ = (source)

未记录

Formula = (source)

未记录

@property
es = (source)

图的边序列

@property
vs = (source)

图的顶点序列

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

从Python的pickled格式重建一个Graph对象。

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

@property
_as_parameter_ = (source)

未记录