Python Tutorial from Basics to Advanced

A complete guide with clear concepts and simple explanations. Fresh examples included.

1. Getting Started

Concept Python is an interpreted and high level language. It reads your code line by line. It focuses on readability and has batteries included through its standard library.

Why it matters

• You can prototype quickly
• Code is easy to read and share
• Many libraries for web, data, automation, and AI

Install and Run

• Install from the official site or a package manager
• Check version with python --version or python3 --version
• Run a file with python file.py
• Start the REPL by typing python then press Enter

Your First Program

print("Hello, Python!")

Explanation print sends text to the console. Strings are inside quotes.

2. Syntax and Variables

Concept Python uses indentation to define blocks. Variables are names that store values. Types are inferred at runtime.

Names and Assignment

age = 21
name = "Asha"
pi = 3.14159
is_active = True

Explanation

• Use lowercase with underscores for variables
• Strings use quotes
• True and False are booleans

Comments

# This is a comment

Explanation Comments are ignored by Python and help explain intent.

Dynamic Typing

x = 10
x = "now a string"

Explanation The type of x changes based on the assigned value. Use type hints to add clarity in larger codebases.

3. Data Types

Concept Core built in types cover most needs. Know when to use each.

Numbers

a = 12         # int
b = 2.5        # float
c = 7 + 3j     # complex
print(a + b)   # 14.5

Explanation Use ints for counts, floats for measurements, complex for specialized math.

Strings

s = "coconut"
print(s.upper())
print(s[0], s[-1])
print("price: ₹{}".format(120))
print(f"length is {len(s)}")

Explanation Strings are immutable. Indexing gets characters. f strings format values cleanly.

Lists

items = ["tea", "coffee", "juice"]
items.append("lassi")
items[1] = "filter coffee"
print(items[:2])

Explanation Lists are ordered and mutable. Slices select ranges.

Tuples

point = (3, 4)
x, y = point

Explanation Tuples are ordered and immutable. Great for fixed sized records and unpacking.

Sets

seen = {1, 2, 2, 3}
seen.add(4)
print(seen)  # unique values only

Explanation Sets hold unique items and support fast membership tests.

Dicts

user = {"id": 101, "name": "Meera", "active": True}
user["role"] = "admin"
print(user.get("email", "not set"))

Explanation Dictionaries map keys to values. Access safely with get.

None

result = None
if result is None:
    print("no result yet")

Explanation None represents no value. Use is None for checks.

4. Operators

Concept Operators perform actions on values. Know operator precedence and data type behavior.

Arithmetic

