JavaScript to Python: The Polyglot Developer's Guide

// Iterative approach
function fibonacciIterative(n) {
  if (n <= 0) return [];
  if (n === 1) return [0];
  if (n === 2) return [0, 1];
  
  const sequence = [0, 1];
  for (let i = 2; i < n; i++) {
    sequence.push(sequence[i-1] + sequence[i-2]);
  }
  return sequence;
}

// Recursive approach with memoization
function fibonacciRecursive(n, memo = {}) {
  if (n <= 0) return [];
  if (n === 1) return [0];
  if (n === 2) return [0, 1];
  
  if (memo[n]) return memo[n];
  
  const prevSequence = fibonacciRecursive(n - 1, memo);
  const nextValue = prevSequence[prevSequence.length - 1] + 
                    prevSequence[prevSequence.length - 2];
  
  memo[n] = [...prevSequence, nextValue];
  return memo[n];
}

# Iterative approach
def fibonacci_iterative(n):
    if n <= 0:
        return []
    if n == 1:
        return [0]
    if n == 2:
        return [0, 1]
    
    sequence = [0, 1]
    for i in range(2, n):
        sequence.append(sequence[i-1] + sequence[i-2])
    return sequence

# Recursive approach with memoization
def fibonacci_recursive(n, memo=None):
    if memo is None:
        memo = {}
    
    if n <= 0:
        return []
    if n == 1:
        return [0]
    if n == 2:
        return [0, 1]
    
    if n in memo:
        return memo[n]
    
    prev_sequence = fibonacci_recursive(n - 1, memo)
    next_value = prev_sequence[-1] + prev_sequence[-2]
    
    memo[n] = prev_sequence + [next_value]
    return memo[n]

function wordFrequency(text) {
  // Remove punctuation and convert to lowercase
  const cleanText = text.toLowerCase().replace(/[^\w\s]/g, '');
  
  // Split into words
  const words = cleanText.split(/\s+/);
  
  // Count frequencies
  const frequency = {};
  for (const word of words) {
    if (word === '') continue;
    frequency[word] = (frequency[word] || 0) + 1;
  }
  
  return frequency;
}

// Example usage
const text = "The quick brown fox jumps over the lazy dog. The dog was not happy about that!";
console.log(wordFrequency(text));
// { the: 2, quick: 1, brown: 1, fox: 1, ... }

import re
from collections import Counter

def word_frequency(text):
    # Remove punctuation and convert to lowercase
    clean_text = re.sub(r'[^\w\s]', '', text.lower())
    
    # Split into words
    words = clean_text.split()
    
    # Count frequencies using Counter
    return dict(Counter(words))

# Alternative manual implementation
def word_frequency_manual(text):
    # Remove punctuation and convert to lowercase
    clean_text = re.sub(r'[^\w\s]', '', text.lower())
    
    # Split into words
    words = clean_text.split()
    
    # Count frequencies
    frequency = {}
    for word in words:
        if word == '':
            continue
        frequency[word] = frequency.get(word, 0) + 1
    
    return frequency

# Example usage
text = "The quick brown fox jumps over the lazy dog. The dog was not happy about that!"
print(word_frequency(text))
# {'the': 2, 'quick': 1, 'brown': 1, 'fox': 1, ...}

async function getWeather(city, apiKey) {
  try {
    const response = await fetch(
      `https://api.openweathermap.org/data/2.5/weather?q=${city}&units=metric&appid=${apiKey}`
    );
    
    if (!response.ok) {
      throw new Error(`HTTP error! Status: ${response.status}`);
    }
    
    const data = await response.json();
    
    return {
      location: `${data.name}, ${data.sys.country}`,
      temperature: data.main.temp,
      description: data.weather[0].description,
      humidity: data.main.humidity,
      windSpeed: data.wind.speed
    };
  } catch (error) {
    console.error('Error fetching weather data:', error);
    return null;
  }
}

// Example usage
const API_KEY = 'your_openweathermap_api_key';
getWeather('London', API_KEY)
  .then(weather => {
    if (weather) {
      console.log(`Current weather in ${weather.location}:`);
      console.log(`Temperature: ${weather.temperature}°C`);
      console.log(`Conditions: ${weather.description}`);
      console.log(`Humidity: ${weather.humidity}%`);
      console.log(`Wind Speed: ${weather.windSpeed} m/s`);
    }
  });

import requests

def get_weather(city, api_key):
    try:
        response = requests.get(
            f"https://api.openweathermap.org/data/2.5/weather",
            params={
                "q": city,
                "units": "metric",
                "appid": api_key
            }
        )
        
        # Raise exception for HTTP errors
        response.raise_for_status()
        
        data = response.json()
        
        return {
            "location": f"{data['name']}, {data['sys']['country']}",
            "temperature": data['main']['temp'],
            "description": data['weather'][0]['description'],
            "humidity": data['main']['humidity'],
            "wind_speed": data['wind']['speed']
        }
    except requests.exceptions.RequestException as error:
        print(f"Error fetching weather data: {error}")
        return None

# Example usage
API_KEY = 'your_openweathermap_api_key'
weather = get_weather('London', API_KEY)

if weather:
    print(f"Current weather in {weather['location']}:")
    print(f"Temperature: {weather['temperature']}°C")
    print(f"Conditions: {weather['description']}")
    print(f"Humidity: {weather['humidity']}%")
    print(f"Wind Speed: {weather['wind_speed']} m/s")

