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]

类方法	`邻接矩阵`	从其邻接矩阵生成一个图。
类方法	`二分图`	使用给定的顶点类型和边创建二分图。这类似于图的默认构造函数，唯一的区别是它检查所有边是否在两个顶点类之间，并将类型向量分配给 ...
类方法	`数据帧`	从一个或两个数据帧生成一个图。
类方法	`字典列表`	从列表字典表示形式构造一个图。
类方法	`来自_graph_tool`	从 graph-tool 转换图
类方法	`来自_networkx`	从 networkx 转换图
类方法	`完整_二分图`	生成完整的二分图（有向或无向，带或不带环）。
类方法	`GRG`	生成一个随机几何图。
类方法	`关联`	从关联矩阵创建一个二分图。
类方法	`随机_二分图`	生成具有给定数量的顶点和边（如果给定 m）或具有给定数量的顶点和给定连接概率（如果给定 p）的随机二分图。
类方法	`读取`	用于图的统一读取函数。
类方法	`读取_邻接`	根据给定文件中的邻接矩阵构造图。
类方法	`读取_DIMACS`	从符合 DIMACS 最小成本流文件格式的文件中读取图。
类方法	`读取_GraphMLz`	从压缩的 GraphML 文件中读取图。
类方法	`读取_Pickle`	从 Python pickle 格式读取图
类方法	`读取_Picklez`	从压缩的 Python pickle 格式读取图，并即时解压缩。
类方法	`元组列表`	从元组列表表示形式构造一个图。
类方法	`加权_邻接`	从其加权邻接矩阵生成图。
方法	`__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 上下文
方法	`__reduce__`	支持 pickle 操作。
方法	`__str__`	返回图的字符串表示形式。
方法	`__sub__`	从图中删除给定的对象
方法	`添加_边`	向图中添加单条边。
方法	`添加_边`	向图中添加一些边。
方法	`添加_顶点`	向图中添加单个顶点。关键字参数将分配为顶点属性。请注意`名称`作为关键字参数被特殊处理；如果一个图有`名称`作为顶点属性，它允许人们在 igraph 期望顶点 ID 的大多数地方按名称引用顶点。
方法	`添加_顶点`	向图中添加一些顶点。
方法	`所有_st_割`	返回有向图中源顶点和目标顶点之间的所有割。
方法	`所有_st_最小割`	返回有向图中源顶点和目标顶点之间的所有最小割。
方法	`作为_有向图`	返回此图的有向副本。参数传递给 `GraphBase.to_directed()`，该函数在副本上调用。
方法	`作为_无向图`	返回此图的无向副本。参数传递给 `GraphBase.to_undirected()`，该函数在副本上调用。
方法	`双连通_组件`	计算图的双连通分量。
方法	`二分图_投影`	将二分图投影到两个单模图中。投影时忽略边的方向。
方法	`二分图_投影_大小`	根据指定的顶点类型计算此图的二分图投影中的顶点数和边数。如果您有一个二分图，并且想要估计计算投影本身所需的内存量，这将非常有用。
方法	`清除`	清除图，删除所有顶点、边和属性。
方法	`聚类`	计算给定图的（强或弱）聚类（连接组件）。
方法	`凝聚_块`	计算图的凝聚块结构。
方法	`社区_边_介数`	基于网络中边的介数的社区结构。
方法	`社区_快速贪婪`	基于模块化贪婪优化的社区结构。
方法	`社区_信息图`	根据 Martin Rosvall 和 Carl T. Bergstrom 的 Infomap 方法查找网络的社区结构。
方法	`社区_标签_传播`	根据 Raghavan 等人的标签传播方法查找图的社区结构。
方法	`社区_主导_特征向量`	纽曼的领先特征向量法，用于检测社区结构。
方法	`社区_主导_特征向量_朴素`	纽曼特征向量社区结构检测的朴素实现。
方法	`社区_莱顿`	使用 Traag、van Eck 和 Waltman 的 Leiden 算法查找图的社区结构。
方法	`社区_多层`	基于 Blondel 等人的多层算法的社区结构。
方法	`社区_最佳_模块化`	计算图的最佳模块化分数和相应的社区结构。
方法	`社区_旋转玻璃`	根据 Reichardt & Bornholdt 的自旋玻璃社区检测方法查找图的社区结构。
方法	`社区_随机漫步陷阱`	Latapy & Pons 的社区检测算法，基于随机游走。
方法	`计数_自同构_vf2`	返回图的自同构数。
方法	`度数_分布`	计算图的度分布。
方法	`删除_边`	从图中删除一些边。
方法	`深度优先搜索`	对图执行深度优先搜索 (DFS)。
方法	`不相交_并集`	创建两个（或多个）图的不相交并集。
方法	`二元_人口普查`	计算图的二元人口普查。
方法	`获取_邻接矩阵`	返回图的邻接矩阵。
方法	`获取_邻接矩阵_稀疏`	将图的邻接矩阵作为 SciPy CSR 矩阵返回。
方法	`获取_邻接列表`	返回图的邻接列表表示形式。
方法	`获取_所有_简单_路径`	计算图中从给定节点到其他一些节点（或所有节点）的所有简单路径。
方法	`获取_自同构_vf2`	返回图的所有自同构
方法	`获取_边_数据帧`	将带有属性的边导出到 pandas.DataFrame
方法	`获取_关联矩阵`	返回二分图的关联矩阵。关联矩阵是 n 乘以 m 矩阵，其中 n 和 m 是两个顶点类中的顶点数。
方法	`获取_关联列表`	返回图的关联列表表示形式。
方法	`获取_顶点_数据帧`	将带有属性的顶点导出到 pandas.DataFrame
方法	`戈莫里_胡_树`	计算具有可选边容量的无向图的 Gomory-Hu 树。
方法	`入度`	在列表中返回入度。
方法	`交集`	创建两个（或多个）图的交集。
方法	`是否_已命名`	返回图是否已命名。
方法	`是否_已加权`	返回图是否已加权。
方法	`k_核`	返回图的一些 k 核。
方法	`布局`	根据布局算法返回图的布局。
方法	`布局_自动`	根据图的简单拓扑属性选择并运行合适的布局函数。
方法	`布局_杉山`	使用分层 Sugiyama 布局放置顶点。
方法	`最大流`	返回图中给定源顶点和目标顶点之间的最大流。
方法	`最大_二分图_匹配`	在二分图中查找最大匹配。
方法	`最小割`	计算给定源顶点和目标顶点之间或整个图中的最小割。
方法	`模块化`	计算图相对于给定聚类的模块化分数。
方法	`出度`	在列表中返回出度。
方法	`页面排名`	计算图的 PageRank 值。
方法	`路径_长度_直方图`	返回图的路径长度直方图
方法	`生成树`	计算图的最小生成树。
方法	`st_最小割`	计算图中源顶点和目标顶点之间的最小割。
方法	`摘要`	返回图的摘要。
方法	`到_graph_tool`	将图转换为 graph-tool
方法	`到_networkx`	将图转换为 networkx 格式。
方法	`传递性_平均局部_无向`	计算图的顶点传递性的平均值。
方法	`三合会_人口普查`	计算图的三元人口普查。
方法	`并集`	创建两个（或多个）图的并集。
方法	`写入`	用于图的统一写入函数。
方法	`写入_邻接矩阵`	将图的邻接矩阵写入给定的文件
方法	`写入_dimacs`	以 DIMACS 格式将图写入给定的文件。
方法	`写入_graphmlz`	将图写入压缩的 GraphML 文件。
方法	`写入_pickle`	以 Python pickle 格式保存图
方法	`写入_picklez`	以 Python pickle 格式保存图，并使用 gzip 压缩。
方法	`写入_svg`	将图另存为 SVG（可缩放矢量图形）文件
类变量	`__hash__`	未归档
类变量	`__iter__`	未归档
类变量	`公式`	未归档
属性	`es`	图的边序列
属性	`vs`	图的顶点序列
类方法	`_识别_格式`	_identify_format(filename)
类方法	`_重建`	从 Python 的 pickle 格式重建 Graph 对象。
类变量	`_格式_映射`	未归档
类变量	`_布局_映射`	未归档
属性	`_作为_参数_`	未归档

继承自 GraphBase

方法	`__new__`	创建并返回一个新对象。有关准确的签名，请参见 help(type)。
方法	`所有_最小_st_分隔符`	返回一个列表，其中包含图的所有最小 s-t 分离器。
方法	`是否_已连接`	确定两个给定的顶点是否直接连接。
方法	`割点`	返回图中铰接点的列表。
方法	`匹配性`	基于顶点的数值属性返回图的 assortativity。
方法	`匹配性_度`	基于顶点度数返回图的 assortativity。
方法	`匹配性_名义`	基于顶点类别返回图的 assortativity。
方法	`不对称_偏好`	基于非对称顶点类型和连接概率生成图。
方法	`图谱`	从图谱生成图。
方法	`属性`	无摘要
方法	`权威_分数`	计算图中顶点的 Kleinberg 权威分数
方法	`平均_路径_长度`	计算图中的平均路径长度。
方法	`Barabasi`	基于 Barabasi-Albert 模型生成图。
方法	`介数`	计算或估计图中顶点的介数。
方法	`广度优先搜索`	对图进行广度优先搜索 (BFS)。
方法	`广度优先搜索迭代器`	构造图的广度优先搜索 (BFS) 迭代器。
方法	`文献耦合`	计算图中给定顶点的书目耦合分数。
方法	`桥`	返回图中桥的列表。
方法	`规范_排列`	使用 BLISS 同构算法计算图的规范置换。
方法	`弦图_补全`	chordal_complation(alpha=None, alpham1=None) --
方法	`团_数`	返回图的团数。
方法	`团`	返回图的一些或所有团，作为元组列表。
方法	`接近度`	计算图中给定顶点的接近度中心性。
方法	`共引`	计算图中给定顶点的共被引分数。
方法	`补图`	返回图的补图
方法	`组合`	返回两个图的组合。
方法	`约束`	计算图中给定顶点的 Burt 的约束分数。
方法	`收缩_顶点`	收缩图中的一些顶点，即将顶点组替换为单个顶点。边不受影响。
方法	`收敛_度`	未记录（尚未）。
方法	`收敛_场_大小`	未记录（尚未）。
方法	`复制`	创建图的副本。
方法	`核数`	查找网络顶点的 coreness（壳索引）。
方法	`计数_同构_vf2`	确定图与另一个图之间的同构数
方法	`计数_多重`	计算给定边的重数。
方法	`计数_子同构_vf2`	确定图与另一个图之间的子同构数
方法	`De_Bruijn`	生成具有参数 (m, n) 的 de Bruijn 图
方法	`分解`	将图分解为子图。
方法	`度`	从图中返回一些顶点度数。
方法	`度_序列`	生成具有给定度数序列的图。
方法	`删除_顶点`	从图中删除顶点及其所有边。
方法	`密度`	计算图的密度。
方法	`深度优先搜索迭代器`	构造图的深度优先搜索 (DFS) 迭代器。
方法	`直径`	计算图的直径。
方法	`差集`	从原始图中减去给定的图
方法	`多样性`	计算顶点的结构多样性指数。
方法	`支配者`	从给定根节点返回支配树
方法	`离心率`	计算图中给定顶点的离心率。
方法	`边数`	计算边的数量。
方法	`边_属性`	无摘要
方法	`边_介数`	计算或估计图中边的介数。
方法	`边_连通性`	计算图或某些顶点之间的边连通性。
方法	`特征_邻接矩阵`	未归档
方法	`特征向量_中心性`	计算图中顶点的特征向量中心性。
方法	`Erdos_Renyi`	基于 Erdos-Renyi 模型生成图。
方法	`建立`	基于具有顶点类型的简单增长模型生成图。
方法	`著名`	基于其名称生成一个著名的图。
方法	`最远_点`	返回两个顶点 ID，它们的距离等于图的实际直径。
方法	`反馈_弧_集`	计算近似或精确的最小反馈弧集。
方法	`森林_火灾`	基于森林火灾模型生成图
方法	`完整`	生成一个完整的图（有向或无向，带有或不带有环）。
方法	`完整_引文`	生成一个完整的引用图
方法	`获取_所有_最短_路径`	计算从/到图中给定节点的所有最短路径。
方法	`获取_直径`	返回具有图的实际直径的路径。
方法	`获取_边列表`	返回图的边列表。
方法	`获取_边 ID`	返回顶点 v1 和 v2 之间任意边的边 ID
方法	`获取_边 ID`	返回某些顶点之间某些边的边 ID。
方法	`获取_同构_vf2`	返回图与另一个图之间的所有同构
方法	`获取_最短_路径`	计算从/到图中给定节点的最短路径。
方法	`获取_子同构_lad`	使用 LAD 算法返回图与另一个图之间的所有子同构。
方法	`获取_子同构_vf2`	返回图与另一个图之间的所有子同构
方法	`周长`	返回图的 girth。
方法	`增长_随机`	生成一个增长随机图。
方法	`调和_中心性`	计算图中给定顶点的谐波中心性。
方法	`具有_多重`	检查图是否有多条边。
方法	`枢纽_分数`	计算图中顶点的 Kleinberg hub 分数
方法	`关联`	返回给定顶点所在的边。
方法	`独立性_数`	返回图的独立数。
方法	`独立_顶点_集`	返回图的一些或所有独立顶点集，作为元组列表。
方法	`导出_子图`	返回由给定顶点生成的子图。
方法	`是否_二分图`	确定图是否为二分图。
方法	`是否_弦图`	返回图是否为弦图。
方法	`是否_已连接`	确定图是否已连接。
方法	`是否_有向无环图`	检查图是否为 DAG（有向无环图）。
方法	`是否_有向`	检查图是否为有向图。
方法	`是否_环`	检查一组特定的边是否包含环边
方法	`是否_最小_分隔符`	确定给定的顶点集是否为最小分隔符。
方法	`是否_多重`	检查边是否为多条边。
方法	`是否_互惠`	检查边是否具有相反的边对。
方法	`是否_分隔符`	确定删除给定的顶点是否会断开图的连接。
方法	`是否_简单`	检查图是否为简单图（没有环或多条边）。
方法	`是否_树`	检查图是否为（有向或无向）树图。
方法	`Isoclass`	生成具有给定同构类的图。
方法	`同类`	返回图或其子图的同构类。
方法	`同构`	检查图是否与另一个图同构。
方法	`同构_bliss`	使用 BLISS 同构算法检查图是否与另一个图同构。
方法	`同构_vf2`	使用 VF2 同构算法检查图是否与另一个图同构。
方法	`K_正则`	生成一个 k-正则随机图
方法	`Kautz`	生成具有参数 (m, n) 的 Kautz 图
方法	`knn`	计算每个顶点的邻居的平均度数，以及作为顶点度数函数的相同数量。
方法	`拉普拉斯算子`	返回图的拉普拉斯矩阵。
方法	`最大_团`	返回图的最大团，作为元组列表。
方法	`最大_独立_顶点_集`	返回图的最大独立顶点集，作为元组列表。
方法	`晶格`	生成一个规则晶格。
方法	`布局_二分图`	将二分图的顶点放置在两层中。
方法	`布局_圆`	将图的顶点均匀地放置在圆或球面上。
方法	`布局_戴维森_哈雷尔`	根据 Davidson-Harel 布局算法将顶点放置在 2D 平面上。
方法	`布局_drl`	根据 DrL 布局算法将顶点放置在 2D 平面或 3D 空间中。
方法	`布局_弗鲁特曼_赖因戈尔德`	根据 Fruchterman-Reingold 算法将顶点放置在 2D 平面上。
方法	`布局_图形优化`	这是 Michael Schmuhl 的 graphopt 布局算法的端口。 graphopt 版本 0.4.1 已用 C 重写，并且删除了对层的支持。
方法	`布局_网格`	将图的顶点放置在 2D 或 3D 网格中。
方法	`布局_卡马达_卡瓦伊`	根据 Kamada-Kawai 算法将顶点放置在平面上。
方法	`布局_lgl`	根据 Large Graph Layout 将顶点放置在 2D 平面上。
方法	`布局_mds`	使用多维缩放将顶点放置在具有给定维数的欧几里得空间中。
方法	`布局_随机`	随机放置图的顶点。
方法	`布局_赖因戈尔德_蒂尔福德`	根据 Reingold-Tilford 布局算法将顶点放置在 2D 平面上。
方法	`布局_赖因戈尔德_蒂尔福德_圆形`	树的圆形 Reingold-Tilford 布局。
方法	`布局_星形`	计算图的星形布局。
方法	`LCF`	从 LCF 表示法生成图。
方法	`线图`	返回图的线图。
方法	`最大度`	返回图中顶点集的最大度数。
方法	`最大流_值`	返回源顶点和目标顶点之间的最大流的值。
方法	`最大_团`	返回图的最大团，作为元组列表。
方法	`最大_独立_顶点_集`	返回图的最大独立顶点集，作为元组列表。
方法	`最大_基数_搜索`	对图执行最大基数搜索。该函数计算每个顶点的等级 alpha，以便按降序访问顶点的顺序对应于始终选择具有最多已访问邻居的顶点作为下一个要访问的顶点。
方法	`最小割_值`	返回源顶点和目标顶点之间或整个图中的最小割。
方法	`最小_大小_分隔符`	返回一个列表，其中包含所有最小尺寸的分隔符顶点集。
方法	`主题_randesu`	计算图中 motif 的数量
方法	`主题_randesu_估计`	计算图中 motif 的总数
方法	`主题_randesu_无`	计算图中 motif 的总数
方法	`邻域`	对于 vertices 指定的每个顶点，返回最多 order 步可以从该顶点到达的顶点。如果 mindist 大于零，则排除少于 mindist 步可到达的顶点。
方法	`邻域_大小`	对于 vertices 指定的每个顶点，返回最多 order 步可以从该顶点到达的顶点数。如果 mindist 大于零，则少于 mindist 可到达的顶点...
方法	`邻居`	返回给定顶点的相邻顶点。
方法	`排列_顶点`	根据给定的置换置换图的顶点并返回新图。
方法	`个性化_页面排名`	计算图的个性化 PageRank 值。
方法	`前任`	返回给定顶点的前身。
方法	`偏好`	基于顶点类型和连接概率生成图。
方法	`半径`	计算图的半径。
方法	`随机_漫步`	从给定节点执行给定长度的随机游走。
方法	`读取_DL`	读取 UCINET DL 文件并基于它创建一个图。
方法	`读取_边列表`	从文件中读取边列表并基于它创建一个图。
方法	`读取_GML`	读取 GML 文件并基于它创建一个图。
方法	`读取_GraphDB`	读取 GraphDB 格式文件并基于它创建一个图。
方法	`读取_GraphML`	读取 GraphML 格式文件并基于它创建一个图。
方法	`读取_Lgl`	读取 LGL 使用的 .lgl 文件。
方法	`读取_Ncol`	读取 LGL 使用的 .ncol 文件。
方法	`读取_Pajek`	读取 Pajek 格式文件并基于该文件创建图。
方法	`实现_度_序列`	从度数序列生成图。
方法	`最近_度`	基于随机模型生成图，其中边获得新节点的概率与给定时间窗口中获得的边成正比。
方法	`互易性`	互易性定义了有向图中相互连接的比例。它最常定义为有向边的相反对应物也包含在图中的概率...
方法	`重新连接`	随机重新连接图，同时保留度数分布。
方法	`重新连接_边`	以恒定概率重新连接图的边。
方法	`环`	生成一个环图。
方法	`SBM`	基于随机块模型生成图。
方法	`最短_路径`	计算图中给定顶点的最短路径长度。
方法	`相似性_骰子`	顶点的 Dice 相似性系数。
方法	`相似性_逆_日志_加权`	顶点的反向对数加权相似性系数。
方法	`相似性_杰卡德`	顶点的 Jaccard 相似性系数。
方法	`简化`	通过删除自环和/或多条边来简化图。
方法	`星`	生成一个星形图。
方法	`静态_适应度`	生成一个非增长图，其边概率与节点适应度成正比。
方法	`静态_幂_律`	生成具有规定的幂律度数分布的非增长图。
方法	`强度`	从图中返回某些顶点的强度（加权度数）
方法	`子组件`	确定与给定顶点位于同一组件中的顶点的索引。
方法	`子图_边`	返回由给定边生成的子图。
方法	`子同构_lad`	检查图的子图是否与另一个图同构。
方法	`子同构_vf2`	检查图的子图是否与另一个图同构。
方法	`后继`	返回给定顶点的后继者。
方法	`到_有向图`	将无向图转换为有向图。
方法	`到_prufer`	将树图转换为 Prufer 序列。
方法	`到_无向图`	将有向图转换为无向图。
方法	`拓扑_排序`	计算图的可能的拓扑排序。
方法	`传递性_局部_无向`	计算图中给定顶点的局部传递性（聚类系数）。
方法	`传递性_无向`	计算图的全局传递性（聚类系数）。
方法	`树`	生成一棵树，其中几乎所有顶点都具有相同数量的子节点。
方法	`树_游戏`	通过从具有给定数量节点的标记树集中均匀采样来生成一棵随机树。
方法	`展开_树`	通过使用广度优先搜索将图展开为树，从而根据需要复制顶点。
方法	`顶点数`	计算顶点数。
方法	`顶点_属性`	无摘要
方法	`顶点_连通性`	计算图的顶点连通性或某些顶点之间的连通性。
方法	`Watts_Strogatz`	无摘要
方法	`写入_dot`	以 DOT 格式将图写入给定文件。
方法	`写入_边列表`	将图的边列表写入文件。
方法	`写入_gml`	以 GML 格式将图写入给定文件。
方法	`写入_graphml`	将图写入 GraphML 文件。
方法	`写入_leda`	以 LEDA 原生格式将图写入文件。
方法	`写入_lgl`	以 .lgl 格式将图的边列表写入文件。
方法	`写入_ncol`	以 .ncol 格式将图的边列表写入文件。
方法	`写入_pajek`	以 Pajek 格式将图写入给定文件。
方法	`__graph_作为_胶囊`	__graph_as_capsule()
方法	`__注册_析构函数`	注册一个析构函数，以便在 Python 释放对象时调用。igraph 用户不应直接使用此函数。
方法	`_二分图`	内部函数，未记录。
方法	`_完整_二分图`	内部函数，未记录。
方法	`_获取_所有_简单_路径`	内部函数，未记录。
方法	`_GRG`	内部函数，未记录。
方法	`_关联`	内部函数，未记录。
方法	`_是否_匹配`	内部函数，未记录。
方法	`_是否_最大_匹配`	内部函数，未记录。
方法	`_布局_杉山`	内部函数，未记录。
方法	`_最大_二分图_匹配`	内部函数，未记录。
方法	`_随机_二分图`	内部函数，未记录。
方法	`_原始_指针`	将 Python 对象封装的 igraph 图的内存地址作为普通的 Python 整数返回。
方法	`_生成树`	内部函数，未记录。

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

覆盖 igraph._igraph.GraphBase.Adjacency

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

参数
矩阵	邻接矩阵。可能的类型是列表的列表 numpy 2D 数组或矩阵（将转换为列表的列表） scipy.sparse 矩阵（将转换为 COO 矩阵，而不是稠密矩阵）
模式	要使用的模式。可能的值是 `"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): ¶

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

