Articles

DiGraph-Graphes dirigés avec auto-boucles¶

Overview¶

classeDiGraph(incoming_graph_data=None, **attr)¶

Classe de base pour les graphes dirigés.

Un DiGraph stocke des nœuds et des arêtes avec des données optionnelles, ou attributs.

Les DiGraphes détiennent des arêtes dirigées. Les auto-boucles sont autorisées mais les arêtes multiples (parallèles) ne le sont pas.

Les nœuds peuvent être des objets Python arbitraires (hachables) avec des attributs optionnelsalkey/value. Par convention, None n’est pas utilisé comme un nœud.

Les arêtes sont représentées comme des liens entre les nœuds avec des attributs optionnelsalkey/value.

Paramètres

  • incoming_graph_data (input graph (facultatif, par défaut : None)) – Données pour initialiser le graphe. Si aucun (par défaut), un graphique vide est créé. Les données peuvent être n’importe quel format qui est supportépar la fonction to_networkx_graph(), incluant actuellement la liste d’arêtes,le dict de dicts, le dict de listes, le graphe NetworkX, la matrice NumPy ou 2d ndarray, la matrice éparse SciPy, ou le graphe PyGraphviz.

  • attr (arguments de mots-clés, facultatif (par défaut= aucun attribut)) – Attributs à ajouter au graphe comme paires clé=valeur.

See also

Graph, MultiGraph, MultiDiGraph, OrderedDiGraph

Examples

Créer une structure de graphe vide (un « graphe nul ») sans nœuds et sans arêtes.

>>> G = nx.DiGraph()

G peut être développé de plusieurs façons.

Nœuds:

Ajouter un nœud à la fois:

>>> G.add_node(1)

Ajouter les nœuds de n’importe quel conteneur (une liste, un dict, un ensemble ou même les lignes d’un fichier ou les nœuds d’un autre graphe).

>>> G.add_nodes_from()>>> G.add_nodes_from(range(100, 110))>>> H = nx.path_graph(10)>>> G.add_nodes_from(H)

En plus des chaînes et des entiers, tout objet Python hachable(sauf None) peut représenter un nœud, par exemple un objet nœud personnalisé,ou même un autre graphe.

>>> G.add_node(H)

Arêtes:

G peut également être agrandi en ajoutant des arêtes.

Ajouter une arête,

>>> G.add_edge(1, 2)

une liste d’arêtes,

>>> G.add_edges_from()

ou une collection d’arêtes,

>>> G.add_edges_from(H.edges)

Si certaines arêtes connectent des nœuds qui ne sont pas encore dans le graphe, les nœuds sont ajoutés automatiquement. Il n’y a pas d’erreur lors de l’ajout de nœuds ou d’arêtes qui existent déjà.

Attributs:

Chaque graphe, nœud et arête peut contenir des paires d’attributs clé/valeur dans un dictionnaire d’attributs associé (les clés doivent être hachables).Par défaut, ceux-ci sont vides, mais peuvent être ajoutés ou modifiés en utilisantadd_edge, add_node ou en manipulant directement les dictionnaires d’attributs nommés respectivement graphe, nœud et arête.

>>> G = nx.DiGraph(day="Friday")>>> G.graph{'day': 'Friday'}

Ajouter des attributs de nœuds en utilisant add_node(), add_nodes_from() ou G.nodes

Ajouter des attributs d’arêtes en utilisant add_edge(), add_edges_from(), subscriptnotation, ou G.edges.

Shortcuts:

Plusieurs caractéristiques communes des graphes permettent d’utiliser la syntaxe python pour accélérer les rapports.

>>> 1 in G # check if node in graphTrue>>> # iterate through nodes>>> len(G) # number of nodes in graph5

Souvent, la meilleure façon de traverser toutes les arêtes d’un graphe est via les voisins.Les voisins sont signalés comme un dict d’adjacence G.adj ou G.adjacency()

>>> for n, nbrsdict in G.adjacency():... for nbr, eattr in nbrsdict.items():... if "weight" in eattr:... # Do something useful with the edges... pass

