Generate Pandas DataFrame Code with AI Prompts

```python
import pandas as pd

# Load the CSV file, parsing the 'date' column as datetime for easy year filtering
df = pd.read_csv('sales.csv', parse_dates=['date'])

# Filter rows for the 'West' region and year 2024 using vectorized boolean masks
mask = (df['region'] == 'West') & (df['date'].dt.year == 2024)
filtered_df = df.loc[mask]

# Group by product_id and aggregate: total revenue and mean units sold per transaction
product_summary = (
    filtered_df
    .groupby('product_id')
    .agg(
        total_revenue=('revenue', 'sum'),
        avg_units_per_transaction=('units_sold', 'mean')
    )
    .reset_index()
)

# Sort by total_revenue descending and take the top 5 products
top_5_products = product_summary.sort_values('total_revenue', ascending=False).head(5)

# Display the result
print(top_5_products)
```

**Explanation:**

This code reads `sales.csv` and parses the `date` column as datetime objects so we can easily extract the year. It then applies a vectorized boolean mask to keep only rows where the region equals `'West'` and the year is `2024`. The filtered data is grouped by `product_id`, and for each product we compute two aggregates: the sum of `revenue` (total revenue) and the mean of `units_sold` (average units per transaction — assuming each row in the CSV represents one transaction). Finally, we sort by total revenue in descending order and take the top 5 rows.

**Assumptions:**
- Each row in `sales.csv` represents a single transaction (so `mean` of `units_sold` gives the per-transaction average).
- The `date` column is in a format pandas can parse automatically (e.g., `YYYY-MM-DD`).
- The `region` column uses the exact string `'West'` (case-sensitive match).
- `revenue` and `units_sold` are numeric columns with no problematic nulls; if NaNs exist, `sum` and `mean` will ignore them by default.

```python
import pandas as pd

# Load the CSV file
df = pd.read_csv('sales.csv')

# Convert date column to datetime format for proper filtering
df['date'] = pd.to_datetime(df['date'])

# Filter for West region and year 2024
df_filtered = df[(df['region'] == 'West') & (df['date'].dt.year == 2024)]

# Group by product_id to calculate total revenue and average units sold per transaction
product_summary = df_filtered.groupby('product_id').agg(
    total_revenue=('revenue', 'sum'),
    avg_units_per_transaction=('units_sold', 'mean')
).reset_index()

# Sort by total_revenue in descending order and select top 5 products
top_5_products = product_summary.nlargest(5, 'total_revenue')

# Display the results
print(top_5_products)
```

**Explanation:**

This code performs the following operations:

1. **Loads the CSV file** into a pandas DataFrame using `read_csv()`.
2. **Converts the date column** to datetime format to enable proper year-based filtering.
3. **Filters the data** using boolean indexing to keep only rows where `region == 'West'` AND the year extracted from the date is `2024`.
4. **Groups by product_id** and uses `agg()` to calculate two metrics:
   - `total_revenue`: Sum of all revenue for each product
   - `avg_units_per_transaction`: Mean units sold per transaction (row) for each product
5. **Resets the index** to convert the grouped columns back to regular DataFrame columns.
6. **Selects the top 5 products** by total revenue using `nlargest()`, which is more efficient than sorting and slicing.

**Assumptions:**
- The date column is parseable by `pd.to_datetime()` (standard date formats).
- The `region` values are strings (case-sensitive match for 'West').
- The `revenue` and `units_sold` columns contain numeric values.
- Each row represents a single transaction; "per transaction" average refers to the mean across all rows for that product.

```python
import pandas as pd

# Load the CSV file into a DataFrame
df = pd.read_csv("sales.csv")

# Convert the 'date' column to datetime so we can filter by year reliably
df["date"] = pd.to_datetime(df["date"], errors="coerce")

# Filter rows for:
# 1) region == 'West'
# 2) year == 2024
filtered = df[
    (df["region"] == "West") &
    (df["date"].dt.year == 2024)
]

# Group by product_id and calculate:
# - total revenue per product
# - average units sold per transaction per product
product_summary = (
    filtered
    .groupby("product_id", as_index=False)
    .agg(
        total_revenue=("revenue", "sum"),
        avg_units_sold_per_transaction=("units_sold", "mean")
    )
)

# Sort by total revenue descending and keep the top 5 products
top_5_products = (
    product_summary
    .sort_values("total_revenue", ascending=False)
    .head(5)
)

# Optional: reset index for a clean final output
top_5_products = top_5_products.reset_index(drop=True)

# Display the result
print(top_5_products)
```

This code loads `sales.csv`, parses the `date` column as a datetime, filters to rows where `region` is `"West"` and the year is `2024`, then groups by `product_id` to compute total revenue and average units sold per transaction. It finally sorts by total revenue and returns the top 5 products. Assumes the CSV has the columns `date`, `product_id`, `region`, `units_sold`, and `revenue`, and that each row represents a transaction.

```python
import pandas as pd
import numpy as np

# Create a sample DataFrame to simulate loading from 'sales.csv'.
# In a real scenario, you would use: df = pd.read_csv('sales.csv')
data = {
    'date': pd.to_datetime([
        '2024-01-10', '2024-01-12', '2023-12-15', '2024-02-01',
        '2024-02-05', '2024-02-10', '2024-03-12', '2024-04-20',
        '2024-0

```python
import pandas as pd

# Load the CSV file into a DataFrame
df = pd.read_csv('sales.csv')

# Convert the 'date' column to datetime for year extraction
df['date'] = pd.to_datetime(df['date'])

# Filter for 'West' region and sales in 2024 only (vectorized boolean indexing)
df_filtered = df[(df['region'] == 'West') & (df['date'].dt.year == 2024)]

# Group by 'product_id', compute total revenue (sum) and average units sold (mean) per product
# Sort by total revenue descending and select top 5 (vectorized groupby and sort)
result = (df_filtered
          .groupby('product_id')
          .agg(total_revenue=('revenue', 'sum'),
               avg_units_sold=('units_sold', 'mean'))
          .sort_values('total_revenue', ascending=False)
          .head(5)
          .reset_index()  # Make 'product_id' a regular column for cleaner output
         )

# Display the result (optional, for verification)
print(result)
```

This code loads the CSV, parses dates, filters for West region in 2024 using vectorized operations, groups by product_id to compute total revenue and average units sold per transaction (row), sorts descending by total revenue, and returns the top 5 as a DataFrame. Assumptions: 'date' column is in a standard parseable format (e.g., YYYY-MM-DD); no NaNs in key columns; each row represents one transaction; revenue and units_sold are numeric.