Pythons namnområde och omfattning av en variabel

I den här handledningen lär du dig om namnområdet, kartläggning från namn till objekt och omfattningen av en variabel.

Vad är namnet i Python?

Om du någonsin har läst 'The Zen of Python' (skriv import thisin Python-tolk), säger den sista raden, Namnrymden är en bra idé - låt oss göra mer av dem! Så vad är dessa mystiska namnområden? Låt oss först titta på vad namnet är.

Namn (även kallat identifierare) är helt enkelt ett namn som ges till objekt. Allt i Python är ett objekt. Namn är ett sätt att komma åt det underliggande objektet.

Till exempel när vi gör uppdraget a = 2, 2är ett objekt lagras i minnet och ett är namnet vi förknippar det med. Vi kan få adressen (i RAM) för något objekt genom den inbyggda funktionen id(). Låt oss titta på hur du använder den.

 # Note: You may get different values for the id a = 2 print('id(2) =', id(2)) print('id(a) =', id(a))

Produktion

 id (2) = 9302208 id (a) = 9302208

Här hänvisar båda till samma objekt 2, så de har samma id(). Låt oss göra saker lite mer intressanta.

 # Note: You may get different values for the id a = 2 print('id(a) =', id(a)) a = a+1 print('id(a) =', id(a)) print('id(3) =', id(3)) b = 2 print('id(b) =', id(b)) print('id(2) =', id(2))

Produktion

 id (a) = 9302208 id (a) = 9302240 id (3) = 9302240 id (b) = 9302208 id (2) = 9302208

Vad händer i ovanstående steg? Låt oss använda ett diagram för att förklara detta:

Minnesdiagram över variabler i Python

Inledningsvis 2skapas ett objekt och namnet a associeras med det, när vi gör det skapas a = a+1ett nytt objekt 3och nu associeras ett med detta objekt.

Observera att id(a)och id(3)ha samma värden.

Vidare, när det b = 2körs, associeras det nya namnet b med det tidigare objektet 2.

Detta är effektivt eftersom Python inte behöver skapa ett nytt duplikatobjekt. Denna dynamiska karaktär av namnbindning gör Python kraftfull; ett namn kan referera till vilken typ av objekt som helst.

 >>> a = 5 >>> a = 'Hello World!' >>> a = (1,2,3)

Alla dessa är giltiga och a kommer att hänvisa till tre olika typer av objekt i olika fall. Funktioner är också objekt, så ett namn kan också hänvisa till dem.

 def printHello(): print("Hello") a = printHello a()

Produktion

 Hej

Samma namn kan referera till en funktion och vi kan kalla funktionen med detta namn.

Vad är ett namnområde i Python?

Nu när vi förstår vad namnen är kan vi gå vidare till begreppet namnområden.

För att helt enkelt uttrycka det är ett namnområde en samling namn.

I Python kan du föreställa dig ett namnområde som en mappning av varje namn du har definierat till motsvarande objekt.

Olika namnområden kan existera vid en given tidpunkt men är helt isolerade.

Ett namnområde som innehåller alla de inbyggda namnen skapas när vi startar Python-tolk och finns så länge som tolk körs.

Detta är anledningen till att inbyggda funktioner som id(), print()etc. är alltid tillgänglig för oss från någon del av programmet. Varje modul skapar sitt eget globala namnområde.

Dessa olika namnområden är isolerade. Därför kolliderar inte samma namn som kan finnas i olika moduler.

Moduler kan ha olika funktioner och klasser. Ett lokalt namnområde skapas när en funktion anropas, som har alla namn definierade i sig. Liknande är fallet med klass. Följande diagram kan hjälpa till att klargöra detta koncept.

Ett diagram över olika namnområden i Python

Python-variabelt omfång

Även om det finns olika unika namnområden definierade kanske vi inte kommer åt alla från alla delar av programmet. Begreppet omfattning spelar in.

Ett omfång är den del av ett program varifrån ett namnutrymme kan nås direkt utan något prefix.

När som helst finns det minst tre kapslade omfång.

1. Omfattning av den aktuella funktionen som har lokala namn
2. Omfattning av modulen som har globala namn
3. Yttersta omfång som har inbyggda namn

När en referens görs i en funktion söks namnet i det lokala namnområdet, sedan i det globala namnområdet och slutligen i det inbyggda namnområdet.

Om det finns en funktion inuti en annan funktion kapas ett nytt omfång inuti det lokala omfånget.

Exempel på omfattning och namnområde i Python

 def outer_function(): b = 20 def inner_func(): c = 30 a = 10

Här finns variabeln a i det globala namnområdet. Variabel b finns i det lokala namnområdet för outer_function()och c finns i det kapslade lokala namnområdet för inner_function().

När vi är i inner_function()är c lokalt för oss, b är icke-lokalt och a är globalt. Vi kan läsa såväl som tilldela nya värden till c men kan bara läsa b och a från inner_function().

Om vi ​​försöker tilldela som ett värde till b skapas en ny variabel b i det lokala namnområdet som skiljer sig från den icke-lokala b. Samma sak händer när vi tilldelar a ett värde.

Men om vi förklarar a som global går all referens och tilldelning till global a. På samma sätt, om vi vill ändra variabeln b, måste den förklaras som icke-lokal. Följande exempel klargör detta ytterligare.

 def outer_function(): a = 20 def inner_function(): a = 30 print('a =', a) inner_function() print('a =', a) a = 10 outer_function() print('a =', a)

Som du kan se är resultatet av detta program

 a = 30 a = 20 a = 10

I detta program definieras tre olika variabler a i separata namnområden och åtkomst därefter. I följande program,

 def outer_function(): global a a = 20 def inner_function(): global a a = 30 print('a =', a) inner_function() print('a =', a) a = 10 outer_function() print('a =', a)

Programmets resultat är.

 a = 30 a = 30 a = 30 

Här är alla referenser och uppdrag till det globala a på grund av användningen av nyckelord global.