Pandas¶

# Import Pandas
import pandas as pd
import numpy as np

print(f"Pandas version: {pd.__version__}")
print(f"NumPy version: {np.__version__}")

# Display settings for better output
pd.set_option('display.max_columns', None)
pd.set_option('display.precision', 2)

# Create a Series from a list
s = pd.Series([10, 20, 30, 40], index=['a', 'b', 'c', 'd'])
print("Series from list:")
print(s)

# Create a Series from a dictionary
data_dict = {'x': 100, 'y': 200, 'z': 300}
s_dict = pd.Series(data_dict)
print("\nSeries from dictionary:")
print(s_dict)

# Create a Series from scalar value (broadcasts to all indices)
s_scalar = pd.Series(5, index=['a', 'b', 'c'])
print("\nSeries from scalar value:")
print(s_scalar)

# Accessing elements
print("\nAccessing by label s['b']:", s['b'])
print("Accessing by position s.iloc[2]:", s.iloc[2])
print("Slicing s['a':'c']:")
print(s['a':'c'])

# Create DataFrame from a dictionary of lists
df = pd.DataFrame({
    'Name': ['Alice', 'Bob', 'Charlie'],
    'Age': [25, 30, 35],
    'City': ['New York', 'Paris', 'London']
})
print("DataFrame from dictionary:")
print(df)

# Create DataFrame from a list of lists with column names
df2 = pd.DataFrame(
    [[1, 2, 3],
     [4, 5, 6],
     [7, 8, 9]],
    columns=['ColA', 'ColB', 'ColC'],
    index=['row1', 'row2', 'row3']
)
print("\nDataFrame from list of lists:")
print(df2)

# Create DataFrame from list of dictionaries
df3 = pd.DataFrame([
    {'Name': 'Alice', 'Age': 25},
    {'Name': 'Bob', 'Age': 30},
    {'Name': 'Charlie', 'Age': 35}
])
print("\nDataFrame from list of dictionaries:")
print(df3)

# Check basic attributes
print("\n--- DataFrame Attributes ---")
print("Shape:", df2.shape)  # (rows, columns)
print("Columns:", df2.columns.tolist())
print("Index:", df2.index.tolist())
print("Data types:\n", df.dtypes)

# Create a MultiIndex from tuples
tuples = [('Group1', 'Row1'), ('Group1', 'Row2'),
          ('Group2', 'Row1'), ('Group2', 'Row2')]
multi_index = pd.MultiIndex.from_tuples(tuples, names=['Group', 'Row'])

# Create a DataFrame using the MultiIndex
df_multi = pd.DataFrame(
    np.random.randn(4, 2),
    index=multi_index,
    columns=['ColX', 'ColY']
)
print("MultiIndex DataFrame:")
print(df_multi)

# Access data with MultiIndex
print("\n--- Accessing MultiIndex Data ---")
print("All rows in Group1:")
print(df_multi.loc['Group1'])

print("\nSpecific row (Group2, Row1):")
print(df_multi.loc[('Group2', 'Row1')])

# MultiIndex from product (Cartesian product)
from itertools import product
index_product = pd.MultiIndex.from_product([['A', 'B'], [1, 2]], names=['Letter', 'Number'])
df_product = pd.DataFrame(np.random.randn(4, 2), index=index_product, columns=['X', 'Y'])
print("\nMultiIndex from product:")
print(df_product)

# Using the df we created above
print("Original DataFrame:")
print(df)

# Select a single column by label (returns Series)
print("\nSingle column df['Name']:")
print(df['Name'])

# Select multiple columns (returns DataFrame)
print("\nMultiple columns df[['Name', 'Age']]:")
print(df[['Name', 'Age']])

# Using .loc (label-based)
print("\n--- .loc (Label-based) ---")
print("Single value df.loc[0, 'Age']:", df.loc[0, 'Age'])
print("\nSlice rows and columns df.loc[0:1, ['Name', 'City']]:")
print(df.loc[0:1, ['Name', 'City']])  # inclusive slicing

