Why Learn Python?

Common Uses of Python

Install Python on Windows

1. Visit the official Python download page and download the current Python 3 installer for Windows.
2. Open the downloaded installer.
3. Follow the installation prompts and allow Python to be available from the command line.
4. Finish the installation and open Command Prompt or PowerShell.

python --version

You may also need:

py --version

Install Python on macOS

1. Download the macOS installer from the official Python website.
2. Open the installer package and follow the installation steps.
3. Open Terminal after the installation finishes.
4. Verify the installation using the command below.

python3 --version

Install Python on Linux

Python is often already installed on Linux. Check the installed version before installing anything.

python3 --version

If Python is missing, install it using your Linux distribution’s package manager.

Run Your First Python Program

Create a new file named hello.py and add the following code:

print("Hello, World!")

Run the file:

python hello.py

python3 hello.py

Hello, World!

Set Up Python in VS Code

1. Install Visual Studio Code.
2. Open the Extensions panel.
3. Search for and install the official Python extension.
4. Open your Python project folder.
5. Select the correct Python interpreter when prompted.
6. Open a .py file and run it from the editor.

Basic Python Syntax Rules

Indentation

Indentation is required in Python. The standard convention is four spaces for each indentation level.

# Calculate the final price
price = 100
tax = 0.25
total = price * (1 + tax)

total = (
    product_price
    + shipping_cost
    + tax
)

languages = [
    "Python",
    "JavaScript",
    "SQL",
]

name = "Alice"
Name = "Bob"

print(name)
print(Name)

Alice
Bob

x = 10; y = 20; print(x + y)

x = 10
y = 20
print(x + y)

Creating Variables

Assign a value using the equals sign (=).

name = "Alice"
age = 28
height = 1.75
is_student = False

Variable Naming Rules

Multiple Assignment

Python allows assigning several variables in one line.

x, y, z = 1, 2, 3

Swapping Variables

Python can swap variables without using a temporary variable.

a = 10
b = 20

a, b = b, a

print(a)
print(b)

20
10

Constants

Python doesn’t have true constants, but uppercase names indicate values that shouldn’t change.

PI = 3.14159
MAX_USERS = 100

Built-in Data Types

Checking a Data Type

Use the built-in type() function to inspect the type of an object.

age = 25

print(type(age))
print(type("Python"))
print(type(True))

<class 'int'>
<class 'str'>
<class 'bool'>

Type Conversion

Python allows converting values between compatible data types.

Mutable vs Immutable

Mutable objects can be modified after creation. Immutable objects cannot be changed once created.

Truthy and Falsy Values

In Python, every object evaluates to either True or False in conditional statements.

Arithmetic Operators

Comparison Operators

Logical Operators

Assignment Operators

Identity vs Equality

The == operator compares values, while is checks whether two variables reference the same object.

a = [1,2,3]
b = [1,2,3]

print(a == b)
print(a is b)

True
False

Membership Operators

fruits = ["apple", "banana", "orange"]

print("banana" in fruits)
print("pear" not in fruits)

True
True

Creating Strings

Strings can be enclosed in either single or double quotes.

name = "Alice"

city = 'London'

message = """Hello
World"""

String Indexing

Each character has an index starting at 0. Negative indexes count from the end.

text = "Python"

print(text[0])

print(text[3])

print(text[-1])

P
h
n

String Slicing

Slicing extracts part of a string using the syntax [start:end].

text = "Python"

print(text[0:3])

print(text[2:])

print(text[:4])

print(text[::-1])

Pyt
thon
Pyth
nohtyP

Creating a List

Create a list using square brackets. List items can contain the same or different data types.

fruits = ["apple", "banana", "orange"]
numbers = [1, 2, 3, 4]
mixed = ["Python", 3.12, True]

List Indexes

List indexes begin at 0. Negative indexes count backward from the end.

animals = ["Dog", "Cat", "Fox", "Cow"]

print(animals[0])
print(animals[2])
print(animals[-1])

Dog
Fox
Cow

Changing List Items

Lists are mutable, which means their values can be changed after creation.

fruits = ["apple", "banana", "orange"]

fruits[1] = "mango"

print(fruits)

["apple", "mango", "orange"]

Adding and Removing Items

List Slicing

Use slicing to extract part of a list with [start:end:step]. The ending index is not included.

numbers = [0, 1, 2, 3, 4, 5]

print(numbers[1:4])
print(numbers[:3])
print(numbers[::2])
print(numbers[::-1])

