Hvad er forskellen mellem calledtuple og ordbog i Python?


Svar 1:

De er dybest set ikke forbundet.

Overvej disse:

fra samlinger importeret nametuple
Point = namedtuple ('Point', ('x', 'y'))
p = Punkt (2,3)
d = dict (x = 2, y = 3)

Vi har nu en ordbog med indhold (nøgleværdipar) på 'x' som 2 og 'y' som 3 ... og et lignende "Point" med egenskaber for 'x' lig med 2 og 'y' lig med 3.

Men hvordan får vi adgang til dette indhold eller egenskaber?

Til den navngivne tuple kan vi enten bruge deres attribut / egenskabsnavn, der fås adgang til via. (dot) -operatør, som vi ville gøre for enhver anden objektattribut, metode eller egenskab: px == 2 og py == 3, eller vi kan bruge numeriske indekser og endda skiver, nøjagtigt som vi ville gøre med enhver normal tuple: p [0] == 2 og p [:] == (2,3)

Sammenlign dette med vores ordbog, hvor vi får adgang til indholdet ved hjælp af en nøgle: d [‘x’] == 2 og d [‘y’] == 3

Den navngivne tuple er uforanderlig (ligesom enhver anden tuple). Ordbogen er mutbar (vi kan tilføje yderligere nøgle / værdipar, slette taster (og deres værdier) fra den og ændre bindingen af ​​en hvilken som helst nøgle til enhver ny værdi (objekt).

Den navngivne tuple er en sekvens. Vi kan gentage dets værdier. Ordbogen understøtter iteration, men er IKKE en sekvens.

Iterering over en ordbog giver en liste over dens nøgler. Vi kan også iterere over dens værdier ved hjælp af en af ​​dens metoder (dict.values ​​()), eller vi kan iterere over dens nøgleværdipar ved hjælp af dets .items () -metode (for k, v i somedict.items (): ...).

Fordi navngivne tuples implementeres ved hjælp af Python “egenskaber”, har forekomster af sådanne objekter en .__ slots__ attribut. Ordbøger er en indbygget Python-type. De har hverken en "slots" eller en .__ dict__ attribut.

Du kan implementere dine egne lette genstande ved hjælp af noget som:

klasse LightWeight:
    passere

foo = LightWeight ()
foo.x = 2
foo.y = 3

Normale brugerdefinerede klasseforekomster er forbundet med deres eget .__ dict__-objekt, som internt er, hvordan Python administrerer deres attributter. Selvom dette tillader betydelig fleksibilitet og endda monkey patch, pådrager det sig også hukommelse og udførelsesomkostninger. Samlinger af tusinder af lignende objekter (ved hjælp af standard Python klasse / instans semantik) vil tage betydeligt mere hukommelse end et lignende antal tuples, navngivne tuples eller forekomster af andre objekter defineret ved hjælp af Pythons “egenskaber” -funktioner. Adgang til attributter vil også tage længere tid end adgang til egenskaber på grund af den dynamiske karakter af førstnævnte kontra de mere statiske garantier, som sidstnævnte tilbyder.

Vi kunne bruge vores "LightWeight" -forekomster på lignende måde som de typiske måder, som folk brugte navngivne tuples (ved hjælp af attributten adgangsoperation:. (Dot)). Det er ikke uforanderligt, og vi kan ikke få adgang til det via heltalindekser. Men vi kunne endda skrive kode for at få det til at efterligne disse funktioner.

Imidlertid vil dette "LightWeight" -objekt stadig være meget "tungere" end en navngivet tuple. Vi vil ikke have opnået betydelige ydelsesfordele ved at gøre det. Sådanne objekter kan ses som en slags "objektordbog" eller "simpelt (ikke) struktureret struktur" -objekt. Deres eneste fordel i forhold til ordbøger er, at man kan få adgang til deres indhold ved hjælp af “dot” -adgangsnotationen snarere end den forholdsvis mere ordrette dict [‘nøgle’] -syntaks. (En ulempe er, at du muligvis eksplicit skal bruge din forekomst .__ dict__-accessor til at arbejde med alle nøgler, der ikke er lovlige variabler / navn-identifikatorer i Python. For eksempel vil foo.1 = 4 hæve en SyntaxError, selvom foo .__ dict __ [1 ] = 4 er helt lovligt som et nøgle / værdipar i den underliggende ordbog).

Den vigtigste grund til at bruge tuples over andre objekter har som regel været på grund af disse førnævnte ydelsesovervejelser (som typisk kun bliver vigtige for samlinger af maj tusinder af objekter eller kode, som skal sløjpes over deres attributreferencer mange tusinder eller millioner af gange).

Navngivne tuples er dybest set en måde at skabe flyvevægtobjekter på. Adgang til felter (egenskaber, attributter) er syntaktisk identisk med den normale objektattributadgang ... så kode, der bruger en sådan syntaks, behøver ikke ændres. Den resulterende kode er generelt også meget mere læsbar end heltal indekseret adgang til normale tuples; så det er lettere at skrive, læse og vedligeholde.


Svar 2:

Hovedforskellen mellem namnetuple og ordbog er, at namnetoplen ikke kan ændres, mens ordbogen er mutabel, vi kan tilføje et hvilket som helst nøgleværdipar eller fjerne, hvis vi ikke kan gøre det efter oprettelsen af ​​ordbogen.

vi kan få adgang til de navngivne tuple-medlemmer med indekset og nøglen begge, men for at få adgang til medlemmet i ordbogen skal vi bruge nøglen.

Eksempel på navngivet titel:

# importerer "samlinger" til namestuple ()
importer samlinger
# Erklæring navngivet nummer ()
Student = samlinger.nametuple ('Student', ['navn', 'alder', 'DOB'])
# Tilføjelse af værdier
S = Student ('Nandini', '19', '2541997')
# Adgang ved hjælp af indeks
print ("Studenteralderen ved hjælp af indeks er:", end = "")
tryk (S [1])
# Adgang ved hjælp af navn
print ("Studentens navn ved hjælp af keyname er:", end = "")
print (S. navn)
# Adgang ved hjælp af getattr ()
print ("Student DOB ved hjælp af getattr () er:", end = "")
print (getattr (S, 'DOB'))

Eksempel på dictionay:

# Initialisering af ordbog
Student = {'Student': 'Nandini', 'alder': '19', 'DOB': '2541997'}
# ved hjælp af get () til at udskrive en nøgleværdi
print ("Alderen er:")
print (Student.get ('alder', 'Ikke til stede'))

Svar 3:

Hovedforskellen mellem namnetuple og ordbog er, at namnetoplen ikke kan ændres, mens ordbogen er mutabel, vi kan tilføje et hvilket som helst nøgleværdipar eller fjerne, hvis vi ikke kan gøre det efter oprettelsen af ​​ordbogen.

vi kan få adgang til de navngivne tuple-medlemmer med indekset og nøglen begge, men for at få adgang til medlemmet i ordbogen skal vi bruge nøglen.

Eksempel på navngivet titel:

# importerer "samlinger" til namestuple ()
importer samlinger
# Erklæring navngivet nummer ()
Student = samlinger.nametuple ('Student', ['navn', 'alder', 'DOB'])
# Tilføjelse af værdier
S = Student ('Nandini', '19', '2541997')
# Adgang ved hjælp af indeks
print ("Studenteralderen ved hjælp af indeks er:", end = "")
tryk (S [1])
# Adgang ved hjælp af navn
print ("Studentens navn ved hjælp af keyname er:", end = "")
print (S. navn)
# Adgang ved hjælp af getattr ()
print ("Student DOB ved hjælp af getattr () er:", end = "")
print (getattr (S, 'DOB'))

Eksempel på dictionay:

# Initialisering af ordbog
Student = {'Student': 'Nandini', 'alder': '19', 'DOB': '2541997'}
# ved hjælp af get () til at udskrive en nøgleværdi
print ("Alderen er:")
print (Student.get ('alder', 'Ikke til stede'))

Svar 4:

Hovedforskellen mellem namnetuple og ordbog er, at namnetoplen ikke kan ændres, mens ordbogen er mutabel, vi kan tilføje et hvilket som helst nøgleværdipar eller fjerne, hvis vi ikke kan gøre det efter oprettelsen af ​​ordbogen.

vi kan få adgang til de navngivne tuple-medlemmer med indekset og nøglen begge, men for at få adgang til medlemmet i ordbogen skal vi bruge nøglen.

Eksempel på navngivet titel:

# importerer "samlinger" til namestuple ()
importer samlinger
# Erklæring navngivet nummer ()
Student = samlinger.nametuple ('Student', ['navn', 'alder', 'DOB'])
# Tilføjelse af værdier
S = Student ('Nandini', '19', '2541997')
# Adgang ved hjælp af indeks
print ("Studenteralderen ved hjælp af indeks er:", end = "")
tryk (S [1])
# Adgang ved hjælp af navn
print ("Studentens navn ved hjælp af keyname er:", end = "")
print (S. navn)
# Adgang ved hjælp af getattr ()
print ("Student DOB ved hjælp af getattr () er:", end = "")
print (getattr (S, 'DOB'))

Eksempel på dictionay:

# Initialisering af ordbog
Student = {'Student': 'Nandini', 'alder': '19', 'DOB': '2541997'}
# ved hjælp af get () til at udskrive en nøgleværdi
print ("Alderen er:")
print (Student.get ('alder', 'Ikke til stede'))