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() :

• 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 :

• 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é.

   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 en namedtuple les instances sont immuables.
2. Méthodes : Les classes peuvent contenir des méthodes (fonctions) tandis que namedtuple fournit 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 que namedtuple ne 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 le typing module) fournit des astuces de type pour les dictionnaires avec des paires clé-valeur spécifiques utiles pour la vérification de type. namedtuple ne fournit pas d'indications de type.
2. Mutabilité : TypedDict les instances sont mutables, permettant de modifier les valeurs pendant namedtuple les instances sont immuables.
3. Structure : TypedDict est utilisé pour définir la structure des dictionnaires avec des types spécifiques pour chaque clé alors que namedtuple fournit des champs nommés pour les données de type tuple.