# Using .iloc (integer position-based)
print("\n--- .iloc (Position-based) ---")
print("Single value df.iloc[1, 2]:", df.iloc[1, 2])  # second row, third column
print("\nSlice df.iloc[0:2, 0:2]:")
print(df.iloc[0:2, 0:2])  # exclusive slicing

# Boolean indexing
print("\n--- Boolean Indexing ---")
print("Rows where Age > 25:")
print(df[df['Age'] > 25])

# Multiple conditions
print("\nRows where Age > 25 AND City == 'London':")
print(df[(df['Age'] > 25) & (df['City'] == 'London')])

# Using .at and .iat for fast scalar access
print("\n--- Fast Scalar Access ---")
print("df.at[0, 'Name']:", df.at[0, 'Name'])
print("df.iat[0, 0]:", df.iat[0, 0])

# Example DataFrame (wide format)
df_wide = pd.DataFrame({
    'id': [1, 2, 3],
    'varA': [10, 20, 30],
    'varB': [40, 50, 60]
})
print("Wide DataFrame:")
print(df_wide)

# Melt (wide → long)
df_long = pd.melt(df_wide, id_vars='id', var_name='variable', value_name='value')
print("\nMelted (long) DataFrame:")
print(df_long)

# Pivot (long → wide)
df_pivoted = df_long.pivot(index='id', columns='variable', values='value')
print("\nPivoted (wide) DataFrame:")
print(df_pivoted)

# Stack and unstack (for MultiIndex manipulation)
df_stacked = df_wide.set_index('id').stack()
print("\nStacked (Series with MultiIndex):")
print(df_stacked)

df_unstacked = df_stacked.unstack()
print("\nUnstacked (back to DataFrame):")
print(df_unstacked)

# Concat examples (combining DataFrames)
df_part1 = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
df_part2 = pd.DataFrame({'A': [5, 6], 'B': [7, 8]})

# Vertical concatenation (stack rows)
df_concat = pd.concat([df_part1, df_part2], ignore_index=True)
print("\nConcatenated vertically (ignore_index=True):")
print(df_concat)

# Horizontal concatenation (side by side)
df_concat_horiz = pd.concat([df_part1, df_part2], axis=1)
print("\nConcatenated horizontally (axis=1):")
print(df_concat_horiz)

# Using df_wide from previous example
print("Original DataFrame:")
print(df_wide)

# Subset columns
subset_columns = df_wide[['id', 'varA']]
print("\nSubset of columns ['id', 'varA']:")
print(subset_columns)

# Subset rows by index slicing
subset_rows = df_wide.iloc[0:2]  # first two rows
print("\nSubset of rows (first two rows using iloc):")
print(subset_rows)

# Subset using head() and tail()
print("\nFirst 2 rows using head(2):")
print(df_wide.head(2))

# Subset using a condition
condition_subset = df_wide[df_wide['varA'] > 10]
print("\nSubset where varA > 10:")
print(condition_subset)

# Subset using isin()
subset_isin = df_wide[df_wide['id'].isin([1, 3])]
print("\nSubset where id is in [1, 3]:")
print(subset_isin)

# Subset rows and columns together
subset_both = df_wide.loc[df_wide['varA'] > 10, ['id', 'varB']]
print("\nSubset rows (varA > 10) and columns ['id', 'varB']:")
print(subset_both)

# Create a DataFrame with mixed types
np.random.seed(42)
df_stats = pd.DataFrame({
    'Col1': np.random.randint(0, 100, 5),
    'Col2': np.random.randint(0, 100, 5),
    'Col3': np.random.randint(0, 100, 5),
    'Category': ['A', 'B', 'A', 'C', 'B'],
    'Status': ['Active', 'Inactive', 'Active', 'Active', 'Inactive']
})
print("DataFrame with mixed types:")
print(df_stats)

# Basic stats (numeric columns only)
print("\n--- Numerical Statistics (describe) ---")
print(df_stats.describe())

# Basic stats for object columns
print("\n--- Categorical Statistics (describe) ---")
print(df_stats.describe(include=['object']))

