🗂️ Data Structures & File Handling

# ═══ CREATING LISTS ═══
# Empty list
tasks = []

# List with initial values
fruits = ['apple', 'banana', 'cherry']

# Lists can hold mixed types (but usually don't in practice)
mixed = [42, 'hello', 3.14, True]

# ═══ ACCESSING ITEMS ═══
print(fruits[0])        # First item: 'apple'
print(fruits[-1])       # Last item: 'cherry'
print(fruits[1:3])      # Slice: ['banana', 'cherry']

# ═══ MODIFYING LISTS ═══
fruits[0] = 'orange'    # Change first item
fruits.append('date')     # Add to end
fruits.insert(1, 'kiwi')  # Insert at index 1
fruits.remove('banana')   # Remove by value
removed = fruits.pop()     # Remove and return last item

print(fruits)  # ['orange', 'kiwi', 'cherry']

numbers = [3, 1, 4, 1, 5, 9]

# ═══ COMMON OPERATIONS ═══
print(len(numbers))           # Length: 6
print(numbers.count(1))       # Count occurrences: 2
print(numbers.index(4))       # Find index of value: 2

# ═══ SORTING & REVERSING ═══
numbers.sort()                  # Sort in place (modifies original)
numbers.reverse()               # Reverse in place

sorted_copy = sorted(numbers)  # Returns new sorted list (doesn't modify original)

# ═══ LIST COMPREHENSIONS (Advanced but Pythonic) ═══
squares = [x**2 for x in range(1, 6)]  # [1, 4, 9, 16, 25]
evens = [x for x in numbers if x % 2 == 0]    # Filter evens

# ═══ ITERATION ═══
for fruit in fruits:
    print(fruit)

# With index using enumerate()
for i, fruit in enumerate(fruits):
    print(f"{i}: {fruit}")

# ═══ CREATING DICTIONARIES ═══
# Empty dictionary
user = {}

# Dictionary with initial values
person = {
    'name': 'Alice',
    'age': 30,
    'city': 'New York',
    'is_student': False
}

# ═══ ACCESSING VALUES ═══
print(person['name'])           # 'Alice' (raises KeyError if key missing)
print(person.get('age'))       # 30 (returns None if key missing)
print(person.get('job', 'N/A'))  # 'N/A' (default value if key missing)

# ═══ ADDING/MODIFYING VALUES ═══
person['email'] = 'alice@example.com'  # Add new key-value pair
person['age'] = 31                        # Update existing value

# ═══ REMOVING VALUES ═══
del person['is_student']  # Remove key-value pair
removed = person.pop('city')     # Remove and return value

scores = {'Alice': 95, 'Bob': 87, 'Charlie': 92}

# ═══ USEFUL METHODS ═══
print(scores.keys())      # dict_keys(['Alice', 'Bob', 'Charlie'])
print(scores.values())    # dict_values([95, 87, 92])
print(scores.items())     # dict_items([('Alice', 95), ...])

# Check if key exists
if 'Alice' in scores:
    print("Alice's score found!")

# ═══ ITERATION PATTERNS ═══
# Loop through keys
for name in scores:
    print(name)

# Loop through values
for score in scores.values():
    print(score)

# Loop through key-value pairs (MOST COMMON)
for name, score in scores.items():
    print(f"{name} scored {score}")

# ═══ DICTIONARY COMPREHENSION ═══
# Create dict from lists
names = ['Alice', 'Bob', 'Charlie']
ages = [25, 30, 35]
people = {name: age for name, age in zip(names, ages)}

# Filter and transform
passing = {name: score for name, score in scores.items() if score >= 90}

# ★ PRACTICAL EXAMPLE: Building a user profile system

# Create user profile with nested dictionaries
user_profile = {
    'username': 'alice123',
    'email': 'alice@example.com',
    'preferences': {
        'theme': 'dark',
        'notifications': True,
        'language': 'en'
    },
    'tags': ['python', 'data science', 'ml']
}

# Safe access to nested values
theme = user_profile.get('preferences', {}).get('theme', 'light')
print(f"User theme: {theme}")  # dark

# Update nested dictionary
user_profile['preferences']['notifications'] = False

# Merge dictionaries (Python 3.9+)
defaults = {'theme': 'light', 'font_size': 14}
user_prefs = user_profile['preferences']
combined = defaults | user_prefs  # user_prefs overrides defaults

# Alternative: .update() method (modifies in place)
defaults.update(user_prefs)

# ═══ CREATING TUPLES ═══
# Tuples use parentheses (but they're optional for assignment)
coordinates = (10, 20)
rgb_color = (255, 128, 0)

# Single-element tuple needs trailing comma
single = (42,)  # Without comma, it's just a number in parentheses

# Empty tuple
empty = ()

# Tuple unpacking (very Pythonic!)
x, y = coordinates            # x=10, y=20
red, green, blue = rgb_color  # red=255, green=128, blue=0

# ═══ ACCESSING TUPLE ITEMS ═══
print(coordinates[0])  # 10 (indexing works like lists)
print(coordinates[-1]) # 20 (negative indexing works too)

# ═══ TUPLES ARE IMMUTABLE ═══
# coordinates[0] = 15  # This raises TypeError!

# But you can create a new tuple
new_coords = (15, coordinates[1])  # (15, 20)

# ★ MULTIPLE RETURN VALUES
def get_user_info():
    name = "Alice"
    age = 30
    city = "NYC"
    return name, age, city  # Returns a tuple (parentheses optional)

user_name, user_age, user_city = get_user_info()  # Unpack immediately

# ★ SWAP VALUES WITHOUT TEMP VARIABLE
a = 5
b = 10
a, b = b, a  # Now a=10, b=5 (Python uses tuples internally!)

# ★ NAMED TUPLES (from collections module)
from collections import namedtuple

Point = namedtuple('Point', ['x', 'y'])
p = Point(10, 20)
print(p.x, p.y)  # More readable than p[0], p[1]

# ★ ENUMERATE WITH TUPLES
fruits = ['apple', 'banana', 'cherry']
for index, fruit in enumerate(fruits):
    print(f"{index}: {fruit}")  # enumerate returns (index, value) tuples

# ═══ CREATING SETS ═══
# Sets use curly braces (like dicts, but no key-value pairs)
unique_numbers = {1, 2, 3, 3, 4}  # Duplicates automatically removed
print(unique_numbers)  # {1, 2, 3, 4}

# Create set from list (removes duplicates)
list_with_dupes = [1, 2, 2, 3, 3, 3]
unique_set = set(list_with_dupes)  # {1, 2, 3}

# Empty set (can't use {} because that's an empty dict!)
empty_set = set()

# ═══ ADDING AND REMOVING ═══
tags = {'python', 'data'}
tags.add('ml')           # Add single item
tags.update(['ai', 'cloud'])  # Add multiple items
tags.remove('data')      # Remove (raises KeyError if not found)
tags.discard('data')     # Remove (silent if not found)

# ═══ MEMBERSHIP TESTING (FAST!) ═══
if 'python' in tags:
    print("Python tag found!")  # O(1) average time vs O(n) for lists

# ★ SET OPERATIONS
python_devs = {'Alice', 'Bob', 'Charlie'}
javascript_devs = {'Bob', 'Diana', 'Eve'}

# Union (all items from both sets)
all_devs = python_devs | javascript_devs
# Or: all_devs = python_devs.union(javascript_devs)
print(all_devs)  # {'Alice', 'Bob', 'Charlie', 'Diana', 'Eve'}

# Intersection (items in both sets)
fullstack = python_devs & javascript_devs
# Or: fullstack = python_devs.intersection(javascript_devs)
print(fullstack)  # {'Bob'}

# Difference (items in first set but not second)
python_only = python_devs - javascript_devs
# Or: python_only = python_devs.difference(javascript_devs)
print(python_only)  # {'Alice', 'Charlie'}

# Symmetric difference (items in either set, but not both)
exclusive = python_devs ^ javascript_devs
print(exclusive)  # {'Alice', 'Charlie', 'Diana', 'Eve'}

# ★ SET COMPREHENSIONS
squares = {x**2 for x in range(10)}  # {0, 1, 4, 9, 16, 25, 36, 49, 64, 81}

# ★ ALWAYS USE 'with' STATEMENT (Context Manager)
# It automatically closes the file, even if errors occur

# Read entire file as string
with open('data.txt', 'r') as file:
    content = file.read()
    print(content)

# Read file line by line (memory efficient for large files)
with open('data.txt', 'r') as file:
    for line in file:
        print(line.strip())  # .strip() removes newline characters

# Read all lines into a list
with open('data.txt', 'r') as file:
    lines = file.readlines()  # ['line1\n', 'line2\n', ...]
    clean_lines = [line.strip() for line in lines]

# File is automatically closed here, even if an exception occurred

# ═══ WRITING TO FILES ═══

# Write mode (overwrites existing file)
with open('output.txt', 'w') as file:
    file.write("Hello, World!\n")
    file.write("This is line 2\n")

# Write multiple lines at once
lines = ["Line 1\n", "Line 2\n", "Line 3\n"]
with open('output.txt', 'w') as file:
    file.writelines(lines)

# Append mode (adds to existing file)
with open('log.txt', 'a') as file:
    file.write("New log entry\n")

# ★ REAL-WORLD PATTERN: Logging user actions
from datetime import datetime

def log_action(action):
    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    with open('user_actions.log', 'a') as file:
        file.write(f"[{timestamp}] {action}\n")

log_action("User logged in")
log_action("User viewed dashboard")

import csv

# ═══ READING CSV FILES ═══

# Reading as list of rows
with open('data.csv', 'r') as file:
    csv_reader = csv.reader(file)
    header = next(csv_reader)  # First row is usually headers
    print(f"Columns: {header}")
    
    for row in csv_reader:
        print(row)  # Each row is a list: ['value1', 'value2', ...]

# Reading as dictionaries (RECOMMENDED)
with open('employees.csv', 'r') as file:
    csv_reader = csv.DictReader(file)
    
    for row in csv_reader:
        print(row['name'], row['department'])  # Access by column name!

# ═══ WRITING CSV FILES ═══

# Writing rows
data = [
    ['Name', 'Age', 'City'],
    ['Alice', 30, 'NYC'],
    ['Bob', 25, 'SF']
]

with open('output.csv', 'w', newline='') as file:
    csv_writer = csv.writer(file)
    csv_writer.writerows(data)  # Write all rows at once

# Writing dictionaries (RECOMMENDED)
employees = [
    {'name': 'Alice', 'dept': 'Engineering', 'salary': 90000},
    {'name': 'Bob', 'dept': 'Marketing', 'salary': 75000}
]

with open('employees.csv', 'w', newline='') as file:
    fieldnames = ['name', 'dept', 'salary']
    csv_writer = csv.DictWriter(file, fieldnames=fieldnames)
    
    csv_writer.writeheader()  # Write column headers
    csv_writer.writerows(employees)  # Write data rows

# ★ ROBUST FILE HANDLING

from pathlib import Path

# Check if file exists before reading
file_path = Path('data.txt')

if file_path.exists():
    with open(file_path, 'r') as file:
        content = file.read()
else:
    print("File not found!")

# Handle exceptions
try:
    with open('data.txt', 'r') as file:
        content = file.read()
        data = int(content)  # May raise ValueError
except FileNotFoundError:
    print("Error: File doesn't exist")
except ValueError:
    print("Error: File content is not a valid number")
except Exception as e:
    print(f"Unexpected error: {e}")

# ★ REAL-WORLD PATTERN: Safe config file loader
import json

def load_config(filename, default_config):
    """Load JSON config file with fallback to defaults"""
    try:
        with open(filename, 'r') as file:
            return json.load(file)
    except FileNotFoundError:
        print(f"Config file not found. Using defaults.")
        return default_config
    except json.JSONDecodeError:
        print(f"Invalid JSON in config file. Using defaults.")
        return default_config

config = load_config('config.json', {'debug': False, 'port': 8000})

# ═══ IMPORT PATTERNS ═══

# Import entire module
import math
print(math.sqrt(16))  # 4.0
print(math.pi)       # 3.141592653589793

# Import with alias (shorter name)
import datetime as dt
now = dt.datetime.now()
print(now)

# Import specific functions/classes
from random import randint, choice
print(randint(1, 10))         # Random integer between 1 and 10
print(choice(['a', 'b', 'c']))  # Random choice from list

# Import everything (NOT RECOMMENDED - pollutes namespace)
# from math import *  # Avoid this!

# ★ DATETIME - Working with dates and times
from datetime import datetime, timedelta

now = datetime.now()
print(now.strftime("%Y-%m-%d %H:%M:%S"))  # Format: 2024-03-15 14:30:00
tomorrow = now + timedelta(days=1)

# ★ OS - Operating system operations
import os

print(os.getcwd())           # Current working directory
print(os.listdir('.'))      # List files in directory
api_key = os.getenv('API_KEY')  # Get environment variable

# ★ JSON - Working with JSON data
import json

data = {'name': 'Alice', 'age': 30}
json_string = json.dumps(data)  # Python dict -> JSON string
back_to_dict = json.loads(json_string)  # JSON string -> Python dict

# Save/load JSON files
with open('data.json', 'w') as file:
    json.dump(data, file, indent=2)  # Pretty-print with indentation

with open('data.json', 'r') as file:
    loaded_data = json.load(file)

# ★ COLLECTIONS - Specialized data structures
from collections import Counter, defaultdict

# Counter - Count occurrences
words = ['apple', 'banana', 'apple', 'cherry', 'apple']
word_counts = Counter(words)
print(word_counts)  # Counter({'apple': 3, 'banana': 1, 'cherry': 1})

