The Most Impactful Python Interview Questions

def find_duplicates(lst):
    seen = set()
    duplicates = set()
    for item in lst:
        if item in seen:
            duplicates.add(item)
        else:
            seen.add(item)
    return list(duplicates)
# Alternative using Counter
from collections import Counter
def find_duplicates_counter(lst):
    counts = Counter(lst)
    return [item for item, count in counts.items() if count > 1]

def reverse_string(s):
    return s[::-1]  # Pythonic way
def reverse_string_manual(s):
    result = ""
    for i in range(len(s) - 1, -1, -1):
        result += s[i]
    return result
def reverse_string_recursive(s):
    if len(s) <= 1:
        return s
    return s[-1] + reverse_string_recursive(s[:-1])

from functools import wraps
def simple_cache(func):
    cache = {}
    
    @wraps(func)
    def wrapper(*args, **kwargs):
        # Create hashable key
        key = str(args) + str(sorted(kwargs.items()))
        
        if key not in cache:
            cache[key] = func(*args, **kwargs)
        return cache[key]
    
    return wrapper
@simple_cache
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

def flatten_list(nested_list):
    result = []
    for item in nested_list:
        if isinstance(item, list):
            result.extend(flatten_list(item))
        else:
            result.append(item)
    return result
# Using generators for memory efficiency
def flatten_generator(nested_list):
    for item in nested_list:
        if isinstance(item, list):
            yield from flatten_generator(item)
        else:
            yield item

def are_anagrams(str1, str2):
    # Remove spaces and convert to lowercase
    str1 = str1.replace(" ", "").lower()
    str2 = str2.replace(" ", "").lower()
    
    # Check if lengths are equal
    if len(str1) != len(str2):
        return False
    
    # Count characters
    from collections import Counter
    return Counter(str1) == Counter(str2)
# Alternative without Counter
def are_anagrams_sort(str1, str2):
    str1 = str1.replace(" ", "").lower()
    str2 = str2.replace(" ", "").lower()
    return sorted(str1) == sorted(str2)

# conftest.py
import pytest
from selenium import webdriver
@pytest.fixture(scope="session")
def browser():
    driver = webdriver.Chrome()
    yield driver
    driver.quit()
# test_example.py
def test_page_title(browser):
    browser.get("https://example.com")
    assert "Example" in browser.title
def test_element_present(browser):
    browser.get("https://example.com")
    element = browser.find_element_by_id("main")
    assert element.is_displayed()

from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.by import By
def wait_for_element_clickable(driver, locator, timeout=10):
    wait = WebDriverWait(driver, timeout)
    return wait.until(EC.element_to_be_clickable(locator))
def wait_for_text_present(driver, locator, text, timeout=10):
    wait = WebDriverWait(driver, timeout)
    return wait.until(EC.text_to_be_present_in_element(locator, text))
# Usage
element = wait_for_element_clickable(driver, (By.ID, "submit-btn"))
element.click()

import pytest
test_data = [
    ("valid_user", "valid_pass", True),
    ("invalid_user", "valid_pass", False),
    ("valid_user", "invalid_pass", False),
]
@pytest.mark.parametrize("username,password,expected", test_data)
def test_login(username, password, expected):
    result = login_function(username, password)
    assert result == expected
# Reading from CSV
import csv
def load_test_data():
    with open('test_data.csv', 'r') as file:
        return list(csv.DictReader(file))
@pytest.mark.parametrize("data", load_test_data())
def test_with_csv_data(data):
    result = process_data(data['input'])
    assert result == data['expected']

import pandas as pd
from typing import Iterator
def process_large_csv(filename: str, chunk_size: int = 10000) -> Iterator:
    """Process large CSV files in chunks to manage memory."""
    for chunk in pd.read_csv(filename, chunksize=chunk_size):
        # Process each chunk
        processed_chunk = chunk.groupby('category').sum()
        yield processed_chunk
# Usage
results = []
for processed_chunk in process_large_csv('large_data.csv'):
    results.append(processed_chunk)
final_result = pd.concat(results).groupby(level=0).sum()

import pandas as pd
from sqlalchemy import create_engine
import logging
class ETLPipeline:
    def __init__(self, source_conn, target_conn):
        self.source_engine = create_engine(source_conn)
        self.target_engine = create_engine(target_conn)
        self.logger = logging.getLogger(__name__)
    
    def extract(self, query: str) -> pd.DataFrame:
        """Extract data from source database."""
        self.logger.info(f"Extracting data with query: {query}")
        return pd.read_sql(query, self.source_engine)
    
    def transform(self, df: pd.DataFrame) -> pd.DataFrame:
        """Transform the extracted data."""
        self.logger.info("Transforming data")
        # Data cleaning and transformation
        df = df.dropna()
        df['processed_date'] = pd.Timestamp.now()
        return df
    
    def load(self, df: pd.DataFrame, table_name: str):
        """Load transformed data to target database."""
        self.logger.info(f"Loading data to {table_name}")
        df.to_sql(table_name, self.target_engine, if_exists='append')