示例

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

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

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

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

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

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

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

此表示假定顶点和边编码在两个列表中，每个列表分别包含每个顶点和每条边的 Python 字典。顶点字典的一个独特元素包含一个顶点 ID，该 ID 在边字典中用于引用源顶点和目标顶点。字典的所有剩余元素都被视为顶点和边属性。请注意，该实现不假定传递给此方法的对象确实是字典列表，但它们应该是可迭代的，并且它们应该产生行为类似于字典的对象。因此，例如，数据库查询结果很可能适合，只要它是可迭代的，并且每次迭代都产生类似字典的对象。

参数
顶点	顶点的数据源或`None`如果没有分配给顶点的特殊属性，我们应该简单地使用字典的边列表来推断顶点名称。
边	边的数据源。
有向	构造的图是否为有向图
顶点_名称_属性	顶点数据源中字典中包含顶点名称的独特键的名称。如果`顶点`是`None`.
边_外键	边数据源中字典中包含源顶点和目标顶点名称的属性的名称。
迭代	是否逐个迭代地将边添加到图中，或者首先构建一个大的边列表，然后使用它来构造图。后一种方法更快，但如果您的数据集很大，则可能不合适。默认是从边列表批量添加边。
返回值
构造的图

@classmethod
def from_graph_tool(cls, g): ¶

