Que sont les «tuples nommés» en Python?

En lisant les changements dans Python 3.1 , j'ai trouvé quelque chose de ... inattendu:

Le tuple sys.version_info est maintenant un tuple nommé :

Je n'avais jamais entendu parler de tuples nommés auparavant, et je pensais que les éléments pouvaient être indexés par des nombres (comme dans les tuples et les listes) ou par des clés (comme dans les dict). Je ne m'attendais pas à ce qu'ils puissent être indexés dans les deux sens.

Ainsi, mes questions sont:

• Quels sont les tuples nommés?
• Comment les utiliser?
• Pourquoi / quand dois-je utiliser des tuples nommés au lieu de tuples normaux?
• Pourquoi / quand dois-je utiliser des tuples normaux au lieu de tuples nommés?
• Existe-t-il une sorte de "liste nommée" (une version modifiable du tuple nommé)?

Les tuples nommés sont essentiellement des types d'objet légers et faciles à créer. Les instances de tuple nommées peuvent être référencées à l'aide d'un déréférencement de variable de type objet ou de la syntaxe de tuple standard. Ils peuvent être utilisés de la même manière que d' structautres types d'enregistrement courants, sauf qu'ils sont immuables. Ils ont été ajoutés dans Python 2.6 et Python 3.0, bien qu'il existe une recette pour l'implémentation dans Python 2.4 .

Par exemple, il est courant de représenter un point comme un tuple (x, y). Cela conduit à un code comme celui-ci:

pt1 = (1.0, 5.0)
pt2 = (2.5, 1.5)

from math import sqrt
line_length = sqrt((pt1[0]-pt2[0])**2 + (pt1[1]-pt2[1])**2)

En utilisant un tuple nommé, il devient plus lisible:

from collections import namedtuple
Point = namedtuple('Point', 'x y')
pt1 = Point(1.0, 5.0)
pt2 = Point(2.5, 1.5)

from math import sqrt
line_length = sqrt((pt1.x-pt2.x)**2 + (pt1.y-pt2.y)**2)

Cependant, les tuples nommés sont toujours rétrocompatibles avec les tuples normaux, donc les éléments suivants fonctionneront toujours:

Point = namedtuple('Point', 'x y')
pt1 = Point(1.0, 5.0)
pt2 = Point(2.5, 1.5)

from math import sqrt
# use index referencing
line_length = sqrt((pt1[0]-pt2[0])**2 + (pt1[1]-pt2[1])**2)
 # use tuple unpacking
x1, y1 = pt1

Ainsi, vous devez utiliser des tuples nommés au lieu de tuples partout où vous pensez que la notation d'objet rendra votre code plus pythonique et plus facilement lisible . Personnellement, j'ai commencé à les utiliser pour représenter des types de valeurs très simples, en particulier lors de leur transmission en tant que paramètres aux fonctions. Il rend les fonctions plus lisibles, sans voir le contexte de l'empaquetage de tuple.

De plus, vous pouvez également remplacer les classes immuables ordinaires qui n'ont pas de fonctions , seulement des champs avec elles. Vous pouvez même utiliser vos types de tuple nommés comme classes de base:

class Point(namedtuple('Point', 'x y')):
    [...]

Cependant, comme pour les tuples, les attributs des tuples nommés sont immuables:

>>> Point = namedtuple('Point', 'x y')
>>> pt1 = Point(1.0, 5.0)
>>> pt1.x = 2.0
AttributeError: can't set attribute

Si vous souhaitez pouvoir modifier les valeurs, vous avez besoin d'un autre type. Il existe une recette pratique pour les types d'enregistrement mutables qui vous permettent de définir de nouvelles valeurs pour les attributs.

>>> from rcdtype import *
>>> Point = recordtype('Point', 'x y')
>>> pt1 = Point(1.0, 5.0)
>>> pt1 = Point(1.0, 5.0)
>>> pt1.x = 2.0
>>> print(pt1[0])
    2.0

Je ne connais cependant aucune forme de "liste nommée" qui vous permette d'ajouter de nouveaux champs. Vous pouvez simplement utiliser un dictionnaire dans cette situation. Les tuples nommés peuvent être convertis en dictionnaires à l'aide de pt1._asdict()quels retours {'x': 1.0, 'y': 5.0}et peuvent être utilisés avec toutes les fonctions de dictionnaire habituelles.

