Forem: Shahrouz Nikseresht

Introduction to Classes in Python Explained Simply (Basic OOP)

Shahrouz Nikseresht — Thu, 16 Apr 2026 17:00:00 +0000

Classes let you create your own data types by combining data and functions. This is the start of object-oriented programming (OOP) in Python.

What is a class?

A class is a blueprint for creating objects. An object is an instance of a class.

Define a simple class with the class keyword:

class Dog:
    pass

Create an object (instance):

my_dog = Dog()

Adding attributes

Attributes are variables that belong to an object.

Use __init__ (the constructor) to set initial attributes:

class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age

Create objects with values:

dog1 = Dog("Buddy", 3)
dog2 = Dog("Luna", 5)

print(dog1.name)  # Buddy
print(dog2.age)   # 5

self refers to the current object and is always the first parameter in methods.

Adding methods

Methods are functions that belong to a class.

class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def bark(self):
        print("Woof!")

    def get_info(self):
        print(f"{self.name} is {self.age} years old.")

Call methods on objects:

dog1 = Dog("Buddy", 3)

dog1.bark()       # Woof!
dog1.get_info()   # Buddy is 3 years old.

Simple examples

A basic Person class:

class Person:
    def __init__(self, name, city):
        self.name = name
        self.city = city

    def introduce(self):
        print(f"Hi, I'm {self.name} from {self.city}.")

p = Person("Alex", "Berlin")
p.introduce()  # Hi, I'm Alex from Berlin.

A Rectangle class:

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

rect = Rectangle(10, 5)
print(rect.area())  # 50

Important notes

Class names use CamelCase by convention.
__init__ runs automatically when creating an object.
All methods take self as the first parameter.
Attributes are accessed with dot notation (object.attribute).

Quick summary

Define classes with class.
Use __init__ to set initial attributes.
Add methods to define behavior.
Create objects with ClassName().
Access attributes and methods with dot notation.

Practice creating simple classes for real-world objects. Classes help organize code and model data in Python programs.

Python Modules and Imports Explained Simply

Shahrouz Nikseresht — Thu, 09 Apr 2026 17:00:00 +0000

Modules help organize code by splitting it into separate files. They make programs easier to manage and allow code reuse.

What is a module?

A module is a Python file (.py) containing functions, variables, or classes.

For example, create a file named math_utils.py:

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

def multiply(a, b):
    return a * b

pi = 3.14159

This file is now a module.

Importing modules

Use import to load a module.

import math_utils

result = math_utils.add(5, 3)
print(result)  # 8

print(math_utils.pi)  # 3.14159

Import specific items:

from math_utils import add, pi

print(add(10, 20))  # 30
print(pi)          # 3.14159

Import everything (not recommended for large modules):

from math_utils import *

print(multiply(4, 5))  # 20

Using built-in modules

Python has many built-in modules.

Random module:

import random

print(random.randint(1, 10))  # Random number between 1 and 10
print(random.choice(["apple", "banana", "cherry"]))  # Random item

Math module:

import math

print(math.sqrt(16))   # 4.0
print(math.pi)         # 3.141592653589793

Aliasing for shorter names

Give a module a shorter name with as:

import random as rnd

print(rnd.randint(1, 100))

Simple examples

Create a greeting module greet.py:

def hello(name):
    return f"Hello, {name}!"

def goodbye(name):
    return f"Goodbye, {name}!"

Use it in main file:

from greet import hello, goodbye

print(hello("Alex"))
print(goodbye("Sam"))

Important notes

The module file must be in the same folder or in Python's path.
Use descriptive module names (lowercase, underscores).
Avoid from module import * in larger programs (can cause name conflicts).
Modules are loaded only once per program run.

Quick summary

Modules are separate .py files with reusable code.
Import with import module or from module import item.
Use as for aliases.
Built-in modules like random and math provide extra functionality.
Organize code into modules for better structure.

Practice creating and importing small modules. They are essential for building larger Python programs.

Reading and Writing Files in Python Explained Simply

Shahrouz Nikseresht — Thu, 02 Apr 2026 17:00:00 +0000

