This page includes an interactive code editor. Try modifying and running the examples!

← Visualization Performance Optimization →

Pandas Data Exporting

Data exporting is a crucial step in the data analysis workflow, allowing you to save your processed data in various formats for sharing, reporting, or integration with other systems.

1. Common Export Formats

Format	File Extension	Best For
CSV	`.csv`	Universal compatibility, simple data
Excel	`.xlsx`	Business reporting, multiple sheets
JSON	`.json`	Web applications, APIs
Parquet	`.parquet`	Large datasets, analytics
HTML	`.html`	Web display, reports

Basic Export Operations

Basic Export Examples

import pandas as pd
import numpy as np

# Create sample dataset for export
np.random.seed(42)
dates = pd.date_range('2024-01-01', periods=100, freq='D')
data = {
    'Date': dates,
    'Product': np.random.choice(['Laptop', 'Tablet', 'Phone', 'Monitor'], 100),
    'Category': np.random.choice(['Electronics', 'Accessories'], 100),
    'Sales': np.random.randint(100, 5000, 100),
    'Quantity': np.random.randint(1, 50, 100),
    'Price': np.random.uniform(50, 2000, 100).round(2),
    'Region': np.random.choice(['North', 'South', 'East', 'West'], 100),
    'In_Stock': np.random.choice([True, False], 100)
}

df = pd.DataFrame(data)
df['Total_Revenue'] = (df['Sales'] * df['Price']).round(2)

print("Sample Data (first 5 rows):")
print(df.head())

# 1. Export to CSV - Most common format
print("\n1. Exporting to CSV:")
df.to_csv('sales_data.csv', index=False)
print("✓ Exported to sales_data.csv")

# Export with specific columns
df[['Date', 'Product', 'Sales', 'Total_Revenue']].to_csv(
    'sales_summary.csv', 
    index=False,
    float_format='%.2f'
)
print("✓ Exported summary to sales_summary.csv")

# 2. Export to Excel
print("\n2. Exporting to Excel:")
with pd.ExcelWriter('sales_data.xlsx', engine='openpyxl') as writer:
    df.to_excel(writer, sheet_name='All_Data', index=False)
    
    summary = df.groupby('Product').agg({
        'Sales': 'sum',
        'Total_Revenue': 'sum'
    }).round(2)
    summary.to_excel(writer, sheet_name='Product_Summary')

print("✓ Exported to sales_data.xlsx with multiple sheets")

# 3. Export to JSON
print("\n3. Exporting to JSON:")
df.to_json('sales_data.json', orient='records', indent=2)
print("✓ Exported to sales_data.json")

# 4. Export to Parquet
print("\n4. Exporting to Parquet:")
df.to_parquet('sales_data.parquet', index=False)
print("✓ Exported to sales_data.parquet")

# 5. Export to HTML
print("\n5. Exporting to HTML:")
html_string = df.head(10).to_html(index=False, classes='table table-striped')
with open('sales_table.html', 'w') as f:
    f.write(html_string)
print("✓ Exported to sales_table.html")

print("\nExport completed successfully!")

Advanced Export Techniques

Advanced Export Methods

import pandas as pd
import numpy as np

# Advanced export techniques
np.random.seed(123)
employees = pd.DataFrame({
    'EmployeeID': range(1, 101),
    'Name': [f'Employee_{i}' for i in range(1, 101)],
    'Department': np.random.choice(['IT', 'HR', 'Finance', 'Marketing', 'Operations'], 100),
    'Salary': np.random.randint(40000, 120000, 100),
    'Join_Date': pd.date_range('2018-01-01', periods=100, freq='M')
})

print("Employee Data Sample:")
print(employees.head())

# 1. Export with formatting
print("\n1. Export with Advanced Formatting:")
with pd.ExcelWriter('employees_advanced.xlsx', engine='openpyxl') as writer:
    employees.to_excel(writer, sheet_name='Raw_Data', index=False)
    
    summary = employees.describe().round(2)
    summary.to_excel(writer, sheet_name='Summary_Stats')
    
    dept_analysis = employees.groupby('Department').agg({
        'EmployeeID': 'count',
        'Salary': ['mean', 'median']
    }).round(2)
    dept_analysis.to_excel(writer, sheet_name='Department_Analysis')

print("✓ Advanced Excel export completed")

# 2. Export with compression
print("\n2. Export with Compression:")
employees.to_csv('employees.csv.gz', index=False, compression='gzip')
print("✓ Exported to employees.csv.gz")

# 3. Export to multiple formats
print("\n3. Export to Multiple Formats:")
formats = [
    ('csv', lambda path: employees.to_csv(path, index=False)),
    ('json', lambda path: employees.to_json(path, orient='records', indent=2)),
    ('parquet', lambda path: employees.to_parquet(path, index=False))
]

for format_name, export_func in formats:
    try:
        filename = f'employees_backup.{format_name}'
        export_func(filename)
        print(f"✓ Successfully exported to {filename}")
    except Exception as e:
        print(f"✗ Failed to export to {format_name}: {e}")

Performance Comparison

Export Formats Performance

import pandas as pd
import numpy as np
import time
import os

# Performance comparison of export formats
print("=== EXPORT FORMATS PERFORMANCE COMPARISON ===\n")

# Create large dataset
np.random.seed(42)
large_df = pd.DataFrame({
    'value': np.random.randn(100000),
    'category': np.random.choice(['A', 'B', 'C', 'D'], 100000),
    'number': np.random.randint(1, 1000, 100000)
})

print(f"Dataset size: {large_df.shape[0]:,} rows")

# Performance tests
results = {}
file_sizes = {}