# Value counts for categorical columns
print("\n--- Value Counts ---")
print("Category value counts:")
print(df_stats['Category'].value_counts())
print("\nStatus value counts:")
print(df_stats['Status'].value_counts())

# Individual statistics
print("\n--- Individual Statistics ---")
print("Mean of numeric columns:")
print(df_stats.mean(numeric_only=True))

print("\nMedian of numeric columns:")
print(df_stats.median(numeric_only=True))

print("\nStandard deviation:")
print(df_stats.std(numeric_only=True))

print("\nMin and Max:")
print("Min:", df_stats[['Col1', 'Col2', 'Col3']].min())
print("Max:", df_stats[['Col1', 'Col2', 'Col3']].max())

# Count of non-null values
print("\nCount of non-null values:")
print(df_stats.count())

# Number of unique values per column
print("\nNumber of unique values:")
print(df_stats.nunique())

# Correlation matrix (numeric columns only)
print("\nCorrelation matrix:")
print(df_stats[['Col1', 'Col2', 'Col3']].corr())

# Create a DataFrame with NaN values
df_missing = pd.DataFrame({
    'A': [1, np.nan, 3, np.nan, 5],
    'B': [5, 6, np.nan, 8, np.nan],
    'C': [10, 20, 30, 40, 50]
})
print("Original DataFrame with missing values:")
print(df_missing)

# Detect missing values
print("\n--- Detecting Missing Values ---")
print("isnull():")
print(df_missing.isnull())

print("\nSum of missing values per column:")
print(df_missing.isnull().sum())

print("\nAny missing values?", df_missing.isnull().any().any())

# Drop rows with any missing values
print("\n--- Drop rows with any NaN ---")
print(df_missing.dropna())

# Drop columns with any missing values
print("\n--- Drop columns with any NaN ---")
print(df_missing.dropna(axis=1))

# Drop rows where ALL values are NaN
print("\n--- Drop rows where ALL values are NaN (how='all') ---")
df_all_nan = pd.DataFrame({'A': [1, np.nan], 'B': [2, np.nan]})
print("Before:", df_all_nan)
print("After:", df_all_nan.dropna(how='all'))

# Fill missing values with a constant
print("\n--- Fill NaN with constant (0) ---")
filled_df = df_missing.fillna(0)
print(filled_df)

# Forward fill (propagate last valid observation forward)
print("\n--- Forward fill (ffill) ---")
print(df_missing.ffill())

# Backward fill (use next valid observation to fill gap)
print("\n--- Backward fill (bfill) ---")
print(df_missing.bfill())

# Fill with column mean
print("\n--- Fill with column mean ---")
print(df_missing.fillna(df_missing.mean()))

# Interpolate (linear interpolation)
print("\n--- Interpolate missing values ---")
print(df_missing.interpolate())

df_new_cols = pd.DataFrame({
    'Length': [2, 3, 4],
    'Width': [5, 6, 7]
})
print("Original DataFrame:")
print(df_new_cols)

# 1. Direct assignment (most common)
df_new_cols['Area'] = df_new_cols['Length'] * df_new_cols['Width']
print("\n--- Added 'Area' column (direct assignment) ---")
print(df_new_cols)

# 2. Using assign (returns a copy, useful for chaining)
df_assigned = df_new_cols.assign(
    Perimeter=lambda x: 2 * (x['Length'] + x['Width']),
    Volume=lambda x: x['Area'] * 2  # Can reference newly created columns
)
print("\n--- Using assign() (creates copy) ---")
print(df_assigned)

# 3. Multiple columns at once
df_new_cols['Sum'] = df_new_cols['Length'] + df_new_cols['Width']
df_new_cols['Diff'] = df_new_cols['Length'] - df_new_cols['Width']
print("\n--- Added multiple columns ---")
print(df_new_cols)

# 4. Using apply to create new column
df_new_cols['Category'] = df_new_cols['Area'].apply(
    lambda x: 'Large' if x > 15 else 'Small'
)
print("\n--- Added 'Category' using apply ---")
print(df_new_cols)

# 5. Using np.where (vectorized conditional)
df_new_cols['Size'] = np.where(df_new_cols['Area'] > 15, 'Large', 'Small')
print("\n--- Added 'Size' using np.where ---")
print(df_new_cols)