Working with files lets your programs store and retrieve data. Python makes basic file operations easy with the open() function.

Opening a file

Use open() with the file name and mode.

Common modes:

"r": read (default)
"w": write (overwrites if file exists)
"a": append (adds to end)
"r+": read and write

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

Always close the file when done:

file.close()

Better: use with (automatically closes):

with open("example.txt", "r") as file:
    # work with file
# file is closed here automatically

Reading from a file

Read entire content:

with open("example.txt", "r") as file:
    content = file.read()
    print(content)

Read line by line:

with open("example.txt", "r") as file:
    for line in file:
        print(line.strip())  # strip removes newline

Read all lines into a list:

with open("example.txt", "r") as file:
    lines = file.readlines()
    print(lines)

Writing to a file

Write (overwrites):

with open("output.txt", "w") as file:
    file.write("Hello, file!\n")
    file.write("Second line.")

Append:

with open("output.txt", "a") as file:
    file.write("\nNew appended line.")

Write multiple lines:

lines = ["First line\n", "Second line\n", "Third line\n"]

with open("list.txt", "w") as file:
    file.writelines(lines)

Simple examples

Save user input to a file:

name = input("Enter your name: ")

with open("names.txt", "a") as file:
    file.write(name + "\n")

Read and display a file:

try:
    with open("data.txt", "r") as file:
        print(file.read())
except FileNotFoundError:
    print("File not found.")

Important notes

Use with to avoid forgetting to close files.
Specify encoding if needed: open("file.txt", "r", encoding="utf-8")
Handle FileNotFoundError when reading non-existent files.
Writing in "w" mode deletes existing content.

Quick summary

Open files with open() and use with for safety.
Read with .read(), .readlines(), or loop.
Write with .write() or .writelines().
Use "r" for reading, "w" for writing, "a" for appending.
Always handle possible errors.

Practice reading from and writing to simple text files. File operations are essential for persistent data in Python programs.

Python List Comprehensions Explained Simply (Concise Syntax)

Shahrouz Nikseresht — Thu, 26 Mar 2026 17:00:00 +0000

List comprehensions provide a short and readable way to create new lists based on existing ones. They combine loops and conditions in one line.

What is a list comprehension?

A basic list comprehension looks like this:

numbers = [1, 2, 3, 4, 5]
squares = [x * x for x in numbers]
print(squares)  # [1, 4, 9, 16, 25]

The structure is:
[new_value for item in sequence]

It works like a for loop but written inside square brackets.

Adding conditions

Filter items with an if clause:

even_squares = [x * x for x in numbers if x % 2 == 0]
print(even_squares)  # [4, 16]

Only items where the condition is True are included.

More examples

Double values greater than 3:

doubled = [x * 2 for x in numbers if x > 3]
print(doubled)  # [8, 10]

Convert strings to uppercase:

words = ["hello", "world", "python"]
upper = [word.upper() for word in words]
print(upper)  # ['HELLO', 'WORLD', 'PYTHON']

Replace values conditionally:

adjusted = [x + 1 if x < 3 else x - 1 for x in numbers]
print(adjusted)  # [2, 3, 4, 3, 4]

Equivalent with regular loops

The same result without comprehension:

squares = []
for x in numbers:
    squares.append(x * x)

Comprehensions are shorter and often clearer for simple cases.

Important notes

Use comprehensions for simple transformations and filters.
Avoid complex logic (multiple nested loops or long conditions) to keep code readable.
They create a new list; the original stays unchanged.

Quick summary

Basic form: [expression for item in sequence]
Add filter: [expression for item in sequence if condition]
Add if-else: [expr1 if condition else expr2 for item in sequence]
Great for creating transformed or filtered lists quickly.

Practice rewriting simple for loops as comprehensions. They make Python code more concise and elegant.

Basic Error Handling in Python: try and except Explained Simply

Shahrouz Nikseresht — Thu, 19 Mar 2026 17:00:00 +0000

Errors (exceptions) happen in every program. Python's try and except blocks let you handle them gracefully instead of crashing.

Why handle errors?

Without handling, an error stops the program.

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

If the user enters "zero" or "hello", the program crashes.

