Lijst met trefwoorden in Python-programmering

Deze tutorial biedt korte informatie over alle trefwoorden die in Python worden gebruikt.

Sleutelwoorden zijn de gereserveerde woorden in Python. We kunnen een trefwoord niet gebruiken als een variabelenaam, functienaam of een andere identificatie.

Hier is een lijst met alle trefwoorden in Python Programming

Sleutelwoorden in programmeertaal Python

Vals	wachten	anders	importeren	voorbij gaan aan
Geen	breken	behalve	in	verhogen
Klopt	klasse	Tenslotte	is	terugkeer
en	doorgaan met	voor	lambda	proberen
net zo	def	van	niet-lokaal	terwijl
beweren	del	globaal	niet	met
asynch	elif	als	of	opbrengst

De bovenstaande sleutelwoorden kunnen worden gewijzigd in verschillende versies van Python. Er kan wat extra worden toegevoegd of er kunnen er worden verwijderd. U kunt altijd de lijst met trefwoorden in uw huidige versie krijgen door het volgende in de prompt te typen.

  >>> import keyword >>> print(keyword.kwlist) ('False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield') 

Beschrijving van trefwoorden in Python met voorbeelden

Waar onwaar

Trueen Falsezijn waarheidswaarden in Python. Het zijn de resultaten van vergelijkingsbewerkingen of logische (Booleaanse) bewerkingen in Python. Bijvoorbeeld:

  >>> 1 == 1 True >>> 5> 3 True >>> True or False True >>> 10 >> 3> 7 False >>> True and False False 

Hier kunnen we zien dat de eerste drie uitspraken waar zijn, dus de interpreter keert terug Trueen retourneert Falsevoor de resterende drie uitspraken. Trueen Falsein python is hetzelfde als 1en 0. Dit kan worden gerechtvaardigd met het volgende voorbeeld:

 >>> True == 1 True >>> False == 0 True >>> True + True 2 

Geen

None is een speciale constante in Python die de afwezigheid van een waarde of een null-waarde vertegenwoordigt.

Het is een object van zijn eigen datatype, de NoneType. We kunnen niet meerdere Noneobjecten maken, maar kunnen deze wel aan variabelen toewijzen. Deze variabelen zijn gelijk aan elkaar.

We moeten speciale zorg nemen die Noneniet impliceert False, 0of een lege lijst, woordenboek, tekenreeks enz. Bijvoorbeeld:

 >>> None == 0 False >>> None == () False >>> None == False False >>> x = None >>> y = None >>> x == y True 

Ongeldige functies die niets retourneren, zullen Noneautomatisch een object retourneren . Nonewordt ook geretourneerd door functies waarin de programmastroom geen return-instructie tegenkomt. Bijvoorbeeld:

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

Uitvoer

 Geen 

Dit programma heeft een functie die geen waarde retourneert, hoewel het binnen enkele bewerkingen uitvoert. Dus als we x afdrukken, krijgen we Nonewat automatisch (impliciet) wordt geretourneerd. Evenzo is hier nog een ander voorbeeld:

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

Uitvoer

 Geen 

Hoewel deze functie een returnstatement heeft, wordt deze niet in alle gevallen bereikt. De functie keert Truealleen terug als de invoer even is.

Als we de functie een oneven getal geven, Nonewordt impliciet geretourneerd.

en, of, niet

and, or, notZijn de logische operatoren in Python. andzal Truealleen resulteren in als beide operanden zijn True. De waarheidstabel voor andwordt hieronder gegeven:

and Waarheidstafel voor

EEN	B	A en B
Klopt	Klopt	Klopt
Klopt	Vals	Vals
Vals	Klopt	Vals
Vals	Vals	Vals

orzal resulteren in Trueals een van de operanden is True. De waarheidstabel voor orwordt hieronder gegeven:

or Waarheidstafel voor

EEN	B	A of B
Klopt	Klopt	Klopt
Klopt	Vals	Klopt
Vals	Klopt	Klopt
Vals	Vals	Vals

