Python vs Other Languages—The GIL That Destroyed Throughput

# ── PYTHON VERSION ──────────────────────────────────────────────
# Python needs no imports, no class wrapper, no type declarations.
# Indentation (4 spaces) defines the code blocks — no curly braces.

def check_voting_eligibility(name, age):
    # 'if' block is marked by indentation, not { }
    if age >= 18:
        print(f"Welcome, {name}! You are eligible to vote.")
    else:
        print(f"Sorry, {name}. You can vote in {18 - age} year(s).")

# Call the function — clean and readable
check_voting_eligibility("Alice", 20)
check_voting_eligibility("Ben", 15)


# ── WHAT JAVA EQUIVALENT LOOKS LIKE (as a comment for comparison) ──
# public class VotingCheck {
#     public static void checkVotingEligibility(String name, int age) {
#         if (age >= 18) {
#             System.out.println("Welcome, " + name + "! You are eligible to vote.");
#         } else {
#             System.out.println("Sorry, " + name + ". You can vote in " + (18 - age) + " year(s).");
#         }
#     }
#     public static void main(String[] args) {
#         checkVotingEligibility("Alice", 20);
#         checkVotingEligibility("Ben", 15);
#     }
# }
#
# Python: 6 meaningful lines. Java: 14 lines with class boilerplate.
# The logic is identical. The overhead is not.

# ── DYNAMIC TYPING IN ACTION ────────────────────────────────────
# Python infers the type from the value you assign.
# No 'int', 'str', or 'float' keyword needed upfront.

product_price = 29.99          # Python sees a decimal → treats it as float
product_name = "Wireless Mouse" # Python sees quotes → treats it as string
stock_count = 142               # Python sees a whole number → treats it as int

print(type(product_price))  # Shows: <class 'float'>
print(type(product_name))   # Shows: <class 'str'>
print(type(stock_count))    # Shows: <class 'int'>

# ── PYTHON TYPE HINTS (modern best practice for larger projects) ──
# Python 3.5+ allows optional type hints. They don't enforce anything
# at runtime, but tools like mypy and IDEs use them to catch bugs early.

def calculate_discounted_price(original_price: float, discount_percent: float) -> float:
    """
    Returns the price after applying a percentage discount.
    Type hints make it clear what this function expects and returns.
    """
    discount_amount = original_price * (discount_percent / 100)
    final_price = original_price - discount_amount
    return final_price

sale_price = calculate_discounted_price(29.99, 10)  # 10% off
print(f"Sale price: ${sale_price:.2f}")

# ── WHAT JAVA EQUIVALENT LOOKS LIKE (as a comment) ───────────────
# // In Java, every variable type is declared explicitly:
# double productPrice = 29.99;   // must say 'double'
# String productName = "Wireless Mouse"; // must say 'String'
# int stockCount = 142;          // must say 'int'
#
# This catches errors before running, but demands more upfront thought.

# ── USE CASE 1: DATA ANALYSIS (Python's sweet spot) ─────────────
# With pandas (a library), analysing data is just a few lines.
# In Java this would require hundreds of lines and custom parsing.
# We simulate this without installing pandas to keep it runnable.

monthly_sales = [12400, 15300, 13750, 17800, 16200, 19500]

total_revenue = sum(monthly_sales)                       # built-in sum
average_monthly = total_revenue / len(monthly_sales)     # len() counts items
best_month_index = monthly_sales.index(max(monthly_sales)) # find peak month

print(f"Total Revenue:    ${total_revenue:,}")
print(f"Monthly Average:  ${average_monthly:,.2f}")
print(f"Best Month:       Month {best_month_index + 1} (${max(monthly_sales):,})")


# ── USE CASE 2: AUTOMATION / SCRIPTING ──────────────────────────
# Python can rename 1,000 files in seconds. In C++ that's a project.
import os

