Python Tutorial

name = input("What is your name? ")
print(f"Hello, {name}! Welcome to Python.")

year = 2026
print(f"{name} started learning Python in {year}.")

python3 hello.py

count = 42                 # int: whole numbers of any size
price = 19.99              # float: decimal numbers
title = "Python Basics"    # str: text
is_published = True        # bool: True or False
discount = None            # NoneType: "no value"

print(type(count), type(price), type(title), type(is_published), type(discount))

big = 2 ** 100             # ints never overflow
print(big)

print(7 / 2, 7 // 2, 7 % 2, 2 ** 3)   # 3.5 3 1 8

# Converting between types
quantity = int("12")
total = quantity * price
print(f"Total: {total:.2f}")          # format with two decimal places
print(round(0.1 + 0.2, 2), 0.1 + 0.2 == 0.3)   # floats are approximate

text = "  Learning Python is Fun  "

print(text.strip())                 # remove surrounding spaces
print(text.lower(), text.upper())
print(text.strip().split(" "))      # ['Learning', 'Python', 'is', 'Fun']
print("-".join(["2026", "10", "18"]))
print(text.replace("Fun", "Rewarding"))
print("Python" in text)             # True

word = "programming"
print(word[0], word[-1])            # first and last character: p g
print(word[0:7], word[3:], word[::-1])   # slicing: progra, gramming, reversed

language, version = "Python", 3.14
print(f"{language} {version} | {language:>10} | {version:.1f}")

report = """Line one
Line two"""
print(report.splitlines())

# list
scores = [72, 95, 88]
scores.append(64)
scores.sort(reverse=True)
print(scores, len(scores), max(scores), sum(scores) / len(scores))

# tuple and unpacking
location = (12.97, 77.59)
lat, lon = location
print(f"lat={lat}, lon={lon}")

# dict
student = {"name": "Ravi", "age": 21, "courses": ["Maths", "Physics"]}
student["age"] += 1
student["city"] = "Chennai"
print(student.get("email", "no email"))      # safe lookup with a default
for key, value in student.items():
    print(f"{key}: {value}")

# set
tags_a = {"python", "web", "api"}
tags_b = {"python", "data"}
print(tags_a & tags_b, tags_a | tags_b, tags_a - tags_b)   # intersection, union, difference

# Useful helpers from the standard library
from collections import Counter, defaultdict
words = "to be or not to be".split()
print(Counter(words).most_common(2))          # [('to', 2), ('be', 2)]

by_length = defaultdict(list)
for w in words:
    by_length[len(w)].append(w)
print(dict(by_length))

marks = 78

if marks >= 90:
    grade = "A"
elif marks >= 75:
    grade = "B"
else:
    grade = "C"
print("Grade:", grade)

# for loops iterate over any sequence or iterable
for i in range(1, 6):
    print(i, end=" ")
print()

fruits = ["apple", "mango", "banana"]
for index, fruit in enumerate(fruits, start=1):
    print(index, fruit)

for name, score in zip(["Ana", "Ben"], [91, 84]):
    print(f"{name} scored {score}")

# while loop with break
attempts = 0
while True:
    attempts += 1
    if attempts == 3:
        break
print("Stopped after", attempts, "attempts")

# match / case (Python 3.10+): structural pattern matching
def describe(command):
    match command.split():
        case ["go", direction]:
            return f"Moving {direction}"
        case ["pick", "up", item]:
            return f"Picked up {item}"
        case ["quit" | "exit"]:
            return "Goodbye"
        case _:
            return "Unknown command"

print(describe("go north"), "|", describe("pick up lamp"), "|", describe("dance"))

def bmi(weight_kg, height_m):
    """Return the body-mass index rounded to one decimal place."""
    return round(weight_kg / height_m ** 2, 1)

print(bmi(68, 1.75))
print(bmi(height_m=1.62, weight_kg=55))      # keyword arguments, any order

def greet(name, greeting="Hello"):           # default argument
    return f"{greeting}, {name}!"

print(greet("Meera"), greet("Meera", "Namaste"))

def stats(*numbers):                         # any number of positional arguments
    return min(numbers), max(numbers), sum(numbers) / len(numbers)

low, high, avg = stats(4, 8, 15, 16, 23, 42) # functions can return several values
print(low, high, avg)

def build_profile(name, **details):          # any number of keyword arguments
    return {"name": name, **details}

print(build_profile("Kiran", city="Pune", role="Developer"))

# Functions are objects: pass them around, and write small ones as lambdas
products = [("pen", 10), ("book", 250), ("bag", 799)]
print(sorted(products, key=lambda p: p[1], reverse=True))

numbers = range(1, 11)

squares = [n * n for n in numbers]
evens = [n for n in numbers if n % 2 == 0]
labels = ["even" if n % 2 == 0 else "odd" for n in range(1, 5)]

prices = {"pen": 10, "book": 250, "bag": 799}
with_tax = {item: round(price * 1.18, 2) for item, price in prices.items()}
initials = {name[0] for name in ["Asha", "Arjun", "Bela"]}

print(squares, evens, labels, with_tax, initials, sep="\n")

# Generator expression: computes values lazily, without building a list
total = sum(n * n for n in range(1_000_000))
print(total)

import json
import random
from datetime import date, timedelta
from pathlib import Path

order = {"id": 101, "items": ["kettle", "mug"], "total": 1798.0}
text = json.dumps(order, indent=2)          # dict -> JSON text
print(json.loads(text)["items"])            # JSON text -> dict

print(random.choice(["red", "green", "blue"]))
print(date.today() + timedelta(days=30))
print([p.name for p in Path(".").glob("*.py")])

def main():
    print("Running as a script")

if __name__ == "__main__":     # true only when this file is run directly, not imported
    main()

# Create and activate a virtual environment
python3 -m venv .venv
source .venv/bin/activate          # Windows: .venv\Scripts\activate

# Install packages and record the versions
pip install requests
pip freeze > requirements.txt

# Recreate the same environment elsewhere
pip install -r requirements.txt

import csv

rows = [("item", "amount"), ("books", "450"), ("lunch", "180.5"), ("metro", "sixty")]

with open("expenses.csv", "w", newline="", encoding="utf-8") as f:
    csv.writer(f).writerows(rows)

total = 0.0
with open("expenses.csv", encoding="utf-8") as f:
    for record in csv.DictReader(f):
        try:
            total += float(record["amount"])
        except ValueError:
            print(f"Skipping bad amount: {record['amount']!r}")

print(f"Total: {total:.2f}")

class InsufficientFunds(Exception):
    """Raised when a withdrawal is larger than the balance."""

def withdraw(balance, amount):
    if amount > balance:
        raise InsufficientFunds(f"Cannot withdraw {amount}; balance is {balance}")
    return balance - amount

try:
    withdraw(100, 250)
except InsufficientFunds as e:
    print("Error:", e)
finally:
    print("Transaction attempt finished")

import math
from abc import ABC, abstractmethod
from dataclasses import dataclass, field

class Shape(ABC):
    @abstractmethod
    def area(self) -> float: ...

    def __str__(self):
        return f"{type(self).__name__} with area {self.area():.2f}"

class Circle(Shape):
    def __init__(self, radius: float):
        self.radius = radius

    def area(self) -> float:
        return math.pi * self.radius ** 2

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

    def area(self) -> float:
        return self.width * self.height

for shape in [Circle(1.5), Rectangle(2, 3.5)]:   # polymorphism: same call, different classes
    print(shape)

# dataclass: generates __init__, __repr__ and __eq__ automatically
@dataclass
class Product:
    name: str
    price: float
    tags: list[str] = field(default_factory=list)

    @property
    def price_with_tax(self) -> float:
        return round(self.price * 1.18, 2)

kettle = Product("Kettle", 1499.0, ["kitchen"])
print(kettle, kettle.price_with_tax)
print(kettle == Product("Kettle", 1499.0, ["kitchen"]))   # True

import time
from functools import lru_cache, wraps

def fibonacci():
    a, b = 0, 1
    while True:              # an endless sequence, produced lazily
        yield a
        a, b = b, a + b

gen = fibonacci()
print([next(gen) for _ in range(10)])

def read_large_file(path):
    with open(path, encoding="utf-8") as f:
        for line in f:       # files are iterators: one line in memory at a time
            yield line.rstrip("\n")

def timed(func):
    @wraps(func)             # keep the original function's name and docstring
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        print(f"{func.__name__} took {time.perf_counter() - start:.4f}s")
        return result
    return wrapper

@lru_cache(maxsize=None)     # built-in decorator: remember previous results
def ways_to_climb(steps):
    return 1 if steps <= 1 else ways_to_climb(steps - 1) + ways_to_climb(steps - 2)

@timed
def compute():
    return ways_to_climb(200)

print(compute())

from typing import TypedDict

class User(TypedDict):
    id: int
    name: str
    email: str | None

def find_user(users: list[User], user_id: int) -> User | None:
    for user in users:
        if user["id"] == user_id:
            return user
    return None

def average(values: list[float]) -> float:
    return sum(values) / len(values) if values else 0.0

users: list[User] = [{"id": 1, "name": "Ana", "email": None}]
print(find_user(users, 1), average([2.5, 3.5]))

import asyncio
import time

async def fetch(name: str, delay: float) -> str:
    await asyncio.sleep(delay)          # stands in for a network call
    return f"{name} done after {delay}s"

async def main():
    start = time.perf_counter()
    results = await asyncio.gather(     # run all three concurrently
        fetch("orders", 1.0),
        fetch("users", 1.2),
        fetch("stock", 0.8),
    )
    print(results)
    print(f"Total time: {time.perf_counter() - start:.1f}s")   # about 1.2s, not 3s

asyncio.run(main())

import pytest

def apply_discount(price: float, percent: float) -> float:
    if not 0 <= percent <= 100:
        raise ValueError("percent must be between 0 and 100")
    return round(price * (1 - percent / 100), 2)

@pytest.mark.parametrize("price, percent, expected", [
    (100, 10, 90.0),
    (59.99, 0, 59.99),
    (80, 100, 0.0),
])
def test_apply_discount(price, percent, expected):
    assert apply_discount(price, percent) == expected

def test_invalid_percent():
    with pytest.raises(ValueError):
        apply_discount(100, 150)