notoperator wordt gebruikt om de waarheidswaarde om te keren. De waarheidstabel voor notwordt hieronder gegeven:

not Waarheidstabel voor

EEN	niet A
Klopt	Vals
Vals	Klopt

hieronder wordt een voorbeeld van hun gebruik gegeven

 >>> True and False False >>> True or False True >>> not False True 

net zo

aswordt gebruikt om een ​​alias te maken tijdens het importeren van een module. Het betekent dat u een module een andere naam geeft (door de gebruiker gedefinieerd) tijdens het importeren.

Python heeft bijvoorbeeld een standaardmodule met de naam math. Stel dat we willen berekenen welke cosinus pi een alias gebruikt. We kunnen het als volgt doen met as:

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

Hier hebben we de mathmodule geïmporteerd door deze de naam te geven myAlias. Nu kunnen we verwijzen naar de mathmodule met deze naam. Met deze naam hebben we cos (pi) berekend en -1.0als antwoord gekregen.

beweren

assert wordt gebruikt voor foutopsporing.

Tijdens het programmeren willen we soms de interne toestand weten of controleren of onze aannames waar zijn. asserthelpt ons dit te doen en bugs gemakkelijker te vinden. assertwordt gevolgd door een conditie.

Als de voorwaarde waar is, gebeurt er niets. Maar als de voorwaarde vals is, AssertionErrorwordt deze verhoogd. Bijvoorbeeld:

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

Voor een beter begrip kunnen we ook een bericht leveren om te worden afgedrukt met de AssertionError.

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

Op dit punt kunnen we opmerken dat,

 assert condition, message 

is gelijk aan,

 if not condition: raise AssertionError(message)

async, wacht

De asyncen awaitsleutelwoorden worden geleverd door de asynciobibliotheek in Python. Ze worden gebruikt om gelijktijdige code in Python te schrijven. Bijvoorbeeld,

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

Om het programma uit te voeren, gebruiken we

 asyncio.run(main())

In het bovenstaande programma geeft het asyncsleutelwoord aan dat de functie asynchroon wordt uitgevoerd.

Hier wordt eerst Hallo afgedrukt. Het awaitsleutelwoord laat het programma 1 seconde wachten. En dan wordt de wereld gedrukt.

breken, doorgaan

breaken continueworden binnen foren whileloops gebruikt om hun normale gedrag te veranderen.

breakbeëindigt de kleinste lus waarin deze zich bevindt en de besturing stroomt naar de instructie direct onder de lus. continuezorgt ervoor dat de huidige iteratie van de lus wordt beëindigd, maar niet de hele lus.

Dit kan worden geïllustreerd met de volgende twee voorbeelden:

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

Uitvoer

 1 2 3 4 

Hier is de forlus bedoeld om getallen van 1 tot 10 af te drukken. Maar aan de ifvoorwaarde is voldaan als i gelijk is aan 5 en we de lus verlaten. Zo wordt alleen het bereik 1 tot 4 afgedrukt.

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

Uitvoer

 1 2 3 4 6 7 8 9 10 

Hier gebruiken we continuevoor hetzelfde programma. Dus als aan de voorwaarde is voldaan, wordt die iteratie overgeslagen. Maar we verlaten de lus niet. Daarom worden alle waarden behalve 5 afgedrukt.

Lees meer over Python break and continue statement.

klasse

class wordt gebruikt om een ​​nieuwe door de gebruiker gedefinieerde klasse in Python te definiëren.

Class is a collection of related attributes and methods that try to represent a real-world situation. This idea of putting data and functions together in a class is central to the concept of object-oriented programming (OOP).

Classes can be defined anywhere in a program. But it is a good practice to define a single class in a module. Following is a sample usage:

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

Learn more about Python Objects and Class.

def

def is used to define a user-defined function.

Function is a block of related statements, which together does some specific task. It helps us organize code into manageable chunks and also to do some repetitive task.

The usage of def is shown below:

 def function_name(parameters):… 

Learn more about Python functions.

del

