Intégration efficace des données multi-fichiers à l'aide du didacticiel Pandas: IP, Mac et Port Association

Ce didacticiel montre en détail comment extraire, corréler et intégrer efficacement des données spécifiques à partir de plusieurs fichiers texte à l'aide de la bibliothèque Pandas de Python. En chargeant les données du fichier dans une dataframe et en utilisant l'opération de fusion pour effectuer des connexions internes en fonction de l'adresse IP et de l'adresse MAC, de l'implémentation finale de correspondance précise et de diffusion des informations d'association de l'IP, de l'adresse MAC et des ports correspondants à partir de fichiers provenant de différentes sources.

Description de la scène et défis

Dans les tâches quotidiennes de traitement des données, nous rencontrons souvent des scénarios où les informations doivent être extraites de plusieurs fichiers texte diffusés et les associons en fonction de certains identifiants communs. Par exemple, vous pouvez avoir un fichier contenant une liste d'adresses IP, un fichier qui enregistre la relation de mappage entre l'adresse IP et l'adresse MAC, et un fichier qui contient la relation correspondante entre l'adresse MAC et le port de commutateur. Notre objectif est de donner une liste d'adresses IP, de trouver l'adresse MAC correspondant à chaque IP, puis de trouver le port de commutateur auquel l'adresse MAC est connectée, et enfin de publier la correspondance entre IP, l'adresse MAC et le port.

La réalisation manuelle de cette tâche via l'itération du fichier et la correspondance des chaînes est non seulement inefficace, mais également complexe et sujette aux erreurs. Cette approche est presque impossible lorsque la taille du fichier augmente. Heureusement, la bibliothèque Pandas de Python fournit des structures de données puissantes (DataFrame) et des outils de manipulation de données qui peuvent simplifier considérablement ces tâches.

Présentation de la solution Pandas

Le cœur de la bibliothèque Pandas est DataFrame, qui est une structure de données tabulaire bidimensionnelle similaire à une table dans une feuille de calcul ou une base de données SQL. Pandas fournit une multitude de fonctions pour lire diverses sources de données, nettoyer, transformer, fusionner et analyser les données. Pour les problèmes d'association de données multiples, nous pouvons charger chaque fichier sous forme de dataframe, puis utiliser la méthode de fusion pour les connecter comme l'opération de jointure de SQL.

Préparation des données: Chargement du fichier à DataFrame

Tout d'abord, nous devons charger les trois fichiers texte fournis (file1.txt, file2.txt, file3.txt) dans pandas dataframe. pd.read_csv est la fonction principale pour charger des fichiers texte et peut s'adapter à divers formats de fichiers en ajustant ses paramètres.

Supposons que notre contenu de fichier soit le suivant:

file1.txt

 1.1.1.1
1.1.1.2
1.1.1.3
1.1.1.6
1.1.1.11

file2.txt

 Interface de type Addr de l'adresse du protocole (min)
Internet 1.1.1.1 5 6026.AA11.1111 A Ethernet1 / 49
Internet 1.1.1.2 - 0006.f2d2.2d2f A VLAN1
Internet 1.1.1.3 - 6026.AA33.3333 A VLAN1
Internet 1.1.1.4 0 incomplet A
Internet 1.1.1.5 0 incomplet A
Internet 1.1.1.6 64 FA16.6EDB.6666 A VLAN1
Internet 1.1.1.11 23 FA16.7E7D.7777 A VLAN1

file3.txt

 Entrées unicast
 Port de protocole de type d'adresse MAC VLAN
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 1 6026.AA11.1111 IP statique, IPX, affecté, autre commutateur
 1 0006.f2d2.2d2f IP dynamique, ipx, attribué, autre Ethernet1 / 24
 1 6026.AA33.3333 IP dynamique, ipx, affecté, autre Ethernet1 / 12
 1 FA16.6EDB.6666 IP dynamique, ipx, affecté, autre Ethernet1 / 8
 1 FA16.7E7D.7777 IP dynamique, IPX, affecté, autre Ethernet1 / 10

Maintenant, chargeons ces fichiers:

 Importer des pandas en tant que PD
Import IO # est utilisé pour simuler la lecture des fichiers. Le nom de fichier est utilisé directement dans les applications réelles # simule le contenu du fichier. Le pd.read_csv ('file_name.txt', ...)
file1_content = "" "1.1.1.1
1.1.1.2
1.1.1.3
1.1.1.6
1.1.1.11 "" "

file2_content = "" "Adresse du protocole Interface de type addr de l'adresse du protocole (min)
Internet 1.1.1.1 5 6026.AA11.1111 A Ethernet1 / 49
Internet 1.1.1.2 - 0006.f2d2.2d2f A VLAN1
Internet 1.1.1.3 - 6026.AA33.3333 A VLAN1
Internet 1.1.1.4 0 incomplet A
Internet 1.1.1.5 0 incomplet A
Internet 1.1.1.6 64 FA16.6EDB.6666 A VLAN1
Internet 1.1.1.11 23 FA16.7E7D.7777 A VLAN1 "" ""

file3_content = "" "Entrées unicast
 Port de protocole de type d'adresse MAC VLAN
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 1 6026.AA11.1111 IP statique, IPX, affecté, autre commutateur
 1 0006.f2d2.2d2f IP dynamique, ipx, attribué, autre Ethernet1 / 24
 1 6026.AA33.3333 IP dynamique, ipx, affecté, autre Ethernet1 / 12
 1 FA16.6EDB.6666 IP dynamique, ipx, affecté, autre Ethernet1 / 8
 1 FA16.7E7D.7777 IP dynamique, IPX, affecté, d'autres Ethernet1 / 10 "" "

# 1. Chargez un fichier1.txt: il n'y a qu'une seule colonne d'adresses IP, pas d'en-tête df1 = pd.read_csv (io.stringio (file1_content), en-tête = aucun, names = ['ipv4']))
Print ("DF1:")
print (df1.head ())
imprimer ("-" * 30)

# 2. Charge File2.txt: plusieurs colonnes, séparées par des espaces, avec l'en-tête de table # Utilisez SEP = R '\ S' pour correspondre à un ou plusieurs espaces en tant que délimiteurs, moteur = 'Python' prend en charge les séparateurs d'expression réguliers df2 = pd.read_csv (io.stringio ')
Print ("DF2:")
print (df2.head ())
imprimer ("-" * 30)

# 3. Charge File3.txt: plusieurs colonnes, séparées par des espaces, avec des en-têtes de table, mais la deuxième ligne est la ligne de délimiteur, vous devez sauter # skiprows = [1] sauter les lignes avec l'index 1 (c'est-à-dire la deuxième ligne)
df3 = pd.read_csv (io.stringio (file3_content), sep = r '\ s', moteur = 'python', skiprows = [1])
Print ("DF3:")
print (df3.head ())
imprimer ("-" * 30)

illustrer:

• io.stringio () est utilisé pour simuler le contenu de chaîne dans des objets de fichier pour une démonstration facile. Dans l'application réelle, remplacez directement io.stringio (...) par le chemin du fichier, tel que «file1.txt».
• En-tête = Aucun: signifie que le fichier n'a pas d'en-tête, Pandas générera des noms de colonne numériques par défaut.
• noms = ['ipv4']: spécifiez les noms de colonne pour les fichiers sans en-têtes de table.
• sep = r '\ s': utilisez des expressions régulières pour correspondre à un ou plusieurs espaces en tant que délimiteurs, ce qui convient aux cas où il existe des espaces irréguliers entre les colonnes.
• moteur = 'python': Lorsque le paramètre SEP utilise une expression régulière, vous devez spécifier moteur = 'python'.
• skiprows = [1]: sautez la deuxième ligne du fichier (ligne avec l'index 1) car c'est un séparateur.

Fonctionnement central: DataFrame Merge (fusion)

Maintenant que nous avons trois dataframes, l'étape suivante consiste à les associer. La méthode de fusion de Pandas est similaire à l'opération de jointure dans SQL, qui peut connecter deux dataframes en fonction d'une ou plusieurs touches (colonnes).

Nous effectuerons deux fusions intérieures:

1. Merge d'abord: fusionner DF1 (liste IP) avec DF2 (carte IP-MAC) et utiliser la colonne IPv4 de DF1 et la colonne d'adresse de DF2 comme touches de jointure. Cela filtrera les IPS présents dans File1 et obtiendra leurs adresses MAC correspondantes (colonne Addr) dans File2.
2. Deuxième fusion: fusionnez le résultat de la première fusion avec DF3 (Mac-Port Map) et utilisez la colonne Addr du premier résultat de fusion et la colonne d'adresse MAC du DF3 comme touches de jointure. Cela obtiendra les informations de port correspondantes.

 # First Merge: DF1 (IPv4) et DF2 (adresse)
# Left_on = 'ipv4' indique que la clé de connexion de DF1 est 'ipv4' colonne # droite_on = 'adresse' indique que la clé de connexion de DF2 est `` Adresse 'la colonne # comment =' inner 'signifie que seuls les correspondances qui existent dans les deux data right_on = "adresse")
Print ("First Merge Result (IP-MAC):")
print (fusion_df_ip_mac.head ())
imprimer ("-" * 30)

# Deuxième fusion: le résultat de la première fusion (ADDR) et DF3 (adresse MAC)
# Left_on = 'addr' indique que la clé de connexion de Merged_DF_IP_MAC est 'Addr' colonne # droite_on = 'Adresse mac' indique que la clé de connexion de DF3 est la colonne 'MACAD' Column Final_merged_df = Merged_DF_IP_MAC.MERGE (DF3, How = "Inner", Left_on = "Addr", droite ")
Print ("Résultat de fusion finale (IP-Mac-Port):")
print (final_merged_df.head ())
imprimer ("-" * 30)

Extraction et affichage des résultats

Après deux fusions, final_merged_df contient toutes les informations associées dont nous avons besoin. Maintenant, nous devons seulement sélectionner les trois colonnes de IPv4, Addr (adresse MAC) et du port, et de les imprimer au format spécifié.

 # Extraire la colonne requise result_df = final_merged_df [["ipv4", "addr", "port"]]

# Imprime le résultat final Print ("Sortie finale:")
Pour index, Row in result_df.Iterrows ():
    # .strip () est utilisé pour supprimer les éventuels espaces supplémentaires imprimer (f "ip {row ['ipv4']} addr {row ['addr']. strip ()} port {row ['port']. strip ()}")

Sortie attendue:

 IP 1.1.1.1 Addr 6026.AA11.1111 Interrupteur de port
IP 1.1.1.2 Addr 0006.f2d2.2d2f Port Ethernet1 / 24
IP 1.1.1.3 Addr 6026.AA33.3333 Port Ethernet1 / 12
IP 1.1.1.6 ADDR FA16.6EDB.6666 Port Ethernet1 / 8
IP 1.1.1.11 Addr FA16.7E7D.7777 Port Ethernet1 / 10

Exemple de code complet

 Importer des pandas en tant que PD
Importer IO

# Simuler le contenu du fichier, utilisez le nom de fichier fichier1_content = "" "1.1.1.1.1 dans l'application réelle
1.1.1.2
1.1.1.3
1.1.1.6
1.1.1.11 "" "

file2_content = "" "Adresse du protocole Interface de type addr de l'adresse du protocole (min)
Internet 1.1.1.1 5 6026.AA11.1111 A Ethernet1 / 49
Internet 1.1.1.2 - 0006.f2d2.2d2f A VLAN1
Internet 1.1.1.3 - 6026.AA33.3333 A VLAN1
Internet 1.1.1.4 0 incomplet A
Internet 1.1.1.5 0 incomplet A
Internet 1.1.1.6 64 FA16.6EDB.6666 A VLAN1
Internet 1.1.1.11 23 FA16.7E7D.7777 A VLAN1 "" ""

file3_content = "" "Entrées unicast
 Port de protocole de type d'adresse MAC VLAN
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 1 6026.AA11.1111 IP statique, IPX, affecté, autre commutateur
 1 0006.f2d2.2d2f IP dynamique, ipx, attribué, autre Ethernet1 / 24
 1 6026.AA33.3333 IP dynamique, ipx, affecté, autre Ethernet1 / 12
 1 FA16.6EDB.6666 IP dynamique, ipx, affecté, autre Ethernet1 / 8
 1 FA16.7E7D.7777 IP dynamique, IPX, affecté, d'autres Ethernet1 / 10 "" "

# 1. Chargement des données dans DataFrame
df1 = pd.read_csv (io.stringio (file1_content), en-tête = aucun, names = ['ipv4'])
df2 = pd.read_csv (io.stringio (file2_content), sep = r '\ s', moteur = 'python')
df3 = pd.read_csv (io.stringio (file3_content), sep = r '\ s', moteur = 'python', skiprows = [1])

# 2. Effectuer l'opération de fusion DataFrame # First Merge: Associez DF1 et DF2 en fonction de l'adresse IP
fusion_df_ip_mac = df1.merge (df2, comment = "inner", left_on = "ipv4", droit_on = "adresse")

#Second fusion: lié le premier résultat de fusion et DF3 selon l'adresse MAC
final_merged_df = fusion_df_ip_mac.merge (df3, comment = "inner", left_on = "addr", droit_on = "adresse MAC")

# 3. Extraire la colonne requise et formater la sortie result_df = final_merged_df [["ipv4", "addr", "port"]]

Imprimer ("Sortie finale:")
Pour index, Row in result_df.Iterrows ():
    # Use .strip () pour effacer les caractères vides avant et après les valeurs de colonne possibles imprimer (f "ip {row ['ipv4']} addr {row ['addr']. Strip ()} port {row ['port']. Strip ()}")

Notes et meilleures pratiques

1. Diversité du format de fichier: le fichier réel peut être plus complexe que l'exemple. PD.Read_csv fournit un grand nombre de paramètres (tels que Demiter, Qutechar, SkipinitialSpace, NA_Values, etc.), qui peut gérer de manière flexible divers fichiers CSV, TSV ou d'autres fichiers de délimiter.
2. Sélection de type fusion (comment paramètre):
   • Inner (par défaut): seules les correspondances qui existent dans les deux dataframes sont conservées.
   • Gauche: gardez toutes les lignes de la longueur de données gauche et faites correspondre les lignes du DataFrame droit; S'il n'y a pas de correspondance pour le bon DataFrame, remplissez NAN.
   • À droite: gardez toutes les lignes du DataFrame droit et faites correspondre les lignes du DataFrame gauche; S'il n'y a pas de correspondance pour le dataframe gauche, remplissez NAN.
   • Extérieur: Gardez toutes les lignes de deux dataframes et remplissez Nan s'il n'y a pas de correspondance d'un côté. Choisissez le bon type de fusion en fonction des besoins de votre entreprise.
3. Considérations de performances: la couche sous-jacente de Pandas est mise en œuvre en C, de sorte que ses opérations (en particulier la fusion) sont beaucoup plus rapides que les boucles Python pures sur de grands ensembles de données. Les pandas peuvent ne plus être le meilleur choix pour les données au niveau TB, et un cadre informatique distribué tel que Dask ou Pyspark peut être pris en compte.
4. Nettoyage des données: avant la fusion, assurez-vous que les types de données de colonne utilisés pour la jointure sont cohérents et qu'il n'y a pas d'espaces de leaders / de fuite ou de cas incohérent. Par exemple, vous pouvez utiliser .str.str.str () pour supprimer les espaces dans les colonnes de chaîne et utiliser .str.lower () pour effectuer l'uniformité du cas.
5. Nom de la colonne Conflit: si deuxfrèmes de données ont le même nom de colonne mais ne sont pas les clés utilisées pour la fusion, les pandas ajouteront automatiquement les suffixes _x et _y après la fusion pour les distinguer. Ces suffixes peuvent être personnalisés à l'aide du paramètre de suffixes.

Résumer

Grâce à ce tutoriel, nous avons appris à utiliser la bibliothèque Pandas pour résoudre efficacement des problèmes d'association de données multiples. La conversion des données brutes en données de données et intelligemment à l'aide des opérations de fusion rend non seulement la logique de code claire et facile à maintenir, mais améliore également considérablement l'efficacité du traitement des données. La maîtrise de cette fonction centrale des pandas apportera une grande commodité à vos tâches d'analyse et d'automatisation des données.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!