Nyckelord är reserverade ord i Python. Vi kan inte använda ett nyckelord som variabelnamn, funktionsnamn eller någon annan identifierare.

Här är en lista över alla nyckelord i Pythonprogrammering

.

Ovanstående nyckelord kan ändras i olika versioner av Python. Några extra kan läggas till eller några kan tas bort. Du kan alltid få listan över nyckelord i din aktuella version genom att skriva följande i prompten.

>>> import keyword>>> print(keyword.kwlist)

Beskrivning av nyckelord i Python med exempel

True, False

True och False är sanningsvärden i Python. De är resultaten av jämförelseoperationer eller logiska (booleska) operationer i Python. Till exempel:

>>> 1 == 1True>>> 5 > 3True>>> True or FalseTrue>>> 10 <= 1False>>> 3 > 7False>>> True and FalseFalse

Här kan vi se att de tre första påståendena är sanna så tolkaren returnerar True och returnerar False för de återstående tre påståendena. True och False i python är samma sak som 1 och 0. Detta kan motiveras med följande exempel:

>>> True == 1True>>> False == 0True>>> True + True2

None

None är en speciell konstant i Python som representerar frånvaron av ett värde eller ett nollvärde.

Det är ett objekt med en egen datatyp, NoneType. Vi kan inte skapa flera None-objekt men kan tilldela den till variabler. Dessa variabler kommer att vara lika varandra.

Vi måste vara särskilt noga med att None inte innebär False, 0 eller någon tom lista, ordbok, sträng etc. Till exempel:

>>> None == 0False>>> None == False>>> None == FalseFalse>>> x = None>>> y = None>>> x == yTrue

Voida funktioner som inte returnerar något returnerar automatiskt ett None-objekt. None returneras också av funktioner där programflödet inte stöter på en returangivelse. Till exempel:

def a_void_function(): a = 1 b = 2 c = a + bx = a_void_function()print(x)

Output

None

Detta program har en funktion som inte returnerar något värde, även om den utför vissa operationer inuti. Så när vi skriver ut x får vi None som returneras automatiskt (implicit). På samma sätt är här ett annat exempel:

def improper_return_function(a): if (a % 2) == 0: return Truex = improper_return_function(3)print(x)

Output

None

Trots att denna funktion har en return-angivelse nås den inte i alla fall. Funktionen returnerar True endast när inmatningen är jämn.

Om vi ger funktionen ett udda tal returneras None implicit.

och, eller , inte

and, or, not är de logiska operatörerna i Python. and resulterar i True endast om båda operanderna är True. Sanningstabellen för and ges nedan:

or resulterar i True om någon av operanderna är True. Sanningstabellen för or ges nedan:

not operatören används för att invertera sanningsvärdet. Sanningstabellen för not ges nedan:

några exempel på deras användning ges nedan

>>> True and FalseFalse>>> True or FalseTrue>>> not FalseTrue

as

as används för att skapa ett alias vid import av en modul. Det innebär att man ger ett annat namn (användardefinierat) till en modul när man importerar den.

Som exempel har Python en standardmodul som heter math. Antag att vi vill beräkna vilken cosinus pi är med hjälp av ett alias. Vi kan göra det på följande sätt genom att använda as:

>>> import math as myAlias>>>myAlias.cos(myAlias.pi)-1.0

Här importerade vi modulen math genom att ge den namnet myAlias. Nu kan vi hänvisa till modulen math med detta namn. Med hjälp av detta namn beräknade vi cos(pi) och fick -1.0 som svar.

assert

assert används i felsökningssyfte.

Under programmering vill vi ibland känna till det interna tillståndet eller kontrollera om våra antaganden är sanna. assert hjälper oss att göra detta och hitta fel lättare. assert följs av ett villkor.

Om villkoret är sant händer ingenting. Men om villkoret är falskt, så väcks AssertionError. Till exempel:

>>> a = 4>>> assert a < 5>>> assert a > 5Traceback (most recent call last): File "<string>", line 301, in runcode File "<interactive input>", line 1, in <module>AssertionError

För vår bättre förståelse kan vi också tillhandahålla ett meddelande som skrivs ut tillsammans med AssertionError.

>>> a = 4>>> assert a > 5, "The value of a is too small"Traceback (most recent call last): File "<string>", line 301, in runcode File "<interactive input>", line 1, in <module>AssertionError: The value of a is too small

I det här läget kan vi notera att,

assert condition, message

är likvärdigt med,

if not condition: raise AssertionError(message)

