Python keywords are reserved words that have predefined meanings in the language. They define the rules and structure of Python's syntax and cannot be used for any other purpose in the program, such as variable names, function names, or identifiers.
All Keywords are case sensitive and are written in lowercase except True, False and None.
As of Python version 3.8, there are 35 reserved keywords.
You can view the complete list using the keyword module
import keyword
print(keyword.kwlist)Output
['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']
| Keyword | Explanation |
|---|---|
| and | A logical operator that returns True only if both the operands are true. |
| as | Used to create an alias while importing a module. |
| assert | Used for debugging purposes to test if a condition in the code returns true. |
| async | Used to define a coroutine function or an asynchronous context manager. |
| await | Used to call a coroutine function. |
| break | Used to exit a loop prematurely. |
| class | Used for defining a class in object-oriented programming. |
| continue | Used to skip the current iteration of a loop and move to the next. |
| def | Used to define a function.. |
| del | Used to delete a reference to an object. |
| elif | Used in conditional statements, same as else if in other programming languages. |
| else | Used in conditional statements to define an alternative path of execution. |
| except | Used with exceptions, contains the code that is executed if an exception occurs. |
| False | The Boolean value of false.. |
| finally | Used with exceptions, contains a block of code that is always executed, regardless if an exception has occurred or not. |
| for | Used to create a for loop. |
| from | Used in import statements to import specific attributes or functions from a module. |
| global | Used to declare a global variable. |
| if | Used to create a conditional statement. |
| import | Used to import modules into the current Python script. |
| in | Used to check if a value exists in a sequence or to iterate through a sequence in a loop. |
| is | Used to test if two variables are the same object. |
| lambda | Used to create an anonymous function. |
| None | Defines a null value or a void. |
| nonlocal | Used to declare that a variable inside a nested function is not local to it, meaning it lies in the outer enclosing function. |
| not | A logical operator that returns True if the operand is false. |
| or | A logical operator that returns True if at least one of the operands is true. |
| pass | A null operation; nothing happens when it executes. |
| raise | Used to raise an exception. |
| return | Used inside a function to exit it and return a value. |
| True | The Boolean value of true. |
| try | Used for exception handling to catch and handle errors. |
| while | Used to create a while loop. |
| with | Used to simplify exception handling by cleaning up resources and wrapping up codes that may potentially throw exceptions. |
| yield | Used inside a function like a return statement, but yields a generator. |
Let us understand each keyword using examples.
True, False, None are foundational to programming in Python, each serving a unique purpose.
True: This keyword represents the boolean true value in Python. It's used in logic operations and control flow.
False: False represents the boolean false value in Python. Like True, it is primarily used in logical and control flow statements.
Here's an example of its use in a simple conditional statement:
a = 10
b = 20
print(a < b) # Output: True
print(a > b) # Output: FalseNone: It is used when we want to specify that a variable exists, but it does not have a value yet. It's also a common default return value for functions. Here's an example:
It's not the same as False, zero, or any empty list. It is a datatype of its own - the NoneType. It can be used when you want to assign a variable, but you don't have an initial value for it.
For example:
def a_function():
pass
result = a_function()
print(result) # Output: Noneand: This is a logical operator that returns True only if both operands are true. Otherwise, it returns False.
Truth table for ‘and’
| A | B | A and B |
|---|---|---|
| True | True | True |
| True | False | False |
| False | True | False |
| False | False | False |
or: This is a logical operator that returns True if at least one of the operands is true. Otherwise, it returns False.
Truth table for ‘or’
| A | B | A and B |
|---|---|---|
| True | True | True |
| True | False | True |
| False | True | True |
| False | False | False |
not: This is a logical operator that returns True if the operand is false, and False if the operand is true. It's used to reverse the logical state of its operand.
Truth table for ‘not’
| A | not A |
|---|---|
| True | False |
| False | True |
Let see some examples below
# and
print(True and True) # Output: True
print(True and False) # Output: False
# or
print(True or False) # Output: True
print(False or False) # Output: False
# in
print(not True) # Output: False
print(not False) # Output: Truein: The in keyword checks if a value is present in a sequence like a list, tuple, dictionary, string, etc.
# For a list
print(3 in [1, 2, 3]) # Output: True
print(4 in [1, 2, 3]) # Output: False
# For a string
print('y' in 'Python') # Output: True
print('z' in 'Python') # Output: Falseis: The is keyword checks if both the operands refer to the same object (not if they are equal).
x = 5
y = 5
z = x
print(x is y) # Output: True
print(x is z) # Output: True
print(x is not y) # Output: Falsefor: This keyword is used in for loops, which iterate over a sequence such as a list, tuple, string, or other iterable object.
for i in range(5):
print(i)Output:
0
1
2
3
4while: The while keyword is used in while loops, which continuously execute a block of code as long as a certain condition is true.
i = 0
while i < 5:
print(i)
i += 1Output:
0
1
2
3
4break: The break keyword is used to exit a loop prematurely. It can be used in both for and while loops.
for i in range(5):
if i == 3:
break
print(i)Output:
0
1
2Continue: Unlike break, continue does not terminate the loop entirely; instead, it is used to skip the current iteration of a loop and immediately proceed to the next one. It can be used in both for and while loops.
for i in range(5):
if i == 3:
continue
print(i)Output:
0
1
2
4if: The if keyword is used to create a conditional statement that executes some specified code after checking if its condition is True.
a = 10
if a > 0:
print("a is a positive number.")Output:
a is a positive number.else: This keyword is used to specify a block of code to be executed if the condition in the if statement is False.
a = -10
if a > 0:
print("a is a positive number.")
else:
print("a is not a positive number.")Output:
a is not a positive number.elif: The elif keyword (short for "else if") is used to specify a new condition to check for if the previous condition was False.
a = 0
if a > 0:
print("a is a positive number.")
elif a == 0:
print("a is zero.")
else:
print("a is a negative number.")Output:
a is zero.return: It is used in a function to signify the end of the function and to specify the result that the function should produce.
def add(a, b):
return a + b
print(add(2, 3))Output:
5yield: The yield keyword is used in a function like a return statement, but it returns a generator—a special type of iterable that generates values on-the-fly.
def count_up_to(n):
i = 1
while i <= n:
yield i
i += 1
for number in count_up_to(5):
print(number)Output:
1
2
3
4
5def: The def keyword is used to define a function in Python. A function is a block of reusable code that performs a specific task.
def greet(name):
print(f"Hello, {name}!")
greet("Alice")
Output:
Hello, Alice!Class: The Class keyword is used to define a user-defined class. A class is a blueprint for creating objects in an object-oriented programming language. An object is a data structure that contains data (attributes) and methods (functions) that operate on those data. In Python, almost everything is an object - numbers, strings, lists, functions, and so on.
class Greeting:
def __init__(self, name):
self.name = name
def greet(self):
print(f"Hello, {self.name}!")
greeting = Greeting("Bob")
greeting.greet()Output:
Hello, Bob!with and as: The with statement is used in exception handling to make the code cleaner and much more readable. It simplifies the management of common resources like file streams. The as keyword is used to create an alias while importing a module, or to define a context manager in a with statement.
with open("example.txt", "w") as file:
file.write("Hello, world!")pass: The pass keyword is used as a placeholder for future code. When the pass statement is executed, nothing happens, but you avoid getting an error when empty code is not allowed.
def some_function():
pass # An empty function that will be implemented in the futurelambda: The lambda is used to create anonymous functions. This means that the function doesn't have a name. It's useful when you want to declare a small, one-time-use function that you don't want to reuse elsewhere.
square = lambda x: x ** 2
print(square(5))Output:
25import: It is used to import a module into your Python script. Once a module is imported, you can use its functions and classes.
import math
print(math.sqrt(16))Output:
4.0from: The from is used with import to import specific attributes or functions from a module, rather than importing the whole module.
from math import sqrt
print(sqrt(16))Output:
4.0try and except: The try block lets you test a block of code for errors, while the except block lets you handle the error.
try:
print(undefined_variable)
except NameError:
print("An error occurred")Output:
An error occurredraise: The raise keyword is used to throw an exception. You can define what kind of error to raise, and the text to print to the user.
raise TypeError("This is a TypeError")Output:
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: This is a TypeErrorfinally: The finally block lets you execute code, regardless of the result of the try and except blocks.
try:
print(undefined_variable)
except NameError:
print("An error occurred")
finally:
print("The 'try except' is finished")Output:
An error occurred
The 'try except' is finishedassert: The assert is used when debugging code. The assert keyword lets you test if a condition in your code returns True, if not, the program will raise an AssertionError.
x = "hello"
# if the condition returns False, AssertionError is raised:
assert x == "goodbye", "x should be 'goodbye'"Output:
AssertionError: x should be 'goodbye'async: This keyword is used to declare an asynchronous function. An asynchronous function is a function that is designed to perform tasks concurrently. Asynchronous functions are defined using the async def syntax.
await: This keyword is used to call an asynchronous function and wait for it to complete. The await keyword can only be used inside an asynchronous function.
import asyncio
async def main():
print('Hello')
await asyncio.sleep(1)
print('World')
# Python 3.7+
asyncio.run(main())del: The del is used to delete objects. In Python, everything is an object, so the del keyword can be used to delete variables, lists, or parts of a list, dictionary items etc.
# Delete a variable
var = "Hello, World!"
del var # var no longer exists
# Delete an item from a list
list_var = [1, 2, 3, 4, 5]
del list_var[1] # list_var is now [1, 3, 4, 5]global: The global keyword is used to declare that a variable inside the function is global (outside the function). If you need to read or write a global variable from inside a function, use the global keyword.
var = 10 # Global variable
def function():
global var # Reference the global variable
var = 20 # Modify the global variable
function()
print(var) # Prints 20nonlocal: The nonlocal keyword is used to work with variables inside nested functions, where the variable should not belong to the inner function. It is used to refer to a variable of the nearest enclosing scope that is not global.
def outer_function():
var = 10 # Belongs to outer_function
def inner_function():
nonlocal var # Reference the variable of outer_function
var = 20 # Modify the variable of outer_function
inner_function()
print(var) # Prints 20
outer_function()
