DEV Community: Shahrouz Nikseresht

Python String Methods Explained Simply (Common Operations)

Shahrouz Nikseresht — Thu, 21 May 2026 17:00:00 +0000

Strings have many built-in methods for common tasks. These methods return new strings and do not change the original.

Basic methods for changing case

text = "hello python"

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

Removing whitespace

messy = "  hello  "

print(messy.strip())   # "hello"
print(messy.lstrip())  # "hello  "
print(messy.rstrip())  # "  hello"

Finding and replacing

sentence = "I like cats and cats like me"

print(sentence.find("cats"))     # 7 (first position)
print(sentence.replace("cats", "dogs"))  # I like dogs and dogs like me

Checking content

email = "user@example.com"

print(email.startswith("user"))  # True
print(email.endswith(".com"))    # True
print("123".isdigit())           # True
print("abc".isalpha())           # True

Splitting and joining

words = "apple,banana,cherry"

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

new_string = "-".join(word_list)
print(new_string)  # apple-banana-cherry

Simple examples

Clean user input:

name = "  Alice  "
clean_name = name.strip().title()
print(clean_name)  # Alice

Count occurrences (use count method):

text = "hello hello world"
print(text.count("hello"))  # 2

Quick summary

Methods like .upper(), .lower(), .strip() for formatting.
.find(), .replace() for searching and changing.
.startswith(), .endswith(), .isdigit() for checks.
.split() and .join() for lists and strings.

Practice common string methods on text. They are essential for cleaning and processing strings in Python programs.

Python Virtual Environments Explained Simply

Shahrouz Nikseresht — Thu, 14 May 2026 17:00:00 +0000

Virtual environments let you create isolated spaces for Python projects. Each project can have its own packages and versions without conflicts.

Why use virtual environments?

Different projects might need different versions of the same package.

Without isolation, installing packages globally can cause version conflicts.

Virtual environments solve this by keeping dependencies separate.

Creating a virtual environment

Python has a built-in module called venv.

Create one:

python -m venv myenv

This creates a folder called myenv with an isolated Python setup.

Common names: venv, .venv, or project-specific like myproject-env.

Activating the environment

Activate to use the isolated Python and packages.

On Windows:

myenv\Scripts\activate

On macOS/Linux:

source myenv/bin/activate

After activation, your terminal prompt usually changes (e.g., (myenv) appears).

Now python and pip refer to the isolated versions.

Installing packages

With the environment active:

pip install requests
pip install django

These packages install only inside the current environment.

Deactivating

Leave the environment:

deactivate

You return to the global Python setup.

Simple workflow example

# Create project folder and env
mkdir myproject
cd myproject
python -m venv venv

# Activate
source venv/bin/activate    # or venv\Scripts\activate on Windows

# Install packages
pip install flask requests

# Work on project...
python app.py

# When done
deactivate

Checking installed packages

List packages in the current environment:

pip list

Save requirements for sharing:

pip freeze > requirements.txt

Install from requirements in a new environment:

pip install -r requirements.txt

Important notes

Never commit the virtual environment folder to version control (it's large and system-specific).
Always add it to .gitignore.
Include requirements.txt for others to recreate the environment.
Use the same Python version for consistency.

Quick summary

Create with python -m venv name.
Activate with source (macOS/Linux) or Scripts\activate (Windows).
Install packages with pip while activated.
Deactivate when finished.
Use requirements.txt to share dependencies.

Practice setting up a virtual environment for a small project. They are essential for clean and reproducible Python development.

Making Simple HTTP Requests in Python with requests Explained

Shahrouz Nikseresht — Thu, 07 May 2026 17:00:00 +0000

The requests library is the easiest way to interact with web APIs and download data from the internet. It handles many details automatically.

Installing requests

First, install the library (only once):

pip install requests

Importing the library

import requests

Making a GET request

GET is used to retrieve data.

response = requests.get("https://api.github.com")

print(response.status_code)  # 200 means success
print(response.text)         # Raw text response

Convert JSON responses easily:

data = response.json()
print(data["current_user_url"])

Passing parameters

Add query parameters with params:

params = {"q": "python", "sort": "stars"}

response = requests.get("https://api.github.com/search/repositories", params=params)

repos = response.json()
print(repos["total_count"])  # Number of results

Making a POST request

POST is used to send data (e.g., create something).

payload = {"username": "testuser", "score": 100}

response = requests.post("https://httpbin.org/post", json=payload)

print(response.json()["json"])  # Echoed back data

Adding headers

Set custom headers (common for authentication):

headers = {"User-Agent": "my-script", "Authorization": "token abc123"}

response = requests.get("https://api.example.com/data", headers=headers)

Handling responses

Check status:

if response.status_code == 200:
    print("Success!")
elif response.status_code == 404:
    print("Not found.")

Raise an exception for bad status (optional):

response.raise_for_status()  # Raises error for 4xx/5xx

Simple examples

Fetch a random quote:

response = requests.get("https://api.quotable.io/random")
quote = response.json()

print(f'"{quote["content"]}" — {quote["author"]}')

Download an image:

img_response = requests.get("https://httpbin.org/image/png")

with open("downloaded.png", "wb") as file:
    file.write(img_response.content)

Important notes

Always check response.status_code.
Use .json() for JSON APIs.
Use json= parameter to send JSON in POST.
Handle network errors with try/except.
Respect API rate limits and terms of service.

Quick summary

Import with import requests.
Use get() for retrieving data, post() for sending.
Pass parameters with params=, data with json= or data=.
Convert JSON with .json().
Check status_code and use raise_for_status().

Practice making requests to free APIs like quotable.io or jsonplaceholder.typicode.com. The requests library is essential for working with web services in Python programs.

Inheritance in Python Classes Explained Simply

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

Inheritance allows a class to inherit attributes and methods from another class. This promotes code reuse and creates logical hierarchies.

What is inheritance?

The parent class (superclass or base class) provides common functionality.

The child class (subclass or derived class) inherits and can extend or override it.

Define a parent class:

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        print("Some generic sound")

    def info(self):
        print(f"This is {self.name}")

Create a child class with inheritance:

class Dog(Animal):
    pass

Now Dog inherits everything from Animal:

my_dog = Dog("Buddy")
my_dog.info()    # This is Buddy
my_dog.speak()   # Some generic sound

Extending the child class

Add new methods or attributes specific to the child:

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)  # Call parent __init__
        self.breed = breed

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

    def fetch(self):
        print("Fetching the ball!")

