#python #programming #developer #programmer #coding #coder #softwaredeveloper #computerscience #webdev #webdeveloper #webdevelopment #pythonprogramming #pythonquiz #ai #ml #machinelearning #datascience #django

https://t.me/DataScience4

#python #programming #developer #programmer #coding #coder #softwaredeveloper #computerscience #webdev #webdeveloper #webdevelopment #pythonprogramming #pythonquiz #ai #ml #machinelearning #datascience #django

https://t.me/DataScience4

import collections  

# defaultdict - Eliminate key errors with auto-initialization  
from collections import defaultdict  
gradebook = defaultdict(int)  
gradebook['Alice'] += 95  
print(gradebook['Alice'])  # Output: 95  
print(gradebook['Bob'])    # Output: 0  

# defaultdict for grouping operations  
anagrams = defaultdict(list)  
words = ["eat", "tea", "tan"]  
for w in words:  
    key = ''.join(sorted(w))  
    anagrams[key].append(w)  
print(anagrams['aet'])  # Output: ['eat', 'tea']  

# Counter - Frequency analysis in one line  
from collections import Counter  
text = "abracadabra"  
freq = Counter(text)  
print(freq['a'])          # Output: 5  
print(freq.most_common(2)) # Output: [('a', 5), ('b', 2)]  

# Counter arithmetic for problem-solving  
inventory = Counter(apples=10, oranges=5)  
sales = Counter(apples=3, oranges=2)  
print(inventory - sales)  # Output: Counter({'apples': 7, 'oranges': 3})  

# namedtuple - Self-documenting data structures  
from collections import namedtuple  
Employee = namedtuple('Employee', 'name role salary')  
dev = Employee('Alex', 'Developer', 95000)  
print(dev.role)           # Output: Developer  
print(dev[2])             # Output: 95000  

# deque - Optimal for BFS and sliding windows  
from collections import deque  
queue = deque([1, 2, 3])  
queue.append(4)  
queue.popleft()  
print(queue)              # Output: deque([2, 3, 4])  
queue.rotate(1)  
print(queue)              # Output: deque([4, 2, 3])  

# OrderedDict - Track insertion order (LRU cache essential)  
from collections import OrderedDict  
cache = OrderedDict()  
cache['A'] = 1  
cache['B'] = 2  
cache.move_to_end('A')  
cache.popitem(last=False)  
print(list(cache.keys())) # Output: ['B', 'A']  

# ChainMap - Manage layered configurations  
from collections import ChainMap  
defaults = {'theme': 'dark', 'font': 'Arial'}  
user_prefs = {'theme': 'light'}  
settings = ChainMap(user_prefs, defaults)  
print(settings['font'])   # Output: Arial  

# Practical Interview Tip: Anagram detection  
print(Counter("secure") == Counter("rescue"))  # Output: True  

# Pro Tip: Sliding window maximum  
def max_sliding_window(nums, k):  
    dq, result = deque(), []  
    for i, n in enumerate(nums):  
        while dq and nums[dq[-1]] < n:  
            dq.pop()  
        dq.append(i)  
        if dq[0] == i - k:  
            dq.popleft()  
        if i >= k - 1:  
            result.append(nums[dq[0]])  
    return result  
print(max_sliding_window([1,3,-1,-3,5,3,6,7], 3))  # Output: [3,3,5,5,6,7]  

# Expert Move: Custom LRU Cache implementation  
class LRUCache:  
    def __init__(self, capacity):  
        self.cache = OrderedDict()  
        self.capacity = capacity  
    def get(self, key):  
        if key not in self.cache:  
            return -1  
        self.cache.move_to_end(key)  
        return self.cache[key]  
    def put(self, key, value):  
        if key in self.cache:  
            del self.cache[key]  
        self.cache[key] = value  
        if len(self.cache) > self.capacity:  
            self.cache.popitem(last=False)  
cache = LRUCache(2)  
cache.put(1, 10)  
cache.put(2, 20)  
cache.get(1)  
cache.put(3, 30)  
print(list(cache.cache.keys()))  # Output: [2, 1, 3] → Wait! Correction: Should be [1, 3] (capacity=2 triggers eviction of '2')  

# Bonus: Multiset operations with Counter  
primes = Counter([2, 3, 5, 7])  
odds = Counter([1, 3, 5, 7, 9])  
print(primes | odds)  # Output: Counter({3:1, 5:1, 7:1, 2:1, 9:1, 1:1})  