# defaultdict - Dict with default values
scores = defaultdict(list)  # Missing keys default to empty list
scores['Alice'].append(95)  # No KeyError!
scores['Alice'].append(87)

# ═══ PIP: Python Package Installer ═══

# Install a package
pip install requests

# Install specific version
pip install pandas==2.0.0

# Upgrade a package
pip install --upgrade numpy

# Uninstall a package
pip uninstall matplotlib

# List installed packages
pip list

# Show package info
pip show pandas

# ═══ REQUIREMENTS.TXT - Project Dependencies ═══

# Save current environment to file
pip freeze > requirements.txt

# Install all packages from file
pip install -r requirements.txt

# ★ REQUESTS - HTTP library (install with: pip install requests)
import requests

response = requests.get('https://api.github.com/users/python')
data = response.json()  # Parse JSON response
print(data['name'])  # Python

# ★ PANDAS - Data analysis (install with: pip install pandas)
import pandas as pd

df = pd.read_csv('data.csv')
print(df.head())  # First 5 rows

# ═══ WHY VIRTUAL ENVIRONMENTS? ═══
# - Isolate project dependencies
# - Avoid version conflicts between projects
# - Easy to recreate environments on other machines

# Create virtual environment
python -m venv venv

# Activate (Windows)
venv\Scripts\activate

# Activate (Mac/Linux)
source venv/bin/activate

# Now install packages - they go into venv, not system Python
pip install requests pandas

# Deactivate when done
deactivate

# ═══ BEST PRACTICE WORKFLOW ═══
# 1. Create venv for new project
# 2. Activate venv
# 3. Install packages
# 4. Save dependencies: pip freeze > requirements.txt
# 5. Commit requirements.txt to Git (NOT the venv folder!)

# ═══ LISTS ═══
fruits = ['apple', 'banana', 'cherry']
fruits.append('date')           # Add to end
fruits.insert(1, 'kiwi')        # Insert at index
fruits.remove('banana')         # Remove by value
popped = fruits.pop()            # Remove and return last
fruits.sort()                    # Sort in place
sorted_copy = sorted(fruits)    # Return new sorted list
print(fruits[0], fruits[-1])   # First and last item
print(fruits[1:3])            # Slice: items 1 to 2

# ═══ DICTIONARIES ═══
person = {'name': 'Alice', 'age': 30}
print(person['name'])           # Access (KeyError if missing)
print(person.get('job', 'N/A'))  # Safe access with default
person['city'] = 'NYC'          # Add/update
del person['age']             # Delete key

for key, val in person.items():
    print(key, val)              # Iterate key-value pairs

# ═══ TUPLES ═══
coords = (10, 20)                # Immutable
x, y = coords                     # Tuple unpacking
a, b = b, a                       # Swap values

# ═══ SETS ═══
tags = {'python', 'data', 'ml'}
tags.add('ai')                   # Add item
tags.discard('data')            # Remove (no error if missing)
unique = set([1, 2, 2, 3])       # Remove duplicates: {1, 2, 3}

set1 | set2                       # Union
set1 & set2                       # Intersection
set1 - set2                       # Difference

# ═══ FILE HANDLING ═══
# Read file
with open('data.txt', 'r') as file:
    content = file.read()         # Read all
    # lines = file.readlines()  # Read as list

# Write file
with open('output.txt', 'w') as file:
    file.write("Hello\n")        # Write string

# Append to file
with open('log.txt', 'a') as file:
    file.write("New entry\n")

# ═══ CSV FILES ═══
import csv

# Read CSV
with open('data.csv', 'r') as file:
    reader = csv.DictReader(file)
    for row in reader:
        print(row['name'], row['age'])

# Write CSV
with open('output.csv', 'w', newline='') as file:
    writer = csv.DictWriter(file, fieldnames=['name', 'age'])
    writer.writeheader()
    writer.writerow({'name': 'Alice', 'age': 30})

# ═══ MODULES ═══
import math                      # Import module
import datetime as dt            # Import with alias
from random import randint      # Import specific function

# Useful standard library modules:
# - datetime: Dates and times
# - os: Operating system operations
# - json: JSON encoding/decoding
# - csv: CSV file reading/writing
# - collections: Counter, defaultdict, etc.
# - pathlib: Cross-platform path operations

# ═══ PIP & VIRTUAL ENVIRONMENTS ═══
# Create virtual environment:
#   python -m venv venv
# Activate (Windows):
#   venv\Scripts\activate
# Activate (Mac/Linux):
#   source venv/bin/activate
# Install package:
#   pip install requests
# Save dependencies:
#   pip freeze > requirements.txt
# Install from requirements:
#   pip install -r requirements.txt