With error handling, you can recover or show a friendly message.

The basic try-except structure

try:
    number = int(input("Enter a number: "))
    result = 10 / number
    print(result)
except:
    print("Something went wrong. Please enter a valid number.")

The code in try runs normally.

If an error occurs, Python jumps to except instead of crashing.

Handling specific errors

It is better to catch specific exceptions.

Common ones:

ValueError: wrong type (e.g., int("hello"))
ZeroDivisionError: division by zero
IndexError: list index out of range
KeyError: dictionary key not found

try:
    age = int(input("Enter your age: "))
    print(100 / age)
except ValueError:
    print("Please enter a valid number.")
except ZeroDivisionError:
    print("Age cannot be zero.")

Using else and finally

else: runs only if no error occurred
finally: runs always (error or not)

try:
    file = open("data.txt")
    content = file.read()
except FileNotFoundError:
    print("File not found.")
else:
    print("File read successfully.")
    file.close()
finally:
    print("Operation complete.")

Simple examples

Safe division:

try:
    num = float(input("Enter numerator: "))
    den = float(input("Enter denominator: "))
    result = num / den
except ZeroDivisionError:
    print("Cannot divide by zero.")
except ValueError:
    print("Please enter numbers only.")
else:
    print(f"Result: {result}")

Safe list access:

scores = [85, 92, 78]

try:
    index = int(input("Enter index: "))
    print(scores[index])
except IndexError:
    print("Index out of range.")
except ValueError:
    print("Please enter a number.")

Important notes

Be specific with exceptions when possible.
Avoid bare except: in real programs (it catches everything, including system exits).
Use finally for cleanup (closing files, connections).

Quick summary

Put risky code in try.
Catch errors with except (specific types when possible).
Use else for code that runs only on success.
Use finally for cleanup.
Handling errors makes programs more robust.

Practice adding try-except to small scripts. Error handling is essential for reliable Python programs.

Python Sets Explained Simply (Unique and Unordered Collections)

Shahrouz Nikseresht — Thu, 12 Mar 2026 17:00:00 +0000

Sets are collections that store unique items with no duplicates. They are useful for membership testing and removing duplicates quickly.

What is a set?

A set is created with curly braces {} and items separated by commas. Order does not matter.

fruits = {"apple", "banana", "cherry"}
numbers = {1, 2, 3, 4, 5}
mixed = {10, "hello", True}

You can also create a set from a list:

unique_numbers = set([1, 2, 2, 3, 3, 3])
print(unique_numbers)  # {1, 2, 3}

An empty set (note: {} makes a dictionary):

empty_set = set()

Sets automatically remove duplicates.

Adding and removing items

Add an item with add():

fruits.add("orange")
print(fruits)  # Includes orange

Remove an item with remove() (raises error if not found) or discard() (no error):

fruits.remove("banana")
fruits.discard("missing")  # No error

Common operations

Check membership:

print("apple" in fruits)  # True or False

Get length:

print(len(fruits))  # Number of unique items

Loop over a set:

for fruit in fruits:
    print(fruit)

Set operations

Union (all items):

set1 = {1, 2, 3}
set2 = {3, 4, 5}
combined = set1.union(set2)  # or set1 | set2
print(combined)  # {1, 2, 3, 4, 5}

Intersection (common items):

common = set1.intersection(set2)  # or set1 & set2
print(common)  # {3}

Difference (items in one but not both):

diff = set1.difference(set2)  # or set1 - set2
print(diff)  # {1, 2}

Simple examples

Remove duplicates from a list:

scores = [85, 92, 85, 78, 92]
unique_scores = set(scores)
print(unique_scores)  # {85, 92, 78}

Check common friends:

friends_a = {"Ali", "Sara", "Reza"}
friends_b = {"Sara", "Mohammad", "Reza"}
common = friends_a & friends_b
print(common)  # {"Sara", "Reza"}

Important notes

Sets are unordered: items have no index.
Sets are mutable, but items must be immutable (no lists inside sets).
Sets are fast for checking if an item exists.

Quick summary

