数据分析学习笔记(三)-NetworkX的使用

 

创建简单的空图形(没有边和点)
    
    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进行数据分析的实例

你可能感兴趣的:(数据挖掘)