Comme déjà indiqué, vous devriez vérifier la documentation pour plus d'informations à partir desquelles ces exemples ont été construits.

namedtuple est une fonction d'usine pour créer une classe de tuple. Avec cette classe, nous pouvons également créer des tuples appelables par leur nom.

import collections

#Create a namedtuple class with names "a" "b" "c"
Row = collections.namedtuple("Row", ["a", "b", "c"], verbose=False, rename=False)   

row = Row(a=1,b=2,c=3) #Make a namedtuple from the Row class we created

print row    #Prints: Row(a=1, b=2, c=3)
print row.a  #Prints: 1
print row[0] #Prints: 1

row = Row._make([2, 3, 4]) #Make a namedtuple from a list of values

print row   #Prints: Row(a=2, b=3, c=4)

Quels sont les tuples nommés?

Un tuple nommé est un tuple.

Il fait tout ce qu'un tuple peut.

Mais c'est plus qu'un simple tuple.

Il s'agit d'une sous-classe spécifique d'un tuple créé par programme selon vos spécifications, avec des champs nommés et une longueur fixe.

Cela, par exemple, crée une sous-classe de tuple, et en plus d'être de longueur fixe (dans ce cas, trois), il peut être utilisé partout où un tuple est utilisé sans rupture. Ceci est connu sous le nom de substituabilité Liskov.

Nouveau dans Python 3.6 , nous pouvons utiliser une définition de classe avectyping.NamedTuplepour créer un tuple nommé:

from typing import NamedTuple

class ANamedTuple(NamedTuple):
    """a docstring"""
    foo: int
    bar: str
    baz: list

Ce qui précède est le même que ci-dessous, sauf que ce qui précède a en outre des annotations de type et une docstring. Ce qui suit est disponible en Python 2+:

>>> from collections import namedtuple
>>> class_name = 'ANamedTuple'
>>> fields = 'foo bar baz'
>>> ANamedTuple = namedtuple(class_name, fields)

Cela l'instancie:

>>> ant = ANamedTuple(1, 'bar', [])

Nous pouvons l'inspecter et utiliser ses attributs:

>>> ant
ANamedTuple(foo=1, bar='bar', baz=[])
>>> ant.foo
1
>>> ant.bar
'bar'
>>> ant.baz.append('anything')
>>> ant.baz
['anything']

Explication plus approfondie

Pour comprendre les tuples nommés, vous devez d'abord savoir ce qu'est un tuple. Un tuple est essentiellement une liste immuable (ne peut pas être modifiée sur place en mémoire).

Voici comment utiliser un tuple standard:

>>> student_tuple = 'Lisa', 'Simpson', 'A'
>>> student_tuple
('Lisa', 'Simpson', 'A')
>>> student_tuple[0]
'Lisa'
>>> student_tuple[1]
'Simpson'
>>> student_tuple[2]
'A'

Vous pouvez développer un tuple avec un déballage itérable:

>>> first, last, grade = student_tuple
>>> first
'Lisa'
>>> last
'Simpson'
>>> grade
'A'

Les tuples nommés sont des tuples qui permettent d'accéder à leurs éléments par leur nom au lieu d'un simple index!

Vous créez un tuple nommé comme ceci:

>>> from collections import namedtuple
>>> Student = namedtuple('Student', ['first', 'last', 'grade'])

Vous pouvez également utiliser une seule chaîne avec les noms séparés par des espaces, une utilisation légèrement plus lisible de l'API:

>>> Student = namedtuple('Student', 'first last grade')

Comment les utiliser?

Vous pouvez faire tout ce que les tuples peuvent faire (voir ci-dessus) ainsi que les opérations suivantes:

