Python understøtter en type containerordbog kaldet ' namedtuple() 'til stede i modulet' samlinger '. I denne artikel skal vi se, hvordan man opretter en NameTuple og operationer på NamedTuple.

Hvad er NamedTuple i Python?

I Python NamedTuple er til stede inde i indsamlingsmodul . Det giver en måde at skabe simple letvægtsdatastrukturer, der ligner en klasse, men uden at det er nødvendigt at definere en fuld klasse. Ligesom ordbøger indeholder de nøgler, der er hashed til en bestemt værdi. Tværtimod understøtter den både adgang fra nøgleværdi og iteration funktionaliteten, der ordbøger mangel.

Python NamedTuple-syntaks

namedtuple(typenavn feltnavne)

• typenavn - Navnet på namedtuple.
• field_names - Listen over attributter gemt i namedtuple.

Eksempel: Kodeimplementering af NamedTuple er vist 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  

Operationer på NamedTuple

Nedenfor er de følgende handlinger, der kan udføres ved at bruge namedtuple():

• Opret en NameTuple
• Access Operations
• Konverteringsoperationer
• Yderligere operationer

Opret en NameTuple i Python

Dette opretter en ny namedtuple-klasse ved hjælp af namedtuple()-funktionen fra samlinger modul. Det første argument er navnet på den nye klasse, og det andet argument er en liste over feltnavne.

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

1 2  

Access Operations

Namedtuples i Python giver praktiske måder at få adgang til deres felter på. Nedenfor er nogle adgangshandlinger i Python til NamedTuple:

• Adgang via indeks
• Adgang via nøglenavn
• Adgang ved hjælp af getattr()

Adgang efter indeks

Attributværdierne for namedtuple() er ordnet og kan tilgås ved hjælp af indeksnummeret i modsætning til ordbøger, som ikke er tilgængelige via indeks. I dette eksempel får vi adgang til den studerendes ved at bruge 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  

Adgang via nøglenavn

Adgang med nøglenavn er også tilladt som i ordbøger. I dette eksempel bruger vi nøglenavn til at få adgang til elevens 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  

Adgang ved hjælp af getattr()

Dette er endnu en måde at få adgang til værdien ved at give namedtuple og nøgleværdi som argument. I dette eksempel bruger vi getattr() til at få adgang til elevens id i den givne 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  

Konverteringsoperationer

Namedtuples giver et par nyttige konverteringsoperationer til at arbejde med andre datatyper i Python . Nedenfor er de følgende konverteringsoperationer, der er tilvejebragt for nameduples i Python:

• Brug af _make()
• Brug af _asdict()
• Bruger ** (dobbeltstjerne) operator

Konvertering ved hjælp af _make()

Denne funktion bruges til at returnere en namedtuple() fra iterable passeret som argument. I dette eksempel bruger vi _make() til at 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')  

Konverteringsoperation ved hjælp af _asdict()

Denne funktion vender tilbage de OrderedDict() som konstrueret ud fra de tilknyttede værdier af namedtuple(). I dette eksempel bruger vi _asdict() til at konvertere inputlisten til namedtuple-instans.

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

Brug af '**' (dobbeltstjerne) operator

Denne funktion bruges til at konvertere en ordbog til namedtuple(). I dette eksempel bruger vi '**' til at konvertere inputlisten 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')  

Yderligere operationer 

Der er nogle yderligere operationer, der er tilvejebragt i Python for NamedTuples:

• _felter
• _erstatte()
• __ny__()
• __getnewargs__()

_felter

Denne dataattribut bruges til at få alle nøglenavne af det deklarerede navneområde. I dette eksempel bruger vi _fields til at få alle nøglenavne i navneområdet erklæret.

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

_erstatte()

_replace() er ligesom str.replace() men målretter navngivne felter( ændrer ikke de oprindelige værdier). I dette eksempel bruger vi _replace() til at 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 funktion returnerer en ny forekomst af Student-klassen ved at tage de værdier, som vi ønsker at tildele tasterne i den navngivne tuple. I dette eksempel bruger vi __new__() til at returnere en ny forekomst af 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 funktion returnerer den navngivne tuple som en almindelig tuple. I dette eksempel gør vi det samme ved at bruge __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. Foranderlighed : Forekomster af en klasse kan være mutable eller uforanderlige mens namedtuple tilfælde er uforanderlige.
2. Metoder : Klasser kan indeholde metoder (funktioner) mens namedtuple giver primært en måde at gemme data med navngivne felter.
3. Arv : Klasser understøtter nedarvning, hvilket tillader oprettelsen af ​​komplekse hierarkier namedtuple understøtter ikke arv.

Hvad er forskellen mellem skrevet dict og namedtuple?

1. Typekontrol : TypedDict (fra typing modul) giver typetip til ordbøger med specifikke nøgle-værdi-par, der er nyttige til typekontrol. namedtuple giver ikke typetip.
2. Foranderlighed : TypedDict forekomster kan ændres, hvilket tillader ændringer af værdierne, mens namedtuple tilfælde er uforanderlige.
3. Struktur : TypedDict bruges til at definere strukturen af ​​ordbøger med specifikke typer for hver nøgle namedtuple giver navngivne felter til tupellignende data.