[1, 2, 3]
[0, 1, 2]
[0, 2, 4]
[5, 4, 3, 2, 1, 0]

Looping Through Lists

fruits = ["apple", "banana", "orange"]

for fruit in fruits:
    print(fruit)

List Comprehensions

List comprehensions provide a compact way to create a new list from an iterable.

numbers = [1, 2, 3, 4, 5]

squares = [number ** 2 for number in numbers]
even_numbers = [number for number in numbers if number % 2 == 0]

print(squares)
print(even_numbers)

[1, 4, 9, 16, 25]
[2, 4]

Creating Tuples

Create tuples using parentheses. A single-item tuple requires a trailing comma.

colors = ("red", "green", "blue")

numbers = (1, 2, 3)

single = ("apple",)

Tuple Indexes

Tuple indexing works exactly like lists.

colors = ("red", "green", "blue")

print(colors[0])

print(colors[-1])

red
blue

Tuple Methods

Tuple Packing and Unpacking

Python can automatically pack values into a tuple and unpack them into variables.

person = ("John", 30)

name, age = person

print(name)

print(age)

John
30

Tuple vs List

Creating Sets

Create a set using curly braces or the set() constructor.

fruits = {"apple", "banana", "orange"}

numbers = {1, 2, 3, 4}

letters = set(["a", "b", "c"])

Set Characteristics

Removing Duplicates

numbers = [1,2,2,3,3,4,5]

unique = set(numbers)

print(unique)

Common Set Methods

Set Operations

a = {1,2,3}
b = {3,4,5}

print(a | b)
print(a & b)
print(a - b)
print(a ^ b)

{1,2,3,4,5}
{3}
{1,2}
{1,2,4,5}

Set Operators

Creating Dictionaries

Create a dictionary using curly braces with keys and values separated by colons.

person = {
    "name": "John",
    "age": 30,
    "country": "USA"
}

print(person)

Dictionary Structure

Think of a dictionary as a collection of labels (keys) connected to values.

Accessing Values

person = {
    "name": "John",
    "age": 30
}

print(person["name"])
print(person["age"])

John
30

Adding and Updating Values

person = {
    "name": "John"
}

person["age"] = 30

person["name"] = "Alice"

print(person)

Common Dictionary Methods

Looping Through Dictionaries

person = {
    "name":"John",
    "age":30,
    "country":"USA"
}

for key, value in person.items():
    print(key, value)

Dictionary vs List

The if Statement

Use if when code should only run if a condition is true.

age = 16

if age >= 18:
    print("Adult")
else:
    print("Minor")

Minor

if…elif…else

Use elif when you need multiple conditions.

age = 25
has_ticket = True

if age >= 18 and has_ticket:
    print("Entry allowed")

Nested if Statements

fruits = ["apple", "banana", "orange"]

for fruit in fruits:
    print(fruit)

apple
banana
orange

range()

for i in range(5):
    print(i)

while Loop

count = 1

while count <= 5:
    print(count)
    count += 1

break

for i in range(10):

    if i == 5:
        break

    print(i)

continue

for i in range(5):

    if i == 2:
        continue

    print(i)

enumerate()

fruits = ["apple","banana","orange"]

for index, fruit in enumerate(fruits):
    print(index, fruit)

zip()

names = ["John","Anna"]
ages = [25,30]

for name, age in zip(names, ages):
    print(name, age)

Defining and Calling a Function

Use def to define a function. The indented code runs when the function is called.

def greet():
    print("Hello!")

greet()

Hello!

Parameters and Arguments

Parameters are names defined by the function. Arguments are the values supplied when calling it.

def greet(name):
    print(f"Hello, {name}!")

greet("Alice")

Hello, Alice!

Returning Values

Use return to send a value back to the caller.

def add(a, b):
    return a + b

result = add(5, 3)
print(result)

8

Default Parameters

Default values are used when an argument is not provided.

def greet(name="Guest"):
    print(f"Hello, {name}!")

greet()
greet("John")

Hello, Guest!
Hello, John!

Keyword Arguments

Keyword arguments identify values by parameter name, so their order can be changed.

def create_user(name, age, active):
    print(name, age, active)

create_user(age=30, active=True, name="Alice")

*args and **kwargs

def total(*numbers):
    return sum(numbers)

print(total(10, 20, 30))

60

def show_user(**user):
    for key, value in user.items():
        print(key, value)