async, await

Nyckelorden async och await tillhandahålls av asyncio biblioteket i Python. De används för att skriva samtidig kod i Python. Till exempel,

import asyncioasync def main(): print('Hello') await asyncio.sleep(1) print('world')

För att köra programmet använder vi

asyncio.run(main())

I programmet ovan anger nyckelordet async att funktionen kommer att exekveras asynkront.

Här skrivs första Hello ut. Nyckelordet await gör att programmet väntar i 1 sekund. Och sedan skrivs världen ut.

break, continue

break och continue används inuti for och while slingor för att ändra deras normala beteende.

break avslutar den minsta slinga som den befinner sig i och kontrollen flyter till uttalandet omedelbart under slingan. continue gör att den aktuella iterationen i slingan avslutas, men inte hela slingan.

Detta kan illustreras med följande två exempel:

for i in range(1,11): if i == 5: break print(i)

Output

1234

Här avser for-slingan att skriva ut siffror från 1 till 10. Men if villkoret uppfylls när i är lika med 5 och vi bryter från slingan. Således skrivs endast intervallet 1 till 4 ut.

for i in range(1,11): if i == 5: continue print(i)

Output

1234678910

Här använder vi continue för samma program. Så när villkoret är uppfyllt hoppas vi över den iterationen. Men vi lämnar inte slingan. Därför skrivs alla värden utom 5 ut.

Lär dig mer om Python break och continue statement.

class

class används för att definiera en ny användardefinierad klass i Python.

Klass är en samling relaterade attribut och metoder som försöker representera en verklig situation. Den här idén att samla data och funktioner i en klass är central för begreppet objektorienterad programmering (OOP).

Klasser kan definieras var som helst i ett program. Men det är en god praxis att definiera en enda klass i en modul. Nedan följer ett exempel på användning:

class ExampleClass: def function1(parameters): … def function2(parameters): …

Lär dig mer om Python Objects and Class.

def

def används för att definiera en användardefinierad funktion.

Funktion är ett block av relaterade uttalanden, som tillsammans utför en viss uppgift. Den hjälper oss att organisera kod i hanterbara bitar och även att utföra vissa repetitiva uppgifter.

Användningen av def visas nedan:

def function_name(parameters): …

Lär dig mer om Python-funktioner.

del

del används för att ta bort referensen till ett objekt. Allt är objekt i Python. Vi kan ta bort en referens till en variabel med hjälp av del

>>> a = b = 5>>> del a>>> aTraceback (most recent call last): File "<string>", line 301, in runcode File "<interactive input>", line 1, in <module>NameError: name 'a' is not defined>>> b5

Här kan vi se att referensen till variabeln a har tagits bort. Den är alltså inte längre definierad. Men b finns fortfarande kvar.

del används också för att radera objekt från en lista eller ett lexikon:

>>> a = >>> del a>>> a

if, else, elif

if, else, elif används för villkorlig förgrening eller beslutsfattande.

När vi vill testa ett visst villkor och exekvera ett block endast om villkoret är sant använder vi if och elif. elif är en förkortning för else if. else är det block som utförs om villkoret är falskt. Detta blir tydligt med följande exempel:

def if_example(a): if a == 1: print('One') elif a == 2: print('Two') else: print('Something else')if_example(2)if_example(4)if_example(1)

Output

TwoSomething elseOne

Här kontrollerar funktionen det inmatade talet och skriver ut resultatet om det är 1 eller 2. All annan inmatning än detta gör att else delen av koden exekveras.

Lär dig mer om Python if och if…else Statement.

except, raise, try

except, raise, try används med undantag i Python.

Utantag är i princip fel som antyder att något gick fel när vi exekverade vårt program. IOError, ValueError, ZeroDivisionError, ImportError, NameError, TypeError etc. är några exempel på undantag i Python. try...except block används för att fånga upp undantag i Python.

Vi kan väcka ett undantag explicit med nyckelordet raise. Nedan följer ett exempel:

def reciprocal(num): try: r = 1/num except: print('Exception caught') return return rprint(reciprocal(10))print(reciprocal(0))

Output

0.1Exception caughtNone

Här returnerar funktionen det inmatade talets reciprok.

När vi matar in 10 får vi den normala utgången 0,1. Men när vi matar in 0 uppstår automatiskt en ZeroDivisionError.

Detta fångas upp av vårt try…except-block och vi returnerar None. Vi kunde också ha tagit upp ZeroDivisionError explicit genom att kontrollera inmatningen och hanterat det på annat håll enligt följande:

