When you begin learning a new spoken language, the first thing you master is its core vocabulary, the words that have fixed meanings and cannot be changed. Programming languages work the exact same way.
In Python, these foundational words are known as Keywords. Understanding them is essential for writing clean, efficient, and error-free code. Let's break down what they are, why they matter, and how they are categorized. 

Table of Contents

What is a Python Keyword?

A Python Keyword is a reserved word that has a specific, predefined meaning and purpose within the language. Because the Python interpreter relies on these words to understand the structure and logic of your code, you cannot use keywords as regular names. This means you cannot name your variables, functions, classes, or constants after them. Doing so will immediately trigger a SyntaxError.

Characteristics of Keywords

1. Strictly Case-Sensitive: Python treats uppercase and lowercase letters as entirely different characters. The interpreter will only recognize a keyword if it matches the exact casing defined by the language rules.

• The vast majority of Python keywords are entirely lowercase (e.g., if, else, and).
• There are exactly three keywords that begin with a capital letter: True, False, and None.

Note:

If you type true or IF, Python will treat them as regular variable names, not keywords.

2. Reserved and Cannot Be Used as Identifiers: Because keywords are woven into the fundamental grammar of the language, they are completely off-limits for naming your own code elements. You cannot use a keyword as a:

• Variable name
• Function name
• Class name
• Constant or directory key

If you attempt to assign a value to a keyword, Python's parser will reject it immediately

3. Trigger Compile-Time (Syntax) Errors: If you misuse a keyword, Python flags it as a SyntaxError, not a runtime error. This means the Python interpreter catches the mistake during the initial parsing phase (when it builds the abstract syntax tree) and refuses to execute a single line of your script until it is fixed.

4. They Have Fixed, Hardcoded Meanings: The behavior of a keyword is deeply embedded in Python's core compiler logic. Unlike built-in functions (such as print() or len()), which can technically be overwritten or shadowed by custom code. Their functional meaning remains identical across every script, module, and project.

5. Numbers Evolve with Python Versions: The total count of keywords is not fixed permanently; it changes as the core Python development team introduces new language features or deprecates old ones.

• In Python 2, there were roughly 31 keywords.
• In Python 3, keywords like exec and print became built-in functions, while new keywords like as, True, False, with, and None were introduced.
• More recent versions introduced asynchronous programming keywords (async and await), bringing the total count to 35 keywords in modern Python 3.

Conditional Keywords

These keywords are used for decision-making and controlling the flow of execution.
Keywords:

• if Keyword: Evaluates a condition. If the condition is true, its indented block of code runs.
• else Keyword: Acts as a final catch-all block that runs automatically if none of the previous conditions were met.
• elif Keyword: Checks an alternative condition only if all preceding if or elif conditions turned out to be false.

Example

# Python program to implement conditional keywords
score = 85

if score == 90:
    print("Grade: A")
elif score == 80:
    print("Grade: B")  
else:
    print("Grade: C")

Output

Grade: C

Explanation

1. Line-by-Line Execution: Python checks the if statement first, finds that 85 == 90 is false, and skips it.
2. The Decision: It moves to the elif statement, evaluates 85 == 80 as false, and skips it.
3. The Exit: Because a true condition was not found, Python executes the else block and finishes the program.

Looping Keywords

Looping keywords allow you to execute a block of code repeatedly. Python has two primary keywords for creating loops: for and while.
Keywords:

for
while

for Keyword: Used to iterate over a sequence (like a list, tuple, string, or a range of numbers), a predetermined number of times.
Example:

# Python program to implement for keyword
for i in range(5): 
 print(i)

Output:

0
1
2
3
4

Explanation:

1. The for keyword tracks the sequence generated by range(5) (which is 0, 1, 2, 3, 4).
2. It assigns each number to the variable i one by one, executing the print statement exactly five times before stopping automatically.

while Keyword: Repeats a block of code continually as long as a specified condition remains true.
Example:

# Python program to implement while keyword
count = 1
while count = 3:
    print("Count is",count)
    count += 1

Output:

Count is 1
Count is 2
Count is 3

Explanation:

1. The while keyword checks if count = 3 is true before every turn.
2. It runs the print block and increments count each time, automatically exiting the loop the moment count becomes 4.

Loop Control Keywords

These keywords modify the behavior of loops.
Keywords:

break
continue
pass

# Python program to show the working 
# of break keyword
for i in range(1, 11):
    if i == 6:
        break
    print(i)

1
2
3
4
5

1. The loop starts from 1 and goes up to 10.
2. Each value of i is checked.
3. When i becomes 6, the condition i == 6 becomes True.
4. The break statement is executed.
5. The loop terminates immediately.
6. Numbers after 5 are not printed.

# Python program to show the working 
# of continue keyword
for i in range(1, 11):
    if i == 6:
        continue
    print(i)

Output:

1
2
3
4
5
7
8
9
10

Explanation:

