Que sont les “uplets nommé” en Python?

Nommé tuples sont fondamentalement facile à créer, léger types d'objet. Nommé tuple instances peuvent être référencés à l'aide de l'objet comme variable de déférence ou de la norme n-uplet de la syntaxe. Ils peuvent être utilisés de la même manière à struct ou d'autres types d'enregistrements, à l'exception qu'ils sont immuables. Ils ont été ajoutés dans la version 2.6 de Python et Python 3.0, mais il est recette pour la mise en œuvre en Python 2.4.

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

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)

À l'aide d'un nommé tuple 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, nommé n-uplets sont toujours compatible avec la normale de n-uplets, donc la suite sera encore du travail:

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 uplets nommé à la place de n-uplets n'importe où vous pensez object notation permet de rendre votre code plus pythonic et plus facilement lisible. Personnellement, j'ai commencé à les utiliser pour représenter très simple des types de valeur, en particulier lorsque les passant en paramètres de fonctions. Il rend les fonctions plus lisible, sans voir le contexte de la n-uplet d'emballage.

En outre, vous pouvez également remplacer ordinaire immuable classes qui n'ont pas de fonctions, seuls les champs avec eux. Vous pouvez même utiliser votre nommée tuple types de classes de base:

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

Cependant, comme avec n-uplets, les attributs nommés tuples sont immuables:

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

Si vous voulez être en mesure de modifier les valeurs, vous avez besoin d'un autre type. Il y a une recette pratique pour mutable recordtypes 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 suis pas au courant de toute forme de "liste" qui vous permet d'ajouter de nouveaux champs, cependant. Vous pouvez utiliser un dictionnaire dans cette situation. Nommé tuples peuvent être convertis à l'aide de dictionnaires pt1._asdict() qui renvoie {'x': 1.0, 'y': 5.0} et peut être utilisé avec tous les habituelles fonctions de dictionnaire.

Comme l'a déjà noté, vous devriez consultez la documentation pour plus d'information à partir de laquelle ces exemples ont été construits.

Ce que sont nommés les tuples?

Un nommé n-uplet est un n-uplet.

Il fait tout ce qu'un n-uplet peut.

Mais il est plus que juste un n-uplet.

C'est une sous-classe spécifique d'un tuple qui est créé par programmation à votre cahier des charges, avec le nom des champs et une longueur fixe.

Ce, 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 n-uplet est utilisé sans les casser. Ceci est connu comme Liskov substituabilité:

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

Ce instancie c':

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

Nous pouvons 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

À comprendre nommé tuples, vous devez d'abord savoir ce qu'est un n-uplet est. Un tuple est essentiellement immuable (ne peut pas être modifié sur place en mémoire) de la liste.

Voici comment vous pourriez utiliser un tuple:

>>> 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 itérable déballage:

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

Nommé tuples sont des n-uplets qui permettent à leurs éléments pour être accessible par un nom au lieu de simplement l'index!

Vous faire un namedtuple comme ceci:

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

Vous pouvez également utiliser une chaîne unique avec les noms séparés par des espaces, un peu plus lisible utilisation de l'API:

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

Comment les utiliser?

Vous pouvez tout faire tuples peuvent le faire (voir ci-dessus) ainsi que d'effectuer 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 une grande script ou d'un programme, d'où l'habitude de définir un nom de tuple?

Les types que vous créez avec namedtuple sont essentiellement des classes que vous pouvez créer avec un simple raccourci. Les traiter comme des classes. Définir le niveau de module, de sorte que les cornichons et les autres utilisateurs peuvent les trouver.

L'exemple de travail, sur le module global niveau:

>>> 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 dé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 nommé tuples au lieu de la normale n-uplets?

De les utiliser quand il améliore votre code de la sémantique des n-uplet d'éléments exprimés dans votre code. Vous pouvez les utiliser à la place d'un objet si vous autrement utiliser un objet immuable attributs de données et aucune fonctionnalité. Vous pouvez également une sous-classe 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 à la place de uplets nommé?

Il serait probablement une régression à passer de l'utilisation nommé tuples les tuples. En avance dans la conception de centres de décision de savoir si le coût de l'extra code est la valeur de l'amélioration de la lisibilité lorsque le n-uplet est utilisé.

Il n'y a pas de mémoire supplémentaire utilisé par des n-uplets rapport à n-uplets.

Est-il une sorte de "liste" (une mutable version de l'nommé tuple)?

Vous êtes à la recherche pour une fente objet qui implémente toutes les fonctionnalités d'une manière statique de la taille de la liste ou un sous-classé liste qui fonctionne comme un nom de n-uplet (et qu'en quelque sorte des blocs de la liste de changement dans la taille.)

Une étendue aujourd'hui, et peut-être même de Liskov substituables, l'exemple de la première:

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 à utiliser, il suffit de sous-classe 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

nommé tuples permettre la compatibilité ascendante avec le code qui vérifie la version comme ceci

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

tout en permettant à l'avenir de code pour être plus explicite en utilisant cette syntaxe

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

Qu'est-ce que namedtuple ?

Comme son nom l'indique, namedtuple est un tuple avec le nom. Dans standard n-uplet, nous avons accès aux éléments à l'aide de l'indice, alors que namedtuple permet à l'utilisateur de définir un nom pour les éléments. Ce qui est très pratique en particulier pour l'élaboration csv (valeurs séparées par des virgules) de travail et les dossiers complexes et vaste ensemble de données, d'où le code est incorrect avec l'utilisation d'indices (pas si pythonic).

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)

Lecture

>>>#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 en CSV Traitement :

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)

Essayez ceci:

collections.namedtuple()

Fondamentalement, namedtuples sont faciles à créer, léger types d'objet.
Ils se tournent de n-uplets en pratique des conteneurs pour des tâches simples.
Avec namedtuples, vous n'avez pas à utiliser entier indices 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 a déjà répondu, mais je pense que j'ai encore quelque chose d'autre à ajouter.

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

Voir une lourdeur et de la façon conventionnelle de définir un 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'

Comme pour 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'