Usage:

dog = Dog("Buddy", "Golden Retriever")
dog.info()    # This is Buddy
dog.speak()   # Woof!
dog.fetch()   # Fetching the ball!
print(dog.breed)  # Golden Retriever

super() calls the parent method (useful in __init__ and overrides).

Overriding methods

The child can replace a parent method completely (as speak does above).

Multiple child classes

class Cat(Animal):
    def speak(self):
        print("Meow!")

cat = Cat("Luna")
cat.info()   # This is Luna
cat.speak()  # Meow!

Both Dog and Cat share info from Animal but have their own speak.

Simple examples

Vehicle hierarchy:

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

    def start(self):
        print("Engine started")

class Car(Vehicle):
    def drive(self):
        print("Driving on roads")

class Boat(Vehicle):
    def sail(self):
        print("Sailing on water")

car = Car("Toyota")
car.start()  # Engine started
car.drive()  # Driving on roads

Important notes

Use super() to access parent methods.
A child class can inherit from only one parent in basic inheritance (single inheritance).
Inheritance creates "is-a" relationships (Dog is an Animal).
Keep inheritance shallow for readability.

Quick summary

Child classes inherit from parent classes with (Parent).
Use super() to call parent methods.
Override methods to customize behavior.
Add new methods for child-specific features.
Inheritance reduces code duplication.

Practice building small class hierarchies. Inheritance helps create organized and reusable code in Python programs.

Working with JSON in Python Explained Simply

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

JSON (JavaScript Object Notation) is a common format for storing and exchanging data. Python's json module makes it easy to work with JSON.

What is JSON?

JSON looks similar to Python dictionaries and lists.

Example JSON data:

{
    "name": "Alex",
    "age": 25,
    "hobbies": ["reading", "coding", "hiking"],
    "is_student": false
}

Importing the json module

Always import json first:

import json

Converting Python to JSON (serializing)

Use json.dumps() for a string or json.dump() for a file.

To string:

data = {
    "name": "Alex",
    "age": 25,
    "hobbies": ["reading", "coding"]
}

json_string = json.dumps(data)
print(json_string)
# {"name": "Alex", "age": 25, "hobbies": ["reading", "coding"]}

Pretty print with indentation:

pretty_json = json.dumps(data, indent=4)
print(pretty_json)

To file:

with open("data.json", "w") as file:
    json.dump(data, file, indent=4)

Converting JSON to Python (deserializing)

Use json.loads() for a string or json.load() for a file.

From string:

json_string = '{"name": "Sam", "age": 30}'

data = json.loads(json_string)
print(data["name"])  # Sam

From file:

with open("data.json", "r") as file:
    data = json.load(file)

print(data["hobbies"])  # ['reading', 'coding']

Simple examples

Save a list of users to JSON:

users = [
    {"name": "Alex", "age": 25},
    {"name": "Sam", "age": 30}
]

with open("users.json", "w") as file:
    json.dump(users, file, indent=4)

Read and print names:

with open("users.json", "r") as file:
    users = json.load(file)

for user in users:
    print(user["name"])

Important notes

JSON keys must be strings.
Supported types: dict, list, str, int, float, bool, None.
Use indent for readable files.
Handle errors with try/except (e.g., invalid JSON or file not found).

Quick summary

Import json to work with JSON data.
dumps() and dump() convert Python to JSON.
loads() and load() convert JSON to Python.
Use indentation for human-readable output.
JSON is perfect for configuration files and web APIs.

Practice saving and loading small data structures as JSON. It is essential for data exchange in Python programs.

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.