import pandas as pd
from typing import Dict, Any
class SchemaValidator:
    def __init__(self, expected_schema: Dict[str, Any]):
        self.expected_schema = expected_schema
    
    def validate_and_adapt(self, df: pd.DataFrame) -> pd.DataFrame:
        """Validate schema and adapt if necessary."""
        current_columns = set(df.columns)
        expected_columns = set(self.expected_schema.keys())
        
        # Handle missing columns
        missing_columns = expected_columns - current_columns
        for col in missing_columns:
            default_value = self.expected_schema[col].get('default')
            df[col] = default_value
        
        # Handle extra columns
        extra_columns = current_columns - expected_columns
        df = df.drop(columns=list(extra_columns))
        
        # Validate data types
        for col, schema in self.expected_schema.items():
            expected_type = schema['type']
            if df[col].dtype != expected_type:
                df[col] = df[col].astype(expected_type)
        
        return df

import numpy as np
class SimpleNeuralNetwork:
    def __init__(self, input_size, hidden_size, output_size):
        self.W1 = np.random.randn(input_size, hidden_size) * 0.01
        self.b1 = np.zeros((1, hidden_size))
        self.W2 = np.random.randn(hidden_size, output_size) * 0.01
        self.b2 = np.zeros((1, output_size))
    
    def sigmoid(self, x):
        return 1 / (1 + np.exp(-np.clip(x, -250, 250)))
    
    def forward(self, X):
        self.z1 = np.dot(X, self.W1) + self.b1
        self.a1 = self.sigmoid(self.z1)
        self.z2 = np.dot(self.a1, self.W2) + self.b2
        self.a2 = self.sigmoid(self.z2)
        return self.a2
    
    def backward(self, X, y, output):
        m = X.shape[0]
        
        # Calculate gradients
        dz2 = output - y
        dW2 = (1/m) * np.dot(self.a1.T, dz2)
        db2 = (1/m) * np.sum(dz2, axis=0, keepdims=True)
        
        dz1 = np.dot(dz2, self.W2.T) * self.a1 * (1 - self.a1)
        dW1 = (1/m) * np.dot(X.T, dz1)
        db1 = (1/m) * np.sum(dz1, axis=0, keepdims=True)
        
        return dW1, db1, dW2, db2

import numpy as np
from sklearn.metrics.pairwise import cosine_similarity
class CollaborativeFilter:
    def __init__(self):
        self.user_item_matrix = None
        self.similarity_matrix = None
    
    def fit(self, user_item_matrix):
        """Fit the collaborative filtering model."""
        self.user_item_matrix = user_item_matrix
        # Calculate user-user similarity
        self.similarity_matrix = cosine_similarity(user_item_matrix)
    
    def recommend(self, user_id, n_recommendations=5):
        """Generate recommendations for a user."""
        if user_id >= len(self.user_item_matrix):
            return []
        
        user_similarities = self.similarity_matrix[user_id]
        user_ratings = self.user_item_matrix[user_id]
        
        # Find unrated items
        unrated_items = np.where(user_ratings == 0)[0]
        
        recommendations = []
        for item in unrated_items:
            # Calculate predicted rating
            numerator = np.sum(user_similarities * self.user_item_matrix[:, item])
            denominator = np.sum(np.abs(user_similarities))
            
            if denominator > 0:
                predicted_rating = numerator / denominator
                recommendations.append((item, predicted_rating))
        
        # Sort by predicted rating and return top N
        recommendations.sort(key=lambda x: x[1], reverse=True)
        return recommendations[:n_recommendations]

import pandas as pd
from sklearn.preprocessing import StandardScaler, LabelEncoder
from sklearn.feature_extraction.text import TfidfVectorizer
class FeatureEngineer:
    def __init__(self):
        self.scalers = {}
        self.encoders = {}
        self.vectorizers = {}
    
    def engineer_features(self, df):
        """Comprehensive feature engineering pipeline."""
        df_processed = df.copy()
        
        # Handle categorical variables
        categorical_cols = df.select_dtypes(include=['object']).columns
        for col in categorical_cols:
            if col not in self.encoders:
                self.encoders[col] = LabelEncoder()
                df_processed[col] = self.encoders[col].fit_transform(df[col])
            else:
                df_processed[col] = self.encoders[col].transform(df[col])
        
        # Create datetime features
        datetime_cols = df.select_dtypes(include=['datetime64']).columns
        for col in datetime_cols:
            df_processed[f'{col}_year'] = df[col].dt.year
            df_processed[f'{col}_month'] = df[col].dt.month
            df_processed[f'{col}_day'] = df[col].dt.day
            df_processed[f'{col}_weekday'] = df[col].dt.weekday
        
        # Scale numerical features
        numerical_cols = df.select_dtypes(include=['int64', 'float64']).columns
        for col in numerical_cols:
            if col not in self.scalers:
                self.scalers[col] = StandardScaler()
                df_processed[col] = self.scalers[col].fit_transform(df[[col]])
            else:
                df_processed[col] = self.scalers[col].transform(df[[col]])
        
        return df_processed