# 6. Using pd.cut for binning
df_new_cols['Area_Bin'] = pd.cut(
    df_new_cols['Area'],
    bins=[0, 15, 25, 100],
    labels=['Small', 'Medium', 'Large']
)
print("\n--- Added 'Area_Bin' using pd.cut ---")
print(df_new_cols)

# 7. Conditional column with multiple conditions using np.select
conditions = [
    df_new_cols['Area'] < 12,
    (df_new_cols['Area'] >= 12) & (df_new_cols['Area'] < 20),
    df_new_cols['Area'] >= 20
]
choices = ['Tiny', 'Medium', 'Huge']
df_new_cols['Rating'] = np.select(conditions, choices, default='Unknown')
print("\n--- Added 'Rating' using np.select ---")
print(df_new_cols)

# 8. Insert column at specific position
df_new_cols.insert(1, 'Height', [1, 2, 3])
print("\n--- Inserted 'Height' at position 1 ---")
print(df_new_cols)

# 9. Create column from index
df_idx = pd.DataFrame(
    {'Value': [10, 20, 30]},
    index=['A', 'B', 'C']
)
df_idx['Index_Col'] = df_idx.index
print("\n--- Create column from index ---")
print(df_idx)

# 10. Combining string columns
df_names = pd.DataFrame({
    'First': ['John', 'Jane', 'Bob'],
    'Last': ['Doe', 'Smith', 'Johnson']
})
df_names['Full_Name'] = df_names['First'] + ' ' + df_names['Last']
print("\n--- Combine string columns ---")
print(df_names)

df_group = pd.DataFrame({
    'Category': ['A', 'A', 'B', 'B', 'C', 'A'],
    'Values': [10, 15, 10, 25, 5, 20],
    'Score': [100, 150, 200, 250, 300, 175]
})
print("Original DataFrame:")
print(df_group)

# Group by 'Category' and compute aggregations
grouped = df_group.groupby('Category')

print("\n--- Sum by Category ---")
print(grouped['Values'].sum())

print("\n--- Mean by Category ---")
print(grouped['Values'].mean())

print("\n--- Multiple aggregations at once ---")
agg_results = grouped['Values'].agg(['min', 'max', 'mean', 'count', 'sum'])
print(agg_results)

# Aggregate multiple columns with different functions
print("\n--- Different aggregations for different columns ---")
multi_agg = grouped.agg({
    'Values': ['sum', 'mean'],
    'Score': ['min', 'max']
})
print(multi_agg)

# Group by multiple columns
df_multi_group = pd.DataFrame({
    'Region': ['East', 'East', 'West', 'West'],
    'Product': ['A', 'B', 'A', 'B'],
    'Sales': [100, 150, 200, 250]
})
print("\n--- Group by multiple columns ---")
print(df_multi_group)
print("\nGrouped by Region and Product:")
print(df_multi_group.groupby(['Region', 'Product'])['Sales'].sum())

# Using transform (returns same shape as original)
print("\n--- Using .transform() to broadcast group statistics ---")
df_group['Group_Mean'] = grouped['Values'].transform('mean')
print(df_group)

# Filter groups based on condition
print("\n--- Filter groups where sum of Values > 30 ---")
filtered_groups = df_group.groupby('Category').filter(lambda x: x['Values'].sum() > 30)
print(filtered_groups)

# Create a Series for window operations
s_rolling = pd.Series([1, 2, 3, 4, 5, 6, 7, 8])
print("Original Series:")
print(s_rolling)

# Rolling window of size 3, compute mean
rolling_mean = s_rolling.rolling(window=3).mean()
print("\n--- Rolling mean with window=3 ---")
print(rolling_mean)

# Rolling with other aggregations
rolling_sum = s_rolling.rolling(window=3).sum()
print("\n--- Rolling sum with window=3 ---")
print(rolling_sum)

rolling_std = s_rolling.rolling(window=3).std()
print("\n--- Rolling std with window=3 ---")
print(rolling_std)