# CSV performance
print("\n1. CSV Export Performance:")
start = time.time()
large_df.to_csv('large_data.csv', index=False)
results['csv'] = time.time() - start
file_sizes['csv'] = os.path.getsize('large_data.csv')
print(f"   Time: {results['csv']:.2f} seconds")
print(f"   File size: {file_sizes['csv'] / 1024 / 1024:.2f} MB")

# Parquet performance
print("\n2. Parquet Export Performance:")
start = time.time()
large_df.to_parquet('large_data.parquet', index=False)
results['parquet'] = time.time() - start
file_sizes['parquet'] = os.path.getsize('large_data.parquet')
print(f"   Time: {results['parquet']:.2f} seconds")
print(f"   File size: {file_sizes['parquet'] / 1024 / 1024:.2f} MB")

# Results comparison
print("\n=== PERFORMANCE SUMMARY ===\n")
print("Format    | Time (s) | Size (MB) | Ratio")
print("-" * 40)

csv_size = file_sizes['csv'] / 1024 / 1024
parquet_size = file_sizes['parquet'] / 1024 / 1024
compression_ratio = (1 - parquet_size / csv_size) * 100

print(f"CSV     | {results['csv']:.2f} | {csv_size:.2f} | 100%")
print(f"Parquet | {results['parquet']:.2f} | {parquet_size:.2f} | {compression_ratio:.1f}%")

# Cleanup
os.remove('large_data.csv')
os.remove('large_data.parquet')
print("\n✓ Temporary files cleaned up")

Real-World E-commerce Reporting

Enterprise Export System

import pandas as pd
import numpy as np
from datetime import datetime

# Real-world e-commerce reporting system
print("=== E-COMMERCE REPORTING SYSTEM ===\n")

# Generate realistic e-commerce data
np.random.seed(42)
products = ['Laptop', 'Tablet', 'Smartphone', 'Monitor', 'Headphones']
regions = ['North America', 'Europe', 'Asia', 'South America']

orders = pd.DataFrame({
    'order_id': range(1000, 6000),
    'product': np.random.choice(products, 5000),
    'quantity': np.random.randint(1, 5, 5000),
    'unit_price': np.random.uniform(50, 2000, 5000).round(2),
    'region': np.random.choice(regions, 5000),
    'order_date': pd.date_range('2024-01-01', periods=5000, freq='H')
})

orders['total_amount'] = (orders['quantity'] * orders['unit_price']).round(2)

print("Orders Data Sample:")
print(orders.head())
print(f"\nTotal orders: {len(orders):,}")

# Comprehensive export function
def export_ecommerce_reports(df, base_filename):
    timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
    filename_prefix = f"{base_filename}_{timestamp}"
    
    print(f"\nExporting reports with prefix: {filename_prefix}")
    
    # Excel with multiple sheets
    with pd.ExcelWriter(f"{filename_prefix}_full_report.xlsx", engine='openpyxl') as writer:
        df.to_excel(writer, sheet_name='All_Orders', index=False)
        
        daily_summary = df.groupby(df['order_date'].dt.date).agg({
            'order_id': 'count',
            'total_amount': 'sum'
        }).rename(columns={'order_id': 'orders_count'})
        daily_summary.to_excel(writer, sheet_name='Daily_Summary')
        
        product_performance = df.groupby('product').agg({
            'order_id': 'count',
            'total_amount': 'sum'
        }).sort_values('total_amount', ascending=False)
        product_performance.to_excel(writer, sheet_name='Product_Performance')
    
    print("✓ Excel report exported")
    
    # CSV files for different systems
    accounting_data = df[['order_id', 'order_date', 'total_amount']]
    accounting_data.to_csv(f"{filename_prefix}_accounting.csv", index=False)
    
    inventory_data = df.groupby('product')['quantity'].sum().reset_index()
    inventory_data.to_csv(f"{filename_prefix}_inventory.csv", index=False)
    
    print("✓ CSV files exported")
    
    # JSON for web API
    web_data = {
        'summary': {
            'total_orders': len(df),
            'total_revenue': df['total_amount'].sum(),
            'date_range': {
                'start': df['order_date'].min().strftime('%Y-%m-%d'),
                'end': df['order_date'].max().strftime('%Y-%m-%d')
            }
        }
    }
    
    import json
    with open(f"{filename_prefix}_api_data.json", 'w') as f:
        json.dump(web_data, f, indent=2, default=str)
    
    print("✓ JSON API data exported")
    
    return filename_prefix

# Run the export function
export_prefix = export_ecommerce_reports(orders, 'ecommerce_report')

print("\n=== EXPORT COMPLETED ===\n")
print("Files generated:")
print(f"- {export_prefix}_full_report.xlsx")
print(f"- {export_prefix}_accounting.csv")
print(f"- {export_prefix}_inventory.csv")
print(f"- {export_prefix}_api_data.json")

Export Best Practices

Always use index=False unless needed
Specify float_format for currency values
Use compression for large files
Include timestamps in filenames
Validate data before exporting

Performance Tips

Use Parquet format for large datasets
Filter data before exporting when possible
Use gzip compression for CSV files
Avoid Excel format for very large datasets
Use appropriate data types to reduce size

Pro Tip: For production systems, always use context managers (with statements) when working with Excel files to ensure proper resource cleanup and avoid file corruption.

← Visualization Performance Optimization →

Frontend

JavaScript & Frameworks

Backend

Artificial Intelligence

Database

CSS Frameworks

Data Analytics

Digital Marketing

Frontend

Backend

Artificial Intelligence

DevOps

Database

Cyber Security

Pandas Tutorial