1. The loop runs from 1 to 10.
2. When i becomes 6, the condition becomes True.
3. continue is executed.
4. Python skips the print(i) statement for that iteration.
5. The loop proceeds with the next value (7).
6. Therefore, only 6 is skipped.

# Python program to show the working 
# of pass keyword
for i in range(1, 6):
    if i == 3:
        pass
    print(i)

Output:

1
2
3
4
5

Explanation:

1. The loop runs from 1 to 5.
2. When i becomes 3, pass is executed.
3. Since pass does nothing, execution continues normally.
4. All numbers from 1 to 5 are printed.

Logical Keywords

Logical keywords are used to combine or modify conditions. They return either True or False and are commonly used in decision-making statements such as if, elif, and while.
Keywords:

and
or
not

and Keyword: The and operator returns True only when all conditions are true. If any condition is False, the result becomes False.
Syntax:

condition1 and condition2

Example:

# Python program to show the working 
# of and keyword
age = 20
citizen = True

if age == 18 and citizen:
    print("Eligible to vote")
else:
    print("Not Eligible to vote")

Not Eligible to vote

1. age == 18 evaluates to False, and citizen is True.
2. Since one condition is True and one is False, it evaluates to False.
3. The else block executes and prints the message.

condition1 or condition2

# Python program to show the working 
# of or keyword
marks = 35
sports_quota = True

if marks == 40 or sports_quota:
    print("Admission Granted")
else:
    print("Admission is not Granted")

Admission Granted

1. marks == 40 is False.
2. sports_quota is True.
3. Since one condition is True, or returns True.
4. The if block executes.

not condition

# Python program to show the working 
# of not keyword
is_raining = False

if not is_raining:
    print("Go for a walk")

Go for a walk

1. is_raining is False.
2. not False becomes True.
3. The if condition becomes True.
4. The message is printed.

Membership Keywords

Membership keywords are used to check whether a value exists in a sequence such as a string, tuple, set, list, or dictionary. Python provides two membership keywords:

1. in
2. not in

• Returns True if the value exists.
• Returns False if the value does not exist.

value in sequence

#Python Program to show the working 
# of in keyword
numbers = [10, 20, 30, 40]

print(20 in numbers)
print(50 in numbers)

True
False

Explanation:

1. 20 is present in the list, so the result is True.
2. 50 is not present in the list, so the result is False.

• Returns True if the value is absent.
• Returns False if the value exists.

value not in sequence

# Python program to show the working 
# of not in keyword
numbers = [10, 20, 30, 40]
print(50 not in numbers)
print(20 not in numbers)

True
False

Explanation:

1. 50 is not present in the list, so the result is True.
2. 20 is present in the list, so the result is False.

Identity Keywords

Identity Keywords are used to check whether two variables refer to the same object in memory. Python provides two identity keywords:

1. is
2. is not

object1 is object2

# Python program to show the working 
# of is keyword
x = [1, 2, 3]
y = x
print(x is y)

True

Explanation:

1. A list is created and assigned to x.
2. y = x means y refers to the same list object.
3. Both variables point to the same memory location.
4. Therefore, x is y returns True.

is not Keyword: The is not operator returns True if two variables refer to different objects in memory.
Syntax:

object1 is not object2

Example:

# Python program to show the working 
# of is not keyword
x = [1, 2, 3]
y = [1, 2, 3]
print(x is not y)

Output:

True

Explanation:

1. x and y are separate list objects.
2. They occupy different memory locations.
3. Therefore, is not returns True.

Function and Class Definition Keywords

Python provides special keywords for creating functions and classes. These keywords help organize code, improve reusability, and support Object-Oriented Programming (OOP).
The main function and class definition keywords are:

1. def
2. return
3. class

def function_name():
    statements

Example 1: Without Parameters

# Python program to show the working def keyword
def greet():
    print("Welcome to Python")
greet()

Output:

Welcome to Python

Explanation:

1. def greet(): creates a function named greet.
2. The statement inside the function prints a message.
3. greet() calls the function.
4. The function executes and displays the output.

Example 2: With Parameters

# Python program to show the working 
# of def keyword
def add(a, b):
    print(a + b)
add(10, 20)

Output:

30

Explanation:

1. a and b are parameters.
2. Values 10 and 20 are passed to the function.
3. The function adds them and prints the result. 

return Keyword: The return keyword is used to send a value back from a function to the caller. Once return is executed, the function immediately terminates.
Syntax:

def function_name():
    return value

Example:

# Python program to show the working 
# of return keyword
def square(num):
    return num * num
result = square(5)
print(result)

Output:

25

Explanation:

1. The function receives 5 as input.
2. num * num calculates 25.
3. return sends the value back.
4. The returned value is stored in result.
5. print(result) displays 25.

class keyword: The class keyword is used to create a class. A class is a blueprint for creating objects. It defines properties (variables) and behaviors (methods).
Syntax:

class ClassName:
    statements

Example:

# Python program to show the working 
# of class keyword
class Student:
    name = "Rahul"
obj = Student()
print(obj.name)

Output:

Rahul

