Learning Python Programming

Python uses dynamic typing, so you don't need to declare variable types. The type is inferred at runtime. This makes Python flexible and easy to use for beginners.

Built-in Types

• int - Integer numbers (e.g., 42)
• float - Decimal numbers (e.g., 3.14)
• str - Text strings (e.g., "hello")
• bool - Boolean values (True, False)

Variable Assignment

x = 10
name = "Alice"
price = 19.99
is_valid = True

Type Conversion

x = 5
s = str(x)      # '5'
y = float(x)    # 5.0
b = bool(x)     # True

String Formatting

name = "Bob"
age = 30
print(f"Hello, {name}. You are {age} years old.")

Check Types

print(type(42))        # 
print(type("hi"))     # 

Key Takeaway: Python variables are easy to use and flexible. You can reassign variables to different types, but be careful with type errors in larger programs.

Lists and dictionaries are the most commonly used data structures in Python. Lists are ordered, mutable sequences. Dictionaries are key-value stores.

List Basics

fruits = ["apple", "banana", "cherry"]
fruits.append("date")
print(fruits[1])      # banana
print(len(fruits))    # 4

List Comprehensions

squares = [x*x for x in range(5)]
print(squares)  # [0, 1, 4, 9, 16]

Dictionary Basics

person = {"name": "Alice", "age": 25}
print(person["name"])
person["city"] = "NYC"
for key, value in person.items():
    print(key, value)

Nested Structures

users = [
    {"name": "Bob", "age": 30},
    {"name": "Carol", "age": 27}
]
print(users[1]["name"])

Common Mistake: Shallow vs Deep Copy

import copy
list1 = [[1, 2], [3, 4]]
list2 = list1.copy()      # Shallow copy
list3 = copy.deepcopy(list1)  # Deep copy
list1[0][0] = 99
print(list2)  # [[99, 2], [3, 4]]
print(list3)  # [[1, 2], [3, 4]]

Key Takeaway: Lists and dictionaries are flexible and powerful, but be careful with copying nested structures.

Python provides intuitive control flow with if/elif/else and powerful loops with for and while.

# If/elif/else
age = 20
if age >= 18:
    print("Adult")
elif age >= 13:
    print("Teenager")
else:
    print("Child")

# For loops with range
for i in range(5):
    print(i)  # 0, 1, 2, 3, 4

# For loops with lists
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

# While loops
count = 0
while count < 3:
    print(f"Count: {count}")
    count += 1

# Break and continue
for i in range(10):
    if i == 3:
        continue  # Skip 3
    if i == 7:
        break  # Stop at 7
    print(i)

Functions organize code into reusable blocks. Modules let you organize functions across files.

# Function definition
def greet(name):
    """Docstring: This function greets someone."""
    return f"Hello, {name}!"

# Call function
message = greet("Alice")
print(message)

# Default arguments
def power(base, exponent=2):
    return base ** exponent

print(power(3))      # 9 (uses default)
print(power(3, 3))   # 27

# Variable arguments
def sum_all(*numbers):
    return sum(numbers)

print(sum_all(1, 2, 3, 4))  # 10

# Importing modules
import math
print(math.sqrt(16))  # 4.0

from datetime import datetime
print(datetime.now())

Classes bundle data and functions together. Python supports full object-oriented programming.

# Class definition
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def greet(self):
        return f"Hi, I'm {self.name}"
    
    def __str__(self):
        return f"Person({self.name}, {self.age})"

# Create instance
person = Person("Alice", 30)
print(person.greet())
print(person)  # Uses __str__

# Inheritance
class Student(Person):
    def __init__(self, name, age, grade):
        super().__init__(name, age)
        self.grade = grade
    
    def study(self):
        return f"{self.name} is studying"

student = Student("Bob", 16, "10th")
print(student.greet())   # Inherited
print(student.study())    # New method

Python makes file handling easy with context managers. Exceptions handle errors gracefully.

# Writing to a file
with open('data.txt', 'w') as f:
    f.write("Hello\n")
    f.write("World\n")

# Reading from a file
with open('data.txt', 'r') as f:
    content = f.read()
    print(content)

# Reading lines
with open('data.txt', 'r') as f:
    for line in f:
        print(line.strip())

# Exception handling
try:
    number = int(input("Enter a number: "))
    result = 10 / number
    print(f"Result: {result}")
except ValueError:
    print("Invalid number")
except ZeroDivisionError:
    print("Cannot divide by zero")
except Exception as e:
    print(f"Error: {e}")
finally:
    print("Cleanup code runs always")

Decorators modify or enhance functions. They use the @ syntax and are powerful for cross-cutting concerns.

import time
from functools import wraps

# Simple decorator
def timer(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"{func.__name__} took {end - start:.4f}s")
        return result
    return wrapper

@timer
def slow_function():
    time.sleep(1)
    return "Done"

result = slow_function()

# Decorator with arguments
def repeat(times):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for _ in range(times):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@repeat(3)
def say_hello():
    print("Hello!")

say_hello()  # Prints "Hello!" 3 times

Async programming enables concurrent operations without threads. Python's asyncio makes it elegant.

import asyncio

# Async function (coroutine)
async def fetch_data(name, delay):
    print(f"Fetching {name}...")
    await asyncio.sleep(delay)  # Non-blocking wait
    print(f"Done fetching {name}")
    return f"Data from {name}"

# Running async functions
async def main():
    # Run sequentially
    result1 = await fetch_data("API 1", 1)
    result2 = await fetch_data("API 2", 1)
    
    # Run concurrently
    results = await asyncio.gather(
        fetch_data("API 3", 1),
        fetch_data("API 4", 1),
        fetch_data("API 5", 1)
    )
    print(results)

# Run the event loop
asyncio.run(main())

# Async with timeout
async def with_timeout():
    try:
        await asyncio.wait_for(fetch_data("Slow", 5), timeout=2)
    except asyncio.TimeoutError:
        print("Operation timed out")