if num == 0: raise ZeroDivisionError('cannot divide')

finally

finally används tillsammans med try…except-blocket för att stänga resurser eller filflöden.

Användning av finally säkerställer att kodblocket inuti det utförs även om det finns ett obehandlat undantag. Till exempel:

try: Try-blockexcept exception1: Exception1-blockexcept exception2: Exception2-blockelse: Else-blockfinally: Finally-block

Här om det finns ett undantag i Try-block hanteras det i blocket except eller else. Men oavsett i vilken ordning utförandet sker kan vi vara säkra på att Finally-block utförs även om det uppstår ett fel. Detta är användbart för att städa upp resurserna.

Lär dig mer om undantagshantering i Pythonprogrammering.

for

for används för looping. I allmänhet använder vi for när vi vet hur många gånger vi vill slinga.

I Python kan vi använda det med alla typer av sekvenser som en lista eller en sträng. Här är ett exempel där for används för att gå igenom en lista med namn:

names = for i in names: print('Hello '+i)

Output

Hello JohnHello MonicaHello StevenHello Robin

Lär dig mer om Python för loop.

from, import

import Nyckelordet används för att importera moduler till det aktuella namnområdet. from…import används för att importera specifika attribut eller funktioner till det aktuella namnområdet. Till exempel:

import math

kommer att importera modulen math. Nu kan vi använda funktionen cos() inuti den som math.cos(). Men om vi vill importera bara cos()-funktionen kan detta göras med from as

from math import cos

Nu kan vi använda funktionen helt enkelt som cos(), utan att behöva skriva math.cos().

Lär dig mer om Python-moduler och import-anvisning.

global

global används för att deklarera att en variabel inom funktionen är global (utanför funktionen).

Om vi behöver läsa värdet på en global variabel är det inte nödvändigt att definiera den som global. Detta är förstått.

Om vi behöver ändra värdet på en global variabel inne i en funktion måste vi deklarera den med global. Annars skapas en lokal variabel med det namnet.

Följande exempel hjälper oss att klargöra detta.

globvar = 10def read1(): print(globvar)def write1(): global globvar globvar = 5def write2(): globvar = 15read1()write1()read1()write2()read1()

Output

1055

Här läser read1()-funktionen bara värdet av globvar. Vi behöver alltså inte deklarera den som global. Men funktionen write1() ändrar värdet, så vi behöver deklarera variabeln som global.

Vi kan se i vår utdata att ändringen skedde (10 ändras till 5). write2() försöker också ändra detta värde. Men vi har inte deklarerat det som global.

Därmed skapas en ny lokal variabel globvar som inte är synlig utanför denna funktion. Även om vi ändrar denna lokala variabel till 15 förblir den globala variabeln oförändrad. Detta syns tydligt i vårt resultat.

in

in används för att testa om en sekvens (lista, tupel, sträng etc.) innehåller ett värde. Den returnerar True om värdet finns, annars returnerar den False. Till exempel:

>>> a = >>> 5 in aTrue>>> 10 in aFalse

Den sekundära användningen av in är att travestera genom en sekvens i en forslinga.

for i in 'hello': print(i)

Output

hello

is

is används i Python för att testa objekts identitet. Medan operatören == används för att testa om två variabler är lika eller inte, används is för att testa om de två variablerna hänvisar till samma objekt.

Den returnerar True om objekten är identiska och False om inte.

>>> True is TrueTrue>>> False is FalseTrue>>> None is NoneTrue

Vi vet att det bara finns en instans av True, False och None i Python, så de är identiska.

>>> == True>>> is False>>> {} == {}True>>> {} is {}False

En tom lista eller ordbok är lika med en annan tom. Men de är inte identiska objekt eftersom de ligger separat i minnet. Detta beror på att list och dictionary är föränderliga (värdet kan ändras).

>>> '' == ''True>>> '' is ''True>>> () == ()True>>> () is ()True

Till skillnad från list och dictionary är string och tuple oföränderliga (värdet kan inte ändras när det väl har definierats). Därför är två lika strängar eller tupler också identiska. De hänvisar till samma minnesplats.

lambda

lambda används för att skapa en anonym funktion (funktion utan namn). Det är en inline-funktion som inte innehåller ett return-meddelande. Den består av ett uttryck som utvärderas och returneras. Exempel:

a = lambda x: x*2for i in range(1,6): print(a(i))

Output

246810