Mais l’objet de signalement des arêtes est souvent plus pratique:

>>> for u, v, weight in G.edges(data="weight"):... if weight is not None:... # Do something useful with the edges... pass

Signalement:

Pour des détails sur ces méthodes et d’autres méthodes diverses, voir ci-dessous.

Sous-classes (avancées):

La classe Graph utilise une structure de données dict-of-dict-of-dict.Le dict extérieur (node_dict) contient des informations d’adjacence clés par nœud.Le dict suivant (adjlist_dict) représente les informations d’adjacence et contient des données d’arête clés par voisin. Le dict intérieur (edge_attr_dict) représente les données d’arête et détient les valeurs d’attribut d’arête clés par les noms d’attribut.

Chacun de ces trois dicts peut être remplacé dans une sous-classe par un objet de type dict défini par l’utilisateur. En général, les caractéristiques de type dict doivent être maintenues mais des caractéristiques supplémentaires peuvent être ajoutées. Pour remplacer l’un des dicts, créez une nouvelle classe de graphe en changeant la variable class( !) qui contient la fabrique pour cette structure de type dict. Les noms des variables sont arenode_dict_factory, node_attr_dict_factory, adjlist_inner_dict_factory,adjlist_outer_dict_factory, edge_attr_dict_factory et graph_attr_dict_factory.

node_dict_factoryfunction, (default : dict)

Fonction de fabrique à utiliser pour créer le dict contenant les attributs du nœud, clé par l’id du nœud.Elle ne doit nécessiter aucun argument et retourner un objet de type dict

node_attr_dict_factory : fonction, (default : dict)

Fonction de fabrique à utiliser pour créer le nœud attributedict qui contient les valeurs d’attributs clés par le nom de l’attribut.Il ne doit pas nécessiter d’arguments et retourner un objet de type dict

adjlist_outer_dict_factoryfunction, (default : dict)

Fonction de fabrication à utiliser pour créer le dict le plus externe dans la structure de données qui contient des informations d’adjacence clés par le nœud.Il ne doit pas nécessiter d’arguments et retourner un objet de type dict.

adjlist_inner_dict_factoryfunction, optional (default : dict)

Factory function to be used to create the adjacency listdict which holds edge data keyed by neighbor.It should require no arguments and return a dict-like object

edge_attr_dict_factoryfunction, optional (default : dict)

Factory function to be used to create the edge attributedict which holds attribute values keyed by attribute name.Il ne devrait pas nécessiter d’arguments et retourner un objet de type dict.

graph_attr_dict_factoryfunction, (default : dict)

Fonction de fabrique à utiliser pour créer le graphe attributedict qui détient des valeurs d’attributs clés par nom d’attribut.Il ne devrait pas nécessiter d’arguments et retourner un objet de type dict.

Typiquement, si votre extension n’a pas d’impact sur la structure de données, tous lesméthodes seront hérités sans problème sauf : to_directed/to_undirected.Par défaut, ces méthodes créent une classe DiGraph/Graph et vous voulez probablement qu’elles créent votre extension d’un DiGraph/Graph. Pour faciliter cela, nous définissons deux variables de classe que vous pouvez définir dans votre sous-classe.

to_directed_classcallable, (par défaut : DiGraph ou MultiDiGraph)

Classe pour créer une nouvelle structure de graphe dans la méthode to_directed.Si None, une classe NetworkX (DiGraph ou MultiDiGraph) est utilisée.

to_undirected_classcallable, (par défaut : Graph ou MultiGraph)

Classe pour créer une nouvelle structure de graphe dans la méthode to_undirected.Si None, une classe NetworkX (Graph ou MultiGraph) est utilisée.

Exemples

Créer une classe de graphe à faible mémoire qui désapprouve effectivement les attributs d’arêtes en utilisant un seul dict d’attribut pour toutes les arêtes.Cela réduit la mémoire utilisée, mais vous perdez les attributs d’arêtes.

Voir ordered pour plus d’exemples de création de sous-classes de graphe en écrasant la classe de base dict avec un objet de type dictionnaire.

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée.