Python My Course#

• Core Primitives str, int, float, bool, None
• Conversion int(), str(), float()
• Type Checking isinstance(val, type)

In Python, variables are names that point to values in memory. You don't specify variable types when declaring them; Python figures out the type automatically at runtime. Converting between types is done explicitly with functions like str(), int(), float(), and bool().

# Everyday variable assignment
user_name = "Alex"
user_age = 28
user_score = 94.5
is_active = True
session_token = None

# Type conversion
input_str = "150"
total = int(input_str) + 50
print(total)  # 200

# Recommended type checking
if isinstance(total, int):
    print("total is an integer")

• Strength — Fast Prototyping: Dynamic typing lets you assign and manipulate values without repetitive type declarations.
• Weakness — Runtime Type Mismatches: Adding incompatible types like "Score: " + 10 raises a TypeError at runtime instead of converting automatically.

• Formatting f"{variable}" interpolation
• Whitespace Trim .strip(), .split()
• Joining ", ".join(items)

Strings are one of the most commonly used data types in Python. Python strings are immutable (they cannot be changed in place; operations return a new string). Formatted string literals (f-strings) are the modern, standard way to embed variables and expressions inside text.

# Modern f-strings
product = "Coffee Mug"
price = 12.994
print(f"Item: {product} | Cost: ${price:.2f}")  # Item: Coffee Mug | Cost: $12.99

# Cleaning user inputs
raw_email = "   Alex@Company.COM \n"
clean_email = raw_email.strip().lower()
print(clean_email)  # alex@company.com

# Splitting and joining
csv_row = "laptop,electronics,999"
parts = csv_row.split(",")
print(parts)  # ['laptop', 'electronics', '999']

joined = " -> ".join(parts)
print(joined)  # laptop -> electronics -> 999

• Strength — Clean F-strings: F-strings can evaluate expressions inline (like f"{total * 1.08:.2f}") cleanly and quickly.
• Weakness — None Method Calls: Calling .strip() or .lower() on a variable that happens to be None throws an AttributeError.

• Division / float, // int floor
• Truthiness Empty collections are False
• Ternary val if cond else alt

Python uses standard comparison operators (==, !=, <, >) and logical operators (and, or, not). Every object in Python has a boolean value: empty lists, empty dictionaries, empty strings, 0, and None evaluate to False; populated collections and non-zero numbers evaluate to True.

# Truthiness in if statements
cart = []
if not cart:
    print("Your cart is empty.")

# Checking None safely
current_user = None
if current_user is None:
    print("Please log in.")

# Ternary expression
score = 82
result = "Pass" if score >= 60 else "Fail"
print(result)  # Pass

# Checking membership
admin_users = ["alice", "bob"]
if "alice" in admin_users:
    print("Access granted.")

• Strength — Idiomatic Emptiness Checks: if items: and if not items: work identically across strings, lists, tuples, and dictionaries.
• Weakness — Default with or Trap: Using x = val or 10 will override 0 because 0 is falsy (0 or 10 returns 10).

• Counting Loop for i in range(n):
• Index & Item enumerate(seq)
• Loop Control break, continue

Python loops iterate directly over items in a collection, rather than keeping track of an incrementing index variable. When you need the index alongside the item, enumerate() gives you both cleanly.

fruits = ["apple", "banana", "orange"]

# Direct iteration
for fruit in fruits:
    print(fruit)

# Iteration with index
for rank, fruit in enumerate(fruits, start=1):
    print(f"{rank}. {fruit}")
# 1. apple
# 2. banana
# 3. orange

# Parallel iteration with zip
prices = [1.20, 0.50, 0.80]
for fruit, price in zip(fruits, prices):
    print(f"{fruit}: ${price:.2f}")

# While loop for conditions
count = 3
while count > 0:
    print(f"Countdown: {count}")
    count -= 1

• Strength — Clean Syntax: Direct iteration prevents off-by-one errors and out-of-bounds indexing bugs.
• Weakness — Modifying While Looping: Removing items from a list while iterating over it will cause the loop to skip subsequent elements.

• Index Lookup O(1) instant access
• Append list.append(item)
• Slicing seq[start:stop]

A list is Python's standard ordered, mutable array. You can store any types of items in a list. You can access items by index (starting at 0 for the first item, or -1 for the last item). Slicing allows you to extract sub-portions of a list.

todos = ["buy groceries", "pay electric bill", "walk dog"]

# Modifying lists
todos.append("read book")       # Adds to end
completed = todos.pop()         # Removes "read book"
print(f"Finished: {completed}")

# Slicing
numbers = [10, 20, 30, 40, 50]
print(numbers[1:3])   # [20, 30]
print(numbers[:2])    # [10, 20]
print(numbers[-1])    # 50 (last item)
print(numbers[::-1])  # [50, 40, 30, 20, 10] (reversed)

# Membership check
if "buy groceries" in todos:
    print("Don't forget the milk!")

• Strength — Flexible & General Purpose: Lists can grow, shrink, and hold mixed data types effortlessly.
• Weakness — Linear Search Speed: Checking item in my_list scans elements one by one; if you have thousands of items, use a set for instant lookups.

• Key Lookup Instant O(1) hash access
• Safe Retrieval d.get(key, default)
• Iteration for k, v in d.items():

A dict (dictionary) stores data in key-value pairs. Looking up a value by its key is instant (O(1)) regardless of whether the dictionary has 10 items or 1,000,000 items. Keys must be unique and immutable (like strings or numbers).

user = {
    "name": "Sarah Connor",
    "role": "Engineer",
    "level": 3
}

# Safe lookup with .get()
location = user.get("location", "Remote")
print(f"Location: {location}")  # Remote

# Adding and updating
user["level"] = 4
user["team"] = "DevOps"

# Iterating over key-value pairs
for key, value in user.items():
    print(f"{key}: {value}")

• Strength — Instant Key Lookups: Dictionaries are the fastest and most natural way to structure associated data and configuration mappings.
• Weakness — Direct Bracket KeyError: Accessing user["missing_key"] directly crashes with a KeyError; use user.get("missing_key") when a key might be absent.

• Tuples Immutable records: (x, y)
• Sets Unique items, fast in check
• Set Operators Union |, Intersection &

A tuple is an ordered, immutable sequence written with parentheses (1, 2). Once created, you cannot add, remove, or modify items in a tuple. A set is an unordered collection of unique elements written with curly braces {1, 2}. Sets automatically eliminate duplicates and offer instant O(1) membership checks.

# Tuples for fixed records and unpacking
user_coordinate = (37.7749, -122.4194)
lat, lon = user_coordinate
print(f"Latitude: {lat}, Longitude: {lon}")

# Swapping two variables with tuple packing
a = 5
b = 10
a, b = b, a
print(a, b)  # 10 5

# Sets for unique elements
raw_roles = ["admin", "editor", "admin", "viewer", "editor"]
unique_roles = set(raw_roles)
print(unique_roles)  # {'admin', 'editor', 'viewer'}

# Fast membership check
if "admin" in unique_roles:
    print("Admin role found!")

• Strength — Automatic Deduplication & Speed: Converting a list to a set strips duplicates instantly, and val in set is much faster than val in list.
• Weakness — Unordered Sets: Sets do not preserve order; if you need both order and uniqueness, use a list alongside a set.

• Syntax [expr for x in items]
• Filtering [expr for x in items if cond]
• Readability Replaces 4-line loops

A list comprehension provides a concise, readable way to create a new list by transforming or filtering elements from an existing collection. It replaces verbose multi-line for loops that append items one by one.

# Example 1: Squaring numbers
numbers = [1, 2, 3, 4, 5]
squares = [n * n for n in numbers]
print(squares)  # [1, 4, 9, 16, 25]

# Example 2: Filtering even numbers
evens = [n for n in numbers if n % 2 == 0]
print(evens)  # [2, 4]

# Example 3: Cleaning strings
raw_tags = ["  python ", "FASTAPI", "  sql  "]
clean_tags = [tag.strip().lower() for tag in raw_tags]
print(clean_tags)  # ['python', 'fastapi', 'sql']

• Strength — Clean & Expressive: Turns repetitive 4-line accumulator loops into a single self-explanatory statement.
• Weakness — Avoid Overcomplicating: Don't write nested comprehensions spanning three lines with multiple if clauses; write a regular for loop when logic gets complex.

• Definition def fn(param=default):
• Return return result
• Defaults Clean fallbacks

Functions let you package code into reusable blocks. Functions take arguments, execute logic, and return values using the return statement. If a function doesn't include an explicit return, it returns None automatically.

# Function with default parameters
def calculate_total(subtotal: float, tax_rate: float = 0.08) -> float:
    return round(subtotal * (1 + tax_rate), 2)

print(calculate_total(100.0))         # 108.0 (uses default 8% tax)
print(calculate_total(100.0, 0.05))   # 105.0 (overrides tax rate)

# Returning multiple values
def get_min_and_max(numbers: list[int]):
    return min(numbers), max(numbers)

lowest, highest = get_min_and_max([12, 45, 2, 89, 23])
print(f"Min: {lowest}, Max: {highest}")  # Min: 2, Max: 89

• Strength — Reusability & Modularity: Breaking code into focused, well-named functions makes testing and debugging straightforward.
• Weakness — Mutable Default Argument Trap: Never use a mutable list or dictionary as a default argument (like def fn(items=[])); use items=None and initialize inside the function.

• Try / Except Catch specific exceptions
• Common Errors ValueError, KeyError
• Cleanup finally block always runs

Errors happen: an API returns bad text, a user types letters into a number field, or a file doesn't exist. Python uses try / except blocks so your program handles errors gracefully instead of crashing abruptly.

# Catching specific parsing errors
raw_input = "forty-two"

try:
    age = int(raw_input)
    print(f"Age is {age}")
except ValueError:
    print(f"Could not convert '{raw_input}' to an integer. Setting default age to 0.")
    age = 0

# Safe dictionary lookups
config = {"timeout": 30}
try:
    retries = config["retries"]
except KeyError:
    retries = 3

print(f"Using {retries} retries.")

• Strength — Prevents Application Crashes: Catching specific errors lets services log failures and return fallback responses without taking down the server.
• Weakness — Bare except: pass Anti-pattern: Writing except: pass silences every error, including keyboard interrupts and variable typos, making debugging impossible.