del is used to delete the reference to an object. Everything is object in Python. We can delete a variable reference using del

 >>> a = b = 5 >>> del a >>> a Traceback (most recent call last): File "", line 301, in runcode File "", line 1, in NameError: name 'a' is not defined >>> b 5 

Here we can see that the reference of the variable a was deleted. So, it is no longer defined. But b still exists.

del is also used to delete items from a list or a dictionary:

  >>> a = ('x','y','z') >>> del a(1) >>> a ('x', 'z') 

if, else, elif

if, else, elif are used for conditional branching or decision making.

When we want to test some condition and execute a block only if the condition is true, then we use if and elif. elif is short for else if. else is the block which is executed if the condition is false. This will be clear with the following example:

 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

 Two Something else One 

Here, the function checks the input number and prints the result if it is 1 or 2. Any input other than this will cause the else part of the code to execute.

Learn more about Python if and if… else Statement.

except, raise, try

except, raise, try are used with exceptions in Python.

Exceptions are basically errors that suggests something went wrong while executing our program. IOError, ValueError, ZeroDivisionError, ImportError, NameError, TypeError etc. are few examples of exception in Python. try… except blocks are used to catch exceptions in Python.

We can raise an exception explicitly with the raise keyword. Following is an example:

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

Output

 0.1 Exception caught None 

Here, the function reciprocal() returns the reciprocal of the input number.

When we enter 10, we get the normal output of 0.1. But when we input 0, a ZeroDivisionError is raised automatically.

This is caught by our try… except block and we return None. We could have also raised the ZeroDivisionError explicitly by checking the input and handled it elsewhere as follows:

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

finally

finally is used with try… except block to close up resources or file streams.

Using finally ensures that the block of code inside it gets executed even if there is an unhandled exception. For example:

 try: Try-block except exception1: Exception1-block except exception2: Exception2-block else: Else-block finally: Finally-block 

Here if there is an exception in the Try-block, it is handled in the except or else block. But no matter in what order the execution flows, we can rest assured that the Finally-block is executed even if there is an error. This is useful in cleaning up the resources.

Learn more about exception handling in Python programming.

for

for is used for looping. Generally we use for when we know the number of times we want to loop.

In Python we can use it with any type of sequences like a list or a string. Here is an example in which for is used to traverse through a list of names:

 names = ('John','Monica','Steven','Robin') for i in names: print('Hello '+i) 

Output

 Hello John Hello Monica Hello Steven Hello Robin 

Learn more about Python for loop.

from, import

import keyword is used to import modules into the current namespace. from… import is used to import specific attributes or functions into the current namespace. For example:

 import math 

will import the math module. Now we can use the cos() function inside it as math.cos(). But if we wanted to import just the cos() function, this can done using from as

 from math import cos 

now we can use the function simply as cos(), no need to write math.cos().

Learn more on Python modules and import statement.

global

global is used to declare that a variable inside the function is global (outside the function).

If we need to read the value of a global variable, it is not necessary to define it as global. This is understood.

If we need to modify the value of a global variable inside a function, then we must declare it with global. Otherwise, a local variable with that name is created.

Following example will help us clarify this.

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

Output

 10 5 5 

Here, the read1() function is just reading the value of globvar. So, we do not need to declare it as global. But the write1() function is modifying the value, so we need to declare the variable as global.

We can see in our output that the modification did take place (10 is changed to 5). The write2() also tries to modify this value. But we have not declared it as global.

Hence, a new local variable globvar is created which is not visible outside this function. Although we modify this local variable to 15, the global variable remains unchanged. This is clearly visible in our output.

in

in is used to test if a sequence (list, tuple, string etc.) contains a value. It returns True if the value is present, else it returns False. For example:

 >>> a = (1, 2, 3, 4, 5) >>> 5 in a True >>> 10 in a False 

The secondary use of in is to traverse through a sequence in a for loop.

 for i in 'hello': print(i) 

Output

 h e l l o 

is

is is used in Python for testing object identity. While the == operator is used to test if two variables are equal or not, is is used to test if the two variables refer to the same object.

