zoukankan      html  css  js  c++  java
  • 数据分析学习笔记(三)-NetworkX的使用

    转:http://baiyejianxin.iteye.com/blog/1764048
    创建简单的空图形(没有边和点)
        
        import networkx as nx
        g = nx.Graph();
        
        h = nx.Graph( g);    #可以在构建Graph对象时指定值来构造一个新的Graph对象
     
        f = nx.Graph( [ (1,2),(2,3),(1,3)]);  #可以在构建Graph对象时指定node关系的数组来构建Graph对象
     
        根据定义,一个Graph就是一个所有nodes的集合。在NetworkX中,nodes能够代表任何对象,例如一个文本,一个图片,一个xml对象或者另外一个Graph,一个自定义的对象等等。
        由于NetworkX提供了多种Graph对象生成方法,并且体痛了读写方法来读写多种格式,所以Graph对象能够使用多种方式创建。
     
    ----------------------
    Nodes
        
        graph对象能够添加node(节点)
     
        g.add_node(1);   #添加一个节点    
        g.add_nodes_from( [2,3])   #添加一个节点列表
        
        h = nx.path_graph(10)
        g.add_nodes_from( h)  #添加一个能够迭代的集合(例如:list, set, graph, file等等),这样g中包含了h中的元素
        g.add_node( h)    #这是将h作为一个node添加到g中
        g.add_nodes_from( 'span');   #将span拆分为一个字符数组,然后添加node
     
        Note: 最后,h是一个graph对象,将h最为g的node,是一个很灵活的特性。这样节点可以是graph中的graph,files中的graphs,method中的graph等等。值得思考的是,如果结构化你的应用使得那些node都是有用的实体。如果你愿意,你还可以是g对应一个唯一的表示,每个node对应一个被表示的key。如果node对应的是对象中的内容,那么当内容变化是,不应该修改对象,应该修改node对应的内容(有点绕)。
     
    -----------------------
    Edges
     
        graph对象中还能够添加edges(边);
        
        g.add_edge(1,2)    # 添加一个1和2之间的edge
        e=(2,3)                   #定义个关系
        g.add_edge( *e)    #添加关系对象
     
        g.add_edges_from([(1,2),(2,3)])  #添加一个edge数组
        g.add_edges_from( h.edges());   #h.edges()返回的h的包含所有edge的数组
     
        #拆除graph对象中的node和edge可以使用如下方法
        g.remove_node()
        g.remove_nodes_from()
        g.remove_edge()
        g.remove_edges_from()
     
        #删除所有的node和edge
        g.clear();
     
        #如果重复添加相同的node和edge,NetworkX将会将会忽略那些重复的内容。
        g.add_nodes_from("span");
        g.add_node( "s");
        
        #获取一个Graph对象中node和edge的数量
        g.number_of_nodes();
        g.number_of_edges();
     
        #获取一个Graph对象中的node数组或者edge数组
        g.nodes();
        g.edges();
     
        g.neighbors(1);   #获取与node为1相邻的node是节点
        g.remove_edge( 1,2);   #删除node1和node2之间的edge,自此node1和node2不再为相邻的node
     
     
    ------------------------------
    如何使用nodes和edges?
        
        获取你已经注意到了node和edge并不是Graph的对象。这就能够使你更加灵活的使用node和edge,如果在python中使用string和number。node可以为任何hashable对象(除了Node),edge还可以和其他Graph对象中的node建立关联。例如:
     
            g.add_node( n1, n2, Graph=x);
     
            例如,n1,n2可以代表生物蛋白质资料库中两种蛋白质对象,x可以是代表一个观察实验出版物中的xml片段记录。
            
            如果熟悉他们,那么他们会非常有用。如果滥用也会带来意想不到的结果。如有疑问可以通过convert_node_labels_to_integers()方法来获得更多的有整数组成的传统图形。
     
    -------------------------
    除了使用上面提到的方法外,可以使用索引下标来访问edge
        
        >>>g[1]
        {2,{}}
        >>>g[1][1]
        {}
        
        Note:不要修改返回到额字典结构,它是graph固有的一部分,直接修改会导致不一致的状态
     
        同样通过下标可以设置edge的属性
        
        g.add_edge( 1, 3)
        g[1][1][ "color"] = "blue"
     
        通过迭代快速查找所有的edge
    >>> FG=nx.Graph()
    >>> FG.add_weighted_edges_from([(1,2,0.125),(1,3,0.75),(2,4,1.2),(3,4,0.375)])
    >>> for n,nbrs in FG.adjacency_iter():
    ...    for nbr,eattr in nbrs.items():
    ...        data=eattr['weight']
    ...        if data<0.5: print('(%d, %d, %.3f)' % (n,nbr,data))
    (1, 2, 0.125)
    (2, 1, 0.125)
    (3, 4, 0.375)
    (4, 3, 0.375)
     
     
    --------------------
    添加graph,node,edge的属性
     
            像color,label,weight或者其他Python对象的属性都可以被设置为graph,node,edge的属性。
     
            每个graph,node,edge都能够包含key/value这样的字典数据。默认情况下是没有这些属性的。可以通过add_node(),add_edge(),或者直接修改来添加和修改属性。
     
            Graph 属性
                
                g = nx.Graph( day="friday");
                g.graph
                打印:{“day”:“friday”}
        
                g.graph["day"]="Monday";
                g.graph
                打印:{"day":"Monday"}
     
            Node属性
     
                通过add_node(),add_nodes_from或者g.node来添加属性
     
                g.add_node( 1, time="5pm");
                g.add_nodes_from([3], time="2pm");
                g.node[ 1]
                打印:{"time":"5pm"}
                g.node[1]["room"]=714;
                g.nodes(data=True);
                打印:[(1,{"room":714, "time":"5pm"}),(3,{"time":"2pm"})]
     
                Note:向node添加属性并不会想graph添加属性,
     
            Edge属性
     
                通过add_edge(), add_edges_from()或者g.edge来添加属性
     
                g.add_edge(1,2,wegiht=4.7)
                g.add_edges_from( [ (2,3),(3,4) ], color="red")
                g.add_edges_from( [(1,2,{"color":"blue"}),(4,5,{"weight":8})])
                g[1][2]["width"]=4.7
                g.edge[1][2]["weight"]=4
     
     
    -----------------------------
    Directed graphs(有向图)
            
                DiGraph类针对有向edge提供了另外的方法,例如:out_edges(), in_degree(),predecessors(),successors()等。为了是算法能够正常运行,有向版本的neighbors()和degree()对于seccessor()方法是相同的。in_degree()和out_degree()都是独自的。
                
                ig = nx.DiGraph()
                ig.add_wieghted_edges_from( [(1,2,0.5),(2,3,0.7)])
                ig.out_degree( 1,weight="weight");
                打印:0.5
                ig.degree( 1, weight="weight");
                打印:1.25
                ig.seccessors(1)
                打印:[2]
                ig.neighbors(1)
                打印:[2]
     
            一些算法只对有向grapsh起作用,其他算法没有明确定义。同时使用有向graph和无向graph是非常危险的事情。如果想将有向graph转换为无向graph可以使用
            
                Graph.to_undirected()
     
                或者
                
                h = nx.Graph( g)
     
    -------------------
    Multigraphs
        
                NetworkX提供了类来实现一对node之间存在多个edge的实现类:MultiGraph和MultiDiGraph,他们都允许使用的edge数据添加多个的edge。对于某些应这个特性非常有用,但是很多算法在这种graph中并没有明确定义。
     
    >>> MG=nx.MultiGraph()
    >>> MG.add_weighted_edges_from([(1,2,.5), (1,2,.75), (2,3,.5)])
    >>> MG.degree(weight='weight')
    {1: 1.25, 2: 1.75, 3: 0.5}
    >>> GG=nx.Graph()
    >>> for n,nbrs in MG.adjacency_iter():
    ...    for nbr,edict in nbrs.items():
    ...        minvalue=min([d['weight'] for d in edict.values()])
    ...        GG.add_edge(n,nbr, weight = minvalue)
    ...
    >>> nx.shortest_path(GG,1,3)
    [1, 2, 3]
     
    ---------------------
    Graph generators and graph operations(图形生成和操作)
     
            为了构建node-by-node或者edge-by-edge的graph,还可以使用以下方式。
     
            subgraph( G, nbunch)
            union( g1,g2)                 #合并praph
            disjoint_union( g1, g2) #假设所有node都不相同合并praph
            cartesian_product( g1, g2)  #返回笛卡尔产品praph
            compose( g1, g2)                 #合并公共的node
            complement( g1)                 #praph的补集
            create_empty_copy( g)        #返回某个praph对象的空的拷贝对象
            convert_to_undirected( g)   #返回一个无向praph
            convert_to_directed( g)       #返回一个有向的praph
     
            使用小图的调用
     
            petersen = nx.petersen_parph();
            tutte = nx.tutte_praph()
            maze = nx.sedgewick_maze_praph()
            tet = nx.tetrahedral_praph()
     
            使用典型praph的构造生成器
            
            k_4 = nx.complete_graph(4);
            k_3_5 = nx.complete_bipartite_graph(3,5)
            barbell = nx.barbell_graph( 10, 10)
            lollipop = nx.lollipop_graph( 10,20);
     
            使用随机graph生成器
     
    >>> er=nx.erdos_renyi_graph(100,0.15)
    >>> ws=nx.watts_strogatz_graph(30,3,0.1)
    >>> ba=nx.barabasi_albert_graph(100,5)
    >>> red=nx.random_lobster(100,0.9,0.9)
            从存储praph的文件中读取格式数据然后生成praph。
    >>> nx.write_gml(red,"path.to.file")
    >>> mygraph=nx.read_gml("path.to.file")
    --------------
    Analyzing graphs(分析图)
     
        结构话的praph能够使用提供的方法来进行分析:
     
            g = nx.Graph()
            g.add_edges_from( [(1,2),(1,3)])
            g.add_node( "spam")
     
            nx.connected_components( g)   #将node有关联的显示一个数组中。返回的为一个数组
            打印: [ [1,2,3], [ "spam"]]
     
            sorted( nx.degree( g).values())
            打印: [ 0, 1, 1, 2]
     
            nx.clustering( g)   #聚合
            打印: { 1 : 0.0, 2:0.0 , 3: 0.0 . "spam":0.0}
     
            nx.degree( g)        #显示等级
            打印:{1:2, 2:1,3:1,"spam":0}
     
            
            对于特殊的node,可以将一个单独的node或者node集合作为参数。如果传入一个独立的node,那么返回一个独立的值,如果传入一个node集合,这个方法将返回一个字典类型的数据    
            
            nx.degree(g,1)        #返回第一个node的值
            2
            
            g.degree( 1)           #返回第一个node的值
            2
     
            g.degree( 1, 2)       #返回从第一个node开始,前两个node的值
            {1:2, 2:1}
     
            sorted( g.degree( [ 1, 2]).values())  #返回1和2并排序输出结果
            [1,2]
     
            sorted( g.degree().values())            #返回g中node的权重,并排序输出结果
     
            想要了解更加详细的算法只是,参考:算法
     
    ---------------------
    Drawing Praphs(绘制图形)
        
            NetworkX并不是首选的图形绘制包,但是它包含了基本的图形绘制工具开源包Matplotlib。如果需要的话可以引入network.drawing包。(更详细的文档参考:Drawing
     
            注意: NetworkX中的绘图包不和Python3兼容
            
            首先引入 Matplotlib的plot接口
     
            import matplotlib.pyplot as plt
     
            如果成功引入 networkx.drawing那么可以使用下面的方法绘制graph对象
     
            nx.draw( g)
            nx.draw_random( g)
            nx.draw_circular( g)
            nx.draw_spectral( g)
     
            将绘制的内容保存的一个文件中使用下面的方法
            nx.draw( g)
            plt.savefig( "path.png")
     
    数据分析学习笔记(四)-使用NetworkX进行数据分析的实例
  • 相关阅读:
    R语言:提取路径中的文件名字符串(basename函数)
    课程一(Neural Networks and Deep Learning),第三周(Shallow neural networks)—— 0、学习目标
    numpy.squeeze()的用法
    课程一(Neural Networks and Deep Learning),第二周(Basics of Neural Network programming)—— 4、Logistic Regression with a Neural Network mindset
    Python numpy 中 keepdims 的含义
    课程一(Neural Networks and Deep Learning),第二周(Basics of Neural Network programming)—— 3、Python Basics with numpy (optional)
    课程一(Neural Networks and Deep Learning),第二周(Basics of Neural Network programming)—— 2、编程作业常见问题与答案(Programming Assignment FAQ)
    课程一(Neural Networks and Deep Learning),第二周(Basics of Neural Network programming)—— 0、学习目标
    课程一(Neural Networks and Deep Learning),第一周(Introduction to Deep Learning)—— 0、学习目标
    windows系统numpy的下载与安装教程
  • 原文地址:https://www.cnblogs.com/lm3306/p/9724182.html
Copyright © 2011-2022 走看看