Czym są "nazwane krotki" w Pythonie?

Namedtuple jest funkcją fabryczną do tworzenia klasy tuple. Z tą klasą możemy tworzyć krotki, które również można wywołać po nazwie.

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)

Jak nazywa się krotki?

Nazwa krotki to krotka.

Jest to specyficzna podklasa krotki, która jest programowo tworzona zgodnie ze specyfikacją, z nazwanymi polami i stałą długością.

To, na przykład, tworzy podklasę krotki i poza tym, że ma stałą długość (w tym przypadku trzy), może być używana wszędzie, gdzie krotka jest używana bez łamanie. Jest to znane jako substytucyjność Liskowa:

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

To tworzy:

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

Możemy go sprawdzić i użyć jego atrybutów:

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

Głębsze Wyjaśnienie

Aby zrozumieć krotki nazwane, najpierw musisz wiedzieć, co to jest krotka. Krotka jest zasadniczo niezmienną (nie można jej zmienić w pamięci) listą.

Oto jak możesz użyć zwykłej krotki:

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

Możesz rozwinąć krotkę za pomocą iterable rozpakowywanie:

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

Krotki nazwane to krotki, które umożliwiają dostęp do ich elementów Po nazwie, a nie po prostu indeksu!

Tworzysz tak nazwe:

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

Można również użyć pojedynczego ciągu znaków z nazwami oddzielonymi spacjami, nieco bardziej czytelne zastosowanie API:

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

Jak ich używać?

Możesz zrobić wszystko, co możesz zrobić (patrz wyżej), a także wykonać następujące czynności:

>>> 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')

Komentator zapytano:

W dużym skrypcie lub programie, gdzie zwykle definiuje się nazwaną krotkę?

Typy, które tworzysz za pomocą namedtuple, są w zasadzie klasami, które możesz tworzyć za pomocą łatwego skrótu. Traktuj je jak zajęcia. Zdefiniuj je na poziomie modułu, tak aby pickle i inni użytkownicy mogli je znaleźć.

Przykład roboczy na poziomie modułu globalnego:

>>> 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')

I to pokazuje brak przeszukiwania definicji:

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

Dlaczego / Kiedy powinienem używać krotek nazwanych zamiast zwykłych krotek?

Użyj ich, gdy poprawi to Twój kod, aby semantyka elementów krotki była wyrażona w Twoim kodzie. Możesz użyć ich zamiast obiektu, jeśli w przeciwnym razie użyjesz obiektu o niezmiennych atrybutach danych i bez funkcjonalności. Możesz również podklasować je, aby dodać funkcjonalność, na przykład:

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)

Dlaczego / Kiedy powinienem używać zwykłych krotek zamiast nazwanych krotki?

Prawdopodobnie byłoby regresją, aby przełączyć się z krotek nazwanych na krotki. Wstępna decyzja projektowa skupia się na tym, czy koszt dodatkowego kodu jest wart lepszej czytelności przy użyciu krotki.

Nie ma dodatkowej pamięci używanej przez krotki nazwane kontra krotki.

Czy istnieje jakiś rodzaj "nazwanej listy" (zmienna wersja nazwanej krotki)?

Szukasz albo szczelinowego obiektu, który implementuje całą funkcjonalność listy o statycznym rozmiarze lub podklasowanej, która działa jak krotka o nazwie (i w jakiś sposób blokuje listę przed zmianą rozmiaru.)

Teraz rozszerzony, a może nawet zastępowalny Liskow, przykład pierwszego:

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__)

I aby użyć, wystarczy podklasować i zdefiniować __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

Namedtuples są świetną funkcją, są idealnym kontenerem dla danych. Kiedy musisz "przechowywać" dane, używaj krotek lub słowników, takich jak:

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

Lub:

user = ("John", 20)

Podejście słownikowe jest przytłaczające, ponieważ dict są zmienne i wolniejsze niż krotki. Z drugiej strony krotki są niezmienne i lekkie, ale nie są czytelne dla dużej liczby wpisów w polach danych.

Nazwane są idealnym kompromisem dla dwóch podejść, mają wielki czytelność, lekkość i niezmienność (plus są polimorficzne!).

Nazwane krotki umożliwiają wsteczną kompatybilność z kodem, który sprawdza wersję taką jak Ta

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

Pozwalając przyszłemu kodowi być bardziej jawnym, używając tej składni

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

Namedtuple

Jest jednym z najprostszych sposobów na wyczyszczenie kodu i uczynienie go bardziej czytelnym. Sam dokumentuje to, co dzieje się w krotce. Instancje Namedtuples są tak samo wydajne w pamięci jak zwykłe krotki, ponieważ nie mają słowników poszczególnych instancji, dzięki czemu są szybsze niż słowniki.

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"

Bez nazywania każdego elementu krotki, brzmiałoby to tak:

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"

Tworzenie instancji o nazwie namedtuple jest łatwiejsze niż tworzenie słownika.