It returns True if the objects are identical and False if not.

 >>> True is True True >>> False is False True >>> None is None True 

We know that there is only one instance of True, False and None in Python, so they are identical.

 >>> () == () True >>> () is () False >>> () == () True >>> () is () False 

An empty list or dictionary is equal to another empty one. But they are not identical objects as they are located separately in memory. This is because list and dictionary are mutable (value can be changed).

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

Unlike list and dictionary, string and tuple are immutable (value cannot be altered once defined). Hence, two equal string or tuple are identical as well. They refer to the same memory location.

lambda

lambda is used to create an anonymous function (function with no name). It is an inline function that does not contain a return statement. It consists of an expression that is evaluated and returned. For example:

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

Output

 2 4 6 8 10 

Here, we have created an inline function that doubles the value, using the lambda statement. We used this to double the values in a list containing 1 to 5.

Learn more about Python lamda function.

nonlocal

The use of nonlocal keyword is very much similar to the global keyword. nonlocal is used to declare that a variable inside a nested function (function inside a function) is not local to it, meaning it lies in the outer inclosing function. If we need to modify the value of a non-local variable inside a nested function, then we must declare it with nonlocal. Otherwise a local variable with that name is created inside the nested function. Following example will help us clarify this.

 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: 10 Outer function: 10 

Here, the inner_function() is nested within the outer_function.

The variable a is in the outer_function(). So, if we want to modify it in the inner_function(), we must declare it as nonlocal. Notice that a is not a global variable.

Hence, we see from the output that the variable was successfully modified inside the nested inner_function(). The result of not using the nonlocal keyword is as follows:

 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: 10 Outer function: 5 

Here, we do not declare that the variable a inside the nested function is nonlocal. Hence, a new local variable with the same name is created, but the non-local a is not modified as seen in our output.

pass

pass is a null statement in Python. Nothing happens when it is executed. It is used as a placeholder.

Suppose we have a function that is not implemented yet, but we want to implement it in the future. Simply writing,

 def function(args): 

in the middle of a program will give us IndentationError. Instead of this, we construct a blank body with the pass statement.

 def function(args): pass 

We can do the same thing in an empty class as well.

 class example: pass 

return

return statement is used inside a function to exit it and return a value.

If we do not return a value explicitly, None is returned automatically. This is verified with the following example.

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

Output

 10 None 

while

while is used for looping in Python.

The statements inside a while loop continue to execute until the condition for the while loop evaluates to False or a break statement is encountered. Following program illustrates this.

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

Output

 5 4 3 2 1 

Note that 0 is equal to False.

Learn more about Python while loop.

with

with statement is used to wrap the execution of a block of code within methods defined by the context manager.

Context manager is a class that implements __enter__ and __exit__ methods. Use of with statement ensures that the __exit__ method is called at the end of the nested block. This concept is similar to the use of try… finally block. Here, is an example.

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

This example writes the text Hello world! to the file example.txt. File objects have __enter__ and __exit__ method defined within them, so they act as their own context manager.

First the __enter__ method is called, then the code within with statement is executed and finally the __exit__ method is called. __exit__ method is called even if there is an error. It basically closes the file stream.

yield

yieldwordt gebruikt binnen een functie zoals een returnstatement. Maar yieldgeeft een generator terug.

Generator is een iterator die één item tegelijk genereert. Een grote lijst met waarden neemt veel geheugen in beslag. Generatoren zijn handig in deze situatie omdat het slechts één waarde tegelijk genereert in plaats van alle waarden in het geheugen op te slaan. Bijvoorbeeld,

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

zal een generator g creëren die machten van 2 genereert tot het nummer twee verheven tot het vermogen 99. We kunnen de getallen genereren met behulp van de next()functie zoals hieronder weergegeven.

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

En zo verder… Dit type generator wordt geretourneerd door de yieldinstructie van een functie. Hier is een voorbeeld.

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

Uitvoer

 0 1 4 9 16 25 

Hier generator()retourneert de functie een generator die kwadraten genereert van 0 tot 5. Dit wordt afgedrukt in de forlus.