# Check version
python --version
# or
python3 --version

# hello.py
print("Hello, Python!")

# Variables (dynamically typed)
name = "Alice"        # str
age = 25              # int
height = 5.6          # float
is_student = True     # bool

# Type hints (best practice)
def greet(name: str) -> str:
    return f"Hello, {name}!"

print(greet(name))

# if-elif-else
score = 85
if score >= 90:
    grade = 'A'
elif score >= 80:
    grade = 'B'
else:
    grade = 'C'

# for loop
for i in range(5):
    print(i)

# list comprehension (Pythonic!)
squares = [x**2 for x in range(10)]

# while
count = 0
while count < 3:
    print("Counting...", count)
    count += 1

# Basic function
def add(a: int, b: int) -> int:
    """Return sum of two numbers."""
    return a + b

# Default arguments
def greet(name: str, msg: str = "Good morning!") -> str:
    return f"{msg}, {name}"

# *args and **kwargs
def print_items(*args, **kwargs):
    print("Args:", args)
    print("Kwargs:", kwargs)

print_items(1, 2, 3, name="Alice", age=25)

# Lambda functions
double = lambda x: x * 2
print(double(5))

fruits = ["apple", "banana", "cherry"]
fruits.append("orange")
fruits.remove("banana")
print(fruits[1:])  # slicing

person = {
    "name": "Bob",
    "age": 30,
    "city": "New York"
}
person["email"] = "bob@example.com"
print(person.get("phone", "N/A"))

unique = {1, 2, 2, 3}  # {1, 2, 3}
a = {1, 2, 3}
b = {3, 4, 5}
print(a & b)  # intersection
print(a | b)  # union

point = (10, 20)
x, y = point  # unpacking

# Writing
with open("data.txt", "w") as f:
    f.write("Hello, File!\n")
    f.write("Second line.")

# Reading
with open("data.txt", "r") as f:
    content = f.read()
    print(content)

# JSON
import json

data = {"name": "Alice", "age": 25}
with open("data.json", "w") as f:
    json.dump(data, f, indent=2)

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

# math_utils.py
def is_even(n: int) -> bool:
    """Check if number is even."""
    return n % 2 == 0

def factorial(n: int) -> int:
    if n == 0:
        return 1
    return n * factorial(n - 1)

# main.py
from math_utils import is_even, factorial

print(is_even(4))        # True
print(factorial(5))      # 120

class Dog:
    species = "Canis familiaris"  # class variable

    def __init__(self, name: str, age: int):
        self.name = name
        self.age = age

    def bark(self) -> str:
        return f"{self.name} says Woof!"

    def __str__(self) -> str:
        return f"{self.name}, {self.age} years old"

# Inheritance
class Bulldog(Dog):
    def __init__(self, name: str, age: int, stubborn: bool = True):
        super().__init__(name, age)
        self.stubborn = stubborn

    def bark(self) -> str:
        return f"{self.name} grumbles!"

# Usage
my_dog = Bulldog("Rex", 3)
print(my_dog)
print(my_dog.bark())

def divide(a: float, b: float) -> float:
    try:
        result = a / b
    except ZeroDivisionError:
        print("Cannot divide by zero!")
        return None
    except TypeError:
        print("Invalid input type!")
        return None
    else:
        print("Division successful.")
        return result
    finally:
        print("Operation complete.")

print(divide(10, 0))

pip install requests pandas numpy

# requests - HTTP
import requests
response = requests.get("https://api.github.com")
print(response.json()["current_user_url"])

# pandas - Data analysis
import pandas as pd
df = pd.DataFrame({
    "Name": ["Alice", "Bob"],
    "Age": [25, 30]
})
print(df.describe())

# Create virtual environment
python -m venv myenv

# Activate
# Windows:
myenv\Scripts\activate
# macOS/Linux:
source myenv/bin/activate

# Install packages
pip install requests

# Save dependencies
pip freeze > requirements.txt

# Later: install from file
pip install -r requirements.txt

# Good
def calculate_area(radius: float) -> float:
    import math
    return math.pi * radius ** 2

# Bad
def calc(r):
    return 3.14 * r * r

from typing import List, Dict

def process_items(items: List[str]) -> Dict[str, int]:
    return {item: len(item) for item in items}

from pathlib import Path

file_path = Path("data") / "output.txt"
file_path.parent.mkdir(exist_ok=True)
file_path.write_text("Hello")

import logging
logging.basicConfig(level=logging.INFO)
logging.info("Process started")

my_project/
│
├── src/
│   ├── __init__.py
│   ├── main.py
│   ├── utils/
│   │   ├── __init__.py
│   │   └── helpers.py
│   └── models/
│       ├── __init__.py
│       └── user.py
│
├── tests/
│   ├── __init__.py
│   └── test_user.py
│
├── requirements.txt
├── README.md
└── .gitignore

from dataclasses import dataclass
from typing import List
import json
from pathlib import Path

@dataclass
class Task:
    title: str
    done: bool = False

class TaskManager:
    def __init__(self, file_path: str = "tasks.json"):
        self.file = Path(file_path)
        self.tasks: List[Task] = self.load()

    def load(self) -> List[Task]:
        if self.file.exists():
            data = json.loads(self.file.read_text())
            return [Task(**t) for t in data]
        return []

    def save(self):
        data = [t.__dict__ for t in self.tasks]
        self.file.write_text(json.dumps(data, indent=2))

    def add(self, title: str):
        self.tasks.append(Task(title))
        self.save()

    def list(self):
        for i, task in enumerate(self.tasks, 1):
            status = "✓" if task.done else "✗"
            print(f"{i}. [{status}] {task.title}")

    def complete(self, index: int):
        if 1 <= index <= len(self.tasks):
            self.tasks[index-1].done = True
            self.save()

def main():
    tm = TaskManager()
    import sys
    if len(sys.argv) < 2:
        print("Usage: python task_manager.py [add|list|done] ...")
        return

    cmd = sys.argv[1]
    if cmd == "add":
        title = " ".join(sys.argv[2:])
        tm.add(title)
    elif cmd == "list":
        tm.list()
    elif cmd == "done" and len(sys.argv) > 2:
        tm.complete(int(sys.argv[2]))
    else:
        print("Unknown command")

if __name__ == "__main__":
    main()

python task_manager.py add "Learn Python"
python task_manager.py add "Build a project"
python task_manager.py list
python task_manager.py done 1
python task_manager.py list