从 graph-tool 转换图

参数
g	graph-tool Graph

@classmethod
def from_networkx(cls, g): ¶

从 networkx 转换图

顶点名称将转换为“_nx_name”属性，并且顶点将获得从 0 开始的新 ID（作为 igraph 中的标准）。

参数
g	networkx Graph 或 DiGraph

@classmethod
def Full_Bipartite(cls, n1, n2, directed=False, mode='all', *args, **kwds): ¶

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

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

参数
n1	第一种顶点的数量。
n2	第二种顶点的数量。
有向	是否生成有向图。
模式	如果`"out"`，则第一种的所有顶点都连接到其他顶点；`"in"`指定相反方向，`"all"`创建互边。对于无向图，忽略此参数。
*args	未归档
**kwds	未归档
返回值
带有名为`"type"`的二进制顶点属性的图，该属性存储顶点类。

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

生成一个随机几何图。

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

参数
n	图中的顶点数
半径	给定半径
圆环	这应该是`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"`创建互边。对于无向图，忽略此参数。
多重	定义如何处理矩阵中的非零条目。如果`False`，则无论值是什么，非零条目都将创建一条边。如果`True`，则非零条目将四舍五入到最接近的整数，这将是创建的多个边的数量。
加权	定义是否从关联矩阵创建加权图。如果是 c{None}，则创建一个未加权图，并且使用 multiple 参数来确定图的边。如果它是一个字符串，则对于每个非零矩阵条目，都会创建一条边，并且该条目的值将作为名为 weighted 参数的边属性添加。如果是`True`，则创建一个加权图，并且边属性的名称将为“weight”。
*args	未归档
**kwds	未归档
返回值
带有名为`"type"`的二进制顶点属性的图，该属性存储顶点类。
引发
`ValueError`	如果 weighted 和 multiple 一起传递。

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

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

如果给定 m 但未给定 p，则生成的图将具有类型 1 的 n1 个顶点、类型 2 的 n2 个顶点以及它们之间随机选择的 m 条边。如果给定 p 但未给定 m，则生成的图将具有类型 1 的 n1 个顶点和类型 2 的 n2 个顶点，并且它们之间的每条边都将以概率 p 存在。

参数
n1	类型 1 的顶点数。
n2	类型 2 的顶点数。
p	边的概率。如果给定，则`m`必须缺失。
m	边数。如果给定，则`p`必须缺失。
有向	是否生成有向图。
neimode	如果图是有向图，则指定边的生成方式。如果是`"all"`，则边将以两个方向（从类型 1 到类型 2，反之亦然）独立生成。如果是`"out"`，则边将始终从类型 1 指向类型 2。如果是`"in"`，则边将始终从类型 2 指向类型 1。对于无向图，忽略此参数。
*args	未归档
**kwds	未归档

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

用于图的统一读取函数。

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

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

参数
f	包含要加载的图的文件
格式	文件的格式（如果事先已知）。`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): ¶

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

此处未提及的其他位置和关键字参数将完整地传递给 Adjacency。

参数
f	要读取的文件的名称或文件对象
sep	分隔一行中矩阵元素的字符串。`None`表示任意空格字符序列。
注释_字符	以此字符串开头的行被视为注释。
属性	边属性名称，其中边权重存储在加权邻接矩阵的情况下。如果`None`，则不存储权重，大于 1 的值被视为边多重性。
*args	未归档
**kwds	未归档
返回值
创建的图

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

覆盖 igraph._igraph.GraphBase.Read_DIMACS

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

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

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

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

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

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

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

参数
f	文件的名称
索引	如果 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"]。如果您有更多的边属性，请将它们添加到边列表中的每个项目的末尾，并在边_属性中指定相应的边属性名称作为列表。

参数
边	边的数据源。这必须是一个列表，其中每个项目都是一个元组（或列表），其中包含至少两个项目：源顶点和目标顶点的名称。请注意，名称将被分配给`名称`顶点属性（或者另一个顶点属性，如果`顶点_名称_属性`已指定），即使列表中的所有顶点名称实际上都是数字。
有向	构造的图是否为有向图
顶点_名称_属性	顶点属性的名称，该属性将包含顶点名称。
边_属性	边属性的名称，这些属性用边列表中额外的项目填充（从索引 2 开始，因为前两个项目是源顶点和目标顶点）。`None`表示仅从每个项目中提取源顶点和目标顶点。如果您在此处传递一个字符串，则为了方便起见，它将包含在一个列表中。
权重	指定图已加权的替代方法。如果您设置`权重`到`true`和`边_属性`未给出，则将假定`边_属性`是`["weight"]`，igraph 将从每个项目中解析第三个元素到边权重中。如果您设置`权重`为字符串，则将假定`边_属性`仅包含该字符串，igraph 会将边权重存储在该属性中。
返回值
构造的图

@classmethod
def Weighted_Adjacency(cls, matrix, mode='directed', attr='weight', loops=True): ¶

覆盖 igraph._igraph.GraphBase.Weighted_Adjacency

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

参数
矩阵	邻接矩阵。可能的类型是列表的列表 numpy 2D 数组或矩阵（将转换为列表的列表） scipy.sparse 矩阵（将转换为 COO 矩阵，而不是稠密矩阵）
模式	要使用的模式。可能的值是 `"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"`- 具有矩阵左下三角形（包括对角线）的无向图这些值也可以作为字符串给出，而不使用`ADJ`前缀。
attr	存储边权重的边属性的名称。
循环	是否包括环边。当`False`时，将忽略邻接矩阵的对角线。

def __add__(self, other): ¶

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

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

def __and__(self, other): ¶

图交集运算符。

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

def __bool__(self): ¶

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

def __coerce__(self, other): ¶

强制规则。

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

def __iadd__(self, 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__(self, other): ¶

原地减法（差集）。

参见
`__sub__`

def __mul__(self, other): ¶

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

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

def __or__(self, other): ¶

图并集运算符。

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

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

在给定边界框中将图绘制到给定的 Cairo 上下文

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

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

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

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

自动曲线：是否对图绘图上的多条边使用曲线而不是直线。此参数可以是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 以计算布局。请注意，如果您想要一个不随每次绘图而更改的确定性布局，则必须使用确定性布局函数（如 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 的源代码以获取已知颜色列表）、浮点数的三元组（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_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__(self, other): ¶

从图中删除给定的对象

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

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

向图中添加单条边。

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

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

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

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

重写 igraph._igraph.GraphBase.add_edges

向图中添加一些边。

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

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

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

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

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

重写 igraph._igraph.GraphBase.add_vertices

向图中添加一些顶点。

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

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

def all_st_cuts(self, source, target): ¶

重写 igraph._igraph.GraphBase.all_st_cuts

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

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

参数
来源	源顶点 ID
目标	目标顶点 ID
返回值
`Cut` 对象的列表。
未知字段：newfield
ref	参考
未知字段：ref
JS Provan 和 DR Shier：用于列出图中 (s,t) 切割的范例。Algorithmica 15, 351--372, 1996。

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

重写 igraph._igraph.GraphBase.all_st_mincuts

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

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

参数
来源	源顶点 ID
目标	目标顶点 ID
容量	边容量（权重）。如果`None`，则所有边的权重相等。也可能是一个属性名称。
返回值
`Cut` 对象的列表。
未知字段：newfield
ref	参考
未知字段：ref
JS Provan 和 DR Shier：用于列出图中 (s,t) 切割的范例。Algorithmica 15, 351--372, 1996。

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

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

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

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

def biconnected_components(self, return_articulation_points=False): ¶

重写 igraph._igraph.GraphBase.biconnected_components

计算图的双连通分量。

参数
return_articulation_points	是否也返回铰接点
返回值
一个 `VertexCover` 对象，用于描述双连通分量，还可以选择返回铰接点列表

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

重写 igraph._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

参数
类型	一个 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(self, types='type', *args, **kwds): ¶

重写 igraph._igraph.GraphBase.bipartite_projection_size

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

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

def clear(self): ¶

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

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

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

重写 igraph._igraph.GraphBase.clusters

计算给定图的（强或弱）聚类（连接组件）。

参数
模式	必须是`"strong"`之一或`"weak"`，具体取决于正在寻找的聚类。可选，默认为`"strong"`.
返回值
`VertexClustering` 对象

def cohesive_blocks(self): ¶

重写 igraph._igraph.GraphBase.cohesive_blocks

计算图的凝聚块结构。

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

返回值
`CohesiveBlocks` 的一个实例。有关更多信息，请参阅 `CohesiveBlocks` 的文档。
参见
`CohesiveBlocks`

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

重写 igraph._igraph.GraphBase.community_edge_betweenness

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

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

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

def community_fastgreedy(self, weights=None): ¶

重写 igraph._igraph.GraphBase.community_fastgreedy

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

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

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

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

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

重写 igraph._igraph.GraphBase.community_infomap

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

参数
edge_weights	边属性的名称或包含边权重的列表。
vertex_weights	顶点属性的名称或包含顶点权重的列表。
trials	尝试划分网络的次数。
返回值
适当的 `VertexClustering` 对象，其中包含一个名为`codelength`的额外属性，该属性存储由算法确定的代码长度。
未知字段：newfield
ref	参考
未知字段：ref
M. Rosvall 和 C. T. Bergstrom：信息流图揭示复杂网络中的社区结构，PNAS 105, 1118 (2008)。http://dx.doi.org/10.1073/pnas.0706851105，http://arxiv.org/abs/0707.0609。
M. Rosvall、D. Axelsson 和 C. T. Bergstrom：映射方程，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(self, weights=None, initial=None, fixed=None): ¶

重写 igraph._igraph.GraphBase.community_label_propagation

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

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

请注意，由于打破联系是随机的，因此无法保证该算法在每次运行时都返回相同的社区结构。事实上，它们经常不同。有关如何提出聚合社区结构的信息，请参阅 Raghavan 等人的论文。

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

参数
权重	边属性的名称或包含边权重的列表
initial	顶点属性的名称或包含初始顶点标签的列表。标签由从零到 n − 1 的整数标识，其中 n 是顶点的数量。此向量中也可能存在负数，它们表示未标记的顶点。
fixed	每个顶点的布尔值列表。`True`对应于其标签在算法期间不应更改的顶点。仅当还给出了初始标签时才有意义。未标记的顶点无法修复。它也可能是顶点属性的名称；每个属性值都将被解释为一个布尔值。
返回值
适当的 `VertexClustering` 对象。
未知字段：newfield
ref	参考
未知字段：ref
Raghavan, U.N.、Albert, R. 和 Kumara, S. 检测大规模网络中的社区结构的近线性时间算法。Phys Rev E 76:036106, 2007。http://arxiv.org/abs/0709.2938。

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

重写 igraph._igraph.GraphBase.community_leading_eigenvector

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

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

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

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

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

此函数根据模块性矩阵的前导特征向量将网络拆分为两个组件，然后通过将社区拆分为单独的网络递归地执行给定的步骤数。然而，这不是正确的方法，有关解释，请参阅参考资料。考虑改用正确的 community_leading_eigenvector 方法。

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

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

重写 igraph._igraph.GraphBase.community_leiden

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

参数
objective_function	是使用恒定 Potts 模型 (CPM) 还是模块性。必须是`"CPM"`之一或`"modularity"`.
权重	要使用的边权重。可以是序列或可迭代对象，甚至可以是边属性名称。
resolution_parameter	要使用的分辨率参数。较高的分辨率会导致更多较小的社群，而较低的分辨率会导致较少较大的社群。
beta	影响 Leiden 算法中随机性的参数。这仅影响算法的细化步骤。
initial_membership	如果提供，Leiden 算法将尝试改进此提供的成员关系。如果未提供任何参数，则算法仅从单例分区开始。
n_iterations	迭代 Leiden 算法的次数。每次迭代都可能进一步改进分区。使用负数的迭代次数将运行直到遇到稳定的迭代（即，在该迭代期间质量没有提高）。
node_weights	Leiden 算法中使用的节点权重。如果未提供，将根据您是否要使用 CPM 或模块化自动确定。如果您确实提供了此参数，请确保您了解自己在做什么。
返回值
适当的 `VertexClustering` 对象。
未知字段：newfield
ref	参考
未知字段：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(self, weights=None, return_levels=False): ¶

覆盖 igraph._igraph.GraphBase.community_multilevel

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

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

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

参数
权重	边属性名称或包含边权重的列表
return_levels	如果`True`，每个级别的社群都将以列表形式返回。如果`False`，则仅返回具有最佳模块化的社群结构。
返回值
一个 `VertexClustering` 对象列表，每个对象对应于一个级别（如果`return_levels`是`True`），或一个对应于最佳模块化的 `VertexClustering`。
未知字段：newfield
ref	参考
未知字段：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(self, *args, **kwds): ¶

覆盖 igraph._igraph.GraphBase.community_optimal_modularity

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

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

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

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

覆盖 igraph._igraph.GraphBase.community_spinglass

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

参数
*args	未归档
**kwds	未归档
权重	要使用的边权重。可以是序列或可迭代对象，甚至可以是边属性名称。
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	参考
未知字段：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(self, weights=None, steps=4): ¶

覆盖 igraph._igraph.GraphBase.community_walktrap

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

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

参数
权重	边属性的名称或包含边权重的列表
steps	要执行的随机游走的长度
返回值
一个 `VertexDendrogram` 对象，最初在最大模块化处切割。
未知字段：newfield
ref	参考
未知字段：ref
Pascal Pons, Matthieu Latapy: Computing communities in large networks using random walks, http://arxiv.org/abs/physics/0512106.

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

返回图的自同构数。

此函数只是简单地调用count_isomorphisms_vf2与图本身。请参阅count_isomorphisms_vf2以获取参数的解释。

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

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

计算图的度分布。

未知的关键字参数将直接传递给 degree()。

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

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

覆盖 igraph._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
模式	或`"in"`之一或`"out"`之一或`"all"`，对于无向图将被忽略。
返回值
包含以下项目的元组访问的顶点 ID（按顺序） DFS 中每个顶点的父顶点

def disjoint_union(self, other): ¶

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

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

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

覆盖 igraph._igraph.GraphBase.dyad_census

计算图的二元人口普查。

Dyad census 表示将有向图的每对顶点分为三个类别：互惠（存在从a到b的边，也存在从b到a的边）、不对称（存在从a到b的边或从b到a的边，但不是反过来）和空（a和b之间没有连接）。

返回值
一个 `DyadCensus` 对象。
未知字段：newfield
ref	参考
未知字段：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._igraph.GraphBase.get_adjacency

返回图的邻接矩阵。

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

def get_adjacency_sparse(self, attribute=None): ¶

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

参数
属性	如果`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(self, color=None, edge_color=None, node_compat_fn=None, edge_compat_fn=None): ¶