# Expanding: cumulative computations
print("\n--- Expanding Operations ---")
expanding_sum = s_rolling.expanding().sum()
print("Expanding sum:")
print(expanding_sum)

expanding_mean = s_rolling.expanding().mean()
print("\nExpanding mean:")
print(expanding_mean)

# Exponentially Weighted Moving Average
print("\n--- Exponentially Weighted Moving (EWM) ---")
ewm_mean = s_rolling.ewm(span=3).mean()
print("EWM mean (span=3):")
print(ewm_mean)

# Rolling with min_periods (minimum observations needed)
print("\n--- Rolling with min_periods=1 ---")
rolling_min_periods = s_rolling.rolling(window=3, min_periods=1).mean()
print(rolling_min_periods)

# Rolling on DataFrames
df_rolling = pd.DataFrame({
    'A': [1, 2, 3, 4, 5],
    'B': [5, 4, 3, 2, 1]
})
print("\n--- Rolling on DataFrame ---")
print("Original:")
print(df_rolling)
print("\nRolling mean (window=2):")
print(df_rolling.rolling(window=2).mean())

left = pd.DataFrame({'key': ['K0', 'K1', 'K2'], 'A': ['A0', 'A1', 'A2']})
right = pd.DataFrame({'key': ['K0', 'K2', 'K3'], 'B': ['B0', 'B2', 'B3']})

print("Left DataFrame:")
print(left)
print("\nRight DataFrame:")
print(right)

# Inner join (only matching keys)
merged_inner = pd.merge(left, right, on='key', how='inner')
print("\n--- Merged (inner join) ---")
print(merged_inner)

# Left join (all from left, matching from right)
merged_left = pd.merge(left, right, on='key', how='left')
print("\n--- Merged (left join) ---")
print(merged_left)

# Right join (all from right, matching from left)
merged_right = pd.merge(left, right, on='key', how='right')
print("\n--- Merged (right join) ---")
print(merged_right)

# Outer join (all from both)
merged_outer = pd.merge(left, right, on='key', how='outer')
print("\n--- Merged (outer join) ---")
print(merged_outer)

# Concat (stacking rows vertically)
concat_example = pd.concat([left, right], axis=0, ignore_index=True)
print("\n--- Concatenated vertically (stack rows) ---")
print(concat_example)

# Concat (stacking columns horizontally)
concat_horiz = pd.concat([left, right], axis=1)
print("\n--- Concatenated horizontally (side by side) ---")
print(concat_horiz)

# Merge on index
left_idx = pd.DataFrame({'A': ['A0', 'A1', 'A2']}, index=['K0', 'K1', 'K2'])
right_idx = pd.DataFrame({'B': ['B0', 'B2', 'B3']}, index=['K0', 'K2', 'K3'])
print("\n--- Join on index ---")
joined = left_idx.join(right_idx, how='outer')
print(joined)

# Merge with different key columns and suffixes
left = pd.DataFrame({
    'id_left': ['K0', 'K1', 'K2'],
    'name': ['Alice', 'Bob', 'Charlie'],
    'score': [10, 20, 30]
})
right = pd.DataFrame({
    'id_right': ['K0', 'K2', 'K3'],
    'name': ['Alice', 'Charlie', 'David'],
    'score': [15, 35, 45]
})

print("Left DataFrame:")
print(left)
print("\nRight DataFrame:")
print(right)

# Merge with different column names (left_on, right_on)
merged_diff = pd.merge(
    left, right,
    left_on='id_left',
    right_on='id_right',
    how='outer',
    suffixes=('_L', '_R')
)
print("\n--- Merged with different key columns and suffixes ---")
print(merged_diff)

# Merge on multiple columns
df1 = pd.DataFrame({
    'key1': ['A', 'A', 'B', 'B'],
    'key2': [1, 2, 1, 2],
    'val1': [10, 20, 30, 40]
})
df2 = pd.DataFrame({
    'key1': ['A', 'A', 'B', 'C'],
    'key2': [1, 2, 1, 1],
    'val2': [100, 200, 300, 400]
})
print("\n--- Merge on multiple columns ---")
merged_multi = pd.merge(df1, df2, on=['key1', 'key2'], how='inner')
print(merged_multi)