show_user(name="Alice", age=30)

Multiple Return Values

Python can return multiple values as a tuple.

def calculate(a, b):
    return a + b, a * b

total, product = calculate(4, 5)

print(total)
print(product)

9
20

Function Scope

Variables created inside a function are local and normally cannot be used outside it.

message = "Global"

def show_message():
    message = "Local"
    print(message)

show_message()
print(message)

Local
Global

Docstrings

A docstring documents what a function does, its arguments and its return value.

def add(a, b):
    """Return the sum of two numbers."""
    return a + b

print(add.__doc__)

Lambda Syntax

A lambda function can take any number of arguments but can only contain a single expression.

square = lambda x: x * x

print(square(5))

25

Multiple Arguments

Lambda functions can accept multiple arguments.

multiply = lambda a, b: a * b

print(multiply(4, 6))

24

Using Lambda with sorted()

Lambda functions are commonly used as sorting keys.

people = [
    ("John", 25),
    ("Alice", 30),
    ("Bob", 20)
]

people.sort(key=lambda person: person[1])

print(people)

Using Lambda with map()

numbers = [1,2,3,4]

squared = list(map(lambda x: x**2, numbers))

print(squared)

[1, 4, 9, 16]

Using Lambda with filter()

numbers = [1,2,3,4,5,6]

even = list(filter(lambda x: x % 2 == 0, numbers))

print(even)

[2, 4, 6]

Lambda vs Regular Function

Importing a Module

Use the import keyword to access functions, classes and variables from another module.

import math

print(math.sqrt(25))
print(math.pi)

5.0
3.141592653589793

Import Specific Functions

Import only the functions you need to keep your code concise.

from math import sqrt

print(sqrt(81))

9.0

Import with an Alias

Aliases shorten long module names and improve readability.

import numpy as np

array = np.array([1,2,3])

print(array)

Creating Your Own Module

Any Python file (.py) can become a module.

def add(a, b):
    return a + b

Use your custom module:

import calculator

print(calculator.add(5, 3))

Popular Standard Library Modules

Built-in vs Third-Party Modules

Installing Third-Party Packages

pip install requests

pip install pandas

pip install numpy

Opening a File

Use the built-in open() function to open a file.

file = open("example.txt", "r")

print(file.read())

file.close()

File Modes

Reading Files

with open("example.txt", "r") as file:

    print(file.read())

Read Line by Line

with open("example.txt") as file:

    for line in file:
        print(line.strip())

Writing Files

with open("example.txt", "w") as file:

    file.write("Hello World")

Appending to a File

with open("example.txt", "a") as file:

    file.write("\nAnother line")

Why Use with?

Basic try...except

Use try to execute code that may fail and except to handle errors.

try:
    print(10 / 0)

except ZeroDivisionError:
    print("Cannot divide by zero.")

Cannot divide by zero.

Handling Multiple Exceptions

try:
    number = int(input("Enter a number: "))
    print(100 / number)

except ValueError:
    print("Please enter a valid number.")

except ZeroDivisionError:
    print("Number cannot be zero.")

Using else

The else block executes only if no exception occurs.

try:
    result = 20 / 5

except ZeroDivisionError:
    print("Error")

else:
    print(result)

Using finally

The finally block always runs, even if an exception occurs.

try:
    file = open("example.txt")

finally:
    file.close()

Raising Exceptions

Use raise to trigger your own exception.

age = -5

if age < 0:
    raise ValueError("Age cannot be negative.")

Common Built-in Exceptions

What is a Class?

A class is a blueprint used to create objects. It defines what data and behavior an object will have.

Class
 │
 ├── Attributes
 │      name
 │      age
 │
 └── Methods
        speak()
        walk()

            │
            ▼

        Object

Creating Your First Class

class Dog:

    pass

dog = Dog()

print(type(dog))

<class '__main__.Dog'>

The __init__ Constructor

The __init__() method runs automatically when a new object is created.

class Dog:

    def __init__(self, name):

        self.name = name

dog = Dog("Buddy")

print(dog.name)

Buddy

Attributes vs Methods

Creating Methods

class Dog:

    def __init__(self, name):

        self.name = name

    def bark(self):

        print(f"{self.name} says Woof!")

dog = Dog("Buddy")

dog.bark()

Buddy says Woof!

What is a Generator?

A generator function uses the yield keyword instead of return. Each call produces the next value while preserving the function's state.

Generator

yield → 1

yield → 2

