Python støtter en type containerordbok kalt ' namedtuple() 'tilstede i modulen' samlinger '. I denne artikkelen skal vi se hvordan du oppretter en NameTuple og operasjoner på NamedTuple.

Hva er NamedTuple i Python?

I Python NamedTuple er tilstede inne i samlingsmodul . Det gir en måte å lage enkle lette datastrukturer som ligner på en klasse, men uten å måtte definere en full klasse. I likhet med ordbøker inneholder de nøkler som hashes til en bestemt verdi. Tvert imot støtter den både tilgang fra nøkkelverdi og iterasjon funksjonaliteten som ordbøker mangel.

Python NamedTuple-syntaks

namedtuple(typenavn feltnavn)

• typename - Navnet på namedtuple.
• field_names – listen over attributter som er lagret i namedtuple.

Eksempel: Kodeimplementering av NamedTuple vises i 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  

Operasjoner på NamedTuple

Nedenfor er følgende operasjoner som kan gjøres ved å bruke namedtuple():

• Lag en NameTuple
• Tilgang operasjoner
• Konverteringsoperasjoner
• Ytterligere operasjoner

Lag en NameTuple i Python

Dette oppretter en ny namedtuple-klasse ved å bruke namedtuple()-funksjonen fra samlinger modul. Det første argumentet er navnet på den nye klassen og det andre argumentet er en liste over feltnavn.

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

1 2  

Tilgang operasjoner

Namedtuples i Python gir praktiske måter å få tilgang til feltene deres på. Nedenfor er noen tilgangsoperasjoner gitt i Python for NamedTuple:

• Tilgang etter indeks
• Tilgang via nøkkelnavn
• Tilgang ved å bruke getattr()

Tilgang etter indeks

Attributtverdiene til namedtuple() er ordnet og kan nås ved å bruke indeksnummeret i motsetning til ordbøker som ikke er tilgjengelige med indeks. I dette eksemplet får vi tilgang til studentens ved å bruke indeks.

   # 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  

Tilgang via nøkkelnavn

Tilgang med nøkkelnavn er også tillatt som i ordbøker. I dette eksemplet bruker vi nøkkelnavn for å få tilgang til studentens navn.

   # 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  

Tilgang ved å bruke getattr()

Dette er enda en måte å få tilgang til verdien ved å gi namedtuple og nøkkelverdi som argument. I dette eksemplet bruker vi getattr() for å få tilgang til studentens id i den gitte namedtuple.

   # 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  

Konverteringsoperasjoner

Namedtuples gir noen nyttige konverteringsoperasjoner for å jobbe med andre datatyper i Python . Nedenfor er følgende konverteringsoperasjoner som er gitt for namedtuples i Python:

• Bruker _make()
• Bruker _asdict()
• Bruker ** (dobbeltstjerne) operator

Konvertering ved hjelp av _make()

Denne funksjonen brukes til å returnere en namedtuple() fra iterable vedtatt som argument. I dette eksemplet bruker vi _make() for å konvertere listen 'li' til namedtuple.

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

Konverteringsoperasjon ved hjelp av _asdict()

Denne funksjonen returnerer de OrderedDict() som konstruert fra de kartlagte verdiene til namedtuple(). I dette eksemplet bruker vi _asdict() for å konvertere inndatalisten til namedtuple-forekomst.

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

Bruker '**' (dobbeltstjerne) operator

Denne funksjonen brukes til å konvertere en ordbok til namedtuple(). I dette eksemplet bruker vi '**' for å konvertere inndatalisten til 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'  ]   # 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')  

Ytterligere operasjoner 

Det er noen tilleggsoperasjoner som er gitt i Python for NamedTuples:

• _felt
• _erstatt()
• __ny__()
• __getnewargs__()

_felt

Dette dataattributtet brukes til å få alle nøkkelnavnene av det deklarerte navnerommet. I dette eksemplet bruker vi _fields for å få alle nøkkelnavnene til navneområdet deklarert.

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

_erstatt()

_replace() er som str.replace() men målretter navngitte felt( endrer ikke de opprinnelige verdiene). I dette eksemplet bruker vi _replace() for å erstatte et navn fra 'Nandini' til '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')  

__ny__()

Denne funksjonen returnerer en ny forekomst av Student-klassen ved å ta verdiene som vi ønsker å tilordne tastene i den navngitte tuple. I dette eksemplet bruker vi __new__() for å returnere en ny forekomst av Student-klassen.

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

Denne funksjonen returnerer den navngitte tuppelen som en vanlig tuppel. I dette eksemplet gjør vi det samme ved å bruke __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. Foranderlighet : Forekomster av en klasse kan være mutable eller uforanderlige mens namedtuple forekomster er uforanderlige.
2. Metoder : Klasser kan inneholde metoder (funksjoner) mens namedtuple gir først og fremst en måte å lagre data med navngitte felt.
3. Arv : Klasser støtter arv som tillater opprettelse av komplekse hierarkier mens namedtuple støtter ikke arv.

Hva er forskjellen mellom skrevet dict og namedtuple?

1. Typekontroll : TypedDict (fra typing modul) gir typetips for ordbøker med spesifikke nøkkelverdi-par som er nyttige for typekontroll. namedtuple gir ikke typetips.
2. Foranderlighet : TypedDict forekomster kan endres og tillater endringer i verdiene mens namedtuple forekomster er uforanderlige.
3. Struktur : TypedDict brukes til å definere strukturen til ordbøker med spesifikke typer for hver nøkkel mens namedtuple gir navngitte felt for tuppellignende data.