This guide explores ten foundational Python concepts, each accompanied by practical exercises to solidify your understanding of the language.

1. Variables and Data Types

Variables act as containers for storing data. Assigning a name and a value creates a variable. Python supports several core data types:

• Integer (int): e.g., item_count = 42
• Float (float): e.g., exchange_rate = 3.14
• String (str): e.g., user_name = "Alice"
• Boolean (bool): e.g., is_active = True

You can convert between types using built-in functions like int("123") to convert a string to an integer.

2. Operators and Expressions

Operators perform operations on values. Key categories include:

• Arithmetic Operators: +, -, *, /, % (modulo), ** (exponentiation)
• Comparison Operators: ==, !=, >, <, >=, `<=
• Assignment Operators: =, +=, -=, etc.

Exercise: Write a program that takes two numbers from the user and calculates their sum, difference, product, quotient, remainder, and power.

3. Conditional Statements

Conditional logic allows programs to make decisions using if, elif, and else.

humidity = 75
if humidity > 80:
    print("Very humid conditions.")
elif humidity < 30:
    print("Dry air detected.")
else:
    print("Humidity level is moderate.")

4. Loop Structures

Loops execute code repeatedly. Python offers for and while loops.

• For loop with range():

for index in range(3):
    print(f"Iteration {index}")

• While loop:

counter = 0
while counter < 3:
    print(counter)
    counter += 1

Use break to exit a loop early and continue to skip to the next iteration.

Exercise: Use loops to print a numeric pyramid pattern.

5. Lists and Tuples

Lists are ordered, mutable sequences.

inventory = ["hammer", "nails", "screwdriver"]
print(inventory[1])  # Outputs "nails"
inventory.append("tape")
inventory.sort()

Tuples are ordered but immutable.

location = (51.5074, -0.1278)  # London coordinates
print(location[0])  # Outputs 51.5074

Exercise: Create a program to manage a task list, allowing addition, removal, and alphabetical sorting of items.

6. Dictionaries and Sets

Dictionaries store key-value pairs.

employee = {"id": 101, "department": "Engineering", "level": 2}
print(employee["department"])  # Outputs "Engineering"

Sets contain unique, unordered elements and support set operations.

set_a = {"python", "java", "c++"}
set_b = {"java", "javascript", "go"}
common_languages = set_a.intersection(set_b)

Exercise: Build a simple product catalog using dictionaries for item details and a set to track unique categories.

7. Functon Definition and Invocation

Functions encapsulate reusable code blocks.

def calculate_discount(price, rate):
    """Calculate final price after discount."""
    return price * (1 - rate / 100)

final_price = calculate_discount(200, 15)
print(final_price)

Functions can accept parameters, return values, and handle variable arguments with *args and **kwargs.

Exercise: Write a function to compute the area of a circle given its radius.

8. Modules and Importing

Modules organize related code. Import them using various syntaxes.

import statistics
average = statistics.mean([10, 20, 30])

from random import randint
random_value = randint(1, 100)

import custom_module as cm
cm.perform_action()

Exercise: Use the math module to calculate the hypotenuse of a right triangle.

9. Error and Exception Handling

Use try, except, and finally to manage runtime errors gracefully.

try:
    data_file = open("missing_data.csv", "r")
except FileNotFoundError:
    print("Error: Could not locate the specified file.")
finally:
    if 'data_file' in locals():
        data_file.close()

The raise statement can trigger exceptions, and custom exception classes can be defined.

Exercise: Write a program that reads user input and handles potential ValueError exceptions from invalid numeric entries.

10. Introduction to Object-Oriented Programming

Object-Oriented Programming (OOP) models data and behavior using classes and objects.

class Vehicle:
    def __init__(self, brand, model):
        self.brand = brand
        self.model = model

    def describe(self):
        pass  # To be overridden by subclasses

class Car(Vehicle):
    def describe(self):
        return f"{self.brand} {self.model} is a car."

class Motorcycle(Vehicle):
    def describe(self):
        return f"{self.brand} {self.model} is a motorcycle."

my_car = Car("Toyota", "Camry")
my_bike = Motorcycle("Honda", "CBR")

print(my_car.describe())
print(my_bike.describe())

This demonstrates inheritance and polymorphism, where subclasses (Car, Motorcycle) extend a base class (Vehicle) and provide their own implementations of the describe method.