# Indicator parameter shows merge type for each row
merged_indicator = pd.merge(left, right, left_on='id_left', right_on='id_right', 
                             how='outer', indicator=True)
print("\n--- Merge with indicator=True ---")
print(merged_indicator)

import matplotlib.pyplot as plt

df_plot = pd.DataFrame({
    'x': [1, 2, 3, 4, 5],
    'y': [3, 5, 2, 8, 7],
    'z': [1, 3, 4, 2, 6]
})

# Line plot
df_plot.plot(x='x', y='y', kind='line', title='Line Plot', marker='o')
plt.grid(True)
plt.show()

# Scatter plot
df_plot.plot.scatter(x='x', y='y', title='Scatter Plot', s=100, c='red')
plt.show()

# Bar plot
df_plot.plot.bar(x='x', y=['y', 'z'], title='Bar Plot')
plt.show()

# Histogram
df_hist = pd.DataFrame({'values': np.random.randn(100)})
df_hist.plot.hist(bins=20, title='Histogram', alpha=0.7)
plt.show()

# Box plot
df_box = pd.DataFrame({
    'A': np.random.randn(50),
    'B': np.random.randn(50) + 1,
    'C': np.random.randn(50) + 2
})
df_box.plot.box(title='Box Plot')
plt.show()

df_info = pd.DataFrame({
    'Name': ['Alice', 'Bob', 'Charlie'],
    'Age': [25, 30, 35],
    'Salary': [50000.0, 60000.0, 70000.0],
    'Active': [True, False, True]
})

print("--- DataFrame Info ---")
print(df_info.info())

print("\n--- DataFrame Attributes ---")
print("Shape (rows, cols):", df_info.shape)
print("Columns:", df_info.columns.tolist())
print("Index:", df_info.index.tolist())

print("\n--- Data Types ---")
print(df_info.dtypes)

print("\n--- Memory Usage ---")
print(df_info.memory_usage(deep=True))

print("\n--- Descriptive Statistics ---")
print(df_info.describe())

print("\n--- Include all columns in describe ---")
print(df_info.describe(include='all'))

print("\n--- First/Last Rows ---")
print("First 2 rows:")
print(df_info.head(2))
print("\nLast 2 rows:")
print(df_info.tail(2))

print("\n--- Number of rows and columns ---")
print(f"Rows: {len(df_info)}, Columns: {len(df_info.columns)}")

print("\n--- Check for duplicates ---")
print("Any duplicates?", df_info.duplicated().any())

df_apply = pd.DataFrame({
    'A': [1, 2, 3, 4],
    'B': [10, 20, 30, 40],
    'C': [100, 200, 300, 400]
})
print("Original DataFrame:")
print(df_apply)

# Apply function to each column (axis=0, default)
print("\n--- Apply sum to each column (axis=0) ---")
print(df_apply.apply(np.sum, axis=0))

# Apply function to each row (axis=1)
print("\n--- Apply sum to each row (axis=1) ---")
print(df_apply.apply(np.sum, axis=1))

# Apply custom function
def custom_func(x):
    return x.max() - x.min()

print("\n--- Apply custom function (range) to each column ---")
print(df_apply.apply(custom_func, axis=0))

# Apply lambda function to Series (element-wise)
print("\n--- Apply lambda to Series (element-wise) ---")
df_apply['A_squared'] = df_apply['A'].apply(lambda x: x ** 2)
print(df_apply)

# Map (element-wise transformation for Series)
print("\n--- Using .map() on Series ---")
mapping = {1: 'one', 2: 'two', 3: 'three', 4: 'four'}
df_apply['A_mapped'] = df_apply['A'].map(mapping)
print(df_apply)

# DataFrame.map() (element-wise, replaces applymap in pandas 2.1+)
print("\n--- Using .map() on DataFrame (element-wise) ---")
df_small = pd.DataFrame({'X': [1, 2], 'Y': [3, 4]})
print("Original:")
print(df_small)
print("\nAfter .map(lambda x: x * 10):")
print(df_small.map(lambda x: x * 10))

