Ajout de Nœuds

Pour ajouter des nœuds à un graphe existant, vous pouvez utiliser les méthodes suivantes :

• add_node() : Ajoute un nœud unique.
• add_nodes_from() : Ajoute une collection de nœuds.

# Ajout d'un nœud individuel
G.add_node(2)
G.add_node('a')

# Ajout d'une liste de nœuds
G.add_nodes_from([1, 2, 3, 'a', 'b', 'c'])
   

Ajout d'Arêtes

Les arêtes peuvent être ajoutées de manière similaire :

• add_edge() : Ajoute une arête unique entre deux nœuds.
• add_edges_from() : Ajoute une collection d'arêtes.

# Ajout d'une arête unique
G.add_edge('a', 'b')

# Ajout d'une liste d'arêtes
G.add_edges_from([('b', 'c'), ('a', 'd')])
   

Consulattion des Propriétés du Graphe

Informations sur les Nœuds

• number_of_nodes() ou order() : Retourne le nombre total de nœuds.
• nodes() : Renvoie un itérateur sur tous les nœuds du graphe.
• node in G : Vérifie la présence d'un nœud spécifique.

# Nombre de nœuds
nombre_noeuds = G.number_of_nodes()
# Tous les nœuds
liste_noeuds = list(G.nodes())
# Vérification d'un nœud
est_present = 'n' in G
   

Informations sur les Arêtes

• number_of_edges() : Retourne le nombre total d'arêtes.
• edges() : Renvoie un itérateur sur toutes les arêtes du graphe.

# Nombre d'arêtes
nombre_aretes = G.number_of_edges()
# Toutes les arêtes
liste_aretes = list(G.edges())
   

Calcul du Degré

• nx.degree(G) : Renvoie le degré de tous les nœuds.
• nx.degree(G, node) : Renvoie le degré d'un nœud spécifique.
• nx.degree_histogram(G) : Fournit une distribution des degrés.

# Degrés de tous les nœuds
degres = nx.degree(G)
# Degré d'un nœud spécifique
degre_a = nx.degree(G, 'a')
# Histogramme des degrés
histogramme_degres = nx.degree_histogram(G)
   

Densité du Graphe

La densité mesure le ratio des arêtes présentes par rapport au nombre maximal possible.

# Calcul de la densité
densite_graphe = nx.density(G)
   

Informations Générales

nx.info(G) fournit un résumé des propriétés du graphe.

Graphes Orientés et Non Orientés

• nx.is_directed(G) : Vérifie si le graphe est orienté.
• nx.to_directed(G) : Convertit un graphe en sa représentation orientée.
• nx.to_undirected(G) : Convertit un graphe en sa représentation non orientée.

# Vérifier si orienté
est_oriente = nx.is_directed(G)
# Conversion en orienté
G_oriente = nx.to_directed(G)
# Conversion en non orienté
G_non_oriente = nx.to_undirected(G)
   

Graphes Vides

• nx.is_empty(G) : Détermine si le graphe ne contient aucun nœud ni arête.
• nx.create_empty_copy(G) : Crée une copie du graphe sans aucune arête.

# Vérifier si vide
est_vide = nx.is_empty(G)
# Copie vide
G_copie_vide = nx.create_empty_copy(G)
   

Voisinage des Nœuds

• nx.neighbors(G, node) : Renvoie les voisins directs d'un nœud.
• nx.non_neighbors(G, node) : Renvoie les nœuds qui ne sont pas des voisins directs.
• nx.common_neighbors(G, node1, node2) : Trouve les voisins communs entre deux nœuds.

# Voisins de 'a'
voisins_a = list(nx.neighbors(G, 'a'))
# Non-voisins de 'a'
non_voisins_a = list(nx.non_neighbors(G, 'a'))
# Voisins communs entre 'a' et 'c'
voisins_communs = list(nx.common_neighbors(G, 'a', 'c'))
   

Sous-graphes

• nx.subgraph(G, nodes) : Crée un sous-graphe induit par un ensemble de nœuds.
• G.edge_subgraph(edges) : Crée un sous-graphe induit par un ensemble d'arêtes.

# Sous-graphe induit par des nœuds
G_sous_noeuds = nx.subgraph(G_complexe, ['a', 'b', 'c'])

# Sous-graphe induit par des arêtes
# Création d'un chemin pour l'exemple
G_chemin = nx.path_graph(['a', 'b', 'c', 'd', 'e'])
G_sous_aretes = G_chemin.edge_subgraph([('b', 'c'), ('d', 'e')])
   

Suppression de Nœuds et Arêtes

nx.restricted_view() permet de créer une vue filtrée du graphe.

# Création d'un cycle pour l'exemple
G_cycle = nx.cycle_graph(['a', 'b', 'c', 'd', 'e'])
# Création d'une vue restreinte (supprime le nœud 'e' et les arêtes ('c', 'd') et ('a', 'b'))
G_restreint = nx.restricted_view(G_cycle, ['e'], [('c', 'd'), ('a', 'b')])
   