Create sets with curly braces or set().
Sets store unique items only.
Use add(), remove(), and discard() to modify.
Perform union, intersection, and difference easily.
Ideal for removing duplicates and membership tests.

Practice using sets for unique collections. They provide efficient operations not available with lists in Python programs.

Python Tuples Explained Simply (Immutable Sequences)

Shahrouz Nikseresht — Thu, 05 Mar 2026 17:00:00 +0000

Tuples are ordered collections similar to lists, but they cannot be changed after creation. This makes them useful for data that should stay fixed.

What is a tuple?

A tuple is created with parentheses () and items separated by commas.

coordinates = (10, 20)
colors = ("red", "green", "blue")
single_item = (5,)  # Note the comma for one item

You can also create a tuple without parentheses:

point = 3, 4

An empty tuple:

empty_tuple = ()

Tuples can contain mixed types and are immutable.

Accessing elements

Use indexes just like lists (starting at 0).

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

print(colors[0])   # red
print(colors[-1])  # blue

Slicing works too:

print(colors[1:3])  # ("green", "blue")

Why use tuples instead of lists?

Tuples are immutable: you cannot add, remove, or change items.
This protects data from accidental changes.
Tuples are faster than lists.
Tuples can be used as dictionary keys (lists cannot).

Attempting to modify raises an error:

colors[0] = "yellow"  # TypeError: 'tuple' object does not support item assignment

Common operations

Get length:

print(len(colors))  # 3

Check membership:

print("green" in colors)  # True

Loop over a tuple:

for color in colors:
    print(color)

Packing and unpacking

Tuples make it easy to assign multiple values.

Packing:

person = ("Alex", 25, "Berlin")

Unpacking:

name, age, city = person
print(name)  # Alex
print(age)   # 25

This works with functions too:

def get_point():
    return (10, 20)

x, y = get_point()
print(x, y)  # 10 20

Simple examples

Store fixed settings:

screen_size = (1920, 1080)  # Cannot be changed accidentally

RGB color values:

red = (255, 0, 0)

Quick summary

Create tuples with parentheses (and a comma for single items).
Access elements with indexes and slicing.
Tuples are immutable and faster than lists.
Use unpacking to assign multiple values easily.
Choose tuples for data that should not change.

Practice using tuples for fixed collections. They are a safe and efficient alternative to lists in Python programs.

Basic Type Conversion in Python Explained Simply

Shahrouz Nikseresht — Thu, 26 Feb 2026 17:00:00 +0000

Type conversion (also called type casting) changes a value from one data type to another. Python provides built-in functions to do this safely.

Why convert types?

Different operations require specific types. For example, you cannot add a string and an integer directly.

Common situations:

Converting user input (always string) to numbers
Combining numbers into text
Working with different data sources

Common conversion functions

int() → converts to integer (whole number)

text = "25"
age = int(text)
print(age + 5)  # 30

float() → converts to floating-point number (with decimals)

price_text = "19.99"
price = float(price_text)
print(price + 0.01)  # 20.0

str() → converts anything to string

score = 95
message = "Your score: " + str(score)
print(message)  # Your score: 95

bool() → converts to True or False

print(bool(0))     # False
print(bool(1))     # True
print(bool(""))    # False (empty string)
print(bool("hi"))  # True

Examples in action

Convert input for calculations:

height_cm = input("Enter height in cm: ")
height_m = float(height_cm) / 100
print(f"Height in meters: {height_m}")

Build messages with mixed types:

items = 3
total = 45.50
summary = f"You bought {items} items for ${total}"
print(summary)

When conversion fails

Some conversions raise errors:

int("hello")  # ValueError: invalid literal for int()

Always handle possible errors in real programs (covered in later topics).

Quick summary

Use int() for whole numbers.
Use float() for decimal numbers.
Use str() to turn values into text.
Use bool() to get True/False.
Convert types when mixing different data.

Practice converting between types in small scripts. Type conversion is essential for working with real data in Python programs.

Python Input and Output Explained Simply

Shahrouz Nikseresht — Thu, 19 Feb 2026 17:00:00 +0000

Input and output operations let your programs interact with users. Python makes this straightforward with input() and print().

Getting input from the user