>>> named_student_tuple = Student('Lisa', 'Simpson', 'A')
>>> named_student_tuple.first
'Lisa'
>>> named_student_tuple.last
'Simpson'
>>> named_student_tuple.grade
'A'
>>> named_student_tuple._asdict()
OrderedDict([('first', 'Lisa'), ('last', 'Simpson'), ('grade', 'A')])
>>> vars(named_student_tuple)
OrderedDict([('first', 'Lisa'), ('last', 'Simpson'), ('grade', 'A')])
>>> new_named_student_tuple = named_student_tuple._replace(first='Bart', grade='C')
>>> new_named_student_tuple
Student(first='Bart', last='Simpson', grade='C')

Un intervenant a demandé:

Dans un grand script ou programme, où définit-on habituellement un tuple nommé?

Les types que vous créez avec namedtuple sont essentiellement des classes que vous pouvez créer avec un raccourci facile. Traitez-les comme des cours. Définissez-les au niveau du module, afin que les cornichons et les autres utilisateurs puissent les trouver.

L'exemple de travail, au niveau du module global:

>>> from collections import namedtuple
>>> NT = namedtuple('NT', 'foo bar')
>>> nt = NT('foo', 'bar')
>>> import pickle
>>> pickle.loads(pickle.dumps(nt))
NT(foo='foo', bar='bar')

Et cela montre l'échec de la recherche de la définition:

>>> def foo():
...     LocalNT = namedtuple('LocalNT', 'foo bar')
...     return LocalNT('foo', 'bar')
... 
>>> pickle.loads(pickle.dumps(foo()))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
_pickle.PicklingError: Can't pickle <class '__main__.LocalNT'>: attribute lookup LocalNT on __main__ failed

Pourquoi / quand dois-je utiliser des tuples nommés au lieu de tuples normaux?

Utilisez-les pour améliorer votre code afin d'exprimer la sémantique des éléments de tuple dans votre code.

Vous pouvez les utiliser à la place d'un objet si vous utilisez autrement un objet avec des attributs de données immuables et aucune fonctionnalité.

Vous pouvez également les sous-classer pour ajouter des fonctionnalités, par exemple :

class Point(namedtuple('Point', 'x y')):
    """adding functionality to a named tuple"""
        __slots__ = ()
        @property
        def hypot(self):
            return (self.x ** 2 + self.y ** 2) ** 0.5
        def __str__(self):
            return 'Point: x=%6.3f  y=%6.3f  hypot=%6.3f' % (self.x, self.y, self.hypot)

Pourquoi / quand dois-je utiliser des tuples normaux au lieu de tuples nommés?

Ce serait probablement une régression pour passer de l'utilisation de tuples nommés à des tuples. La décision de conception initiale se concentre sur la question de savoir si le coût du code supplémentaire impliqué vaut la lisibilité améliorée lorsque le tuple est utilisé.

Il n'y a pas de mémoire supplémentaire utilisée par les tuples nommés par rapport aux tuples.

Existe-t-il une sorte de "liste nommée" (une version modifiable du tuple nommé)?

Vous recherchez un objet à fente qui implémente toutes les fonctionnalités d'une liste de taille statique ou une liste de sous-classes qui fonctionne comme un tuple nommé (et qui empêche en quelque sorte la liste de changer de taille.)

Un exemple maintenant étendu, et peut-être même substituable par Liskov, du premier:

from collections import Sequence

class MutableTuple(Sequence): 
    """Abstract Base Class for objects that work like mutable
    namedtuples. Subclass and define your named fields with 
    __slots__ and away you go.
    """
    __slots__ = ()
    def __init__(self, *args):
        for slot, arg in zip(self.__slots__, args):
            setattr(self, slot, arg)
    def __repr__(self):
        return type(self).__name__ + repr(tuple(self))
    # more direct __iter__ than Sequence's
    def __iter__(self): 
        for name in self.__slots__:
            yield getattr(self, name)
    # Sequence requires __getitem__ & __len__:
    def __getitem__(self, index):
        return getattr(self, self.__slots__[index])
    def __len__(self):
        return len(self.__slots__)

Et pour l'utiliser, il suffit de sous-classer et de définir __slots__:

class Student(MutableTuple):
    __slots__ = 'first', 'last', 'grade' # customize 


>>> student = Student('Lisa', 'Simpson', 'A')
>>> student
Student('Lisa', 'Simpson', 'A')
>>> first, last, grade = student
>>> first
'Lisa'
>>> last
'Simpson'
>>> grade
'A'
>>> student[0]
'Lisa'
>>> student[2]
'A'
>>> len(student)
3
>>> 'Lisa' in student
True
>>> 'Bart' in student
False
>>> student.first = 'Bart'
>>> for i in student: print(i)
... 
Bart
Simpson
A

Les nommés sont une excellente fonctionnalité, ils sont un conteneur parfait pour les données. Lorsque vous devez "stocker" des données, vous utilisez des tuples ou des dictionnaires, comme:

user = dict(name="John", age=20)

ou:

user = ("John", 20)

L'approche par dictionnaire est écrasante, car les dicts sont mutables et plus lents que les tuples. En revanche, les tuples sont immuables et légers mais manquent de lisibilité pour un grand nombre d'entrées dans les champs de données.

les nommés sont le compromis parfait pour les deux approches, elles ont une grande lisibilité, légèreté et immuabilité (en plus elles sont polymorphes!).

les tuples nommés permettent une compatibilité descendante avec le code qui vérifie la version comme celle-ci

>>> sys.version_info[0:2]
(3, 1)

tout en permettant au futur code d'être plus explicite en utilisant cette syntaxe

>>> sys.version_info.major
3
>>> sys.version_info.minor
1

namedtuple

est l'un des moyens les plus simples de nettoyer votre code et de le rendre plus lisible. Il auto-documente ce qui se passe dans le tuple. Les instances de namedtuples sont aussi efficaces en mémoire que les tuples ordinaires car elles n'ont pas de dictionnaires par instance, ce qui les rend plus rapides que les dictionnaires.

from collections import namedtuple

Color = namedtuple('Color', ['hue', 'saturation', 'luminosity'])

 p = Color(170, 0.1, 0.6)
 if p.saturation >= 0.5:
     print "Whew, that is bright!"
 if p.luminosity >= 0.5:
     print "Wow, that is light"

Sans nommer chaque élément du tuple, il se lirait comme suit:

p = (170, 0.1, 0.6)
if p[1] >= 0.5:
    print "Whew, that is bright!"
if p[2]>= 0.5:
   print "Wow, that is light"

Il est tellement plus difficile de comprendre ce qui se passe dans le premier exemple. Avec un tuple nommé, chaque champ a un nom. Et vous y accédez par nom plutôt que par position ou index. Au lieu de p[1], nous pouvons l'appeler p.saturation. C'est plus facile à comprendre. Et ça a l'air plus propre.

Il est plus facile de créer une instance du nomméuple que de créer un dictionnaire.

# dictionary
>>>p = dict(hue = 170, saturation = 0.1, luminosity = 0.6)
>>>p['hue']
170

#nametuple
>>>from collections import namedtuple
>>>Color = namedtuple('Color', ['hue', 'saturation', 'luminosity'])
>>>p = Color(170, 0.1, 0.6)
>>>p.hue
170

Quand pourriez-vous utiliser namedtuple

1. Comme nous venons de le dire, le tuple nommé facilite la compréhension des tuples. Donc, si vous avez besoin de référencer les éléments dans le tuple, les créer en tant que tuples nommés est tout à fait logique.
2. En plus d'être plus léger qu'un dictionnaire, namedtuple conserve également l'ordre contrairement au dictionnaire.
3. Comme dans l'exemple ci-dessus, il est plus simple de créer une instance de namedtuple que de dictionary. Et référencer l'élément dans le tuple nommé semble plus propre qu'un dictionnaire. p.hueplutôt que p['hue'].

La syntaxe

collections.namedtuple(typename, field_names[, verbose=False][, rename=False])

• namedtuple est dans la bibliothèque des collections.
• typename: il s'agit du nom de la nouvelle sous-classe de tuple.
• field_names: une séquence de noms pour chaque champ. Cela peut être une séquence comme dans une liste ['x', 'y', 'z']ou une chaîne x y z(sans virgule, juste un espace) oux, y, z .
• renommer: si renommer est True, les noms de champs invalides sont automatiquement remplacés par des noms de position. Par exemple, ['abc', 'def', 'ghi','abc']est converti en ['abc', '_1', 'ghi', '_3'], éliminant le mot-clé 'def'(puisque c'est un mot réservé pour définir les fonctions) et le nom de champ en double'abc' .
• verbose: si verbose est True, la définition de classe est imprimée juste avant d'être construite.

Vous pouvez toujours accéder aux couples nommés par leur position, si vous le souhaitez. p[1] == p.saturation. Il déballe toujours comme un tuple ordinaire.

Les méthodes

Toutes les méthodes de tuple standard sont prises en charge. Ex: min (), max (), len (), in, not in, concaténation (+), index, slice, etc. Et il y en a quelques autres pour namedtuple. Remarque: tout cela commence par un trait de soulignement. _replace, _make, _asdict.

_replace Renvoie une nouvelle instance du tuple nommé remplaçant les champs spécifiés par de nouvelles valeurs.

La syntaxe

somenamedtuple._replace(kwargs)

Exemple

>>>from collections import namedtuple

>>>Color = namedtuple('Color', ['hue', 'saturation', 'luminosity'])
>>>p = Color(170, 0.1, 0.6)

>>>p._replace(hue=87)
Color(87, 0.1, 0.6)

>>>p._replace(hue=87, saturation=0.2)
Color(87, 0.2, 0.6)

Remarque : les noms de champ ne sont pas entre guillemets; ce sont des mots-clés ici. Rappelez - vous : les tuples sont immuables - même s'ils sont nommés tuples et ont la _replaceméthode. Le _replaceproduit une newinstance; il ne modifie pas l'original ni ne remplace l'ancienne valeur. Vous pouvez bien sûr enregistrer le nouveau résultat dans la variable.p = p._replace(hue=169)

_make

Rend une nouvelle instance à partir d'une séquence existante ou itérable.

La syntaxe

somenamedtuple._make(iterable)

Exemple

 >>>data = (170, 0.1, 0.6)
 >>>Color._make(data)
Color(hue=170, saturation=0.1, luminosity=0.6)

>>>Color._make([170, 0.1, 0.6])  #the list is an iterable
Color(hue=170, saturation=0.1, luminosity=0.6)

>>>Color._make((170, 0.1, 0.6))  #the tuple is an iterable
Color(hue=170, saturation=0.1, luminosity=0.6)

>>>Color._make(170, 0.1, 0.6) 
Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
    File "<string>", line 15, in _make
TypeError: 'float' object is not callable

Que s'est-il passé avec le dernier? L'élément entre parenthèses doit être l'itérable. Ainsi, une liste ou un tuple à l'intérieur de la parenthèse fonctionne, mais la séquence de valeurs sans entourer comme un itérable renvoie une erreur.

_asdict

Renvoie un nouveau OrderedDict qui mappe les noms de champ à leurs valeurs correspondantes.

La syntaxe

somenamedtuple._asdict()

Exemple

 >>>p._asdict()
OrderedDict([('hue', 169), ('saturation', 0.1), ('luminosity', 0.6)])

Référence : https://www.reddit.com/r/Python/comments/38ee9d/intro_to_namedtuple/

Il existe également une liste nommée qui est similaire à un tuple nommé mais mutable https://pypi.python.org/pypi/namedlist

Qu'est-ce qui est nommé tuple?

Comme son nom l'indique, namedtuple est un tuple avec un nom. Dans le tuple standard, nous accédons aux éléments à l'aide de l'index, tandis que namedtuple permet à l'utilisateur de définir le nom des éléments. Ceci est très pratique, en particulier pour le traitement de fichiers csv (valeurs séparées par des virgules) et pour travailler avec des ensembles de données complexes et volumineux, où le code devient compliqué avec l'utilisation d'indices (pas si pythoniques).

Comment les utiliser?

>>>from collections import namedtuple
>>>saleRecord = namedtuple('saleRecord','shopId saleDate salesAmout totalCustomers')
>>>
>>>
>>>#Assign values to a named tuple 
>>>shop11=saleRecord(11,'2015-01-01',2300,150) 
>>>shop12=saleRecord(shopId=22,saleDate="2015-01-01",saleAmout=1512,totalCustomers=125)

En train de lire

>>>#Reading as a namedtuple
>>>print("Shop Id =",shop12.shopId)
12
>>>print("Sale Date=",shop12.saleDate)
2015-01-01
>>>print("Sales Amount =",shop12.salesAmount)
1512
>>>print("Total Customers =",shop12.totalCustomers)
125

Scénario intéressant dans le traitement CSV:

from csv import reader
from collections import namedtuple

saleRecord = namedtuple('saleRecord','shopId saleDate totalSales totalCustomers')
fileHandle = open("salesRecord.csv","r")
csvFieldsList=csv.reader(fileHandle)
for fieldsList in csvFieldsList:
    shopRec = saleRecord._make(fieldsList)
    overAllSales += shopRec.totalSales;

print("Total Sales of The Retail Chain =",overAllSales)

En Python, à l'intérieur, il existe une bonne utilisation du conteneur appelé tuple nommé, il peut être utilisé pour créer une définition de classe et possède toutes les fonctionnalités du tuple d'origine.

L'utilisation de tuple nommé sera directement appliquée au modèle de classe par défaut pour générer une classe simple, cette méthode permet à beaucoup de code d'améliorer la lisibilité et elle est également très pratique lors de la définition d'une classe.

Une autre façon (une nouvelle façon) d'utiliser le tuple nommé est d'utiliser NamedTuple à partir du package de saisie: Tapez les astuces dans namedtuple

Prenons l'exemple de la première réponse dans ce post pour voir comment l'utiliser.

(1) Avant d'utiliser le tuple nommé, le code est le suivant:

pt1 = (1.0, 5.0)
pt2 = (2.5, 1.5)

from math import sqrt
line_length = sqrt((pt1[0]-pt2[0])**2 + (pt1[1]-pt2[1])**2)
print(line_length)

(2) Maintenant, nous utilisons le tuple nommé

from typing import NamedTuple, Number

héritez de la classe NamedTuple et définissez le nom de la variable dans la nouvelle classe. test est le nom de la classe.

class test(NamedTuple):
x: Number
y: Number

créer des instances à partir de la classe et leur attribuer des valeurs

pt1 = test(1.0, 5.0)   # x is 1.0, and y is 5.0. The order matters
pt2 = test(2.5, 1.5)

utiliser les variables des instances pour calculer

line_length = sqrt((pt1.x-pt2.x)**2 + (pt1.y-pt2.y)**2)
print(line_length)

Essaye ça:

collections.namedtuple()

Fondamentalement, il namedtuplesest facile de créer des types d'objets légers. Ils transforment les tuples en conteneurs pratiques pour des tâches simples. Avec namedtuples, vous n'avez pas besoin d'utiliser des indices entiers pour accéder aux membres d'un tuple.

Exemples:

Code 1:

>>> from collections import namedtuple

>>> Point = namedtuple('Point','x,y')

>>> pt1 = Point(1,2)

>>> pt2 = Point(3,4)

>>> dot_product = ( pt1.x * pt2.x ) +( pt1.y * pt2.y )

>>> print dot_product
11

Code 2:

>>> from collections import namedtuple

>>> Car = namedtuple('Car','Price Mileage Colour Class')

>>> xyz = Car(Price = 100000, Mileage = 30, Colour = 'Cyan', Class = 'Y')

>>> print xyz

Car(Price=100000, Mileage=30, Colour='Cyan', Class='Y')
>>> print xyz.Class
Y

Tout le monde y a déjà répondu, mais je pense que j'ai encore quelque chose à ajouter.

Namedtuple pourrait être intuitivement considéré comme un raccourci pour définir une classe.

Découvrez une manière lourde et conventionnelle de définir a class.

class Duck:
    def __init__(self, color, weight):
        self.color = color
        self.weight = weight
red_duck = Duck('red', '10')

    In [50]: red_duck
    Out[50]: <__main__.Duck at 0x1068e4e10>
    In [51]: red_duck.color
    Out[51]: 'red'

Pour ce qui est de namedtuple

from collections import namedtuple
Duck = namedtuple('Duck', ['color', 'weight'])
red_duck = Duck('red', '10')

In [54]: red_duck
Out[54]: Duck(color='red', weight='10')
In [55]: red_duck.color
Out[55]: 'red'