Génération de Graphes

barabasi_albert_graph(n, m)

Génère un graphe selon le modèle Barabási-Albert, caractérisé par une croissance préférentielle.

• n : Nombre total de nœuds.
• m : Nombre d'arêtes à attacher à chaque nouveau nœud.
• seed : (Optionnel) Graine pour la génération aléatoire.
• initial_graph : (Optionnel) Graphe initial sur lequel construire le modèle.

Erreurs potentielles : Si m n'est pas compris entre 1 et n, ou si le nombre de nœuds du graphe initial n'est pas adéquat par rapport à m.

erdos_renyi_graph(n, p)

Génère un graphe selon le modèle d'Erdős-Rényi.

• n : Nombre de nœuds.
• p : Probabilité de création de chaque arête.
• seed : (Optionnel) Graine pour la génération aléatoire.
• directed : (Booléen, défaut False) Si True, crée un graphe orienté.

Conversions de Formats

Listes

• nx.to_dict_of_lists(G) : Convertit le graphe en un dictionnaire où les clés sont les nœuds et les valeurs sont des listes de leurs voisins.
• nx.from_dict_of_lists(d) : Crée un graphe à partir d'une représentation dictionnaire de listes.
• nx.to_edgelist(G) : Renvoie une liste d'arêtes du graphe.
• nx.from_edgelist(edgelist) : Crée un graphe à partir d'une liste d'arêtes.

Pandas

nx.to_pandas_edgelist(G)

Convertit la liste des arêtes d'un graphe NetworkX en un DataFrame Pandas.

• G : Le graphe NetworkX.
• source, target : Noms des colonnes pour les nœuds source et cible.
• nodelist : (Optionnel) Liste de nœuds à inclure.
• edge_key : (Optionnel) Nom de la colonne pour les clés d'arêtes dans les MultiGraphs.

Retourne : Un DataFrame Pandas représentant les arêtes du graphe.

# Exemple d'utilisation avec un graphe simple
G_exemple = nx.Graph([("A", "B", {"cost": 1, "weight": 7}), ("C", "E", {"cost": 9, "weight": 10})])
df_aretes = nx.to_pandas_edgelist(G_exemple, nodelist=["A", "C"])
print(df_aretes[["source", "target", "cost", "weight"]])
   

nx.from_pandas_edgelist(df, source, target, edge_attr)

Crée un graphe NetworkX à partir d'un DataFrame Pandas représentant une liste d'arêtes.

• df : Le DataFrame Pandas.
• source, target : Noms des colonnes représentent les nœuds source et cible.
• edge_attr : (Optionnel) Colonne(s) à utiliser comme attributs d'arêtes. Peut être une chaîne, une liste de chaînes, ou True pour utiliser toutes les colonnes restantes.
• create_using : (Optionnel) Type de graphe à créer (par défaut nx.Graph).
• edge_key : (Optionnel) Nom de la colonne pour les clés d'arêtes si create_using est un MultiGraph.

Exemple :

import pandas as pd
import numpy as np

# Création d'un DataFrame d'exemple
rng = np.random.RandomState(seed=5)
donnees_numeriques = rng.randint(1, 11, size=(3, 2))
noeuds_source = ["A", "B", "C"]
noeuds_cible = ["D", "A", "E"]
df_creation = pd.DataFrame(donnees_numeriques, columns=["weight", "cost"])
df_creation[0] = noeuds_source
df_creation["b"] = noeuds_cible
df_creation = df_creation[[0, "b", "weight", "cost"]] # Réordonner pour clarté

# Création du graphe
G_cree = nx.from_pandas_edgelist(df_creation, 0, "b", ["weight", "cost"])
print(f"Attribut 'weight' pour l'arête ('E', 'C'): {G_cree['E']['C']['weight']}")

# Autre exemple avec edge_attr=True
edges_df = pd.DataFrame({
   "source": [0, 1, 2],
   "target": [2, 2, 3],
   "weight": [3, 4, 5],
   "color": ["red", "blue", "blue"],
})
G_cree_attr = nx.from_pandas_edgelist(edges_df, edge_attr=True)
print(f"Attribut 'color' pour l'arête (0, 2): {G_cree_attr[0][2]['color']}")
   

Types de Graphes Fondamentaux

Graph.subgraph(nodes)

Renvoie une vue du sous-graphe induit par les nœuds spécifiés. Les modifications d'attributs sont partagées avec le graphe original.

G_original = nx.path_graph(4)
H_sous_graphe = G_original.subgraph([0, 1, 2])
print(f"Arêtes du sous-graphe: {list(H_sous_graphe.edges)}")
   

Graph.edge_subgraph(edges)

Renvoie le sous-graphe induit par un ensemble spécifique d'arêtes. Les attributs des arêtes sont conservés.