返回图的所有自同构

此函数只是简单地调用get_isomorphisms_vf2与图本身。请参阅get_isomorphisms_vf2以获取参数的解释。

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

def get_edge_dataframe(self): ¶

将带有属性的边导出到 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 是边数。dataframe 的前两列表示每个边的源顶点和目标顶点的 ID。这些列的名称为“source”和“target”。如果您的边具有相同名称的属性，它们将存在于 dataframe 中，但不在前两列中。

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

覆盖 igraph._igraph.GraphBase.get_incidence

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

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

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

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

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

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

def get_vertex_dataframe(self): ¶

将带有属性的顶点导出到 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(self, capacity=None, flow='flow'): ¶

覆盖 igraph._igraph.GraphBase.gomory_hu_tree

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

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

参数
容量	边容量（权重）。如果`None`，则所有边的权重相等。也可能是一个属性名称。
flow	返回的图中将存储流量值的边属性的名称。
返回值
Gomory-Hu 树，作为 `Graph` 对象。

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

在列表中返回入度。

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

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

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

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

def is_named(self): ¶

返回图是否已命名。

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

时，该图才会被命名。

返回图是否已加权。

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

def k_core(self, *args): ¶

返回图的一些 k 核。

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

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

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

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

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

auto, automatic：自动布局（请参阅 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_3d）
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 布局（请参阅 layout_sugiyama）

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

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

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

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