yield → 3

yield → ...

(Produces one value at a time)

Creating a Generator

def count():

    yield 1
    yield 2
    yield 3

for number in count():

    print(number)

1
2
3

yield vs return

Using next()

The next() function manually retrieves the next value from a generator.

def numbers():

    yield 10
    yield 20
    yield 30

gen = numbers()

print(next(gen))
print(next(gen))
print(next(gen))

10
20
30

Generator Expression

Generator expressions are similar to list comprehensions but use parentheses instead of square brackets.

squares = (x**2 for x in range(5))

for value in squares:

    print(value)

Memory Comparison

Infinite Generator

def infinite():

    number = 1

    while True:

        yield number

        number += 1

This generator never ends and is useful for streams or continuous data processing.

What is a Decorator?

A decorator wraps another function and adds functionality before or after it runs.

Original Function

       │

       ▼

Decorator

       │

       ▼

Enhanced Function

Functions are First-Class Objects

Functions can be assigned to variables, passed as arguments and returned from other functions. This capability makes decorators possible.

def greet():

    print("Hello!")

say_hello = greet

say_hello()

Hello!

Creating Your First Decorator

def decorator(func):

    def wrapper():

        print("Before")

        func()

        print("After")

    return wrapper

@decorator

def greet():

    print("Hello!")

greet()

Before
Hello!
After

Decorator with Arguments

Use *args and **kwargs so the decorator works with any function signature.

def decorator(func):

    def wrapper(*args, **kwargs):

        print("Running...")

        return func(*args, **kwargs)

    return wrapper

@decorator

def add(a, b):

    return a + b

print(add(4, 5))

Running...
9

Common Uses for Decorators

Built-in Decorators

Basic Type Hints

Use a colon (:) for variables and -> for function return types.

name: str = "Alice"
age: int = 30
height: float = 1.72
active: bool = True

Function Type Hints

Annotate parameters and the return value to clearly document how a function should be used.

def add(a: int, b: int) -> int:

    return a + b

print(add(5, 3))

8

Common Built-in Types

Generic Collection Types

Specify the type of items stored inside collections.

numbers: list[int] = [1, 2, 3]

names: list[str] = ["Alice", "Bob"]

scores: dict[str, int] = {
    "Alice": 95,
    "Bob": 88
}

coordinates: tuple[int, int] = (10, 20)

unique: set[str] = {"red", "blue"}

Optional Values

Use Optional when a value may be None.

from typing import Optional

def get_name() -> Optional[str]:

    return None

Union Types (Python 3.10+)

The pipe operator (|) can specify multiple valid types.

def square(value: int | float) -> float:

    return value * value

Most Useful typing Objects

Why Use a Virtual Environment?

Without virtual environments, installing packages globally can cause version conflicts between projects.

Without venv

Project A
└── requests 2.28

Project B
└── requests 2.32

❌ Version conflict


With venv

Project A
└── venv
    └── requests 2.28

Project B
└── venv
    └── requests 2.32

✅ Completely isolated

Create a Virtual Environment

Run the following command inside your project folder.

python -m venv venv

Activate the Environment

Install Packages

After activating the virtual environment, install packages normally using pip.

pip install requests

pip install pandas

pip install numpy

View Installed Packages

pip list

Create requirements.txt

Save your project's dependencies so others can install the same package versions.

pip freeze > requirements.txt

Install from requirements.txt

pip install -r requirements.txt

Deactivate the Environment

deactivate

Common Commands

Follow PEP 8

PEP 8 is the official Python style guide. Following it makes your code consistent and easier for others to understand.

Use Meaningful Names

Choose descriptive names instead of short or unclear abbreviations.

Keep Functions Small

Each function should perform one clear task. Small functions are easier to understand, test and reuse.

def calculate_total(price, tax):

    return price + tax

Use Constants

Store fixed values in uppercase variables instead of hardcoding them throughout your program.

MAX_USERS = 100

TIMEOUT = 30

Avoid Global Variables

Write Docstrings

Document public functions, classes and modules so other developers understand their purpose.

def add(a, b):

    """Return the sum of two numbers."""

    return a + b

Use Virtual Environments

Create a separate virtual environment for every project to avoid dependency conflicts.

python -m venv venv

Prefer Logging Over print()

Use the logging module for debugging and production applications instead of relying on print().

import logging

logging.basicConfig(level=logging.INFO)

logging.info("Application started")

Common Anti-Patterns