Här har vi skapat en inline-funktion som fördubblar värdet med hjälp av lambda-angivelsen. Vi använde detta för att fördubbla värdena i en lista som innehåller 1 till 5.

Lär dig mer om Python lamda-funktionen.

nonlocal

Användningen av nyckelordet nonlocal liknar i mångt och mycket nyckelordet global. nonlocal används för att deklarera att en variabel i en inbäddad funktion (funktion inom en funktion) inte är lokal för den, vilket innebär att den ligger i den yttre inbäddade funktionen. Om vi behöver ändra värdet på en icke-lokal variabel inuti en nästlad funktion måste vi deklarera den med nonlocal. Annars skapas en lokal variabel med det namnet inuti den nästlade funktionen. Följande exempel hjälper oss att klargöra detta.

def outer_function(): a = 5 def inner_function(): nonlocal a a = 10 print("Inner function: ",a) inner_function() print("Outer function: ",a)outer_function()

Output

Inner function: 10Outer function: 10

Här är inner_function() inbäddad i outer_function.

Variabeln a finns i outer_function(). Så om vi vill ändra den i inner_function() måste vi deklarera den som nonlocal. Observera att a inte är en global variabel.

Därmed ser vi i utmatningen att variabeln ändrades i den inbäddade inner_function(). Resultatet av att inte använda nyckelordet nonlocal är följande:

def outer_function(): a = 5 def inner_function(): a = 10 print("Inner function: ",a) inner_function() print("Outer function: ",a)outer_function()

Output

Inner function: 10Outer function: 5

Här deklarerar vi inte att variabeln a inuti den nästlade funktionen är nonlocal. Därför skapas en ny lokal variabel med samma namn, men den icke-lokala a ändras inte, vilket syns i vår utdata.

pass

pass är ett noll-uttalande i Python. Det händer ingenting när det utförs. Det används som en platshållare.

Antag att vi har en funktion som inte är implementerad ännu, men vi vill implementera den i framtiden. Genom att helt enkelt skriva,

def function(args):

med mitten av ett program får vi IndentationError. Istället konstruerar vi en tom kropp med pass-anvisningen.

def function(args): pass

Vi kan göra samma sak i en tom class också.

class example: pass

return

return-anvisningen används inne i en funktion för att avsluta den och returnera ett värde.

Om vi inte returnerar ett värde uttryckligen returneras None automatiskt. Detta verifieras med följande exempel.

def func_return(): a = 10 return adef no_return(): a = 10print(func_return())print(no_return())

Output

10None

while

while används för slingor i Python.

Angivelserna inom en while-slinga fortsätter att exekveras tills villkoret för while-slingan utvärderas till False eller ett break-meddelande påträffas. Följande program illustrerar detta.

i = 5while(i): print(i) i = i – 1

Output

54321

Bemärk att 0 är lika med False.

Lär dig mer om while-slingan i Python.

med

with-angivelsen används för att omsluta exekveringen av ett kodblock inom metoder som definieras av kontexthanteraren.

Kontexthanteraren är en klass som implementerar __enter__ och __exit__ metoder. Användningen av with-angivelsen säkerställer att __exit__-metoden anropas i slutet av det inbäddade blocket. Detta koncept liknar användningen av try…finally-blocket. Här är ett exempel:

with open('example.txt', 'w') as my_file: my_file.write('Hello world!')

Detta exempel skriver texten Hello world! till filen example.txt. Filobjekten har __enter__– och __exit__-metoden definierade inom dem, så de fungerar som sin egen kontexthanterare.

Först anropas __enter__-metoden, sedan exekveras koden inom with-anvisningen och till sist anropas __exit__-metoden. __exit__-metoden anropas även om det finns ett fel. Den stänger i princip filflödet.

yield

yield används inuti en funktion som ett return-uttalande. Men yield returnerar en generator.

Generator är en iterator som genererar ett objekt i taget. En stor lista med värden tar upp mycket minne. Generatorer är användbara i den här situationen eftersom den genererar endast ett värde i taget i stället för att lagra alla värden i minnet. Till exempel kommer

>>> g = (2**x for x in range(100))

att skapa en generator g som genererar potenser av 2 upp till talet två upphöjt till potensen 99. Vi kan generera talen med hjälp av funktionen next() som visas nedan.

>>> next(g)1>>> next(g)2>>> next(g)4>>> next(g)8>>> next(g)16

Och så vidare… Den här typen av generator returneras av yield-anvisningen från en funktion. Här är ett exempel.

def generator(): for i in range(6): yield i*ig = generator()for i in g: print(i)

Output