Shift and lag operations in Data Analysis Python - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to shift the 'sales' column down by one row.

Data Analysis Python

df['previous_sales'] = df['sales'].[1](1)

Drag options to blanks, or click blank then click option'

Aroll

Blag

Cshift

Dmove

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'lag' which is not a pandas function.

Trying to use 'roll' or 'move' which do not exist in pandas.

The shift function moves the data down by the specified number of rows, creating a lag effect.

2fill in blank

medium

Complete the code to shift the 'temperature' column up by two rows.

Data Analysis Python

df['future_temp'] = df['temperature'].[1](-2)

Drag options to blanks, or click blank then click option'

Aroll

Blag

Cmove

Dshift

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'roll' or 'move' which are not pandas functions.

Using positive numbers to shift up.

Using shift(-2) moves the data up by two rows, showing future values.

3fill in blank

hard

Fix the error in the code to correctly create a lagged column named 'lagged_price'.

Data Analysis Python

df['lagged_price'] = df.price.[1](1)

Drag options to blanks, or click blank then click option'

Ashift

Blag

Cmove

Droll

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'lag' which is not a pandas method.

Using dot notation without quotes for column names is okay but method must be correct.

The correct pandas method to create lagged columns is shift. Using df.price.shift(1) works correctly.

4fill in blank

hard

Fill both blanks to create a 3-period lag for the 'sales' column.

Data Analysis Python

df['sales_lag3'] = df['sales'].[1]([2])

Drag options to blanks, or click blank then click option'

Ashift

B3

Clag

Ddiff

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'lag' which is not a pandas method.

Using negative number which would create a lead instead of lag.

To lag by 3 periods, use shift(3). Positive periods shift index down, equivalent to lagging the values.

5fill in blank

hard

Fill all three blanks to compute the next sales per store group, filling missing with 0.

Data Analysis Python

df['next_sales'] = df.groupby('store')['sales'].[1]([2]).[3](0)

Drag options to blanks, or click blank then click option'

Ashift

B-1

Cfillna

Dmean

Attempts:

3 left

💡 Hint

Common Mistakes

Omitting groupby, causing global shift instead of per-group.

Using positive periods for next values (would be lag).

Forgetting fillna to replace NaNs.

groupby('store')['sales'].shift(-1).fillna(0) creates group-wise leads (next values) and fills trailing NaNs with 0.

Practice

1. What does the shift(1) function do to a pandas DataFrame column?

easy

A. Moves the data down by one row, creating a lag of previous values

B. Moves the data up by one row, creating a lead of next values

C. Sorts the column in ascending order

D. Removes the first row of the column

Solution

1. Step 1: Understand the shift function

   The shift(1) moves data down by one row, so each value is replaced by the previous row's value.

2. Step 2: Identify lag vs lead

   Positive shift values create lag (previous rows), so shift(1) creates lag by one row.

3. Final Answer:

   Moves the data down by one row, creating a lag of previous values -> Option A

4. Quick Check:

   shift(1) = lag by 1 row [OK]

Hint: Positive shift means lag (previous rows), negative means lead [OK]

Common Mistakes:

• Confusing shift(1) with shift(-1)
• Thinking shift sorts data
• Assuming shift removes rows

2. Which of the following is the correct syntax to create a new column 'prev_value' that contains the previous row's value of column 'value' in pandas?

easy

A. df['prev_value'] = df['value'].shift(-1)

B. df['prev_value'] = shift(df['value'], 1)

C. df['prev_value'] = df.shift('value', 1)

D. df['prev_value'] = df['value'].shift(1)

Solution

1. Step 1: Recall pandas shift syntax

   The correct syntax is to call shift() on the Series, like df['value'].shift(1).

2. Step 2: Check each option

   df['prev_value'] = df['value'].shift(1) uses correct syntax. df['prev_value'] = df['value'].shift(-1) shifts in the wrong direction. df['prev_value'] = df.shift('value', 1) uses wrong method call. df['prev_value'] = shift(df['value'], 1) uses undefined function.

3. Final Answer:

   df['prev_value'] = df['value'].shift(1) -> Option D

4. Quick Check:

   Correct pandas shift syntax = df['prev_value'] = df['value'].shift(1) [OK]

Hint: Use Series.shift(n) to lag by n rows [OK]

Common Mistakes:

• Using negative shift for previous row
• Calling shift on DataFrame with wrong arguments
• Using undefined shift function

