Python unterstützt eine Art Container-Wörterbuch namens „ benannttuple() 'im Modul vorhanden' Sammlungen '. In diesem Artikel erfahren Sie, wie Sie ein NameTuple und Operationen für NamedTuple erstellen.

Was ist NamedTuple in Python?

In Python NamedTuple ist im Inneren vorhanden Sammlungsmodul . Es bietet eine Möglichkeit, einfache, schlanke Datenstrukturen zu erstellen, die einer Klasse ähneln, jedoch ohne den Aufwand für die Definition einer vollständigen Klasse. Wie Wörterbücher enthalten sie Schlüssel, die auf einen bestimmten Wert gehasht werden. Im Gegenteil, es unterstützt sowohl den Zugriff über den Schlüsselwert als auch die Iteration der entsprechenden Funktionalität Wörterbücher Mangel.

Python NamedTuple-Syntax

Namedtuple(Typname Feldnamen)

• Typname – Der Name des benannten Tupels.
• field_names – Die Liste der im benannten Tupel gespeicherten Attribute.

Beispiel: Die Code-Implementierung von NamedTuple ist in dargestellt 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  

Operationen für NamedTuple

Im Folgenden sind die folgenden Vorgänge aufgeführt, die mit der Funktion „namedtuple()“ ausgeführt werden können:

• Erstellen Sie ein NameTuple
• Zugriffsoperationen
• Konvertierungsvorgänge
• Zusätzliche Operationen

Erstellen Sie ein NameTuple in Python

Dadurch wird eine neue Namedtuple-Klasse mit der Funktion Namedtuple() aus erstellt Sammlungen Modul. Das erste Argument ist der Name der neuen Klasse und das zweite Argument ist eine Liste von Feldnamen.

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

1 2  

Zugriffsoperationen

Namedtuples in Python bieten bequeme Möglichkeiten, auf ihre Felder zuzugreifen. Nachfolgend sind einige Zugriffsoperationen aufgeführt, die in Python für NamedTuple bereitgestellt werden:

• Zugriff per Index
• Zugriff über Schlüsselnamen
• Zugriff mit getattr()

Zugriff nach Index

Die Attributwerte von „namedtuple()“ sind geordnet und können über die Indexnummer aufgerufen werden, im Gegensatz zu Wörterbüchern, auf die nicht über den Index zugegriffen werden kann. In diesem Beispiel greifen wir über den Index auf die Schülerdaten zu.

   # 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  

Zugriff über Schlüsselnamen

Der Zugriff per Schlüsselname ist wie in Wörterbüchern ebenfalls zulässig. In diesem Beispiel verwenden wir keyname, um auf den Namen des Schülers zuzugreifen.

   # 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  

Zugriff mit getattr()

Dies ist eine weitere Möglichkeit, auf den Wert zuzugreifen, indem man „namedtuple“ und „key value“ als Argument angibt. In diesem Beispiel verwenden wir getattr(), um auf die Schüler-ID im angegebenen benannten Tupel zuzugreifen.

   # 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  

Konvertierungsvorgänge

Namedtuples bieten einige nützliche Konvertierungsvorgänge für die Arbeit mit anderen Datentypen Python . Nachfolgend sind die folgenden Konvertierungsvorgänge aufgeführt, die für benannte Tupel in Python bereitgestellt werden:

• Verwenden von _make()
• Verwendung von _asdict()
• Verwendung des Operators ** (Doppelstern).

Konvertierung mit _make()

Diese Funktion wird verwendet, um a zurückzugeben benannttuple() aus dem iterierbaren als Argument übergeben. In diesem Beispiel verwenden wir _make(), um die Liste „li“ in „namedtuple“ zu konvertieren.

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

Konvertierungsvorgang mit _asdict()

Diese Funktion gibt zurück Die OrderedDict() wie aus den zugeordneten Werten von namedtuple() konstruiert. In diesem Beispiel verwenden wir _asdict(), um die Eingabeliste in eine Namedtuple-Instanz zu konvertieren.

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

Verwendung des Operators „**“ (Doppelstern).

Diese Funktion wird verwendet, um ein Wörterbuch in das Namedtuple() umzuwandeln. In diesem Beispiel verwenden wir „**“, um die Eingabeliste in ein Namedtuple zu konvertieren.

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

Zusätzliche Operationen 

Es gibt einige zusätzliche Operationen, die in bereitgestellt werden Python für NamedTuples:

• _Felder
• _ersetzen()
• __neu__()
• __getnewargs__()

_Felder

Dieses Datenattribut wird zum Abrufen verwendet alle Schlüsselnamen des deklarierten Namensraums. In diesem Beispiel verwenden wir _fields, um alle Schlüsselnamen des deklarierten Namespace abzurufen.

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

_ersetzen()

_replace() ähnelt str.replace(), zielt jedoch auf benannte Felder ab (ändert die ursprünglichen Werte nicht). In diesem Beispiel verwenden wir _replace(), um einen Namen von „Nandini“ durch „Manjeet“ zu ersetzen.

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

__neu__()

Diese Funktion gibt eine neue Instanz der Student-Klasse zurück, indem sie die Werte übernimmt, die wir den Schlüsseln im benannten Tupel zuweisen möchten. In diesem Beispiel verwenden wir __new__(), um eine neue Instanz der Student-Klasse zurückzugeben.

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

Diese Funktion gibt das benannte Tupel als einfaches Tupel zurück. In diesem Beispiel machen wir dasselbe, indem wir __getnewargs__() verwenden.

   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. Wandlungsfähigkeit : Instanzen einer Klasse können währenddessen veränderlich oder unveränderlich sein namedtuple Instanzen sind unveränderlich.
2. Methoden : Klassen können Methoden (Funktionen) enthalten namedtuple Bietet in erster Linie eine Möglichkeit, Daten mit benannten Feldern zu speichern.
3. Nachlass : Klassen unterstützen die Vererbung und ermöglichen die Erstellung komplexer Hierarchien namedtuple unterstützt keine Vererbung.

Was ist der Unterschied zwischen typisiertem Diktat und benanntem Tupel?

1. Typprüfung : TypedDict (aus dem typing Modul) bietet Typhinweise für Wörterbücher mit bestimmten Schlüssel-Wert-Paaren, die für die Typprüfung nützlich sind. namedtuple stellt keine Typhinweise bereit.
2. Wandlungsfähigkeit : TypedDict Instanzen sind veränderbar und ermöglichen Änderungen an den Werten während namedtuple Instanzen sind unveränderlich.
3. Struktur : TypedDict wird verwendet, um die Struktur von Wörterbüchern mit spezifischen Typen für jeden Schlüssel zu definieren namedtuple stellt benannte Felder für tupelartige Daten bereit.