a, b = 9, 4
print(a + b, a - b, a * b, a / b, a // b, a % b, a ** b)

Explanation / gives float division, // floor division, % remainder, ** power.

Comparison and Logic

x = 10
print(5 < x <= 20)
print(not False and True)

Explanation Comparisons can chain. Use and, or, not for logic.

Membership and Identity

names = ["Ravi", "Leena"]
print("Ravi" in names)
print(names is names)  # identity

Explanation in checks membership. is checks object identity not equality.

5. Control Flow

Concept Branch and loop to control execution.

if elif else

temp = 34
if temp > 40:
    print("too hot")
elif temp >= 30:
    print("warm")
else:
    print("cool")

Explanation First true branch runs. Use clear conditions.

while

count = 3
while count > 0:
    print(count)
    count -= 1

Explanation Loop while condition is true. Always make progress to avoid infinite loops.

for

for ch in "mango":
    print(ch)

Explanation for iterates over items in a sequence or any iterable.

break and continue

for n in range(10):
    if n % 2 == 0:
        continue
    if n > 7:
        break
    print(n)

Explanation continue skips to next loop iteration. break exits the loop.

6. Functions

Concept Functions group reusable logic and return results. They improve structure and testing.

Define and Return

def area_circle(r):
    pi = 3.14159
    return pi * r * r

print(area_circle(5))

Explanation Parameters are inputs. return sends a value back. Local variables live inside the function.

Default and Keyword Args

def greet(name, lang="en"):
    msgs = {"en": "Hello", "hi": "Namaste", "ta": "Vanakkam"}
    print(f"{msgs.get(lang, 'Hello')} {name}")

greet("Aman")
greet("Aman", lang="hi")

Explanation Defaults make arguments optional. Keyword args improve clarity.

Variable Args

def average(*numbers):
    return sum(numbers) / len(numbers) if numbers else 0.0

print(average(2, 4, 6))

Explanation *args collects positional arguments into a tuple.

Functions as Values

def apply(fn, x):
    return fn(x)

print(apply(lambda n: n * n, 7))

Explanation Functions are first class values. You can pass them around and return them.

7. Comprehensions

Concept Comprehensions build collections in a concise way and are usually faster than loops.

squares = [n*n for n in range(6)]
evens = {n for n in range(10) if n % 2 == 0}
index_map = {word: i for i, word in enumerate(["alpha", "beta", "gamma"])}

Explanation List, set, and dict comprehensions express map and filter patterns clearly.

8. Modules and Packages

Concept Modules are files with Python code. Packages are folders with modules.

Import

import math
from datetime import datetime

print(math.sqrt(49))
print(datetime.now())

Explanation Use import to access functions from other modules. from X import Y brings names directly.

Create a Module file: math_utils.py

def cube(n):
    return n ** 3

file: app.py

import math_utils
print(math_utils.cube(3))

Explanation Organize code into modules to reuse and test in isolation.

9. Error Handling

Concept Exceptions signal errors. Handle them to keep programs robust.

def to_int(s):
    try:
        return int(s)
    except ValueError as e:
        print("not a number:", e)
        return None
    finally:
        print("done")

to_int("19")
to_int("x")

Explanation try protects a block. except catches specific errors. finally runs no matter what.

10. File I O

Concept Use context managers to safely read and write files.

# write
with open("notes.txt", "w", encoding="utf-8") as f:
    f.write("learn python daily\n")

# read
with open("notes.txt", "r", encoding="utf-8") as f:
    for line in f:
        print(line.strip())

Explanation with closes files automatically. Choose correct mode and encoding.

11. Iterators and Generators

Concept Iterators define how to loop over custom sequences. Generators yield values lazily to save memory.

Iterator class

class Countdown:
    def __init__(self, start):
        self.current = start
    def __iter__(self):
        return self
    def __next__(self):
        if self.current <= 0:
            raise StopIteration
        val = self.current
        self.current -= 1
        return val

for n in Countdown(3):
    print(n)

Generator function

def fib(limit):
    a, b = 0, 1
    while a <= limit:
        yield a
        a, b = b, a + b

print(list(fib(20)))

Explanation yield turns a function into a generator that pauses and resumes.

12. Decorators

Concept Decorators wrap functions to add behavior without changing their code.

import time

def timed(fn):
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        try:
            return fn(*args, **kwargs)
        finally:
            end = time.perf_counter()
            print(f"{fn.__name__} took {end - start:.6f}s")
    return wrapper

@timed
def slow_sum(n):
    total = 0
    for i in range(n):
        total += i
    return total

print(slow_sum(1000000))

Explanation @decorator is syntax sugar for fn = decorator(fn).

13. Context Managers

Concept Context managers set up and tear down resources safely.

class suppress:
    def __init__(self, exc_type):
        self.exc_type = exc_type
    def __enter__(self):
        return self
    def __exit__(self, exc, val, tb):
        return isinstance(val, self.exc_type)

with suppress(ZeroDivisionError):
    print(1 / 0)
print("kept going")

Explanation __enter__ and __exit__ control behavior around the with block.

14. Object Oriented Programming

Concept OOP models real world entities with data and behavior inside classes.

Classes and Objects

class BankAccount:
    def __init__(self, owner, balance=0.0):
        self.owner = owner
        self._balance = balance
    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("amount must be positive")
        self._balance += amount
    def withdraw(self, amount):
        if amount > self._balance:
            raise ValueError("insufficient funds")
        self._balance -= amount
    @property
    def balance(self):
        return self._balance

acct = BankAccount("Neel", 500)
acct.deposit(250)
print(acct.balance)

Explanation Methods operate on data. @property exposes read only views. Leading underscore hints internal use.

Inheritance and Polymorphism

class Animal:
    def speak(self):
        return "some sound"

class Dog(Animal):
    def speak(self):
        return "woof"

class Cat(Animal):
    def speak(self):
        return "meow"

for pet in [Dog(), Cat()]:
    print(pet.speak())

Explanation Subclasses override behavior. Polymorphism means code works with the base type while calling the right method.

15. Dataclasses

Concept Dataclasses reduce boilerplate for classes that mainly store data.

from dataclasses import dataclass
from datetime import date

@dataclass
class Book:
    title: str
    author: str
    published: date
    pages: int = 0

b = Book("Clean Code in Practice", "K P Rao", date(2020, 7, 1), 320)
print(b)

Explanation Dataclasses auto create __init__, __repr__, and comparisons based on fields.

16. Type Hints

Concept Type hints annotate expected types. They aid tooling and readability.

from typing import List, Optional, Dict

def find_email(users: List[Dict[str, str]], name: str) -> Optional[str]:
    for u in users:
        if u["name"] == name:
            return u.get("email")
    return None

Explanation Hints do not enforce at runtime by default. Use a type checker like mypy to validate.

17. Testing

Concept Automated tests catch regressions and document behavior.

pytest style file: app.py

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

file: test_app.py

from app import add

def test_add():
    assert add(2, 3) == 5

Explanation Run tests with pytest. Each test asserts expected outcomes.

18. Virtual Environments and Packaging

Concept Virtual environments isolate dependencies per project. Packaging defines how to distribute your code.

Create and Use

python -m venv .venv
# Windows
# .venv\Scripts\activate
# macOS or Linux
# source .venv/bin/activate
pip install requests

Explanation Activating a venv ensures pip installs into the project environment.

Minimal pyproject.toml

[project]
name = "cooltool"
version = "0.1.0"
description = "A handy utility"
requires-python = ">=3.10"

[build-system]
requires = ["setuptools", "wheel"]
build-backend = "setuptools.build_meta"

Explanation pyproject.toml is the modern metadata file for builds and dependencies.

19. Concurrency

Concept Pick the right model based on the kind of work.

• Threads suit I O bound tasks with waiting
• asyncio suits many small concurrent waits
• multiprocessing suits CPU heavy work

Threads for I O bound tasks

import threading
import time

def fetch(id):
    print(f"start {id}")
    time.sleep(1)
    print(f"end {id}")

threads = [threading.Thread(target=fetch, args=(i,)) for i in range(3)]
for t in threads: t.start()
for t in threads: t.join()

asyncio for many small waits

import asyncio
import random

async def ping(name):
    await asyncio.sleep(random.random())
    return f"pong from {name}"

async def main():
    tasks = [ping(f"s{i}") for i in range(5)]
    for coro in asyncio.as_completed(tasks):
        print(await coro)

asyncio.run(main())

multiprocessing for CPU work

from multiprocessing import Pool

def cube(n):
    return n ** 3

with Pool() as p:
    print(p.map(cube, range(6)))

Explanation Threads share memory. Processes have separate memory. asyncio uses an event loop.

20. Useful Standard Library

Concept The standard library covers many common tasks out of the box.

import pathlib
from collections import Counter, defaultdict
from itertools import groupby, permutations
import json
from datetime import datetime, timedelta

# pathlib
p = pathlib.Path(".").resolve()
print(p)

# Counter
print(Counter("mississippi"))

# defaultdict
d = defaultdict(list)
d["fruits"].append("apple")
print(d)

# groupby
nums = [1,1,2,2,2,3]
for k, g in groupby(nums):
    print(k, list(g))

# permutations
print(list(permutations([1,2,3], 2)))

# json
data = {"ok": True, "time": datetime.now().isoformat()}
s = json.dumps(data)
print(json.loads(s)["ok"])

# datetime math
print(datetime.now() + timedelta(days=5))

Explanation Prefer standard modules first. They are well tested and documented.

21. Regular Expressions

Concept Regex finds patterns in text. Use raw strings to avoid escape confusion.

import re

text = "Order ID: AB1234, Ref: XY987"
pattern = r"[A-Z]{2}\d{3,4}"
print(re.findall(pattern, text))

Explanation [] defines a character class. {m,n} defines repeats. \d matches digits.

22. Working with HTTP

Concept Use requests to call APIs. Always handle errors and timeouts.

import requests

resp = requests.get("https://httpbin.org/json", timeout=5)
resp.raise_for_status()
data = resp.json()
print(data.get("slideshow", {}).get("title"))

Explanation raise_for_status throws for non 2xx codes. .json() parses JSON responses.

23. SQLite Database

Concept SQLite is a lightweight SQL database built into Python. Great for local storage and tests.

import sqlite3

conn = sqlite3.connect(":memory:")
cur = conn.cursor()
cur.execute("create table users(id integer primary key, name text)")
cur.execute("insert into users(name) values (?)", ("Riya",))
cur.execute("select * from users")
print(cur.fetchall())
conn.commit()
conn.close()

Explanation Use parameterized queries to avoid SQL injection. Always commit and close.

24. Simple Web App with Flask

Concept Flask is a minimal web framework. You map URLs to Python functions.

from flask import Flask, request, jsonify

app = Flask(__name__)

STORE = {}

@app.route("/set", methods=["POST"])
def set_value():
    body = request.get_json()
    key = body["key"]
    value = body["value"]
    STORE[key] = value
    return jsonify(ok=True)

@app.route("/get/
<key>")
def get_value(key):
    return jsonify(value=STORE.get(key))

if __name__ == "__main__":
    app.run(debug=True)

Explanation Routes define endpoints. Use JSON for structured data exchange.

25. Data Science Quick Start

Concept NumPy handles arrays and fast math. Pandas handles labeled data. Matplotlib plots data.

Numpy

import numpy as np

a = np.array([[1, 2], [3, 4]])
print(a.mean(), a.sum(), a.dot(a))

Pandas

import pandas as pd

df = pd.DataFrame({"name": ["Anu", "Raj"], "score": [88, 92]})
print(df.describe())
print(df[df.score > 90])

Matplotlib

import matplotlib.pyplot as plt

x = [1,2,3,4]
y = [1,4,9,16]
plt.plot(x, y, marker="o")
plt.title("Square numbers")
plt.show()

Explanation Vectorized operations avoid Python loops and run faster on arrays and columns.

26. CLI Apps with argparse

Concept argparse parses command line options and arguments.

import argparse

parser = argparse.ArgumentParser()
parser.add_argument("--times", type=int, default=1)
args = parser.parse_args()

for _ in range(args.times):
    print("Namaste")

Explanation Provide helpful --help by default. Validate types with type=.

27. Logging

Concept Logging records events for debugging and monitoring. Prefer logging over prints in production.

import logging

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s %(levelname)s %(message)s"
)

logging.info("service started")
logging.warning("low memory")
logging.error("something went wrong")

Explanation Set levels to control verbosity. Use structured formats for better search.

28. Performance Tips

Concept Profile first then optimize where it matters. Use the right data structures.

Guidelines

• Use list for ordered collections and frequent appends
• Use set and dict for fast membership and key lookups
• Move repeated work outside loops
• Prefer comprehensions for simple transforms
• Use vectorized libraries for numeric work

Quick timing

import timeit
print(timeit.timeit("sum(range(1000))", number=10000))

Explanation Measure with timeit to compare approaches fairly.

29. Clean Code Practices

Concept Readable code lasts longer and has fewer bugs.

Principles

• Follow PEP 8 for naming and formatting
• Choose clear names
• Keep functions small and focused
• Write docstrings and comments that explain why
• Add tests and type hints
• Handle errors explicitly

Example docstring

def normalize(text: str) -> str:
    """
    Trim spaces and make lowercase.
    Remove duplicate inner spaces.
    """
    return " ".join(text.strip().lower().split())

Explanation Docstrings describe purpose, arguments, and return values.

30. Putting It All Together

Concept Combine multiple skills to solve real tasks end to end.

This small script reads a CSV, filters rows, and writes JSON.

import csv
import json
from pathlib import Path
from typing import List, Dict

def read_csv(path: Path) -> List[Dict[str, str]]:
    with path.open(newline="", encoding="utf-8") as f:
        return list(csv.DictReader(f))

def filter_rows(rows, threshold: int):
    return [r for r in rows if int(r["score"]) >= threshold]

def write_json(path: Path, data) -> None:
    with path.open("w", encoding="utf-8") as f:
        json.dump(data, f, ensure_ascii=False, indent=2)

def main():
    src = Path("students.csv")
    dst = Path("top_students.json")
    rows = read_csv(src)
    top = filter_rows(rows, 85)
    write_json(dst, top)
    print(f"wrote {len(top)} records to {dst}")

if __name__ == "__main__":
    main()

Explanation This example shows file I O, collections, comprehension like filtering, types, and the standard library working together.

Next steps

• Pick a project such as a to do CLI or a tiny API with Flask
• Practice by rewriting small scripts in cleaner ways
• Add tests and logging as you go