Python 学习教程之networkx-6ren

Python 学习教程之networkx

转载作者：qq735679552 更新时间：2022-09-28 22:32:09

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章Python 学习教程之networkx由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

networkx是python的一个包，用于构建和操作复杂的图结构，提供分析图的算法。图是由顶点、边和可选的属性构成的数据结构，顶点表示数据，边是由两个顶点唯一确定的，表示两个顶点之间的关系。顶点和边也可以拥有更多的属性，以存储更多的信息.

对于networkx创建的无向图，允许一条边的两个顶点是相同的，即允许出现自循环，但是不允许两个顶点之间存在多条边，即出现平行边。边和顶点都可以有自定义的属性，属性称作边和顶点的数据，每一个属性都是一个key:value对.

一，创建图。

在创建图之前，需要导入networkx模块，通常设置别名为nx；如果创建的图中，顶点之间的边没有方向，那么该图称作无向图。在创建图时，可以通过help(g)来获得图的帮助文档.

import networkx as nx 。

g=nx.graph()#创建空的无向图 g=nx.digraph()#创建空的有向图。

二，图的顶点。

图中的每一个顶点node都有一个关键的id属性，用于唯一标识一个节点，id属性可以整数或字符类型；顶点除了id属性之外，还可以自定义其他的属性.

1，向图中增加顶点。

在向图中增加顶点时，可以一次增加一个顶点，也可以一次性增加多个顶点，顶点的id属性是必需的。在添加顶点之后，可以通过g.nodes()函数获得图的所有顶点的视图，返回的实际上nodeview对象；如果为g.nodes(data=true)的data参数设置为true，那么返回的是nodedataview对象，该对象不仅包含每个顶点的id属性，还包括顶点的其他属性.

 
    ? 
   
         g.add_node( 
         1 
         ) 
        
         g.add_nodes_from([ 
         2 
         , 
         3 
         , 
         4 
         ]) 
        
         g.nodes() 
        
         #nodeview((1, 2,3,4))

在向图中添加顶点时，除id属性之外，也可以向顶点中增加自定义的属性，例如，名称属性，权重属性:

 
    ? 
   
 
     
       
       
         >>> g.add_node( 
         1 
         ,name 
         = 
         'n1' 
         ,weight 
         = 
         1 
         ) 
        
 
         >>> g.add_node( 
         2 
         ,name 
         = 
         'n2' 
         ,weight 
         = 
         1.2 
         ) 
        
 
     
 
   

2，查看顶点的属性。

通过属性_node获得图的所有顶点和属性的信息，_node属性返回的是一个字典结构，字典的key属性是顶点的id属性，value属性是顶点的其他属性构成的一个字典.

 
    ? 
   
 
     
       
       
         >>> g._node 
        
 
         { 
         1 
         : { 
         'name' 
         :  
         'n1' 
         ,  
         'weight' 
         :  
         1 
         },  
         2 
         : { 
         'name' 
         :  
         'n2' 
         ,  
         'weight' 
         :  
         1.2 
         },  
         3 
         : {},  
         4 
         : {}} 
        
 
         >>>g.nodes(data 
         = 
         true) 
        
 
     
 
   

可以通过顶点的id属性来查看顶点的其他属性:

 
    ? 
   
         >>> g.node[ 
         1 
         ] 
        
         { 
         'name' 
         :  
         'n1' 
         ,  
         'weight' 
         :  
         1 
         } 
        
         >>> g.node[ 
         1 
         ][ 
         'name' 
         ] 
        
         'n1 new'

通过g.nodes()，按照特定的条件来查看顶点:

 
    ? 
   
 
     
       
       
         >>>  
         list 
         (g.nodes(data 
         = 
         true)) 
        
 
         [( 
         1 
         , { 
         'time' 
         :  
         '5pm' 
         }), ( 
         3 
         , { 
         'time' 
         :  
         '2pm' 
         })] 
        
 
     
 
   

3，删除顶点。

通过remove函数删除图的顶点，由于顶点的id属性能够唯一标识一个顶点，通常删除顶点都需要通过传递id属性作为参数.

 
    ? 
   
         g.remove_node(node_id) 
        
         g.remove_nodes_from(nodes_list)

4，更新顶点。

更新图的顶点，有两种方式，第一种方式使用字典结构的_update函数，第二种方式是通过索引来设置新值:

 
    ? 
   
 
     
       
       
         >>> g._node[ 
         1 
         ].update({ 
         'name' 
         : 
         'n1 new' 
         }) 
        
 
         >>> g.node[ 
         1 
         ][ 
         'name' 
         ] 
         = 
         'n1 new' 
        
 
         { 
         1 
         : { 
         'name' 
         :  
         'n1 new' 
         ,  
         'weight' 
         :  
         1 
         },  
         2 
         : { 
         'name' 
         :  
         'n2' 
         ,  
         'weight' 
         :  
         1.2 
         },  
         3 
         : {},  
         4 
         : {}} 
        
 
     
 
   

5，删除顶点的属性。

使用del命令删除顶点的属性。

del g.nodes[1]['room'] 。

6，检查是否存在顶点。

检查一个顶点是否存在于图中，可以使用 n in g方式来判断，也可以使用函数:

g.has_node(n) 。

三，图的边。

图的边用于表示两个顶点之间的关系，因此，边是由两个顶点唯一确定的。为了表示复杂的关系，通常会为边增加一个权重weight属性；为了表示关系的类型，也会设置为边设置一个关系属性.

1，向图中增加边。

边是由对应顶点的名称构成的，例如，顶点2和3之间有一条边，记作e=(2,3)，通过add_edge(node1,node2)向图中添加一条边，也可以通过add_edges_from(list)向图中添加多条边；在添加边时，如果顶点不存在，那么networkx会自动把相应的顶点加入到图中.

 
    ? 
   
         g.add_edge( 
         2 
         , 
         3 
         ) 
        
         g.add_edges_from([( 
         1 
         , 
         2 
         ),( 
         1 
         , 
         3 
         )]) 
        
         g.edges() 
        
         #edgeview([(1, 2), (1, 3), (2, 3)])

可以向边中增加属性，例如，权重，关系等:

g.add_edge(1, 2, weight=4.7, relationship='renew') 。

由于在图中，边的权重weight是非常有用和常用的属性，因此，networkx模块内置以一个函数，专门用于在添加边时设置边的权重，该函数的参数是三元组，前两个字段是顶点的id属性，用于标识一个边，第三个字段是边的权重:

g.add_weighted_edges_from([(1,2,0.125),(1,3,0.75),(2,4,1.2),(3,4,0.375)]) 。

在增加边时，也可以一次增加多条边，为不同的边设置不同的属性:

g.add_edges_from([(1,2,{'color':'blue'}), (2,3,{'weight':8})]) 。

2，查看边的属性。

查看边的属性，就是查看边的数据(data)，查看所有边及其属性:

 
    ? 
   
         >>> g.edges(data 
         = 
         true) 
        
         edgedataview([( 
         1 
         ,  
         2 
         , {}), ( 
         1 
         ,  
         3 
         , {}), ( 
         2 
         ,  
         3 
         , {})])

查看特定的边的信息有两种方式:

 
    ? 
   
 
     
       
       
         >>> g[ 
         1 
         ][ 
         2 
         ] 
        
 
         >>> g.get_edge_data( 
         1 
         , 
         2 
         ) 
        
 
         { 
         'weight' 
         :  
         0.125 
         ,  
         'relationship' 
         :  
         'renew' 
         ,  
         'color' 
         :  
         'blue' 
         } 
        
 
     
 
   

3，删除边。

边是两个顶点的id属性构成的元组，通过 edge=(node1,node2) 来标识边，进而从图中找到边:

 
    ? 
   
         g.remove_edge(edge) 
        
         g.remove_edges_from(edges_list)

4，更新边的属性。

通过边来更新边的属性，由两种方式，一种是使用update函数，一种是通过属性赋值来实现:

5，删除边的属性。

通过 del命令来删除边的属性。

del g[1][2]['name'] 。

6，检查边是否存在。

检查一条边是否存在于图中。

g.has_edge(1,2) 。

四，图的属性。

图的属性主要是指相邻数据，节点和边.

1，adj 。

ajd返回的是一个adjacencyview视图，该视图是顶点的相邻的顶点和顶点的属性，用于显示用于存储与顶点相邻的顶点的数据，这是一个只读的字典结构，key是顶点，value是顶点的属性数据.

 
    ? 
   
 
     
       
       
         >>> g.adj[ 
         1 
         ][ 
         2 
         ] 
        
 
         { 
         'weight' 
         :  
         0.125 
         ,  
         'relationship' 
         :  
         'renew' 
         ,  
         'color' 
         :  
         'blue' 
         } 
        
 
         >>> g.adj[ 
         1 
         ] 
        
 
         atlasview({ 
         2 
         : { 
         'weight' 
         :  
         0.125 
         ,  
         'relationship' 
         :  
         'renew' 
         ,  
         'color' 
         :  
         'blue' 
         },  
         3 
         : { 
         'weight' 
         :  
         0.75 
         }}) 
        
 
     
 
   

2，edges 。

图的边是由边的两个顶点唯一确定的，边还有一定的属性，因此，边是由两个顶点和边的属性构成的:

 
    ? 
   
 
     
       
       
         >>> g.edges 
        
 
         edgeview([( 
         1 
         ,  
         2 
         ), ( 
         1 
         ,  
         3 
         ), ( 
         2 
         ,  
         3 
         ), ( 
         2 
         ,  
         4 
         ), ( 
         3 
         ,  
         4 
         )]) 
        
 
         >>> g.edges.data() 
        
 
         edgedataview([( 
         1 
         ,  
         2 
         , { 
         'weight' 
         :  
         0.125 
         ,  
         'relationship' 
         :  
         'renew' 
         ,  
         'color' 
         :  
         'blue' 
         }),  
        
 
         ( 
         1 
         ,  
         3 
         , { 
         'weight' 
         :  
         0.75 
         }),  
        
 
         ( 
         2 
         ,  
         3 
         , { 
         'weight' 
         :  
         8 
         }),  
        
 
         ( 
         2 
         ,  
         4 
         , { 
         'weight' 
         :  
         1.2 
         }),  
        
 
         ( 
         3 
         ,  
         4 
         , { 
         'weight' 
         :  
         0.375 
         })]) 
        
 
     
 
   

edgeview仅仅提供边的信息，可以通过属性g.edges或函数g.edges()来获得图的边视图.

edgedataview提供图的边和边的属性，可以通过edgeview对象来调用data()函数获得.

3，nodes 。

图的顶点是顶点和顶点的属性构成的。

 
    ? 
   
 
     
       
       
         >>> g.nodes 
        
 
         nodeview(( 
         1 
         ,  
         2 
         ,  
         3 
         ,  
         4 
         )) 
        
 
         >>> g.nodes.data() 
        
 
         nodedataview({ 
         1 
         : { 
         'name' 
         :  
         'n1 new' 
         ,  
         'weight' 
         :  
         1 
         },  
         2 
         : { 
         'name' 
         :  
         'n2' 
         ,  
         'weight' 
         :  
         1.2 
         },  
         3 
         : {},  
         4 
         : {}}) 
        
 
     
 
   

nodeview 通过属性g.nodes或函数g.nodes()来获得.

nodedataview提供图的边和边的属性，可以通过nodeview对象来调用data()函数获得.

4，degree 。

对于无向图，顶点的度是指跟顶点相连的边的数量；对于有向图，顶点的图分为入度和出度，朝向顶点的边称作入度；背向顶点的边称作出度.

通过g.degree 或g.degree()能够获得degreeview对象，。

五，图的遍历。

图的遍历是指按照图中各顶点之间的边，从图中的任一顶点出发，对图中的所有顶点访问一次且只访问一次。图的遍历按照优先顺序的不同，通常分为深度优先搜索（dfs）和广度优先搜索（bfs）两种方式.

1，查看顶点的相邻顶点。

查看顶点的相邻顶点，有多种方式，例如，以下代码都用于返回顶点1的相邻顶点，g[n]表示图g中，与顶点n相邻的所有顶点:

 
    ? 
   
         g[n] 
        
         g.adj[n] 
        
         g.neighbors(n)

其中，g.neighbors(n)是g.adj[n]的迭代器版本.

2，查看图的相邻。

该函数返回顶点n和相邻的节点信息:

 
    ? 
   
         >>>  
         for 
         n, nbrs  
         in 
         g.adjacency(): 
        
         ...    
         print 
         (n) 
        
         ...    
         print 
         (nbrs)

3，图的遍历。

深度优先遍历的算法:

首先以一个未被访问过的顶点作为起始顶点，沿当前顶点的边走到未访问过的相邻顶点；当当前顶点没有未访问过的相邻顶点时，则回到上一个顶点，继续试探别的相邻顶点，直到所有的顶点都被访问过。深度优先遍历算法的思想是：从一个顶点出发，一条路走到底；如果此路走不通，就返回上一个顶点，继续走其他路.

广度优先遍历的算法:

从顶点v出发，依次访问v的各个未访问过的相邻顶点；。

分别从这些相邻顶点出发依次访问它们的相邻顶点；。

广度优先遍历算法的思想是：以v为起点，按照路径的长度，由近至远，依次访问和v有路径相通且路径长度为1,2...，n的顶点.