Use input() to read text from the keyboard. It always returns a string.

name = input("Enter your name: ")
print(name)

Add a prompt inside input():

age = input("How old are you? ")

The program waits for the user to type something and press Enter.

Converting input types

Since input() returns a string, convert it when needed.

age = int(input("How old are you? "))
print(age + 1)  # Adds 1 to the number

Common conversions:

int() for whole numbers
float() for decimals
str() to convert back to text

Without conversion:

number = input("Enter a number: ")  # "10"
result = number + "5"               # "105" (concatenation, not addition)

Basic output with print

Use print() to display values.

print("Hello, world!")
print(42)
print(True)

Print multiple items:

name = "Alex"
score = 95

print("Name:", name, "Score:", score)

Use f-strings for cleaner output:

print(f"{name} scored {score} points.")

Control formatting:

pi = 3.14159
print(f"Pi rounded: {pi:.2f}")  # Pi rounded: 3.14

Simple program example

A basic calculator addition:

num1 = float(input("Enter first number: "))
num2 = float(input("Enter second number: "))

sum_result = num1 + num2
print(f"The sum is: {sum_result}")

Common mistake: forgetting type conversion

This causes errors when doing math:

age = input("Age: ")  # "25"
next_year = age + 1    # TypeError

Fix:

next_year = int(age) + 1

Quick summary

input() reads user text (always as string).
Convert with int(), float(), etc. for calculations.
print() displays output; use f-strings for formatting.
Combine them to make interactive programs.

Practice building small interactive scripts. Input and output are key for creating useful Python programs.

Python Strings Explained Simply (Common Operations and Methods)

Shahrouz Nikseresht — Thu, 12 Feb 2026 17:00:00 +0000

Strings are used to handle text in Python. They are one of the most common data types and come with many built-in tools.

What is a string?

A string is text enclosed in single quotes ' ' or double quotes " ".

name = "Alex"
message = 'Hello, Python!'
multiline = """This is a
multi-line string."""

Strings are immutable, which means you cannot change them directly. Operations create new strings instead.

Basic operations

Concatenate (join) strings with +:

greeting = "Hello" + " " + "Alex"
print(greeting)  # Hello Alex

Repeat a string with *:

stars = "*" * 10
print(stars)  # **********

Get the length with len():

print(len(name))  # 4

Accessing characters

Use indexes to get individual characters. Indexes start at 0.

text = "Python"

print(text[0])  # P
print(text[-1]) # n (last character)

Slice to get a substring:

print(text[1:4])  # yth
print(text[:3])   # Pyt (from start)
print(text[3:])   # hon (to end)

Common string methods

Convert case:

text = "hello python"

print(text.upper())   # HELLO PYTHON
print(text.lower())   # hello python
print(text.title())   # Hello Python

Replace parts:

message = "I like cats"
new_message = message.replace("cats", "dogs")
print(new_message)  # I like dogs

Split into a list:

words = "apple,banana,cherry"
word_list = words.split(",")
print(word_list)  # ['apple', 'banana', 'cherry']

Check content:

email = "user@example.com"

print(email.startswith("user"))  # True
print(email.endswith(".com"))    # True

Formatting strings

Use f-strings for clean formatting:

name = "Alex"
age = 25

print(f"{name} is {age} years old.")  # Alex is 25 years old.

Common mistake: trying to change a string directly

Strings are immutable, so this causes an error:

text = "hello"
text[0] = "H"  # TypeError: 'str' object does not support item assignment

Create a new string instead:

new_text = "H" + text[1:]
print(new_text)  # Hello

Quick summary

Create strings with quotes.
Use indexing and slicing to access parts.
Apply methods like .upper(), .lower(), .replace(), and .split().
Use f-strings for easy formatting.
Remember strings are immutable.

Practice common operations on strings. They are essential for handling text in Python programs.

Python Dictionaries Explained Simply (Keys, Values, and Access)

Shahrouz Nikseresht — Thu, 05 Feb 2026 17:00:00 +0000

Dictionaries store data as key-value pairs. They are useful when you need to look up values quickly using a unique key instead of an index.

What is a dictionary?