# Django ORM Comparison - Know both frameworks
# Django model (contrast with SQLAlchemy)
from django.db import models

class Department(models.Model):
    name = models.CharField(max_length=50)

class Employee(models.Model):
    name = models.CharField(max_length=100)
    email = models.EmailField(unique=True)
    department = models.ForeignKey(Department, on_delete=models.CASCADE)

# Django query (similar but different syntax)
Employee.objects.filter(department__name="HR").select_related('department')

# Async ORM - Modern Python requirement
# Requires SQLAlchemy 1.4+ and asyncpg
from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession

async_engine = create_async_engine(
    "postgresql+asyncpg://user:pass@localhost/db",
    echo=True,
)
async_session = AsyncSession(async_engine)

async with async_session.begin():
    result = await async_session.execute(
        select(Employee).where(Employee.name == "Alice")
    )
    employee = result.scalar_one()

# Testing Strategies - Interview differentiator
from unittest import mock

# Mock database for unit tests
with mock.patch('sqlalchemy.create_engine') as mock_engine:
    mock_conn = mock.MagicMock()
    mock_engine.return_value.connect.return_value = mock_conn
    
    # Test your ORM-dependent code
    create_employee("Test", "test@company.com")
    mock_conn.execute.assert_called()

# Production Monitoring - Track slow queries
from sqlalchemy import event

@event.listens_for(engine, "before_cursor_execute")
def before_cursor(conn, cursor, statement, params, context, executemany):
    conn.info.setdefault('query_start_time', []).append(time.time())

@event.listens_for(engine, "after_cursor_execute")
def after_cursor(conn, cursor, statement, params, context, executemany):
    total = time.time() - conn.info['query_start_time'].pop(-1)
    if total > 0.1:  # Log slow queries
        print(f"SLOW QUERY ({total:.2f}s): {statement}")

# Interview Power Move: Implement caching layer
from functools import lru_cache

class CachedEmployeeRepository(EmployeeRepository):
    @lru_cache(maxsize=100)
    def get_by_id(self, employee_id):
        return super().get_by_id(employee_id)
    
    def invalidate_cache(self, employee_id):
        self.get_by_id.cache_clear()

# Reduces database hits by 70% in read-heavy applications

# Pro Tip: Schema versioning in CI/CD pipelines
# Sample .gitlab-ci.yml snippet
deploy_db:
  stage: deploy
  script:
    - alembic upgrade head
    - pytest tests/db_tests.py  # Verify schema compatibility
  only:
    - main

# Real-World Case Study: E-commerce inventory system
class Product(Base):
    __tablename__ = 'products'
    id = Column(Integer, primary_key=True)
    sku = Column(String(20), unique=True)
    stock = Column(Integer, default=0)
    
    # Atomic stock update (prevents race conditions)
    def decrement_stock(self, quantity, session):
        result = session.query(Product).filter(
            Product.id == self.id,
            Product.stock >= quantity
        ).update({"stock": Product.stock - quantity})
        if not result:
            raise ValueError("Insufficient stock")

# Usage during checkout
product.decrement_stock(2, session)

# Interview Power Move: Parallel Merging
from concurrent.futures import ThreadPoolExecutor
from PyPDF2 import PdfMerger

def parallel_merge(pdf_list, output, max_workers=4):
    chunks = [pdf_list[i::max_workers] for i in range(max_workers)]
    temp_files = []
    
    def merge_chunk(chunk, idx):
        temp = f"temp_{idx}.pdf"
        merger = PdfMerger()
        for pdf in chunk:
            merger.append(pdf)
        merger.write(temp)
        return temp
    
    with ThreadPoolExecutor() as executor:
        temp_files = list(executor.map(merge_chunk, chunks, range(max_workers)))
    
    # Final merge of chunks
    final_merger = PdfMerger()
    for temp in temp_files:
        final_merger.append(temp)
    final_merger.write(output)

parallel_merge(["doc1.pdf", "doc2.pdf", ...], "parallel_merge.pdf")

# Pro Tip: Validate PDFs before merging
from PyPDF2 import PdfReader

def is_valid_pdf(path):
    try:
        with open(path, "rb") as f:
            reader = PdfReader(f)
            return len(reader.pages) > 0
    except:
        return False

valid_pdfs = [f for f in pdf_files if is_valid_pdf(f)]
merger.append(valid_pdfs)  # Only merge valid files