3. Given the DataFrame:

import pandas as pd
df = pd.DataFrame({'value': [10, 20, 30, 40]})
df['lag1'] = df['value'].shift(1)
df['lead1'] = df['value'].shift(-1)
print(df)

What is the output?

medium

A. value lag1 lead1
0 10 10.0 20.0
1 20 20.0 30.0
2 30 30.0 40.0
3 40 40.0 NaN

B. value lag1 lead1
0 10 20.0 NaN
1 20 30.0 10.0
2 30 40.0 20.0
3 40 NaN 30.0

C. value lag1 lead1
0 10 NaN 20.0
1 20 10.0 30.0
2 30 20.0 40.0
3 40 30.0 NaN

D. value lag1 lead1
0 10 NaN NaN
1 20 10.0 20.0
2 30 20.0 30.0
3 40 30.0 40.0

Solution

1. Step 1: Calculate lag1 column

   shift(1) moves values down by one, so first row is NaN, second row gets 10, third 20, fourth 30.

2. Step 2: Calculate lead1 column

   shift(-1) moves values up by one, so last row is NaN, third row gets 40, second 30, first 20.

3. Final Answer:

   value lag1 lead1 0 10 NaN 20.0 1 20 10.0 30.0 2 30 20.0 40.0 3 40 30.0 NaN -> Option C

4. Quick Check:

   Positive shift = lag, negative shift = lead [OK]

Hint: Positive shift adds NaN on top, negative shift adds NaN at bottom [OK]

Common Mistakes:

• Mixing lag and lead directions
• Forgetting NaN appears at shifted edges
• Confusing shift with sorting

4. What is wrong with this code snippet?

df['prev'] = df.shift(1)['value']

Assuming df is a pandas DataFrame with a column 'value'.

medium

A. It works correctly and creates a lagged column

B. It shifts the entire DataFrame, not just the 'value' column, which is inefficient

C. It causes a syntax error due to wrong indexing

D. It will cause a KeyError because shift returns a Series, not DataFrame

Solution

1. Step 1: Understand what df.shift(1) does

   df.shift(1) shifts the entire DataFrame down by one row, including all columns.

2. Step 2: Check indexing and efficiency

   Accessing ['value'] after shift works, but shifting entire DataFrame is inefficient if only one column is needed.

3. Final Answer:

   It shifts the entire DataFrame, not just the 'value' column, which is inefficient -> Option B

4. Quick Check:

   Shift on DataFrame shifts all columns [OK]

Hint: Shift only the needed column, not whole DataFrame [OK]

Common Mistakes:

• Assuming shift returns Series when called on DataFrame
• Expecting syntax error from indexing
• Ignoring performance impact

5. You have a time series DataFrame df with a column 'sales'. You want to create a new column 'pct_change' that shows the percentage change from the previous day. Which code correctly uses shift to calculate this?

hard

A. df['pct_change'] = (df['sales'] - df['sales'].shift(1)) / df['sales'].shift(1) * 100

B. df['pct_change'] = (df['sales'].shift(1) - df['sales']) / df['sales'] * 100

C. df['pct_change'] = df['sales'].pct_change(1)

D. df['pct_change'] = df['sales'].shift(-1) / df['sales'] * 100

Solution

1. Step 1: Understand percentage change formula

   Percentage change = (current - previous) / previous * 100.

2. Step 2: Apply shift to get previous value

   df['sales'].shift(1) gives previous day's sales, so formula in df['pct_change'] = (df['sales'] - df['sales'].shift(1)) / df['sales'].shift(1) * 100 matches the formula.

3. Step 3: Check other options

   df['pct_change'] = (df['sales'].shift(1) - df['sales']) / df['sales'] * 100 reverses numerator and denominator incorrectly. df['pct_change'] = df['sales'].pct_change(1) uses built-in method but question asks for shift usage. df['pct_change'] = df['sales'].shift(-1) / df['sales'] * 100 uses lead instead of lag.

4. Final Answer:

   df['pct_change'] = (df['sales'] - df['sales'].shift(1)) / df['sales'].shift(1) * 100 -> Option A

5. Quick Check:

   Percentage change uses lag with shift(1) [OK]

Hint: Use (current - shift(1)) / shift(1) for percent change [OK]

Common Mistakes:

• Using shift(-1) instead of shift(1)
• Reversing numerator and denominator
• Confusing built-in pct_change with manual shift