Explanation:

1. A class named Student is created.
2. It contains a class variable name.
3. obj = Student() creates an object.
4. obj.name accesses the variable.

Exception Handling Keywords

Exception handling is a mechanism used to handle runtime errors gracefully so that the program does not terminate unexpectedly. Python provides the following exception-handling keywords:

1. try
2. except
3. finally
4. raise
5. assert

try Keyword: The try block contains the code that may generate an exception. If an exception occurs, Python immediately stops executing the remaining statements in the try block and looks for an appropriate except block.
Syntax:

try:
    # risky code

Example:

# Python program to show the working 
# of try keyword
try:
    num = 10 / 0
    print(num)
except ZeroDivisionError:
    print("Cannot divide by zero")

Output:

Cannot divide by zero

Explanation:

1. Python enters the try block.
2. 10 / 0 causes a ZeroDivisionError.
3. Execution immediately stops in the try block.
4. Control transfers to the matching except block.
5. The error message is displayed instead of terminating the program.

except Keyword: The except block handles exceptions raised in the try block. It prevents the program from crashing and allows execution to continue.
Syntax:

try:
    statements
except ExceptionType:
    statements

Example:

# Python program to show the working
# of except keyword
try:
    number = int("Hello")
except ValueError:
    print("Invalid conversion")

Output:

Invalid conversion

Explanation:

1. int("Hello") attempts to convert text to an integer.
2. Conversion fails and raises a ValueError.
3. The except ValueError block handles the error.
4. The program continues normally

finally Keyword: The finally block executes whether an exception occurs or not. It is commonly used for cleanup tasks such as closing files, database connections, or releasing resources.
Syntax:

try:
    statements
except:
    statements
finally:
    statements

Example:

# Python program to show the working 
# of finally keyword
try:
    print(10 / 0)
except ZeroDivisionError:
    print("Error occurred")
finally:
    print("Execution completed")

Output:

Error occurred
Execution completed

Explanation:

1. Division by zero raises an exception.
2. The except block handles the exception.
3. The finally block executes afterward.
4. It runs regardless of whether an error occurred.

raise Keyword: The raise keyword is used to manually generate an exception. Programmers use it when they want to enforce specific conditions.
Syntax:

raise ExceptionType("Message")

Example:

# Python program to show the working 
# of raise keyword
age = -5
if age == 0:
    raise ValueError("Age cannot be negative")

Output:

ValueError: Age cannot be negative

Explanation:

1. The condition age = 0 becomes True.
2. raise explicitly generates a ValueError.
3. Python stops execution and displays the error message.

assert Keyword: The assert statement is used for debugging and testing assumptions. It checks whether a condition is True.

• If True: Program continues.
• If False: Raises AssertionError.

Syntax:

assert condition, "Error Message"

Example:

# Python program to show the working 
# of assert keyword
x = -5
assert x  0, "Number must be positive"

Output:

AssertionError: Number must be positive

Explanation:

1. Python evaluates x 0.
2. The condition is False.
3. AssertionError is raised.
4. The custom error message is displayed.

# Python program to show the working 
# of import keyword
import math
print(math.sqrt(25))

# Python program to show the working 
# of from keyword
from math import sqrt
print(sqrt(36))

# Python program to show the working 
# of as keyword
import math as m
print(m.sqrt(64))

# Python program to show the working 
# of global and local vbariable
 # Global variable
x = 100      

# Local variable
def display():
    y = 50   
    print(y)

display()
print(x)

# Python program without global keyword
count = 10

def update():
    count = 20
    print("Inside Function:", count)

update()
print("Outside Function:", count)

# Python program with global keyword
count = 10

def update():
    global count
    count = 20
    print("Inside Function:", count)

update()
print("Outside Function:", count)

# Python program without nonlocal keyword
def outer():
    x = 10
    def inner():
        x = 20
        print("Inner:", x)
    inner()
    print("Outer:", x)
outer()

# Python program with nonlocal keyword
def outer():
    x = 10
    def inner():
        nonlocal x
        x = 20
        print("Inner:", x)
    inner()
    print("Outer:", x)
outer()

# Python program to show the working 
# of True keyword
logged_in = True
if logged_in:
    print("Welcome User")

# Python program to show the working 
# of False keyword
is_raining = False
if is_raining:
    print("Take an umbrella")
else:
    print("Enjoy your day")

# Python program to show the working 
# of None keyword
name = None
if name is None:
    print("No value available")

# Python program to show the working 
# of async keyword
import asyncio
async def greet():
    print("Hello Python")

asyncio.run(greet())

# Python program to show the working 
# of await keyword
import asyncio

async def task1():
    print("Task 1 Started")
    await asyncio.sleep(2)
    print("Task 1 Finished")

async def task2():
    print("Task 2 Started")
    await asyncio.sleep(1)
    print("Task 2 Finished")

async def main():
    await asyncio.gather(
        task1(),
        task2()
    )

asyncio.run(main()) # Runs multiple tasks concurrently