# Apply with multiple return values
print("\n--- Apply returning Series ---")
def stats(x):
    return pd.Series({'min': x.min(), 'max': x.max(), 'mean': x.mean()})

print(df_apply[['A', 'B', 'C']].apply(stats, axis=0))

# Using vectorized operations (preferred over apply when possible)
print("\n--- Vectorized operations (faster than apply) ---")
df_apply['D'] = df_apply['A'] * 2 + df_apply['B']
print(df_apply)

s1 = pd.Series([1, 2, 3], index=['a', 'b', 'c'])
s2 = pd.Series([4, 5, 6], index=['b', 'c', 'd'])

print("Series 1:")
print(s1)
print("\nSeries 2:")
print(s2)

# Addition auto-aligns on index (NaN for non-matching labels)
s_sum = s1 + s2
print("\n--- Auto-aligned addition (s1 + s2) ---")
print(s_sum)

# Fill missing with 0 while adding
s_sum_fill = s1.add(s2, fill_value=0)
print("\n--- Addition with fill_value=0 ---")
print(s_sum_fill)

# Other operations with fill_value
print("\n--- Subtraction with fill_value=0 ---")
print(s1.sub(s2, fill_value=0))

print("\n--- Multiplication with fill_value=1 ---")
print(s1.mul(s2, fill_value=1))

# DataFrame alignment
df1 = pd.DataFrame({'A': [1, 2], 'B': [3, 4]}, index=[0, 1])
df2 = pd.DataFrame({'B': [5, 6], 'C': [7, 8]}, index=[1, 2])

print("\n--- DataFrame Alignment ---")
print("DataFrame 1:")
print(df1)
print("\nDataFrame 2:")
print(df2)

print("\ndf1 + df2 (auto-aligned):")
print(df1 + df2)

print("\ndf1.add(df2, fill_value=0):")
print(df1.add(df2, fill_value=0))

# Reindex to match specific index
print("\n--- Reindexing ---")
s_reindexed = s1.reindex(['a', 'b', 'c', 'd', 'e'], fill_value=0)
print("Reindexed s1 with new labels:")
print(s_reindexed)

df_chain = pd.DataFrame({
    'A': [1, 2, 3, 4, 5],
    'B': [5, 6, 7, 8, 9],
    'Category': ['X', 'Y', 'X', 'Y', 'Z']
})
print("Original DataFrame:")
print(df_chain)

# Example of method chaining: filter, create column, sort
result = (
    df_chain
    .query('A > 2')  # Filter rows
    .assign(C=lambda x: x['A'] + x['B'])  # Create new column
    .sort_values('C', ascending=False)  # Sort
    .reset_index(drop=True)  # Reset index
)
print("\n--- Method Chaining Result ---")
print(result)

# More complex chain: melt, rename, filter
df_wide_chain = pd.DataFrame({
    'id': [1, 2, 3],
    'var1': [10, 20, 30],
    'var2': [40, 50, 60]
})

result_complex = (
    df_wide_chain
    .melt(id_vars='id', var_name='Variable', value_name='Value')
    .assign(Value_Doubled=lambda x: x['Value'] * 2)
    .query('Value > 15')
    .sort_values('Value', ascending=False)
    .reset_index(drop=True)
)
print("\n--- Complex Method Chain ---")
print(result_complex)

# Using pipe() for custom functions in chains
def add_suffix(df, col, suffix):
    df[col] = df[col].astype(str) + suffix
    return df

result_pipe = (
    df_chain
    .pipe(add_suffix, 'Category', '_modified')
    .assign(Sum=lambda x: x['A'] + x['B'])
)
print("\n--- Method Chain with pipe() ---")
print(result_pipe)

# Groupby in method chain
result_group = (
    df_chain
    .groupby('Category')
    .agg({'A': 'sum', 'B': 'mean'})
    .reset_index()
    .rename(columns={'A': 'A_sum', 'B': 'B_mean'})
)
print("\n--- GroupBy in Method Chain ---")
print(result_group)