Python obsługuje typ słownika kontenerowego o nazwie „ nazwana krotka() 'obecny w module' zbiory '. W tym artykule zobaczymy, jak utworzyć NameTuple i wykonać operacje na NamedTuple.

Co to jest NamedTuple w Pythonie?

W Pyton NamedTuple jest obecny wewnątrz moduł kolekcji . Umożliwia tworzenie prostych, lekkich struktur danych podobnych do klas, ale bez konieczności definiowania pełnej klasy. Podobnie jak słowniki, zawierają klucze, które są skrótem do określonej wartości. Wręcz przeciwnie, obsługuje zarówno dostęp z pary klucz-wartość, jak i iterację funkcjonalności słowniki brak.

Składnia NamedTuple w języku Python

o nazwietuple(nazwa typu nazwy_pola)

• typename — nazwa nazwanej krotki.
• nazwy_pola — lista atrybutów przechowywanych w nazwanej krotce.

Przykład: Implementacja kodu NamedTuple jest pokazana w Pyton .

   # 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  

Operacje na NamedTuple

Poniżej znajdują się następujące operacje, które można wykonać za pomocą metody Nametuple():

• Utwórz NameTuple
• Dostęp do operacji
• Operacje konwersji
• Dodatkowe operacje

Utwórz NameTuple w Pythonie

Spowoduje to utworzenie nowej klasy o nazwie nazwanej przy użyciu funkcji o nazwietuple() z pliku zbiory moduł. Pierwszym argumentem jest nazwa nowej klasy, drugim argumentem jest lista nazw pól.

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

1 2  

Dostęp do operacji

Namedtuple w Pythonie zapewniają wygodne sposoby dostępu do swoich pól. Poniżej znajdują się niektóre operacje dostępu dostępne w Pythonie dla NamedTuple:

• Dostęp według indeksu
• Dostęp według nazwy klucza
• Dostęp za pomocą getattr()

Dostęp według indeksu

Wartości atrybutów nazwanej() są uporządkowane i można uzyskać do nich dostęp za pomocą numeru indeksu, w przeciwieństwie do słowników, do których nie można uzyskać dostępu za pomocą indeksu. W tym przykładzie uzyskujemy dostęp do konta ucznia za pomocą indeksu.

   # 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  

Dostęp według nazwy klucza

Dostęp według nazwy klucza jest również dozwolony, tak jak w słownikach. W tym przykładzie używamy nazwy klucza, aby uzyskać dostęp do nazwiska ucznia.

   # 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  

Dostęp za pomocą getattr()

Jest to kolejny sposób uzyskania dostępu do wartości poprzez podanie nazwanej krotki i wartości klucza jako argumentu. W tym przykładzie używamy getattr(), aby uzyskać dostęp do identyfikatora ucznia w podanej nazwanej krotce.

   # 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  

Operacje konwersji

Namedtuple udostępniają kilka przydatnych operacji konwersji do pracy z innymi typami danych Pyton . Poniżej znajdują się następujące operacje konwersji dostępne dla nazwanych krotek w Pythonie:

• Używanie _make()
• Używanie _asdict()
• Używanie operatora ** (podwójna gwiazdka).

Konwersja przy użyciu _make()

Ta funkcja służy do zwracania a o nazwietuple() z iterowalnej przekazane jako argument. W tym przykładzie używamy _make() do konwersji listy „li” na nazwaną krotkę.

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

Operacja konwersji przy użyciu _asdict()

Ta funkcja zwraca the ZamówioneDict() skonstruowane na podstawie odwzorowanych wartości metodydtuple(). W tym przykładzie używamy _asdict() do konwersji listy wejściowej na instancję nazwaną.

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

Używanie operatora „**” (podwójna gwiazdka).

Ta funkcja służy do konwersji słownika na metodę nazwaną(). W tym przykładzie używamy „**”, aby przekonwertować listę wejściową na nazwaną krotkę.

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

Dodatkowe operacje 

Istnieją pewne dodatkowe operacje, które są dostępne w Pyton dla NamedTuples:

• _pola
• _zastępować()
• __nowy__()
• __getnewwargs__()

_pola

Ten atrybut danych służy do pobierania wszystkie nazwy klawiszy zadeklarowanej przestrzeni nazw. W tym przykładzie używamy _fields, aby uzyskać wszystkie nazwy kluczy zadeklarowanej przestrzeni nazw.

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

_zastępować()

Funkcja _replace() jest podobna do str.replace(), ale jej celem są pola nazwane (nie modyfikuje oryginalnych wartości). W tym przykładzie używamy funkcji _replace() do zamiany nazwy z „Nandini” na „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')  

__nowy__()

Funkcja ta zwraca nową instancję klasy Student, pobierając wartości, które chcemy przypisać do kluczy w nazwanej krotce. W tym przykładzie używamy __new__() w celu zwrócenia nowej instancji klasy 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')  

__getnewwargs__()

Ta funkcja zwraca nazwaną krotkę jako zwykłą krotkę. W tym przykładzie robimy to samo, używając __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. Zmienność : Instancje klasy mogą być modyfikowalne lub niezmienne while namedtuple instancje są niezmienne.
2. Metody : Klasy mogą zawierać metody (funkcje). namedtuple zapewnia przede wszystkim sposób przechowywania danych za pomocą nazwanych pól.
3. Dziedzictwo : Klasy obsługują dziedziczenie, umożliwiając tworzenie złożonych hierarchii, natomiast namedtuple nie obsługuje dziedziczenia.

Jaka jest różnica między wpisanym dyktatem a nazwaną krotką?

1. Wpisz Sprawdzanie : TypedDict (z typing moduł) udostępnia wskazówki dotyczące typów słowników z określonymi parami klucz-wartość, przydatnymi do sprawdzania typów. namedtuple nie zawiera wskazówek dotyczących typu.
2. Zmienność : TypedDict instancje są modyfikowalne, umożliwiając zmiany wartości while namedtuple instancje są niezmienne.
3. Struktura : TypedDict służy do definiowania struktury słowników z określonymi typami dla każdego klucza, natomiast namedtuple udostępnia nazwane pola dla danych przypominających krotkę.