In [1]:
%pylab inline
from __future__ import print_function
Populating the interactive namespace from numpy and matplotlib
Transcription instances are used to describe (mostly textual) temporally ordered transcription of documents.
They are also known as annotation graphs.
For instance, one can use a Transcription to store the script of an episode of The Big Bang Theory TV series.
In [2]:
from pyannote.core import Transcription
In [3]:
transcription = Transcription()
For instance, to represent a dialogue between Penny and Leonard, we could do the following:
In [4]:
transcription.add_edge(3, 5, speech="hi there, I'm Penny", speaker='Penny')
transcription.add_edge(5, 5.5)
transcription.add_edge(5.5, 7, speech="hi. I'm Leonard", speaker='Leonard')
transcription
Out[4]:
It sometimes happens that we don't know exactly when an edge starts and/or when it ends.
One can use drifting timestamps to do that (as opposed to anchored timestamps whose temporal position is fixed).
T automatically generates a new drifting label every time it is called.
In [5]:
from pyannote.core import T
T.reset() # reset label generator to 'A'
t1, t2 = T(), T()
transcription.add_edge(t1, t2, summary='Leonard meets Penny')
transcription
Out[5]:
As you can see, the transcription is divided into two subgraphs.
We might want to indicate that 'Leonard meets Penny' actually starts with Penny's first line:
In [6]:
transcription.align('A', 3)
transcription
Out[6]:
Also, to indicate that Leonard's line ends before 'Leonard meets Penny' ends, one can just add an empty edge as follows:
In [7]:
transcription.add_edge(7, 'B')
transcription
Out[7]:
Transcription is a subclass of networkx.MultiDiGraph - as such, it inherits all its methods.
You might want to have a look at networkx documentation.
For instance, to iterate over all edges, one can use the following:
In [8]:
for start_time, end_time, data in transcription.edges_iter(data=True):
print(start_time, '-->', end_time, '|', data)
5.5 --> 7.0 | {'speech': "hi. I'm Leonard", 'speaker': 'Leonard'}
5.0 --> 5.5 | {}
7.0 --> B | {}
3.0 --> B | {'summary': 'Leonard meets Penny'}
3.0 --> 5.0 | {'speech': "hi there, I'm Penny", 'speaker': 'Penny'}
However, we might want to get all timestamps (drifting and anchored) in chronological order...
In [9]:
transcription.temporal_sort()
Out[9]:
[3.0, 5.0, 5.5, 7.0, 'B']
... or iterate edges in chronological order:
In [10]:
for start_time, end_time, data in transcription.ordered_edges_iter(data=True):
print(start_time, '-->', end_time, '|', data)
3.0 --> B | {'summary': 'Leonard meets Penny'}
3.0 --> 5.0 | {'speech': "hi there, I'm Penny", 'speaker': 'Penny'}
5.0 --> 5.5 | {}
5.5 --> 7.0 | {'speech': "hi. I'm Leonard", 'speaker': 'Leonard'}
7.0 --> B | {}
You can always try the following...
Who knows? It might give you the information you are looking for!
In [11]:
help(Transcription)
Help on class Transcription in module pyannote.core.transcription:
class Transcription(networkx.classes.multidigraph.MultiDiGraph)
| Transcription stored as annotation graph
|
| Method resolution order:
| Transcription
| networkx.classes.multidigraph.MultiDiGraph
| networkx.classes.multigraph.MultiGraph
| networkx.classes.digraph.DiGraph
| networkx.classes.graph.Graph
| __builtin__.object
|
| Methods defined here:
|
| __init__(self, graph=None, **attrs)
|
| add_edge(self, t1, t2, key=None, attr_dict=None, **attrs)
| Add annotation to the graph between times t1 and t2
|
| Parameters
| ----------
| t1, t2: float, str or None
| data : dict, optional
| {annotation_type: annotation_value} dictionary
|
| Example
| -------
| >>> G = Transcription()
| >>> G.add_edge(T(1.), T(), speaker='John', 'speech'='Hello world!')
|
| align(self, one_t, another_t)
| Align two (potentially drifting) times
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
| o -- [ F ] -- o o o
| ⟍ ⟋
| ==> [ F ]
| ⟋ ⟍
| o -- [ f ] -- o o o
|
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
| Parameters
| ----------
| one_t, another_t
| Two times to be aligned.
|
| Notes
| -----
| * If both `one_t` and `another_t` are drifting, the resulting graph
| will no longer contain `one_t`.
| * In case `another_t` is anchored, `align` is equivalent to `anchor`.
| * `one_t` and `another_t` cannot be both anchored.
|
| anchor(self, drifting_t, anchored_t)
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
| o -- [ D ] -- o ==> o -- [ A ] -- o
|
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
| Anchor `drifting_t` at `anchored_t`
|
| Parameters
| ----------
| drifting_t :
| Drifting time to anchor
| anchored_t :
| When to anchor `drifting_t`
|
| anchored(self)
| Get list of anchored times
|
| crop(self, source, target=None)
| Get minimum subgraph between source time and target time
|
| Parameters
| ----------
| source : Segment
| target : float or str, optional
|
| Returns
| -------
| g : Transcription
| Sub-graph between source and target
|
| drifting(self)
| Get list of drifting times
|
| for_json(self)
|
| ordered_edges_iter(self, nbunch=None, data=False, keys=False)
| Return an iterator over the edges in temporal order.
|
| Ordered edges are returned as tuples with optional data and keys
| in the order (t1, t2, key, data).
|
| Parameters
| ----------
| nbunch : iterable container, optional (default= all nodes)
| A container of nodes. The container will be iterated
| through once.
| data : bool, optional (default=False)
| If True, return edge attribute dict with each edge.
| keys : bool, optional (default=False)
| If True, return edge keys with each edge.
|
| Returns
| -------
| edge_iter : iterator
| An iterator of (u,v), (u,v,d) or (u,v,key,d) tuples of edges.
|
| Notes
| -----
| Nodes in nbunch that are not in the graph will be (quietly) ignored.
| For the same reason you should not completely trust temporal_sort,
| use ordered_edges_iter with care.
|
| ordering_graph(self)
| Ordering graph
|
| t1 --> t2 in the ordering graph indicates that t1 happens before t2.
| A missing edge simply means that it is not clear yet.
|
| post_align(self, t1, t2, t)
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
| [ t1 ] -- s [ t1 ] s
| ⟍ ⟋
| ==> [ t ]
| ⟋ ⟍
| [ t2 ] -- s' [ t2 ] s'
|
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
| pre_align(self, t1, t2, t)
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
| p -- [ t1 ] p [ t1 ]
| ⟍ ⟋
| ==> [ t ]
| ⟋ ⟍
| p' -- [ t2 ] p' [ t2 ]
|
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
| relabel_drifting_nodes(self, mapping=None)
| Relabel drifting nodes
|
| Parameters
| ----------
| mapping : dict, optional
| A dictionary with the old labels as keys and new labels as values.
|
| Returns
| -------
| g : Transcription
| New annotation graph
| mapping : dict
| A dictionary with the new labels as keys and old labels as values.
| Can be used to get back to the version before relabelling.
|
| temporal_sort(self)
| Get nodes sorted in temporal order
|
| Remark
| ------
| This relies on a combination of temporal ordering of anchored times
| and topological ordering for drifting times.
| To be 100% sure that one drifting time happens before another time,
| check the ordering graph (method .ordering_graph()).
|
| timerange(self, t1, t2, inside=True, sort=None)
| Infer edge timerange from graph structure
|
| a -- ... -- [ t1 ] -- A -- ... -- B -- [ t2 ] -- ... -- b
|
| ==> [a, b] (inside=False) or [A, B] (inside=True)
|
| Parameters
| ----------
| t1, t2 : anchored or drifting times
| inside : boolean, optional
|
| Returns
| -------
| segment : Segment
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| from_json(cls, data) from __builtin__.type
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __slotnames__ = []
|
| ----------------------------------------------------------------------
| Methods inherited from networkx.classes.multidigraph.MultiDiGraph:
|
| degree_iter(self, nbunch=None, weight=None)
| Return an iterator for (node, degree).
|
| The node degree is the number of edges adjacent to the node.
|
| Parameters
| ----------
| nbunch : iterable container, optional (default=all nodes)
| A container of nodes. The container will be iterated
| through once.
|
| weight : string or None, optional (default=None)
| The edge attribute that holds the numerical value used
| as a weight. If None, then each edge has weight 1.
| The degree is the sum of the edge weights.
|
| Returns
| -------
| nd_iter : an iterator
| The iterator returns two-tuples of (node, degree).
|
| See Also
| --------
| degree
|
| Examples
| --------
| >>> G = nx.MultiDiGraph()
| >>> G.add_path([0,1,2,3])
| >>> list(G.degree_iter(0)) # node 0 with degree 1
| [(0, 1)]
| >>> list(G.degree_iter([0,1]))
| [(0, 1), (1, 2)]
|
| edges_iter(self, nbunch=None, data=False, keys=False, default=None)
| Return an iterator over the edges.
|
| Edges are returned as tuples with optional data and keys
| in the order (node, neighbor, key, data).
|
| Parameters
| ----------
| nbunch : iterable container, optional (default= all nodes)
| A container of nodes. The container will be iterated
| through once.
| data : string or bool, optional (default=False)
| The edge attribute returned in 3-tuple (u,v,ddict[data]).
| If True, return edge attribute dict in 3-tuple (u,v,ddict).
| If False, return 2-tuple (u,v).
| keys : bool, optional (default=False)
| If True, return edge keys with each edge.
| default : value, optional (default=None)
| Value used for edges that dont have the requested attribute.
| Only relevant if data is not True or False.
|
| Returns
| -------
| edge_iter : iterator
| An iterator of (u,v), (u,v,d) or (u,v,key,d) tuples of edges.
|
| See Also
| --------
| edges : return a list of edges
|
| Notes
| -----
| Nodes in nbunch that are not in the graph will be (quietly) ignored.
| For directed graphs this returns the out-edges.
|
| Examples
| --------
| >>> G = nx.MultiDiGraph()
| >>> G.add_path([0,1,2])
| >>> G.add_edge(2,3,weight=5)
| >>> [e for e in G.edges_iter()]
| [(0, 1), (1, 2), (2, 3)]
| >>> list(G.edges_iter(data=True)) # default data is {} (empty dict)
| [(0, 1, {}), (1, 2, {}), (2, 3, {'weight': 5})]
| >>> list(G.edges_iter(data='weight', default=1))
| [(0, 1, 1), (1, 2, 1), (2, 3, 5)]
| >>> list(G.edges(keys=True)) # default keys are integers
| [(0, 1, 0), (1, 2, 0), (2, 3, 0)]
| >>> list(G.edges(data=True,keys=True)) # default keys are integers
| [(0, 1, 0, {}), (1, 2, 0, {}), (2, 3, 0, {'weight': 5})]
| >>> list(G.edges(data='weight',default=1,keys=True))
| [(0, 1, 0, 1), (1, 2, 0, 1), (2, 3, 0, 5)]
| >>> list(G.edges_iter([0,2]))
| [(0, 1), (2, 3)]
| >>> list(G.edges_iter(0))
| [(0, 1)]
|
| in_degree_iter(self, nbunch=None, weight=None)
| Return an iterator for (node, in-degree).
|
| The node in-degree is the number of edges pointing in to the node.
|
| Parameters
| ----------
| nbunch : iterable container, optional (default=all nodes)
| A container of nodes. The container will be iterated
| through once.
|
| weight : string or None, optional (default=None)
| The edge attribute that holds the numerical value used
| as a weight. If None, then each edge has weight 1.
| The degree is the sum of the edge weights adjacent to the node.
|
| Returns
| -------
| nd_iter : an iterator
| The iterator returns two-tuples of (node, in-degree).
|
| See Also
| --------
| degree, in_degree, out_degree, out_degree_iter
|
| Examples
| --------
| >>> G = nx.MultiDiGraph()
| >>> G.add_path([0,1,2,3])
| >>> list(G.in_degree_iter(0)) # node 0 with degree 0
| [(0, 0)]
| >>> list(G.in_degree_iter([0,1]))
| [(0, 0), (1, 1)]
|
| in_edges(self, nbunch=None, keys=False, data=False)
| Return a list of the incoming edges.
|
| Parameters
| ----------
| nbunch : iterable container, optional (default= all nodes)
| A container of nodes. The container will be iterated
| through once.
| data : bool, optional (default=False)
| If True, return edge attribute dict with each edge.
| keys : bool, optional (default=False)
| If True, return edge keys with each edge.
|
| Returns
| -------
| in_edges : list
| A list of (u,v), (u,v,d) or (u,v,key,d) tuples of edges.
|
| See Also
| --------
| out_edges: return a list of outgoing edges
|
| in_edges_iter(self, nbunch=None, data=False, keys=False)
| Return an iterator over the incoming edges.
|
| Parameters
| ----------
| nbunch : iterable container, optional (default= all nodes)
| A container of nodes. The container will be iterated
| through once.
| data : bool, optional (default=False)
| If True, return edge attribute dict with each edge.
| keys : bool, optional (default=False)
| If True, return edge keys with each edge.
|
| Returns
| -------
| in_edge_iter : iterator
| An iterator of (u,v), (u,v,d) or (u,v,key,d) tuples of edges.
|
| See Also
| --------
| edges_iter : return an iterator of edges
|
| is_directed(self)
| Return True if graph is directed, False otherwise.
|
| is_multigraph(self)
| Return True if graph is a multigraph, False otherwise.
|
| out_degree_iter(self, nbunch=None, weight=None)
| Return an iterator for (node, out-degree).
|
| The node out-degree is the number of edges pointing out of the node.
|
| Parameters
| ----------
| nbunch : iterable container, optional (default=all nodes)
| A container of nodes. The container will be iterated
| through once.
|
| weight : string or None, optional (default=None)
| The edge attribute that holds the numerical value used
| as a weight. If None, then each edge has weight 1.
| The degree is the sum of the edge weights.
|
| Returns
| -------
| nd_iter : an iterator
| The iterator returns two-tuples of (node, out-degree).
|
| See Also
| --------
| degree, in_degree, out_degree, in_degree_iter
|
| Examples
| --------
| >>> G = nx.MultiDiGraph()
| >>> G.add_path([0,1,2,3])
| >>> list(G.out_degree_iter(0)) # node 0 with degree 1
| [(0, 1)]
| >>> list(G.out_degree_iter([0,1]))
| [(0, 1), (1, 1)]
|
| out_edges(self, nbunch=None, keys=False, data=False)
| Return a list of the outgoing edges.
|
| Edges are returned as tuples with optional data and keys
| in the order (node, neighbor, key, data).
|
| Parameters
| ----------
| nbunch : iterable container, optional (default= all nodes)
| A container of nodes. The container will be iterated
| through once.
| data : bool, optional (default=False)
| If True, return edge attribute dict with each edge.
| keys : bool, optional (default=False)
| If True, return edge keys with each edge.
|
| Returns
| -------
| out_edges : list
| An listr of (u,v), (u,v,d) or (u,v,key,d) tuples of edges.
|
| Notes
| -----
| Nodes in nbunch that are not in the graph will be (quietly) ignored.
| For directed graphs edges() is the same as out_edges().
|
| See Also
| --------
| in_edges: return a list of incoming edges
|
| out_edges_iter = edges_iter(self, nbunch=None, data=False, keys=False, default=None)
| Return an iterator over the edges.
|
| Edges are returned as tuples with optional data and keys
| in the order (node, neighbor, key, data).
|
| Parameters
| ----------
| nbunch : iterable container, optional (default= all nodes)
| A container of nodes. The container will be iterated
| through once.
| data : string or bool, optional (default=False)
| The edge attribute returned in 3-tuple (u,v,ddict[data]).
| If True, return edge attribute dict in 3-tuple (u,v,ddict).
| If False, return 2-tuple (u,v).
| keys : bool, optional (default=False)
| If True, return edge keys with each edge.
| default : value, optional (default=None)
| Value used for edges that dont have the requested attribute.
| Only relevant if data is not True or False.
|
| Returns
| -------
| edge_iter : iterator
| An iterator of (u,v), (u,v,d) or (u,v,key,d) tuples of edges.
|
| See Also
| --------
| edges : return a list of edges
|
| Notes
| -----
| Nodes in nbunch that are not in the graph will be (quietly) ignored.
| For directed graphs this returns the out-edges.
|
| Examples
| --------
| >>> G = nx.MultiDiGraph()
| >>> G.add_path([0,1,2])
| >>> G.add_edge(2,3,weight=5)
| >>> [e for e in G.edges_iter()]
| [(0, 1), (1, 2), (2, 3)]
| >>> list(G.edges_iter(data=True)) # default data is {} (empty dict)
| [(0, 1, {}), (1, 2, {}), (2, 3, {'weight': 5})]
| >>> list(G.edges_iter(data='weight', default=1))
| [(0, 1, 1), (1, 2, 1), (2, 3, 5)]
| >>> list(G.edges(keys=True)) # default keys are integers
| [(0, 1, 0), (1, 2, 0), (2, 3, 0)]
| >>> list(G.edges(data=True,keys=True)) # default keys are integers
| [(0, 1, 0, {}), (1, 2, 0, {}), (2, 3, 0, {'weight': 5})]
| >>> list(G.edges(data='weight',default=1,keys=True))
| [(0, 1, 0, 1), (1, 2, 0, 1), (2, 3, 0, 5)]
| >>> list(G.edges_iter([0,2]))
| [(0, 1), (2, 3)]
| >>> list(G.edges_iter(0))
| [(0, 1)]
|
| remove_edge(self, u, v, key=None)
| Remove an edge between u and v.
|
| Parameters
| ----------
| u,v: nodes
| Remove an edge between nodes u and v.
| key : hashable identifier, optional (default=None)
| Used to distinguish multiple edges between a pair of nodes.
| If None remove a single (abritrary) edge between u and v.
|
| Raises
| ------
| NetworkXError
| If there is not an edge between u and v, or
| if there is no edge with the specified key.
|
| See Also
| --------
| remove_edges_from : remove a collection of edges
|
| Examples
| --------
| >>> G = nx.MultiDiGraph()
| >>> G.add_path([0,1,2,3])
| >>> G.remove_edge(0,1)
| >>> e = (1,2)
| >>> G.remove_edge(*e) # unpacks e from an edge tuple
|
| For multiple edges
|
| >>> G = nx.MultiDiGraph()
| >>> G.add_edges_from([(1,2),(1,2),(1,2)])
| >>> G.remove_edge(1,2) # remove a single (arbitrary) edge
|
| For edges with keys
|
| >>> G = nx.MultiDiGraph()
| >>> G.add_edge(1,2,key='first')
| >>> G.add_edge(1,2,key='second')
| >>> G.remove_edge(1,2,key='second')
|
| reverse(self, copy=True)
| Return the reverse of the graph.
|
| The reverse is a graph with the same nodes and edges
| but with the directions of the edges reversed.
|
| Parameters
| ----------
| copy : bool optional (default=True)
| If True, return a new DiGraph holding the reversed edges.
| If False, reverse the reverse graph is created using
| the original graph (this changes the original graph).
|
| subgraph(self, nbunch)
| Return the subgraph induced on nodes in nbunch.
|
| The induced subgraph of the graph contains the nodes in nbunch
| and the edges between those nodes.
|
| Parameters
| ----------
| nbunch : list, iterable
| A container of nodes which will be iterated through once.
|
| Returns
| -------
| G : Graph
| A subgraph of the graph with the same edge attributes.
|
| Notes
| -----
| The graph, edge or node attributes just point to the original graph.
| So changes to the node or edge structure will not be reflected in
| the original graph while changes to the attributes will.
|
| To create a subgraph with its own copy of the edge/node attributes use:
| nx.Graph(G.subgraph(nbunch))
|
| If edge attributes are containers, a deep copy can be obtained using:
| G.subgraph(nbunch).copy()
|
| For an inplace reduction of a graph to a subgraph you can remove nodes:
| G.remove_nodes_from([ n in G if n not in set(nbunch)])
|
| Examples
| --------
| >>> G = nx.Graph() # or DiGraph, MultiGraph, MultiDiGraph, etc
| >>> G.add_path([0,1,2,3])
| >>> H = G.subgraph([0,1,2])
| >>> H.edges()
| [(0, 1), (1, 2)]
|
| to_directed(self)
| Return a directed copy of the graph.
|
| Returns
| -------
| G : MultiDiGraph
| A deepcopy of the graph.
|
| Notes
| -----
| If edges in both directions (u,v) and (v,u) exist in the
| graph, attributes for the new undirected edge will be a combination of
| the attributes of the directed edges. The edge data is updated
| in the (arbitrary) order that the edges are encountered. For
| more customized control of the edge attributes use add_edge().
|
| This returns a "deepcopy" of the edge, node, and
| graph attributes which attempts to completely copy
| all of the data and references.
|
| This is in contrast to the similar G=DiGraph(D) which returns a
| shallow copy of the data.
|
| See the Python copy module for more information on shallow
| and deep copies, http://docs.python.org/library/copy.html.
|
| Examples
| --------
| >>> G = nx.Graph() # or MultiGraph, etc
| >>> G.add_path([0,1])
| >>> H = G.to_directed()
| >>> H.edges()
| [(0, 1), (1, 0)]
|
| If already directed, return a (deep) copy
|
| >>> G = nx.MultiDiGraph()
| >>> G.add_path([0,1])
| >>> H = G.to_directed()
| >>> H.edges()
| [(0, 1)]
|
| to_undirected(self, reciprocal=False)
| Return an undirected representation of the digraph.
|
| Parameters
| ----------
| reciprocal : bool (optional)
| If True only keep edges that appear in both directions
| in the original digraph.
|
| Returns
| -------
| G : MultiGraph
| An undirected graph with the same name and nodes and
| with edge (u,v,data) if either (u,v,data) or (v,u,data)
| is in the digraph. If both edges exist in digraph and
| their edge data is different, only one edge is created
| with an arbitrary choice of which edge data to use.
| You must check and correct for this manually if desired.
|
| Notes
| -----
| This returns a "deepcopy" of the edge, node, and
| graph attributes which attempts to completely copy
| all of the data and references.
|
| This is in contrast to the similar D=DiGraph(G) which returns a
| shallow copy of the data.
|
| See the Python copy module for more information on shallow
| and deep copies, http://docs.python.org/library/copy.html.
|
| Warning: If you have subclassed MultiGraph to use dict-like objects
| in the data structure, those changes do not transfer to the MultiDiGraph
| created by this method.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from networkx.classes.multidigraph.MultiDiGraph:
|
| edge_key_dict_factory = <type 'dict'>
| dict() -> new empty dictionary
| dict(mapping) -> new dictionary initialized from a mapping object's
| (key, value) pairs
| dict(iterable) -> new dictionary initialized as if via:
| d = {}
| for k, v in iterable:
| d[k] = v
| dict(**kwargs) -> new dictionary initialized with the name=value pairs
| in the keyword argument list. For example: dict(one=1, two=2)
|
| ----------------------------------------------------------------------
| Methods inherited from networkx.classes.multigraph.MultiGraph:
|
| add_edges_from(self, ebunch, attr_dict=None, **attr)
| Add all the edges in ebunch.
|
| Parameters
| ----------
| ebunch : container of edges
| Each edge given in the container will be added to the
| graph. The edges can be:
|
| - 2-tuples (u,v) or
| - 3-tuples (u,v,d) for an edge attribute dict d, or
| - 4-tuples (u,v,k,d) for an edge identified by key k
|
| attr_dict : dictionary, optional (default= no attributes)
| Dictionary of edge attributes. Key/value pairs will
| update existing data associated with each edge.
| attr : keyword arguments, optional
| Edge data (or labels or objects) can be assigned using
| keyword arguments.
|
|
| See Also
| --------
| add_edge : add a single edge
| add_weighted_edges_from : convenient way to add weighted edges
|
| Notes
| -----
| Adding the same edge twice has no effect but any edge data
| will be updated when each duplicate edge is added.
|
| Edge attributes specified in edges take precedence
| over attributes specified generally.
|
| Examples
| --------
| >>> G = nx.Graph() # or DiGraph, MultiGraph, MultiDiGraph, etc
| >>> G.add_edges_from([(0,1),(1,2)]) # using a list of edge tuples
| >>> e = zip(range(0,3),range(1,4))
| >>> G.add_edges_from(e) # Add the path graph 0-1-2-3
|
| Associate data to edges
|
| >>> G.add_edges_from([(1,2),(2,3)], weight=3)
| >>> G.add_edges_from([(3,4),(1,4)], label='WN2898')
|
| edges(self, nbunch=None, data=False, keys=False, default=None)
| Return a list of edges.
|
| Edges are returned as tuples with optional data and keys
| in the order (node, neighbor, key, data).
|
| Parameters
| ----------
| nbunch : iterable container, optional (default= all nodes)
| A container of nodes. The container will be iterated
| through once.
| data : bool, optional (default=False)
| Return two tuples (u,v) (False) or three-tuples (u,v,data) (True).
| keys : bool, optional (default=False)
| Return two tuples (u,v) (False) or three-tuples (u,v,key) (True).
|
| Returns
| --------
| edge_list: list of edge tuples
| Edges that are adjacent to any node in nbunch, or a list
| of all edges if nbunch is not specified.
|
| See Also
| --------
| edges_iter : return an iterator over the edges
|
| Notes
| -----
| Nodes in nbunch that are not in the graph will be (quietly) ignored.
| For directed graphs this returns the out-edges.
|
| Examples
| --------
| >>> G = nx.MultiGraph() # or MultiDiGraph
| >>> G.add_path([0,1,2])
| >>> G.add_edge(2,3,weight=5)
| >>> G.edges()
| [(0, 1), (1, 2), (2, 3)]
| >>> G.edges(data=True) # default edge data is {} (empty dictionary)
| [(0, 1, {}), (1, 2, {}), (2, 3, {'weight': 5})]
| >>> list(G.edges_iter(data='weight', default=1))
| [(0, 1, 1), (1, 2, 1), (2, 3, 5)]
| >>> G.edges(keys=True) # default keys are integers
| [(0, 1, 0), (1, 2, 0), (2, 3, 0)]
| >>> G.edges(data=True,keys=True) # default keys are integers
| [(0, 1, 0, {}), (1, 2, 0, {}), (2, 3, 0, {'weight': 5})]
| >>> list(G.edges(data='weight',default=1,keys=True))
| [(0, 1, 0, 1), (1, 2, 0, 1), (2, 3, 0, 5)]
| >>> G.edges([0,3])
| [(0, 1), (3, 2)]
| >>> G.edges(0)
| [(0, 1)]
|
| get_edge_data(self, u, v, key=None, default=None)
| Return the attribute dictionary associated with edge (u,v).
|
| Parameters
| ----------
| u,v : nodes
| default: any Python object (default=None)
| Value to return if the edge (u,v) is not found.
| key : hashable identifier, optional (default=None)
| Return data only for the edge with specified key.
|
| Returns
| -------
| edge_dict : dictionary
| The edge attribute dictionary.
|
| Notes
| -----
| It is faster to use G[u][v][key].
|
| >>> G = nx.MultiGraph() # or MultiDiGraph
| >>> G.add_edge(0,1,key='a',weight=7)
| >>> G[0][1]['a'] # key='a'
| {'weight': 7}
|
| Warning: Assigning G[u][v][key] corrupts the graph data structure.
| But it is safe to assign attributes to that dictionary,
|
| >>> G[0][1]['a']['weight'] = 10
| >>> G[0][1]['a']['weight']
| 10
| >>> G[1][0]['a']['weight']
| 10
|
| Examples
| --------
| >>> G = nx.MultiGraph() # or MultiDiGraph
| >>> G.add_path([0,1,2,3])
| >>> G.get_edge_data(0,1)
| {0: {}}
| >>> e = (0,1)
| >>> G.get_edge_data(*e) # tuple form
| {0: {}}
| >>> G.get_edge_data('a','b',default=0) # edge not in graph, return 0
| 0
|
| has_edge(self, u, v, key=None)
| Return True if the graph has an edge between nodes u and v.
|
| Parameters
| ----------
| u,v : nodes
| Nodes can be, for example, strings or numbers.
|
| key : hashable identifier, optional (default=None)
| If specified return True only if the edge with
| key is found.
|
| Returns
| -------
| edge_ind : bool
| True if edge is in the graph, False otherwise.
|
| Examples
| --------
| Can be called either using two nodes u,v, an edge tuple (u,v),
| or an edge tuple (u,v,key).
|
| >>> G = nx.MultiGraph() # or MultiDiGraph
| >>> G.add_path([0,1,2,3])
| >>> G.has_edge(0,1) # using two nodes
| True
| >>> e = (0,1)
| >>> G.has_edge(*e) # e is a 2-tuple (u,v)
| True
| >>> G.add_edge(0,1,key='a')
| >>> G.has_edge(0,1,key='a') # specify key
| True
| >>> e=(0,1,'a')
| >>> G.has_edge(*e) # e is a 3-tuple (u,v,'a')
| True
|
| The following syntax are equivalent:
|
| >>> G.has_edge(0,1)
| True
| >>> 1 in G[0] # though this gives KeyError if 0 not in G
| True
|
| number_of_edges(self, u=None, v=None)
| Return the number of edges between two nodes.
|
| Parameters
| ----------
| u,v : nodes, optional (default=all edges)
| If u and v are specified, return the number of edges between
| u and v. Otherwise return the total number of all edges.
|
| Returns
| -------
| nedges : int
| The number of edges in the graph. If nodes u and v are specified
| return the number of edges between those nodes.
|
| See Also
| --------
| size
|
| Examples
| --------
| >>> G = nx.Graph() # or DiGraph, MultiGraph, MultiDiGraph, etc
| >>> G.add_path([0,1,2,3])
| >>> G.number_of_edges()
| 3
| >>> G.number_of_edges(0,1)
| 1
| >>> e = (0,1)
| >>> G.number_of_edges(*e)
| 1
|
| remove_edges_from(self, ebunch)
| Remove all edges specified in ebunch.
|
| Parameters
| ----------
| ebunch: list or container of edge tuples
| Each edge given in the list or container will be removed
| from the graph. The edges can be:
|
| - 2-tuples (u,v) All edges between u and v are removed.
| - 3-tuples (u,v,key) The edge identified by key is removed.
| - 4-tuples (u,v,key,data) where data is ignored.
|
| See Also
| --------
| remove_edge : remove a single edge
|
| Notes
| -----
| Will fail silently if an edge in ebunch is not in the graph.
|
| Examples
| --------
| >>> G = nx.MultiGraph() # or MultiDiGraph
| >>> G.add_path([0,1,2,3])
| >>> ebunch=[(1,2),(2,3)]
| >>> G.remove_edges_from(ebunch)
|
| Removing multiple copies of edges
|
| >>> G = nx.MultiGraph()
| >>> G.add_edges_from([(1,2),(1,2),(1,2)])
| >>> G.remove_edges_from([(1,2),(1,2)])
| >>> G.edges()
| [(1, 2)]
| >>> G.remove_edges_from([(1,2),(1,2)]) # silently ignore extra copy
| >>> G.edges() # now empty graph
| []
|
| selfloop_edges(self, data=False, keys=False, default=None)
| Return a list of selfloop edges.
|
| A selfloop edge has the same node at both ends.
|
| Parameters
| ----------
| data : bool, optional (default=False)
| Return selfloop edges as two tuples (u,v) (data=False)
| or three-tuples (u,v,datadict) (data=True)
| or three-tuples (u,v,datavalue) (data='attrname')
| default : value, optional (default=None)
| Value used for edges that dont have the requested attribute.
| Only relevant if data is not True or False.
| keys : bool, optional (default=False)
| If True, return edge keys with each edge.
|
| Returns
| -------
| edgelist : list of edge tuples
| A list of all selfloop edges.
|
| See Also
| --------
| nodes_with_selfloops, number_of_selfloops
|
| Examples
| --------
| >>> G = nx.MultiGraph() # or MultiDiGraph
| >>> G.add_edge(1,1)
| >>> G.add_edge(1,2)
| >>> G.selfloop_edges()
| [(1, 1)]
| >>> G.selfloop_edges(data=True)
| [(1, 1, {})]
| >>> G.selfloop_edges(keys=True)
| [(1, 1, 0)]
| >>> G.selfloop_edges(keys=True, data=True)
| [(1, 1, 0, {})]
|
| ----------------------------------------------------------------------
| Methods inherited from networkx.classes.digraph.DiGraph:
|
| add_node(self, n, attr_dict=None, **attr)
| Add a single node n and update node attributes.
|
| Parameters
| ----------
| n : node
| A node can be any hashable Python object except None.
| attr_dict : dictionary, optional (default= no attributes)
| Dictionary of node attributes. Key/value pairs will
| update existing data associated with the node.
| attr : keyword arguments, optional
| Set or change attributes using key=value.
|
| See Also
| --------
| add_nodes_from
|
| Examples
| --------
| >>> G = nx.Graph() # or DiGraph, MultiGraph, MultiDiGraph, etc
| >>> G.add_node(1)
| >>> G.add_node('Hello')
| >>> K3 = nx.Graph([(0,1),(1,2),(2,0)])
| >>> G.add_node(K3)
| >>> G.number_of_nodes()
| 3
|
| Use keywords set/change node attributes:
|
| >>> G.add_node(1,size=10)
| >>> G.add_node(3,weight=0.4,UTM=('13S',382871,3972649))
|
| Notes
| -----
| A hashable object is one that can be used as a key in a Python
| dictionary. This includes strings, numbers, tuples of strings
| and numbers, etc.
|
| On many platforms hashable items also include mutables such as
| NetworkX Graphs, though one should be careful that the hash
| doesn't change on mutables.
|
| add_nodes_from(self, nodes, **attr)
| Add multiple nodes.
|
| Parameters
| ----------
| nodes : iterable container
| A container of nodes (list, dict, set, etc.).
| OR
| A container of (node, attribute dict) tuples.
| Node attributes are updated using the attribute dict.
| attr : keyword arguments, optional (default= no attributes)
| Update attributes for all nodes in nodes.
| Node attributes specified in nodes as a tuple
| take precedence over attributes specified generally.
|
| See Also
| --------
| add_node
|
| Examples
| --------
| >>> G = nx.Graph() # or DiGraph, MultiGraph, MultiDiGraph, etc
| >>> G.add_nodes_from('Hello')
| >>> K3 = nx.Graph([(0,1),(1,2),(2,0)])
| >>> G.add_nodes_from(K3)
| >>> sorted(G.nodes(),key=str)
| [0, 1, 2, 'H', 'e', 'l', 'o']
|
| Use keywords to update specific node attributes for every node.
|
| >>> G.add_nodes_from([1,2], size=10)
| >>> G.add_nodes_from([3,4], weight=0.4)
|
| Use (node, attrdict) tuples to update attributes for specific
| nodes.
|
| >>> G.add_nodes_from([(1,dict(size=11)), (2,{'color':'blue'})])
| >>> G.node[1]['size']
| 11
| >>> H = nx.Graph()
| >>> H.add_nodes_from(G.nodes(data=True))
| >>> H.node[1]['size']
| 11
|
| clear(self)
| Remove all nodes and edges from the graph.
|
| This also removes the name, and all graph, node, and edge attributes.
|
| Examples
| --------
| >>> G = nx.Graph() # or DiGraph, MultiGraph, MultiDiGraph, etc
| >>> G.add_path([0,1,2,3])
| >>> G.clear()
| >>> G.nodes()
| []
| >>> G.edges()
| []
|
| has_predecessor(self, u, v)
| Return True if node u has predecessor v.
|
| This is true if graph has the edge u<-v.
|
| has_successor(self, u, v)
| Return True if node u has successor v.
|
| This is true if graph has the edge u->v.
|
| in_degree(self, nbunch=None, weight=None)
| Return the in-degree of a node or nodes.
|
| The node in-degree is the number of edges pointing in to the node.
|
| Parameters
| ----------
| nbunch : iterable container, optional (default=all nodes)
| A container of nodes. The container will be iterated
| through once.
|
| weight : string or None, optional (default=None)
| The edge attribute that holds the numerical value used
| as a weight. If None, then each edge has weight 1.
| The degree is the sum of the edge weights adjacent to the node.
|
| Returns
| -------
| nd : dictionary, or number
| A dictionary with nodes as keys and in-degree as values or
| a number if a single node is specified.
|
| See Also
| --------
| degree, out_degree, in_degree_iter
|
| Examples
| --------
| >>> G = nx.DiGraph() # or MultiDiGraph
| >>> G.add_path([0,1,2,3])
| >>> G.in_degree(0)
| 0
| >>> G.in_degree([0,1])
| {0: 0, 1: 1}
| >>> list(G.in_degree([0,1]).values())
| [0, 1]
|
| neighbors = successors(self, n)
| Return a list of successor nodes of n.
|
| neighbors() and successors() are the same function.
|
| neighbors_iter = successors_iter(self, n)
| Return an iterator over successor nodes of n.
|
| neighbors_iter() and successors_iter() are the same.
|
| out_degree(self, nbunch=None, weight=None)
| Return the out-degree of a node or nodes.
|
| The node out-degree is the number of edges pointing out of the node.
|
| Parameters
| ----------
| nbunch : iterable container, optional (default=all nodes)
| A container of nodes. The container will be iterated
| through once.
|
| weight : string or None, optional (default=None)
| The edge attribute that holds the numerical value used
| as a weight. If None, then each edge has weight 1.
| The degree is the sum of the edge weights adjacent to the node.
|
| Returns
| -------
| nd : dictionary, or number
| A dictionary with nodes as keys and out-degree as values or
| a number if a single node is specified.
|
| Examples
| --------
| >>> G = nx.DiGraph() # or MultiDiGraph
| >>> G.add_path([0,1,2,3])
| >>> G.out_degree(0)
| 1
| >>> G.out_degree([0,1])
| {0: 1, 1: 1}
| >>> list(G.out_degree([0,1]).values())
| [1, 1]
|
| predecessors(self, n)
| Return a list of predecessor nodes of n.
|
| predecessors_iter(self, n)
| Return an iterator over predecessor nodes of n.
|
| remove_node(self, n)
| Remove node n.
|
| Removes the node n and all adjacent edges.
| Attempting to remove a non-existent node will raise an exception.
|
| Parameters
| ----------
| n : node
| A node in the graph
|
| Raises
| -------
| NetworkXError
| If n is not in the graph.
|
| See Also
| --------
| remove_nodes_from
|
| Examples
| --------
| >>> G = nx.Graph() # or DiGraph, MultiGraph, MultiDiGraph, etc
| >>> G.add_path([0,1,2])
| >>> G.edges()
| [(0, 1), (1, 2)]
| >>> G.remove_node(1)
| >>> G.edges()
| []
|
| remove_nodes_from(self, nbunch)
| Remove multiple nodes.
|
| Parameters
| ----------
| nodes : iterable container
| A container of nodes (list, dict, set, etc.). If a node
| in the container is not in the graph it is silently
| ignored.
|
| See Also
| --------
| remove_node
|
| Examples
| --------
| >>> G = nx.Graph() # or DiGraph, MultiGraph, MultiDiGraph, etc
| >>> G.add_path([0,1,2])
| >>> e = G.nodes()
| >>> e
| [0, 1, 2]
| >>> G.remove_nodes_from(e)
| >>> G.nodes()
| []
|
| successors(self, n)
| Return a list of successor nodes of n.
|
| neighbors() and successors() are the same function.
|
| successors_iter(self, n)
| Return an iterator over successor nodes of n.
|
| neighbors_iter() and successors_iter() are the same.
|
| ----------------------------------------------------------------------
| Methods inherited from networkx.classes.graph.Graph:
|
| __contains__(self, n)
| Return True if n is a node, False otherwise. Use the expression
| 'n in G'.
|
| Examples
| --------
| >>> G = nx.Graph() # or DiGraph, MultiGraph, MultiDiGraph, etc
| >>> G.add_path([0,1,2,3])
| >>> 1 in G
| True
|
| __getitem__(self, n)
| Return a dict of neighbors of node n. Use the expression 'G[n]'.
|
| Parameters
| ----------
| n : node
| A node in the graph.
|
| Returns
| -------
| adj_dict : dictionary
| The adjacency dictionary for nodes connected to n.
|
| Notes
| -----
| G[n] is similar to G.neighbors(n) but the internal data dictionary
| is returned instead of a list.
|
| Assigning G[n] will corrupt the internal graph data structure.
| Use G[n] for reading data only.
|
| Examples
| --------
| >>> G = nx.Graph() # or DiGraph, MultiGraph, MultiDiGraph, etc
| >>> G.add_path([0,1,2,3])
| >>> G[0]
| {1: {}}
|
| __iter__(self)
| Iterate over the nodes. Use the expression 'for n in G'.
|
| Returns
| -------
| niter : iterator
| An iterator over all nodes in the graph.
|
| Examples
| --------
| >>> G = nx.Graph() # or DiGraph, MultiGraph, MultiDiGraph, etc
| >>> G.add_path([0,1,2,3])
|
| __len__(self)
| Return the number of nodes. Use the expression 'len(G)'.
|
| Returns
| -------
| nnodes : int
| The number of nodes in the graph.
|
| Examples
| --------
| >>> G = nx.Graph() # or DiGraph, MultiGraph, MultiDiGraph, etc
| >>> G.add_path([0,1,2,3])
| >>> len(G)
| 4
|
| __str__(self)
| Return the graph name.
|
| Returns
| -------
| name : string
| The name of the graph.
|
| Examples
| --------
| >>> G = nx.Graph(name='foo')
| >>> str(G)
| 'foo'
|
| add_cycle(self, nodes, **attr)
| Add a cycle.
|
| Parameters
| ----------
| nodes: iterable container
| A container of nodes. A cycle will be constructed from
| the nodes (in order) and added to the graph.
| attr : keyword arguments, optional (default= no attributes)
| Attributes to add to every edge in cycle.
|
| See Also
| --------
| add_path, add_star
|
| Examples
| --------
| >>> G=nx.Graph() # or DiGraph, MultiGraph, MultiDiGraph, etc
| >>> G.add_cycle([0,1,2,3])
| >>> G.add_cycle([10,11,12],weight=7)
|
| add_path(self, nodes, **attr)
| Add a path.
|
| Parameters
| ----------
| nodes : iterable container
| A container of nodes. A path will be constructed from
| the nodes (in order) and added to the graph.
| attr : keyword arguments, optional (default= no attributes)
| Attributes to add to every edge in path.
|
| See Also
| --------
| add_star, add_cycle
|
| Examples
| --------
| >>> G=nx.Graph() # or DiGraph, MultiGraph, MultiDiGraph, etc
| >>> G.add_path([0,1,2,3])
| >>> G.add_path([10,11,12],weight=7)
|
| add_star(self, nodes, **attr)
| Add a star.
|
| The first node in nodes is the middle of the star. It is connected
| to all other nodes.
|
| Parameters
| ----------
| nodes : iterable container
| A container of nodes.
| attr : keyword arguments, optional (default= no attributes)
| Attributes to add to every edge in star.
|
| See Also
| --------
| add_path, add_cycle
|
| Examples
| --------
| >>> G = nx.Graph() # or DiGraph, MultiGraph, MultiDiGraph, etc
| >>> G.add_star([0,1,2,3])
| >>> G.add_star([10,11,12],weight=2)
|
| add_weighted_edges_from(self, ebunch, weight='weight', **attr)
| Add all the edges in ebunch as weighted edges with specified
| weights.
|
| Parameters
| ----------
| ebunch : container of edges
| Each edge given in the list or container will be added
| to the graph. The edges must be given as 3-tuples (u,v,w)
| where w is a number.
| weight : string, optional (default= 'weight')
| The attribute name for the edge weights to be added.
| attr : keyword arguments, optional (default= no attributes)
| Edge attributes to add/update for all edges.
|
| See Also
| --------
| add_edge : add a single edge
| add_edges_from : add multiple edges
|
| Notes
| -----
| Adding the same edge twice for Graph/DiGraph simply updates
| the edge data. For MultiGraph/MultiDiGraph, duplicate edges
| are stored.
|
| Examples
| --------
| >>> G = nx.Graph() # or DiGraph, MultiGraph, MultiDiGraph, etc
| >>> G.add_weighted_edges_from([(0,1,3.0),(1,2,7.5)])
|
| adjacency_iter(self)
| Return an iterator of (node, adjacency dict) tuples for all nodes.
|
| This is the fastest way to look at every edge.
| For directed graphs, only outgoing adjacencies are included.
|
| Returns
| -------
| adj_iter : iterator
| An iterator of (node, adjacency dictionary) for all nodes in
| the graph.
|
| See Also
| --------
| adjacency_list
|
| Examples
| --------
| >>> G = nx.Graph() # or DiGraph, MultiGraph, MultiDiGraph, etc
| >>> G.add_path([0,1,2,3])
| >>> [(n,nbrdict) for n,nbrdict in G.adjacency_iter()]
| [(0, {1: {}}), (1, {0: {}, 2: {}}), (2, {1: {}, 3: {}}), (3, {2: {}})]
|
| adjacency_list(self)
| Return an adjacency list representation of the graph.
|
| The output adjacency list is in the order of G.nodes().
| For directed graphs, only outgoing adjacencies are included.
|
| Returns
| -------
| adj_list : lists of lists
| The adjacency structure of the graph as a list of lists.
|
| See Also
| --------
| adjacency_iter
|
| Examples
| --------
| >>> G = nx.Graph() # or DiGraph, MultiGraph, MultiDiGraph, etc
| >>> G.add_path([0,1,2,3])
| >>> G.adjacency_list() # in order given by G.nodes()
| [[1], [0, 2], [1, 3], [2]]
|
| copy(self)
| Return a copy of the graph.
|
| Returns
| -------
| G : Graph
| A copy of the graph.
|
| See Also
| --------
| to_directed: return a directed copy of the graph.
|
| Notes
| -----
| This makes a complete copy of the graph including all of the
| node or edge attributes.
|
| Examples
| --------
| >>> G = nx.Graph() # or DiGraph, MultiGraph, MultiDiGraph, etc
| >>> G.add_path([0,1,2,3])
| >>> H = G.copy()
|
| degree(self, nbunch=None, weight=None)
| Return the degree of a node or nodes.
|
| The node degree is the number of edges adjacent to that node.
|
| Parameters
| ----------
| nbunch : iterable container, optional (default=all nodes)
| A container of nodes. The container will be iterated
| through once.
|
| weight : string or None, optional (default=None)
| The edge attribute that holds the numerical value used
| as a weight. If None, then each edge has weight 1.
| The degree is the sum of the edge weights adjacent to the node.
|
| Returns
| -------
| nd : dictionary, or number
| A dictionary with nodes as keys and degree as values or
| a number if a single node is specified.
|
| Examples
| --------
| >>> G = nx.Graph() # or DiGraph, MultiGraph, MultiDiGraph, etc
| >>> G.add_path([0,1,2,3])
| >>> G.degree(0)
| 1
| >>> G.degree([0,1])
| {0: 1, 1: 2}
| >>> list(G.degree([0,1]).values())
| [1, 2]
|
| has_node(self, n)
| Return True if the graph contains the node n.
|
| Parameters
| ----------
| n : node
|
| Examples
| --------
| >>> G = nx.Graph() # or DiGraph, MultiGraph, MultiDiGraph, etc
| >>> G.add_path([0,1,2])
| >>> G.has_node(0)
| True
|
| It is more readable and simpler to use
|
| >>> 0 in G
| True
|
| nbunch_iter(self, nbunch=None)
| Return an iterator of nodes contained in nbunch that are
| also in the graph.
|
| The nodes in nbunch are checked for membership in the graph
| and if not are silently ignored.
|
| Parameters
| ----------
| nbunch : iterable container, optional (default=all nodes)
| A container of nodes. The container will be iterated
| through once.
|
| Returns
| -------
| niter : iterator
| An iterator over nodes in nbunch that are also in the graph.
| If nbunch is None, iterate over all nodes in the graph.
|
| Raises
| ------
| NetworkXError
| If nbunch is not a node or or sequence of nodes.
| If a node in nbunch is not hashable.
|
| See Also
| --------
| Graph.__iter__
|
| Notes
| -----
| When nbunch is an iterator, the returned iterator yields values
| directly from nbunch, becoming exhausted when nbunch is exhausted.
|
| To test whether nbunch is a single node, one can use
| "if nbunch in self:", even after processing with this routine.
|
| If nbunch is not a node or a (possibly empty) sequence/iterator
| or None, a NetworkXError is raised. Also, if any object in
| nbunch is not hashable, a NetworkXError is raised.
|
| nodes(self, data=False)
| Return a list of the nodes in the graph.
|
| Parameters
| ----------
| data : boolean, optional (default=False)
| If False return a list of nodes. If True return a
| two-tuple of node and node data dictionary
|
| Returns
| -------
| nlist : list
| A list of nodes. If data=True a list of two-tuples containing
| (node, node data dictionary).
|
| Examples
| --------
| >>> G = nx.Graph() # or DiGraph, MultiGraph, MultiDiGraph, etc
| >>> G.add_path([0,1,2])
| >>> G.nodes()
| [0, 1, 2]
| >>> G.add_node(1, time='5pm')
| >>> G.nodes(data=True)
| [(0, {}), (1, {'time': '5pm'}), (2, {})]
|
| nodes_iter(self, data=False)
| Return an iterator over the nodes.
|
| Parameters
| ----------
| data : boolean, optional (default=False)
| If False the iterator returns nodes. If True
| return a two-tuple of node and node data dictionary
|
| Returns
| -------
| niter : iterator
| An iterator over nodes. If data=True the iterator gives
| two-tuples containing (node, node data, dictionary)
|
| Notes
| -----
| If the node data is not required it is simpler and equivalent
| to use the expression 'for n in G'.
|
| >>> G = nx.Graph() # or DiGraph, MultiGraph, MultiDiGraph, etc
| >>> G.add_path([0,1,2])
|
| Examples
| --------
| >>> G = nx.Graph() # or DiGraph, MultiGraph, MultiDiGraph, etc
| >>> G.add_path([0,1,2])
|
| >>> [d for n,d in G.nodes_iter(data=True)]
| [{}, {}, {}]
|
| nodes_with_selfloops(self)
| Return a list of nodes with self loops.
|
| A node with a self loop has an edge with both ends adjacent
| to that node.
|
| Returns
| -------
| nodelist : list
| A list of nodes with self loops.
|
| See Also
| --------
| selfloop_edges, number_of_selfloops
|
| Examples
| --------
| >>> G = nx.Graph() # or DiGraph, MultiGraph, MultiDiGraph, etc
| >>> G.add_edge(1,1)
| >>> G.add_edge(1,2)
| >>> G.nodes_with_selfloops()
| [1]
|
| number_of_nodes(self)
| Return the number of nodes in the graph.
|
| Returns
| -------
| nnodes : int
| The number of nodes in the graph.
|
| See Also
| --------
| order, __len__ which are identical
|
| Examples
| --------
| >>> G = nx.Graph() # or DiGraph, MultiGraph, MultiDiGraph, etc
| >>> G.add_path([0,1,2])
| >>> len(G)
| 3
|
| number_of_selfloops(self)
| Return the number of selfloop edges.
|
| A selfloop edge has the same node at both ends.
|
| Returns
| -------
| nloops : int
| The number of selfloops.
|
| See Also
| --------
| nodes_with_selfloops, selfloop_edges
|
| Examples
| --------
| >>> G=nx.Graph() # or DiGraph, MultiGraph, MultiDiGraph, etc
| >>> G.add_edge(1,1)
| >>> G.add_edge(1,2)
| >>> G.number_of_selfloops()
| 1
|
| order(self)
| Return the number of nodes in the graph.
|
| Returns
| -------
| nnodes : int
| The number of nodes in the graph.
|
| See Also
| --------
| number_of_nodes, __len__ which are identical
|
| size(self, weight=None)
| Return the number of edges.
|
| Parameters
| ----------
| weight : string or None, optional (default=None)
| The edge attribute that holds the numerical value used
| as a weight. If None, then each edge has weight 1.
|
| Returns
| -------
| nedges : int
| The number of edges or sum of edge weights in the graph.
|
| See Also
| --------
| number_of_edges
|
| Examples
| --------
| >>> G = nx.Graph() # or DiGraph, MultiGraph, MultiDiGraph, etc
| >>> G.add_path([0,1,2,3])
| >>> G.size()
| 3
|
| >>> G = nx.Graph() # or DiGraph, MultiGraph, MultiDiGraph, etc
| >>> G.add_edge('a','b',weight=2)
| >>> G.add_edge('b','c',weight=4)
| >>> G.size()
| 2
| >>> G.size(weight='weight')
| 6.0
|
| ----------------------------------------------------------------------
| Data descriptors inherited from networkx.classes.graph.Graph:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| name
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from networkx.classes.graph.Graph:
|
| adjlist_dict_factory = <type 'dict'>
| dict() -> new empty dictionary
| dict(mapping) -> new dictionary initialized from a mapping object's
| (key, value) pairs
| dict(iterable) -> new dictionary initialized as if via:
| d = {}
| for k, v in iterable:
| d[k] = v
| dict(**kwargs) -> new dictionary initialized with the name=value pairs
| in the keyword argument list. For example: dict(one=1, two=2)
|
| edge_attr_dict_factory = <type 'dict'>
| dict() -> new empty dictionary
| dict(mapping) -> new dictionary initialized from a mapping object's
| (key, value) pairs
| dict(iterable) -> new dictionary initialized as if via:
| d = {}
| for k, v in iterable:
| d[k] = v
| dict(**kwargs) -> new dictionary initialized with the name=value pairs
| in the keyword argument list. For example: dict(one=1, two=2)
|
| node_dict_factory = <type 'dict'>
| dict() -> new empty dictionary
| dict(mapping) -> new dictionary initialized from a mapping object's
| (key, value) pairs
| dict(iterable) -> new dictionary initialized as if via:
| d = {}
| for k, v in iterable:
| d[k] = v
| dict(**kwargs) -> new dictionary initialized with the name=value pairs
| in the keyword argument list. For example: dict(one=1, two=2)
Content source: grantjenks/pyannote-core
Similar notebooks: