Comment convertir OrderedDict imbriqué en Dict en Python ?

Python est un langage de programmation populaire largement utilisé dans diverses applications, notamment le développement Web, la science des données et l'apprentissage automatique. Sa simplicité, sa flexibilité et sa facilité d'utilisation en font un excellent choix pour les développeurs. Une fonctionnalité qui distingue Python est la classe OrderedDict, qui est une sous-classe de dictionnaire qui mémorise l'ordre dans lequel les éléments sont insérés. Cependant, dans certains cas, nous devrons peut-être convertir le OrderedDict imbriqué en un dict normal pour un traitement ultérieur des données.

Dans ce tutoriel, nous expliquerons ce qu'est un OrderedDict imbriqué et pourquoi il est nécessaire de le convertir en un dictionnaire normal. Nous vous présenterons le processus de conversion d'un OrderedDict imbriqué en dictionnaire via une méthode récursive. Nous fournirons également des exemples de code d'utilisation et expliquerons les avantages de l'utilisation d'un dictionnaire normal au lieu d'un OrderedDict imbriqué. Passons donc à l’article suivant et apprenons-en davantage sur la conversion d’un OrderedDict imbriqué en dictionnaire.

Qu'est-ce qu'OrderedDict ?

OrderedDict est une sous-classe de dictionnaire régulier où l'ordre des éléments est conservé. Cela signifie que les éléments d'un OrderedDict sont stockés dans l'ordre dans lequel ils ont été ajoutés au dictionnaire.

Maintenant, continuons à expliquer les dictionnaires ordonnés imbriqués. Comme son nom l'indique, un dictionnaire ordonné imbriqué est un dictionnaire ordonné contenant un autre dictionnaire ordonné. Cela signifie que les valeurs du dictionnaire ordonné externe sont elles-mêmes des dictionnaires ordonnés. Il s'agit d'une structure de données utile pour représenter des données imbriquées ou hiérarchiques.

Voici un exemple de OrderedDict imbriqué :

from collections import OrderedDict

nested_odict = OrderedDict({
    'Name': 'John Doe',
    'Age': 25,
    'Contact': OrderedDict({
        'Email': 'johndoe@example.com',
        'Phone': '123-456-7890'
    }),
    'Address': OrderedDict({
        'Street': '123 Main St',
        'City': 'Anytown',
        'State': 'CA',
        'Zip': '12345'
    })
})

Dans l'exemple ci-dessus, nous avons créé un Nested OrderedDict pour représenter des informations sur une personne, notamment son nom, son âge, ses coordonnées et son adresse. Les valeurs des clés « Contact » et « Adresse » sont elles-mêmes OrderedDicts.

La structure d'un dictionnaire ordonné imbriqué peut être la suivante :

{
    'Name': 'John Doe',
    'Age': 25,
    'Contact': {
        'Email': 'johndoe@example.com',
        'Phone': '123-456-7890'
    },
    'Address': {
        'Street': '123 Main St',
        'City': 'Anytown',
        'State': 'CA',
        'Zip': '12345'
    }
}

Maintenant que nous avons compris la structure d'un dictionnaire ordonné imbriqué, comprenons comment convertir ce dictionnaire ordonné imbriqué en un dictionnaire normal en utilisant la méthode récursive.

Comment convertir OrderedDict imbriqué en dict ?

Une façon de convertir un OrderedDict imbriqué en dict consiste à utiliser la récursivité. La récursivité est une technique de programmation qui implique des appels de fonctions eux-mêmes. Dans ce cas, nous pourrions écrire une fonction qui s'appelle de manière récursive pour convertir chaque OrderedDict imbriqué en un dict normal.

Voici un exemple montrant comment convertir un OrderedDict imbriqué en dict en utilisant la récursivité :

def nested_odict_to_dict(nested_odict):
   # Convert the nested ordered dictionary into a regular dictionary and store it in the variable "result".
   result = dict(nested_odict)

   # Iterate through each key-value pair in the dictionary.
   for key, value in result.items():

       # Check if the value is an instance of the OrderedDict class.
       if isinstance(value, OrderedDict):
           # If the value is an instance of the OrderedDict class, recursively call the function on that value and store the returned dictionary in the "result" dictionary.
           result[key] = nested_odict_to_dict(value)
   return result

Dans le code ci-dessus, nous créons d'abord un dictionnaire régulier à partir d'un Nested OrderedDict à l'aide de la fonction dict() intégrée. Nous parcourons ensuite chaque paire clé-valeur du dictionnaire et vérifions si la valeur est une instance de OrderedDict. Si tel est le cas, nous appelons la même fonction de manière récursive sur cette valeur et remplaçons la valeur dans le dictionnaire d'origine par le dictionnaire régulier renvoyé.

Décomposons le code et comprenons comment il fonctionne :

result = dict(nested_odict)

Cette ligne de code crée un nouveau dictionnaire (résultat) en convertissant le dictionnaire ordonné transmis (nested_odict) en un dictionnaire normal.

for key, value in result.items():
    if isinstance(value, OrderedDict):
        result[key] = nested_odict_to_dict(value)

Cette boucle parcourt tous les éléments du dictionnaire résultant. Pour chaque paire clé-valeur, il vérifie si la valeur est un dictionnaire ordonné. Si tel est le cas, la fonction s'appelle de manière récursive, en passant le dictionnaire trié comme argument et en remplaçant les valeurs du résultat par le dictionnaire renvoyé.

Maintenant, comprenons-le à travers un exemple.

Exemple de conversion de OrderedDict imbriqué en Dict

Prenons le même Nested OrderedDict que nous avons vu auparavant et convertissons-le en un dictionnaire normal à l'aide de la fonction nested_odict_to_dict() :

from collections import OrderedDict

nested_odict = OrderedDict({
    'Name': 'John Doe',
    'Age': 25,
    'Contact': OrderedDict({
        'Email': 'johndoe@example.com',
        'Phone': '123-456-7890'
    }),
    'Address': OrderedDict({
        'Street': '123 Main St',
        'City': 'Anytown',
        'State': 'CA',
        'Zip': '12345'
    })
})

regular_dict = nested_odict_to_dict(nested_odict)
print(regular_dict)

L'extrait de code ci-dessus crée un dictionnaire ordonné imbriqué à plusieurs niveaux nested_odict et appelle une fonction nested_odict_to_dict pour le convertir en un dictionnaire imbriqué régulier. La sortie de ce code sera un dictionnaire imbriqué avec les mêmes clés et valeurs que le dictionnaire ordonné d'origine nested_odict, mais sans les garanties de commande.

Sortie

{
    'Name': 'John Doe',
    'Age': 25,
    'Contact': {
        'Email': 'johndoe@example.com',
        'Phone': '123-456-7890'
    },
    'Address': {
        'Street': '123 Main St',
        'City': 'Anytown',
        'State': 'CA',
        'Zip': '12345'
    }
}

Comme vous pouvez le voir, le Nested OrderedDict a été converti avec succès en un dictionnaire normal à l'aide de la fonction nested_odict_to_dict().

Conclusion

Dans cet article, nous avons expliqué comment convertir OrderedDict imbriqué en dict normal à l'aide de la méthode récursive. Nous avons expliqué ce qu'est OrderedDict et ce que sont les OrderedDicts imbriqués. Nous fournissons également un exemple de OrderedDict imbriqué représentant des informations personnelles. Afin de convertir le OrderedDict imbriqué en un dict régulier, nous avons utilisé la récursion pour écrire une fonction qui s'appelle elle-même pour convertir chaque OrderedDict imbriqué en un dict régulier. Nous fournissons également un exemple qui montre comment utiliser cette fonction pour convertir le OrderedDict imbriqué que nous avons créé précédemment en un dict normal. En convertissant un OrderedDict imbriqué en un dict régulier, nous pouvons simplifier le traitement des données et effectuer diverses opérations plus facilement.

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!