def preview_rename_files(folder_path, old_prefix, new_prefix):
    """
    Previews what files WOULD be renamed — a dry run.
    Safe to run: it only prints, doesn't actually rename anything.
    """
    try:
        all_files = os.listdir(folder_path)  # get all filenames in folder
    except FileNotFoundError:
        print(f"Folder not found: {folder_path}")
        return

    files_to_rename = [f for f in all_files if f.startswith(old_prefix)]

    if not files_to_rename:
        print("No matching files found.")
        return

    print(f"Found {len(files_to_rename)} file(s) to rename:")
    for filename in files_to_rename:
        new_name = filename.replace(old_prefix, new_prefix, 1) # replace first occurrence only
        print(f"  {filename}  →  {new_name}")

# Preview renaming files in the current directory
preview_rename_files(".", "report_", "summary_")


# ── USE CASE 3: WEB API (conceptual — Flask syntax shown) ────────
# A full web API endpoint in Python takes ~5 lines.
# The comment below shows real Flask code — this is production reality.
#
# from flask import Flask, jsonify
# app = Flask(__name__)
#
# @app.route('/api/greeting/<name>')
# def get_greeting(name):
#     return jsonify({"message": f"Hello, {name}!", "status": "ok"})
#
# Equivalent in Java Spring Boot requires a class, annotations,
# a return type, dependency injection config — easily 5x more code.

# ── PYTHON STANDARD LIBRARY: ZERO INSTALLS REQUIRED ─────────────
# Everything below uses only Python's built-in modules.
# In many other languages, each of these would need a separate library.

import json        # Parse and create JSON data
import datetime    # Work with dates and times
import random      # Generate random numbers
import math        # Mathematical functions
import collections # Specialised data structures

# ── 1. JSON HANDLING ─────────────────────────────────────────────
user_profile_dict = {
    "username": "codeforge_learner",
    "joined": "2024-01-15",
    "courses_completed": 3
}

# Convert Python dictionary → JSON string (for sending over a network)
json_string = json.dumps(user_profile_dict, indent=2)
print("── JSON Output ──")
print(json_string)

# Convert JSON string → Python dictionary (for receiving from a network)
parsed_back = json.loads(json_string)
print(f"Username recovered: {parsed_back['username']}\n")

# ── 2. DATE & TIME ───────────────────────────────────────────────
today = datetime.date.today()                          # current date
launch_date = datetime.date(2025, 12, 31)              # a future date
days_until_launch = (launch_date - today).days         # difference in days

print("── Date Calculation ──")
print(f"Today:             {today}")
print(f"Days until launch: {days_until_launch}\n")

# ── 3. COLLECTIONS: Counter (counts items automatically) ─────────
user_feedback_tags = [
    "bug", "feature", "bug", "ui", "bug", "performance", "feature", "bug"
]

tag_counts = collections.Counter(user_feedback_tags)  # counts each unique item
print("── Feedback Tag Counts ──")
for tag, count in tag_counts.most_common():            # sorted by most frequent
    print(f"  {tag:<15} {count} report(s)")

# ── 4. MATH ──────────────────────────────────────────────────────
circle_radius = 7.5
circle_area = math.pi * math.pow(circle_radius, 2)   # π × r²
print(f"\n── Circle Area ──")
print(f"  Radius: {circle_radius}cm  →  Area: {circle_area:.2f} cm²")

# ── GIL DEMO: CPU-bound task in threads vs processes ────────────
import time
import threading
import multiprocessing

def cpu_intensive(n):
    """Simulate a CPU-bound calculation."""
    return sum(i * i for i in range(n))

# ── Using threads (GIL serializes execution) ─────────────────────
def run_threads(n, num_workers=4):
    threads = []
    start = time.time()
    for _ in range(num_workers):
        t = threading.Thread(target=cpu_intensive, args=(n,))
        threads.append(t)
        t.start()
    for t in threads:
        t.join()
    print(f"Threads took: {time.time() - start:.2f}s")

# ── Using processes (bypasses GIL) ───────────────────────────────
def run_processes(n, num_workers=4):
    with multiprocessing.Pool(processes=num_workers) as pool:
        start = time.time()
        pool.map(cpu_intensive, [n] * num_workers)
    print(f"Processes took: {time.time() - start:.2f}s")

if __name__ == "__main__":
    # Run the same CPU-bound function with threads and processes
    run_threads(10_000_000)
    run_processes(10_000_000)

# Output on a quad-core machine:
# Threads took: 2.94s   (only one core used)
# Processes took: 0.82s  (four cores used)