A dictionary is created with curly braces {}. Each item is a pair: a key followed by a colon : and a value. Pairs are separated by commas.

person = {
    "name": "Alex",
    "age": 25,
    "city": "Berlin"
}

settings = {
    "theme": "dark",
    "notifications": True,
    "volume": 75
}

You can also create an empty dictionary:

empty_dict = {}

Keys are usually strings or numbers. Values can be any type.

Accessing values with keys

Use square brackets [] and the key to get a value.

print(person["name"])  # Alex
print(person["age"])   # 25

Modifying and adding items

Dictionaries are mutable. Change a value with its key:

person["age"] = 26
print(person["age"])  # 26

Add a new key-value pair the same way:

person["job"] = "Developer"
print(person["job"])  # Developer

Key differences: list vs dictionary

A list uses numeric indexes (0, 1, 2...) to access items in order.
A dictionary uses custom keys (often strings) to access values directly.

Example comparison:

# List: access by position
fruits_list = ["apple", "banana", "cherry"]
print(fruits_list[1])  # banana

# Dictionary: access by key
fruits_dict = {
    "first": "apple",
    "second": "banana",
    "third": "cherry"
}
print(fruits_dict["second"])  # banana

Dictionaries are faster for lookups when keys are meaningful.

Common examples

Simple translation dictionary:

translate = {
    "hello": "hallo",
    "goodbye": "auf Wiedersehen",
    "thanks": "danke"
}

print(translate["hello"])  # hallo
translate["yes"] = "ja"

User information:

user = {
    "username": "alex123",
    "email": "alex@example.com",
    "active": True
}

print(user["email"])  # alex@example.com

Common mistake: KeyError

If you try to access a key that does not exist, Python raises an error.

print(person["phone"])  # KeyError: 'phone'

Check if a key exists first, or use .get() which returns None if missing:

print(person.get("phone"))  # None

Quick summary

Create dictionaries with curly braces and key-value pairs.
Access and modify values using keys in square brackets.
Add new items by assigning to a new key.
Keys must be unique; use meaningful names.
Dictionaries are key-based, unlike order-based lists.

Practice building small dictionaries for real data. They are essential for organizing information in Python programs.

Python Lists Explained: Create, Access, and Modify Elements

Shahrouz Nikseresht — Thu, 29 Jan 2026 17:00:00 +0000

Lists are one of the most useful data structures in Python. They store an ordered collection of items that can be of different types.

What is a list?

A list is a collection of items enclosed in square brackets []. Items are separated by commas.

fruits = ["apple", "banana", "cherry"]
numbers = [1, 2, 3, 4, 5]
mixed = [10, "hello", True, 3.14]

Lists maintain order, so the first item added stays first.

You can also create an empty list:

empty_list = []

Accessing elements with indexes

Each item in a list has a position called an index. Indexes start at 0.

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

print(fruits[0])  # apple
print(fruits[1])  # banana
print(fruits[2])  # cherry

Use negative indexes to access from the end:

print(fruits[-1])  # cherry (last item)
print(fruits[-2])  # banana

Modifying lists

Lists are mutable, which means you can change items after creation.

Change an item by index:

fruits[1] = "orange"
print(fruits)  # ["apple", "orange", "cherry"]

Add items with append():

fruits.append("grape")
print(fruits)  # ["apple", "orange", "cherry", "grape"]

Getting the length

Use len() to find how many items a list has:

print(len(fruits))  # 4

Common examples

Work with a list of scores:

scores = [85, 92, 78, 90]

print(scores[0])     # First score: 85
print(scores[-1])    # Last score: 90
scores.append(88)
print(len(scores))   # 5

Common mistake: IndexError

Trying to access an index that does not exist causes an error.

fruits = ["apple", "banana"]

print(fruits[5])  # IndexError: list index out of range

Always check the length with len() if needed, or use valid indexes.

Quick summary

Create lists with square brackets [].
Access items with indexes starting at 0.
Use negative indexes for the end of the list.
Modify items directly or use append() to add new ones.
Use len() to get the number of items.

Practice creating and modifying lists. They are essential for storing and working with collections of data in Python programs.