在进行图遍历时，需要访问顶点的相邻顶点，这需要用到adjacency()函数，例如，g是一个无向图，n是顶点，nbrs是顶点n的相邻顶点，是一个字典结构。

 
    ? 
   
         for 
         n,nbrs  
         in 
         g.adjacency():  
        
         print 
         (n, nbrs) 
        
         for 
         nbr,attr  
         in 
         nbrs.items(): 
        
         # nbr表示跟n连接的顶点，attr表示这两个点连边的属性集合 
        
         print 
         (nbr,attr）

六，绘制graph 。

使用networkx模块draw()函数构造graph，使用matplotlib把图显示出来:

 
    ? 
   
         nx.draw(g) 
        
         import 
         matplotlib.pyplot as plt 
        
         plt.show()

修改顶点和边的颜色:

 
    ? 
   
         g  
         = 
         nx.cubical_graph() 
        
         nx.draw(g, pos 
         = 
         nx.spectral_layout(g), nodecolor 
         = 
         'r' 
         , edge_color 
         = 
         'b' 
         ) 
        
         plt.show()

完整的示例如下面的代码所示:

 
    ? 
   
         from 
         matplotlib  
         import 
         pyplot as plt 
        
         import 
         networkx as nx 
        
         g 
         = 
         nx.graph() 
        
         g.add_nodes_from([ 
         1 
         , 
         2 
         , 
         3 
         ]) 
        
         g.add_edges_from([( 
         1 
         , 
         2 
         ),( 
         1 
         , 
         3 
         )]) 
        
         nx.draw_networkx(g) 
        
         plt.show()

七，计算每个顶点的pagerank值。

在计算每个顶点的pagerank（简称pr）值时，可以使用networkx模块中的pagerank()函数，该函数根据顶点的边和边的权重来计算顶点的pr值:

 
    ? 
   
 
     
       
       
         pagerank(g, alpha 
         = 
         0.85 
         , personalization 
         = 
         none, max_iter 
         = 
         100 
         , tol 
         = 
         1e 
         - 
         06 
         , nstart 
         = 
         none, weight 
         = 
         'weight' 
         , dangling 
         = 
         none) 
        
 
     
 
   

常用的参数注释:

g：无向图会被转换为有向图，一条无向边转换为两条又向边。

alpha：阻尼参数，默认值是0.85 。

weight：默认值是weight，表示使用edge的weight属性作为权重，如果没有指定，那么把edge的权重设置为1；。

1，举个例子。

例如，创建一个有向图，由三个顶点（a、b和c），两条边（a指向b，a指向c），边的权重都是0.5 。

 
    ? 
   
         g 
         = 
         nx.digraph() 
        
         g.add_weighted_edges_from([( 
         'a' 
         , 
         'b' 
         , 
         0.5 
         ),( 
         'a' 
         , 
         'c' 
         , 
         0.5 
         )]) 
        
         print 
         ( nx.pagerank(g)) 
        
         #{'a': 0.259740259292235, 'c': 0.3701298703538825, 'b': 0.3701298703538825}

修改边的权重，并查看顶点的pr值:

 
    ? 
   
         g[ 
         'a' 
         ][ 
         'c' 
         ][ 
         'weight' 
         ] 
         = 
         1 
        
         print 
         ( nx.pagerank(g))   
        
         # {'a': 0.259740259292235, 'c': 0.40692640737443164, 'b': 0.3333333333333333}

2，查看各个顶点的pr值。

根据图来创建pagerank，并查看各个顶点的pagerank值。

 
    ? 
   
         pr 
         = 
         nx.pagerank(g) 
        
         #page_rank_value=pr[node] 
        
         for 
         node, pagerankvalue  
         in 
         pr.items(): 
        
         print 
         ( 
         "%s,%.4f" 
         % 
         (node,pagerankvalue))

原文链接：http://www.cnblogs.com/ljhdo/p/10662902.html 。

最后此篇关于Python 学习教程之networkx的文章就讲到这里了,如果你想了解更多关于Python 学习教程之networkx的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！。

文章推荐： python中time包实例详解

文章推荐： python+playwright微软自动化工具的使用

文章推荐：很有水平的昵称内涵有个性有点重口味网名大全最新

文章推荐： python爬虫智能翻页批量下载文件的实例详解

c# - 学习 C# 有助于或阻碍 VB.NET 学习
关闭。这个问题是opinion-based .它目前不接受答案。想要改进这个问题？更新问题，以便 editing this post 可以用事实和引用来回答它. 关闭 9 年前。 Improve
学习.NET8MiniApis入门
介绍篇什么是MiniApis？ MiniApis的特点和优势 MiniApis的应用场景环境搭建系统要求安装MiniApis 配置开发环境基础概念 MiniApis架构概述
Javascript(学习)
我正在从“JavaScript 圣经”一书中学习 javascript，但我遇到了一些困难。我试图理解这段代码: function checkIt(evt) { evt = (evt) ? e
String.intern() 学习
package com.fastone.www.javademo.stringintern; /** * * String.intern()是一个Native方法， * 它的作用是：如果字
macos - 学习 AppleScript
您会推荐哪些资源来学习 AppleScript。我使用具有 Objective-C 背景的传统 C/C++。我也在寻找有关如何更好地开发和从脚本编辑器获取更快文档的技巧。示例提示是“查找要编写脚本的
java - 学习 OpenCMS
关闭。这个问题不满足Stack Overflow guidelines .它目前不接受答案。想改善这个问题吗？更新问题，使其成为 on-topic对于堆栈溢出。 4年前关闭。 Improve thi
extjs - 学习 ExtJS4
关闭。这个问题不满足Stack Overflow guidelines .它目前不接受答案。想改善这个问题吗？更新问题，使其成为 on-topic对于堆栈溢出。 7年前关闭。 Improve thi
f# - 学习 F#
关闭。这个问题不符合 Stack Overflow guidelines 。它目前不接受答案。想改善这个问题吗？更新问题，以便堆栈溢出为 on-topic。 6年前关闭。 Improve this
flutter - 学习 flutter
我是塞内加尔的阿里。我今年60岁(也许这是我真正的问题-笑脸!!!)。我正在学习Flutter和Dart。今天，我想使用给定数据模型的列表(它的名称是Mortalite，请参见下面的代码)。我尝试
powershell - 学习……真的什么都行
关闭。这个问题是off-topic .它目前不接受答案。想改进这个问题？ Update the question所以它是on-topic对于堆栈溢出。 9年前关闭。 Improve this que
cappuccino - 学习 Cappuccino
学习 Cappuccino 的最佳来源是什么？我从事“传统”网络开发，但我对这个新框架非常感兴趣。请注意，我对 Objective-C 毫无了解。最佳答案如上所述，该网站是一个好地方，但还有一些其
java - 学习 HashMap
我正在学习如何使用 hashMap，有人可以检查我编写的这段代码并告诉我它是否正确吗？这个想法是有一个在公司工作的员工列表，我想从 hashMap 添加和删除员工。 public class Staf
jQuery CoffeeScript - 学习
我正在尝试将 jQuery 与 CoffeScript 一起使用。我按照博客中的说明操作，指示使用 $ -> 或 jQuery -> 而不是 .ready() 。我玩了一下代码，但我似乎无法理解我出错
javascript - PHP传递参数给新的字符串(学习)
还在学习，还有很多问题，所以这里有一些。我正在进行 javascript -> PHP 转换，并希望确保这些做法是正确的。是$dailyparams->$calories = $calories;一条
MySQL 使用临时表(学习)
我目前正在学习 SQL，以便从我们的 Magento 数据库制作一个简单的 RFM 报告，我目前可以通过导出两个查询并将它们粘贴到 Excel 模板中来完成此操作，我想摆脱 Excel 模板。我认为
Javascript > PHP (学习)
我知道我很可能会因为这个问题而受到抨击，但没有人问，我求助于你。这是否是一个正确的 javascript > php 转换 - 在我开始不良做法之前，我想知道这是否是解决此问题的正确方法。 JavaS
ruby - 学习/平铺的资源
除了 Ruby-Doc 之外，哪些来源最适合获取一些示例和教程，尤其是关于 Ruby 中的 Tk/Tile？我发现自己更正常了 http://www.tutorialspoint.com/ruby/r
Python 学习。为什么我只在第一次收到警告？
我只在第一次收到警告。这正常吗？ >>> cv=LassoCV(cv=10).fit(x,y) C:\Python27\lib\site-packages\scikit_learn-0.14.1-py
java - 学习/复习Java
按照目前的情况，这个问题不适合我们的问答形式。我们希望答案得到事实、引用或专业知识的支持，但这个问题可能会引发辩论、争论、投票或扩展讨论。如果您觉得这个问题可以改进并可能重新打开，visit the
c# - 学习.NET
As it currently stands, this question is not a good fit for our Q&A format. We expect answers to be

qq735679552

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

Python 学习教程之networkx