# 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

Kiedy możesz użyć namedtuple

1. jak już wspomniano, namedtuple sprawia, że rozumienie krotek jest bardzo łatwiej. Więc jeśli chcesz odwołać się do elementów w krotce, wtedy tworzenie ich jako nazwanych po prostu ma sens.
2. poza tym, że jest bardziej lekki niż słownik, nazywany również zachowuje porządek w przeciwieństwie do słownika.
3. jak w powyższym przykładzie, łatwiej jest utworzyć instancję / align = "left" / I odwołując się do przedmiotu w nazwie tuple wygląda czyściej niż słownik. p.hue zamiast p['hue'].

składnia

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

• namedtuple znajduje się w bibliotece zbiorów.
• typename: jest to nazwa nowej podklasy krotki.
• field_names: Sekwencja nazw dla każdego pola. Może to być sekwencja jak w liście ['x', 'y', 'z'] lub łańcuchu x y z (BEZ przecinków, tylko whitespace) lub x, y, z.
• rename: jeśli rename to True, niepoprawne nazwy pól są automatycznie zastąpione nazwami pozycyjnymi. Na przykład, ['abc', 'def', 'ghi','abc'] jest konwertowane na ['abc', '_1', 'ghi', '_3'], eliminując słowo kluczowe 'def' (ponieważ jest to słowo zarezerwowane do definiowania funkcji) oraz duplikat nazwy pola 'abc'.
• verbose: jeśli verbose to True, definicja klasy jest wypisywana tylko przed zbudowaniem.

Nadal możesz uzyskać dostęp do nazw domen według ich pozycji, jeśli tak zdecydujesz. p[1] == p.saturation. Nadal rozpakowuje się jak zwykła krotka.

Metody

Wszystkie zwykłe metody krotki są obsługiwane. Ex: min (), max (), len (), in, not in, concatenation ( + ), index, slice, itp. I jest kilka dodatkowych dla namedtuple. Uwaga: wszystkie zaczynają się od podkreślam. _replace, _make, _asdict.

_replace Zwraca nową instancję nazwanej krotki, zastępującą określone pola nowymi wartościami.

składnia

somenamedtuple._replace(kwargs)

przykład

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

Uwaga: nazwy pól nie są w cudzysłowach; są tutaj słowami kluczowymi. pamiętaj : krotki są niezmienne - nawet jeśli są nazwane krotkami i mają metodę _replace. _replace tworzy instancję new; nie modyfikuje oryginalna lub zastąp starą wartość. Możesz oczywiście zapisać nowy wynik do zmiennej. p = p._replace(hue=169)

_make

Tworzy nową instancję z istniejącej sekwencji lub można ją iterować.

składnia

somenamedtuple._make(iterable)

przykład

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

_asdict

Zwraca nowy OrderedDict , który mapuje nazwy pól na odpowiadające im wartości.

składnia

somenamedtuple._asdict()

przykład

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

Bibliografia: https://www.reddit.com/r/Python/comments/38ee9d/intro_to_namedtuple/

Istnieje również lista nazw, która jest podobna do nazwanej krotki, ale zmienna https://pypi.python.org/pypi/namedlist

Jak się nazywa ?

Jak sama nazwa wskazuje, namedtuple jest krotką z nazwą. W standardowym tuple uzyskujemy dostęp do elementów za pomocą indeksu, podczas gdy namedtuple pozwala użytkownikowi zdefiniować nazwę dla elementów. Jest to bardzo przydatne szczególnie w przetwarzaniu plików csv (wartości rozdzielane przecinkami) i pracy ze złożonymi i dużymi zbiorami danych, gdzie kod staje się bałagan z wykorzystaniem indeksów (nie tak pythonic).

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

Czytanie

>>>#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

Ciekawe Scenariusz w przetwarzaniu 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)

W Pythonie jest dobre użycie kontenera o nazwie krotka, może być użyty do stworzenia definicji klasy i ma Wszystkie cechy oryginalnej krotki.

Użycie nazwanej krotki zostanie bezpośrednio zastosowane do domyślnego szablonu klasy w celu wygenerowania prostej klasy, metoda ta pozwala dużo kodu poprawić czytelność i jest również bardzo wygodna przy definiowaniu klasy.

Spróbuj tego:

collections.namedtuple()

Zasadniczo, namedtuples są łatwe do tworzenia, lekkie typy obiektów. Przekształcają krotki w wygodne kontenery do prostych zadań. Z namedtuples, nie musisz używać indeksów całkowitych, aby uzyskać dostęp do elementów krotki.

Przykłady:

Kod 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

Kod 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

Wszyscy już na to odpowiedzieli, ale myślę, że mam jeszcze coś do dodania.

Namedtuple można intuicyjnie uznać za skrót do definiowania klasy.

Zobacz uciążliwy i konwencjonalny sposób definiowania 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'

Jak dla 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'