如果图具有名为布局，将被使用。它可以是 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(self, layers=None, weights=None, hgap=1, vgap=1, maxiter=100, return_extended_graph=False): ¶

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

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

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

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

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

覆盖 igraph._igraph.GraphBase.maxflow

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

从source到target的最大流量是向图的边分配非负实数，满足两个属性

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

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

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

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

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

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

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

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

覆盖 igraph._igraph.GraphBase.mincut

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

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

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

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

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

覆盖 igraph._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）。delta(x, y) 当 x = y 时为 1，否则为 0。

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

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

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

在列表中返回出度。

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

def pagerank(self, vertices=None, directed=True, damping=0.85, weights=None, arpack_options=None, implementation='prpack', niter=1000, eps=0.001): ¶

计算图的 PageRank 值。

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

def path_length_hist(self, directed=True): ¶

覆盖 igraph._igraph.GraphBase.path_length_hist

返回图的路径长度直方图

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

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

计算图的最小生成树。

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

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

覆盖 igraph._igraph.GraphBase.st_mincut

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

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

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

返回图的摘要。

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

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

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

def to_graph_tool(self, 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`表示不传输任何图属性。
顶点_属性	要传输的顶点属性的字典。键是顶点的属性，值是数据类型（见下文）。`None`表示不传输任何顶点属性。
边_属性	要传输的边属性的字典。键是边的属性，值是数据类型（见下文）。`None`表示不传输任何顶点属性。

def to_networkx(self, create_using=None): ¶

将图转换为 networkx 格式。

参数
create_using	指定在构造图时要使用的 NetworkX 图类。`None`表示让 igraph 根据该图是否是有向图以及是否具有多重边来推断最合适的类。

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

覆盖 igraph._igraph.GraphBase.transitivity_avglocal_undirected

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

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

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

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

计算图的三元人口普查。

返回值
一个 `TriadCensus` 对象。
未知字段：newfield
ref	参考
未知字段：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(self, other, byname='auto'): ¶

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

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

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

用于图的统一写入函数。

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

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

参数
f	包含要保存的图的文件
格式	文件的格式（如果要覆盖从文件名扩展名确定的格式，或者文件名本身是一个流）。`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(self, f, sep=' ', eol='\n', *args, **kwds): ¶

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

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

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

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

覆盖 igraph._igraph.GraphBase.write_dimacs

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

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

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

将图写入压缩的 GraphML 文件。

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

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

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

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

以 Python pickle 格式保存图

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

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

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

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

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

def write_svg(self, 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 文件句柄
布局	图的布局。可以是显式指定的布局（使用坐标对列表）或布局算法的名称（应引用 `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 _identify_format(cls, filename): ¶

_identify_format(filename)

尝试识别存储在具有给定文件名的文件中的图的格式。它基于文件的扩展名（而不是基于语法评估）来识别大多数文件格式。唯一的例外是邻接矩阵格式和边列表格式：评估文件的前几行以决定两者之间的关系。

参数
filename	文件名或其`名称`属性已设置的文件对象。
返回值
文件的格式，字符串。
注意
内部函数，不应直接调用。

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

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

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

_format_mapping: dict = ¶

未归档

_layout_mapping: dict[str, str] = ¶

未归档

@property
_as_parameter_ = ¶

未归档