# Real-World Case Study: Invoice Processing Pipeline
import glob
from PyPDF2 import PdfMerger

def process_monthly_invoices():
    # 1. Download invoices from SFTP
    download_invoices("sftp://vendor.com/invoices/*.pdf")
    
    # 2. Validate and sort
    invoices = sorted(
        [f for f in glob.glob("invoices/*.pdf") if is_valid_pdf(f)],
        key=lambda x: extract_invoice_date(x)
    )
    
    # 3. Merge with cover page
    merger = PdfMerger()
    merger.append("cover_template.pdf")
    for inv in invoices:
        merger.append(inv, outline_item=get_client_name(inv))
    
    # 4. Add metadata and encrypt
    merger.add_metadata({"/InvoiceCount": str(len(invoices))})
    merger.encrypt(owner_pwd="finance_team_2023")
    merger.write(f"Q3_Invoices_{datetime.now().strftime('%Y%m')}.pdf")
    
    # 5. Upload to secure storage
    upload_to_s3("secure-bucket/processed/", "Q3_Invoices.pdf")

process_monthly_invoices()

# Create a list of squares from 0 to 9
squares = [x**2 for x in range(10)]

print(squares)
# Output: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

name = "Alex"
score = 95.5

# Using an f-string for easy formatting
message = f"Congratulations {name}, you scored {score:.1f}!"

print(message)
# Output: Congratulations Alex, you scored 95.5!

numbers = (1, 2, 3, 4, 5)

# Unpack the first, last, and middle elements
first, *middle, last = numbers

print(f"First: {first}")   # 1
print(f"Middle: {middle}") # [2, 3, 4]
print(f"Last: {last}")     # 5

items = ['keyboard', 'mouse', 'monitor']

for index, item in enumerate(items):
    print(f"Item #{index}: {item}")

# Output:
# Item #0: keyboard
# Item #1: mouse
# Item #2: monitor

# Create a dictionary of numbers and their squares
squared_dict = {x: x**2 for x in range(1, 6)}

print(squared_dict)
# Output: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

students = ["Alice", "Bob", "Charlie"]
scores = [88, 92, 79]

for student, score in zip(students, scores):
    print(f"{student}: {score}")

# Output:
# Alice: 88
# Bob: 92
# Charlie: 79

age = 20

# Assign a value based on a condition in one line
status = "Adult" if age >= 18 else "Minor"

print(status)
# Output: Adult

# Looping 3 times without needing the loop variable
for _ in range(3):
    print("Hello, Python!")

# Unpacking, but only needing the last value
_, _, last_item = (10, 20, 30)
print(last_item) # 30

user_data = {"name": "Alice", "age": 30}

# Safely get a key that exists
name = user_data.get("name")

# Safely get a key that doesn't exist by providing a default
city = user_data.get("city", "Not Specified")

print(f"Name: {name}, City: {city}")
# Output: Name: Alice, City: Not Specified

def dynamic_function(*args, **kwargs):
    print("Positional args (tuple):", args)
    print("Keyword args (dict):", kwargs)

dynamic_function(1, 'go', True, user="admin", status="active")
# Output:
# Positional args (tuple): (1, 'go', True)
# Keyword args (dict): {'user': 'admin', 'status': 'active'}

# The 'with' statement ensures the file is closed automatically
try:
    with open("notes.txt", "w") as f:
        f.write("Context managers are great!")
    # No need to call f.close()
    print("File written and closed.")
except Exception as e:
    print(f"An error occurred: {e}")

x = 10

# Check if x is between 5 and 15 in a clean way
if 5 < x < 15:
    print("x is in range.")

# Output: x is in range.

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

# Use a set to quickly get unique elements
unique_numbers = list(set(numbers))

print(unique_numbers)
# Output: [1, 2, 3, 4, 5]

from collections import Counter

words = ['apple', 'banana', 'apple', 'orange', 'banana', 'apple']
word_counts = Counter(words)

print(word_counts)
# Output: Counter({'apple': 3, 'banana': 2, 'orange': 1})
print(word_counts.most_common(1))
# Output: [('apple', 3)]

from collections import defaultdict

data = [('fruit', 'apple'), ('fruit', 'banana'), ('veg', 'carrot')]
grouped_data = defaultdict(list)

for category, item in data:
    grouped_data[category].append(item)

print(grouped_data)
# Output: defaultdict(<class 'list'>, {'fruit': ['apple', 'banana'], 'veg': ['carrot']})