Python prend en charge un type de dictionnaire de conteneurs appelé ' tuple nommé() 'présent dans le module' collections '. Dans cet article, nous allons voir comment créer un NameTuple et les opérations sur NamedTuple.

Qu’est-ce que NamedTuple en Python ?

Dans Python NamedTuple est présent à l'intérieur du module de collecte . Il fournit un moyen de créer des structures de données simples et légères similaires à une classe mais sans la surcharge liée à la définition d'une classe complète. Comme les dictionnaires, ils contiennent des clés hachées à une valeur particulière. Au contraire, il prend en charge à la fois l'accès à partir de la valeur-clé et l'itération des fonctionnalités qui dictionnaires manque.

Syntaxe Python NamedTuple

nommétuple(typename field_names)

• typename - Le nom du tuple nommé.
• field_names - La liste des attributs stockés dans le tuple nommé.

Exemple: L'implémentation du code de NamedTuple est illustrée dans Python .

# Python code to demonstrate namedtuple() from collections import namedtuple # Declaring namedtuple() Student = namedtuple('Student' ['name' 'age' 'DOB']) # Adding values S = Student('Nandini' '19' '2541997') # Access using index print('The Student age using index is : ' end='') print(S[1]) # Access using name print('The Student name using keyname is : ' end='') print(S.name) 

The Student age using index is : 19 The Student name using keyname is : Nandini 

Opérations sur NamedTuple

Vous trouverez ci-dessous les opérations suivantes qui peuvent être effectuées à l'aide denamedtuple() :

idée complète

• Créer un NameTuple
• Opérations d'accès
• Opérations de conversion
• Opérations supplémentaires

Créer un NameTuple en Python

Cela crée une nouvelle classe nomméetuple en utilisant la fonction nomméetuple() du collections module. Le premier argument est le nom de la nouvelle classe et le deuxième argument est une liste de noms de champs.

from collections import namedtuple Point = namedtuple('Point' ['x' 'y']) p = Point(x=1 y=2) print(p.x p.y) 

1 2 

Opérations d'accès

Les tuples nommés en Python offrent des moyens pratiques d'accéder à leurs champs. Vous trouverez ci-dessous quelques opérations d'accès fournies en Python pour NamedTuple :

• Accès par index
• Accès par nom de clé
• Accès en utilisant getattr()

Accès par index

Les valeurs d'attribut de nametuple() sont ordonnées et accessibles à l'aide du numéro d'index contrairement aux dictionnaires qui ne sont pas accessibles par index. Dans cet exemple, nous accédons à celui de l'étudiant en utilisant index.

# importing 'collections' for namedtuple() import collections # Declaring namedtuple() Student = collections.namedtuple('Student' ['name' 'age' 'DOB']) # Adding values S = Student('Nandini' '19' '2541997') # Access using index print('The Student age using index is : ' end='') print(S[1]) 

The Student age using index is : 19 

Accès par nom de clé

L'accès par nom de clé est également autorisé comme dans les dictionnaires. Dans cet exemple, nous utilisons keyname pour accéder au nom de l'étudiant.

# importing 'collections' for namedtuple() import collections # Declaring namedtuple() Student = collections.namedtuple('Student' ['name' 'age' 'DOB']) # Adding values S = Student('Nandini' '19' '2541997') # Access using name print('The Student name using keyname is : ' end='') print(S.name) 

The Student name using keyname is : Nandini 

Accès en utilisant getattr()

C'est encore une autre façon d'accéder à la valeur en donnant le tuple nommé et la valeur clé comme argument. Dans cet exemple, nous utilisons getattr() pour accéder à l'identifiant de l'étudiant dans le tuple nommé donné.

# importing 'collections' for namedtuple() import collections # Declaring namedtuple() Student = collections.namedtuple('Student' ['name' 'age' 'DOB']) # Adding values S = Student('Nandini' '19' '2541997') # Access using getattr() print('The Student DOB using getattr() is : ' end='') print(getattr(S 'DOB')) 

The Student DOB using getattr() is : 2541997 

Opérations de conversion

Les tuples nommés fournissent quelques opérations de conversion utiles pour travailler avec d'autres types de données dans Python . Vous trouverez ci-dessous les opérations de conversion suivantes fournies pour les tuples nommés en Python :

liste Java

• Utiliser _make()
• Utiliser _asdict()
• Utilisation de l'opérateur ** (double étoile)

Conversion à l'aide de _make()

Cette fonction est utilisée pour renvoyer un nommétuple() à partir de l'itérable passé comme argument. Dans cet exemple, nous utilisons _make() pour convertir la liste 'li' en tuple nommé.

# importing 'collections' for namedtuple() import collections # Declaring namedtuple() Student = collections.namedtuple('Student' ['name' 'age' 'DOB']) # Adding values S = Student('Nandini' '19' '2541997') # initializing iterable li = ['Manjeet' '19' '411997'] di = {'name': 'Nikhil' 'age': 19 'DOB': '1391997'} # using _make() to return namedtuple() print('The namedtuple instance using iterable is : ') print(Student._make(li)) 

The namedtuple instance using iterable is : Student(name='Manjeet' age='19' DOB='411997') 

Opération de conversion utilisant _asdict()

Cette fonction renvoie le OrderedDict() tel que construit à partir des valeurs mappées denamedtuple(). Dans cet exemple, nous utilisons _asdict() pour convertir la liste d'entrée en instance de tuple nommé.

symbole de dérivée partielle latex

import collections # Declaring namedtuple() Student = collections.namedtuple('Student' ['name' 'age' 'DOB']) # Adding values S = Student('Nandini' '19' '2541997') # initializing iterable li = ['Manjeet' '19' '411997'] # initializing dict di = {'name': 'Nikhil' 'age': 19 'DOB': '1391997'} # using _asdict() to return an OrderedDict() print('The OrderedDict instance using namedtuple is : ') print(S._asdict()) 

The OrderedDict instance using namedtuple is : OrderedDict([('name' 'Nandini') ('age' '19') ('DOB' '2541997')]) 

Utilisation de l'opérateur '**' (double étoile)

Cette fonction est utilisée pour convertir un dictionnaire en tuple nommé(). Dans cet exemple, nous utilisons '**' pour convertir la liste d'entrée en tuple nommé.

import collections # Declaring namedtuple() Student = collections.namedtuple('Student' ['name' 'age' 'DOB']) # Adding values S = Student('Nandini' '19' '2541997') # initializing iterable li = ['Manjeet' '19' '411997'] # initializing dict di = {'name': 'Nikhil' 'age': 19 'DOB': '1391997'} # using ** operator to return namedtuple from dictionary print('The namedtuple instance from dict is : ') print(Student(**di)) 

The namedtuple instance from dict is : Student(name='Nikhil' age=19 DOB='1391997') 

Opérations supplémentaires 

Certaines opérations supplémentaires sont fournies dans Python pour les tuples nommés :

• _champs
• _remplacer()
• __nouveau__()
• __getnewargs__()

_champs

Cet attribut de données est utilisé pour obtenir tous les noms clés de l'espace de noms déclaré. Dans cet exemple, nous utilisons _fields pour obtenir tous les noms de clés de l'espace de noms déclaré.

import collections Student = collections.namedtuple('Student' ['name' 'age' 'DOB']) # Adding values S = Student('Nandini' '19' '2541997') # using _fields to display all the keynames of namedtuple() print('All the fields of students are : ') print(S._fields) 

All the fields of students are : ('name' 'age' 'DOB') 

_remplacer()

_replace() est comme str.replace() mais cible les champs nommés (ne modifie pas les valeurs d'origine). Dans cet exemple, nous utilisons _replace() pour remplacer un nom de « Nandini » par « Manjeet ».

import collections # Declaring namedtuple() Student = collections.namedtuple('Student' ['name' 'age' 'DOB']) # Adding values S = Student('Nandini' '19' '2541997') # ._replace returns a new namedtuple  # it does not modify the original print('returns a new namedtuple : ') print(S._replace(name='Manjeet')) 

returns a new namedtuple : Student(name='Manjeet' age='19' DOB='2541997') 

__nouveau__()

Cette fonction renvoie une nouvelle instance de la classe Student en prenant les valeurs que nous souhaitons attribuer aux clés du tuple nommé. Dans cet exemple, nous utilisons __new__() pour renvoyer une nouvelle instance de la classe Student.

import collections # Declaring namedtuple() Student = collections.namedtuple('Student' ['name' 'age' 'DOB']) # Adding values S = Student('Nandini' '19' '2541997') # Student.__new__ returns a new instance of Student(nameageDOB) print(Student.__new__(Student'Himesh''19''26082003')) 

Student(name='Himesh' age='19' DOB='26082003') 

__getnewargs__()

Cette fonction renvoie le tuple nommé sous forme de tuple simple. Dans cet exemple, nous faisons la même chose en utilisant __getnewargs__().

import collections # Declaring namedtuple() Student = collections.namedtuple('Student' ['name' 'age' 'DOB']) # Adding values S = Student('Nandini' '19' '2541997') H=Student('Himesh''19''26082003') # .__getnewargs__ returns the named tuple as a plain tuple print(H.__getnewargs__()) 

('Himesh' '19' '26082003') 

1. Mutabilité : Les instances d'une classe peuvent être mutables ou immuables tout ennamedtupleles instances sont immuables.
2. Méthodes : Les classes peuvent contenir des méthodes (fonctions) tandis quenamedtuplefournit principalement un moyen de stocker des données avec des champs nommés.
3. Héritage : Les classes prennent en charge l'héritage permettant la création de hiérarchies complexes alors quenamedtuplene prend pas en charge l'héritage.

Quelle est la différence entre un dict typé et un tuple nommé ?

1. Vérification de type :TypedDict(depuis letypingmodule) fournit des astuces de type pour les dictionnaires avec des paires clé-valeur spécifiques utiles pour la vérification de type.namedtuplene fournit pas d'indications de type.
2. Mutabilité :TypedDictles instances sont mutables, permettant de modifier les valeurs pendantnamedtupleles instances sont immuables.
3. Structure :TypedDictest utilisé pour définir la structure des dictionnaires avec des types spécifiques pour chaque clé alors quenamedtuplefournit des champs nommés pour les données de type tuple.