const fs = require('fs');
const { parse } = require('csv-parse/sync');
const { stringify } = require('csv-stringify/sync');

function analyzeSalesData(inputFile, outputFile, minSales) {
  try {
    // Read and parse the CSV file
    const csvData = fs.readFileSync(inputFile, 'utf8');
    const records = parse(csvData, {
      columns: true,skip_empty_lines: true
    });
    
    // Filter products with sales above threshold
    const filteredProducts = records.filter(record => 
      parseFloat(record.sales) >= minSales
    );
    
    // Calculate total sales by category
    const salesByCategory = {};
    for (const product of filteredProducts) {
      const category = product.category;
      const sales = parseFloat(product.sales);
      
      if (!salesByCategory[category]) {
        salesByCategory[category] = 0;
      }
      salesByCategory[category] += sales;
    }
    
    // Find top product in each category
    const topProductsByCategory = {};
    for (const product of filteredProducts) {
      const category = product.category;
      const sales = parseFloat(product.sales);
      
      if (!topProductsByCategory[category] || 
          sales > parseFloat(topProductsByCategory[category].sales)) {
        topProductsByCategory[category] = product;
      }
    }
    
    // Create summary data
    const summary = Object.keys(salesByCategory).map(category => ({
      category,
      total_sales: salesByCategory[category].toFixed(2),
      top_product: topProductsByCategory[category].product_name,
      top_product_sales: topProductsByCategory[category].sales
    }));
    
    // Write results to output file
    const csvOutput = stringify(summary, { header: true });
    fs.writeFileSync(outputFile, csvOutput);
    
    return {
      productCount: filteredProducts.length,
      categoryCount: Object.keys(salesByCategory).length,
      totalSales: filteredProducts.reduce((sum, record) => 
        sum + parseFloat(record.sales), 0).toFixed(2)
    };
  } catch (error) {
    console.error('Error processing sales data:', error);
    return null;
  }
}

// Example usage
const result = analyzeSalesData('sales_data.csv', 'sales_summary.csv', 1000);
console.log(`Processed ${result.productCount} products in ${result.categoryCount} categories`);
console.log(`Total sales: $${result.totalSales}`);

import csv
import pandas as pd

# Version 1: Using the csv module
def analyze_sales_data_csv(input_file, output_file, min_sales):
    try:
        # Read CSV file
        with open(input_file, 'r') as file:
            reader = csv.DictReader(file)
            records = list(reader)
        
        # Filter products with sales above threshold
        filtered_products = [
            record for record in records 
            if float(record['sales']) >= min_sales
        ]
        
        # Calculate total sales by category
        sales_by_category = {}
        for product in filtered_products:
            category = product['category']
            sales = float(product['sales'])
            
            if category not in sales_by_category:
                sales_by_category[category] = 0
            sales_by_category[category] += sales
        
        # Find top product in each category
        top_products_by_category = {}
        for product in filtered_products:
            category = product['category']
            sales = float(product['sales'])
            
            if category not in top_products_by_category or \
               sales > float(top_products_by_category[category]['sales']):
                top_products_by_category[category] = product
        
        # Create summary data
        summary = [
            {
                'category': category,
                'total_sales': f"{sales_by_category[category]:.2f}",
                'top_product': top_products_by_category[category]['product_name'],
                'top_product_sales': top_products_by_category[category]['sales']
            }
            for category in sales_by_category
        ]
        
        # Write results to output file
        with open(output_file, 'w', newline='') as file:
            writer = csv.DictWriter(
                file, 
                fieldnames=['category', 'total_sales', 'top_product', 'top_product_sales']
            )
            writer.writeheader()
            writer.writerows(summary)
        
        return {
            'product_count': len(filtered_products),
            'category_count': len(sales_by_category),
            'total_sales': f"{sum(float(record['sales']) for record in filtered_products):.2f}"
        }
    except Exception as error:
        print(f"Error processing sales data: {error}")
        return None

# Version 2: Using Pandas (much simpler)
def analyze_sales_data_pandas(input_file, output_file, min_sales):
    try:
        # Read and process data with pandas
        df = pd.read_csv(input_file)
        
        # Filter products
        filtered_df = df[df['sales'] >= min_sales]
        
        # Calculate totals by category
        category_totals = filtered_df.groupby('category')['sales'].sum().reset_index()
        category_totals['total_sales'] = category_totals['sales'].round(2)
        category_totals = category_totals.drop('sales', axis=1)
        
        # Find top product by category
        top_products = filtered_df.loc[filtered_df.groupby('category')['sales'].idxmax()]
        top_products = top_products[['category', 'product_name', 'sales']]
        top_products = top_products.rename(columns={'sales': 'top_product_sales', 'product_name': 'top_product'})
        
        # Merge results
        summary = pd.merge(category_totals, top_products, on='category')
        
        # Save to CSV
        summary.to_csv(output_file, index=False)
        
        return {
            'product_count': len(filtered_df),
            'category_count': len(summary),
            'total_sales': f"{filtered_df['sales'].sum():.2f}"
        }
    except Exception as error:
        print(f"Error processing sales data: {error}")
        return None

# Example usage
result = analyze_sales_data_pandas('sales_data.csv', 'sales_summary.csv', 1000)
print(f"Processed {result['product_count']} products in {result['category_count']} categories")
print(f"Total sales: ${result['total_sales']}")