LeetCode Study Plan: Introduction to Pandas
Tags: leetcode, pandas, python, learning
Published: 2024-03-15 21:00:13

Hello everyone. I’m Ata, a computer science graduate and currently interested in cybersecurity. I haven’t used LeetCode a lot since college. But recently, I wanted to hone my coding skills and learn new concepts. To achieve this, I wanted to use “study plans” of LeetCode.

## What is Study Plan?
LeetCode Study Plans are plans that consist of LeetCode problems scheduled and categorized. These study plans and problems in them can be specific to some areas such as JavaScript, SQL, etc. or problems that are chosen for training for code interviews. These plans are also split into time schedules to ease the solving process.

## Introduction to Pandas Study Plan
This study plan on LeetCode aims to teach the basics of Pandas through 15 simple questions. I used Pandas few times, mostly for machine learning projects but usually, I just used the DataFrame object. I haven’t used its functions a lot. Therefore, I wanted to start with an easy plan about Pandas and learn its basics.

During my solving process, I took some notes to reinforce my understanding of Pandas functions and their capabilities. This story is written according to these notes. In this story, I’ll name the questions, provide my answers, and explain the functions used in the solutions.

*Note: I won’t delve into the details of the problems, as they are available in a better format and with examples on LeetCode.*

### Create a DataFrame from List
Q: Write a solution to create a DataFrame from a 2D list called `student_data`. This 2D list contains the IDs and ages of some students. The DataFrame should have two columns, `student_id` and `age`, and be in the same order as the original 2D list.

```python
df = pd.DataFrame(student_data)
df.columns = ["student_id", "age"]
return df
```

Creates a DataFrame with specific column names. `df.columns` is used to name the columns of a DataFrame.

### Get the Size of a DataFrame
Q: Write a solution to calculate and display the number of rows and columns of players. Return the result as an array:
`[number of rows, number of columns]`

```python
return [players.shape[0], players.shape[1]]
```

`df.shape` returns a tuple of rows and columns of DataFrame: `[row_count, column_count]`

### Display the First Three Rows
Q: Write a solution to display the first 3 rows of this DataFrame.

```python
return employees.head(3)
```

`df.head(n)` returns the first n rows of df.

### Select Data
Q: Write a solution to select the name and age of the student with student_id = 101.

```python
return students.loc[students['student_id'] == 101, ['name', 'age']]
```
In `df.loc`, the first parameter is the condition used for the search, and the second parameter is a list with desired columns.

Here is an example with multiple conditions:

```python
students.loc[(students['student_id'] == 101) & (students['name'] == "Ulysses"), ['name', 'age']]
```

### Create a New Column
Q: A company plans to provide its employees with a bonus. Write a solution to create a new column name bonus that contains the doubled values of the `salary` column.

```python
bonus = []
for s in employees["salary"]:
    bonus.append(s*2)

result = employees.assign(bonus=bonus)
return result
```

In `df.assign`, there is a column name and a list of values to be used in the column:

`df.assign(column_name=[element1, element2, element3])`

*Note: In the problem “Modify Columns”, I gave some examples about modifying the values in a column of a DataFrame, similar to one I did it in this problem but not at the outside of the DataFrame.*

### Drop Duplicate Rows
Q: There are some duplicate rows in the DataFrame based on the `email` column. Write a solution to remove these duplicate rows and keep only the first occurrence.

```
df = customers.drop_duplicates(subset=['email'])
return df
```

`df.drop_duplicates` simply drops duplicates according to the values given in a column or columns. You can give multiple values as below:

```python
dedup_df = df.drop_duplicates(subset=['A', 'B'])
```

### Drop Missing Data
Q: There are some rows having missing values in the name column. Write a solution to remove the rows with missing values.

```python
return students.dropna(subset=['name'])
```

`df.dropna` drops the rows with missing values. In this question, a column name is given to drop the rows with missing values if they are only in the given column. `df.dropna` can take various parameters to handle missing values in different ways.

### Modify Columns
Q: A company intends to give its employees a pay rise. Write a solution to modify the salary column by multiplying each salary by 2.

```python
employees.salary = employees.salary*2
return employees
```

In this question, it is asked to double the values of a column, and I directly accessed the column with `df.row_name` and doubled its values.

Here is an additional example:

```python
import numpy as np

# Step 1: Select the column
age_column = df['age']

# Step 2: Apply a function to each value
def sqrt(x):
    return np.sqrt(x)
new_age_column = age_column.apply(sqrt)

# Step 3: Assign the new values back to the column
df['age'] = new_age_column
```

`df.apply` is used to apply a function to each value in the column.

### Rename Columns
Q: Write a solution to rename the columns as follows:

- id to student_id
- first to first_name
- last to last_name
- age to age_in_years

```python
return students.rename(columns = {'id':'student_id', 'first':'first_name', 'last':'last_name', 'age':'age_in_years'})
```

`df.rename` can be used to change the names of the index or columns like in this case. With `inplace=True` parameter, df can be modified instead of creating a new one.

### Change Data Type
Q: Write a solution to correct the errors: The grade column is stored as floats, convert it to integers.

```python
return students.astype({'grade': int})
```

`df.astype` is used to change the data type of an object in the DataFrame. It can be used for specific or all columns. To solve this question, different approaches can be used, such as `df.apply `to all elements in a column or `df.to_numeric` to convert non-numeric objects into numeric ones if possible.

### Fill Missing Data
Q: Write a solution to fill in the missing value as 0 in the quantity column.

```python
products['quantity'] = products['quantity'].fillna(0)
return products
```

In this case, it is asked to fill missing data in a single column. That’s why I operated on the `quantity `column. `df.fillna(x)` can be used to replace all missing values with the given parameter x.

To achieve the same result, df.replace could be used too:

```python
df['DataFrame Column'] = df['DataFrame Column'].replace(np.nan, 0)
```

### Reshape Data: Concatenate
Q: Write a solution to concatenate these two DataFrames vertically into one DataFrame.

```python
return pd.concat([df1, df2], axis=0)
```

`pd.concat` can be used to concatenate 2 DataFrames horizontally (same rows, new columns) or vertically (same columns, new rows). `axis = 0` is for vertical, and `axis = 1` is for horizontal concatenation. Other than this, `pd.merge`, `df.append`, and `df.join` can be used for concatenation.

```python
# Concatenation with pd.merge
result = pd.merge(df, df1, on='Courses', how='outer', suffixes=('_df1', '_df2')).fillna(0)

result['Fee'] = result['Fee_df1'] + result['Fee_df2']
result = result[['Courses', 'Fee']]

# Concatenation with df.join
result = df.join(df1)

# Concatenation with df.append (only vertical concatenation)
result = df.append(df1, ignore_index=True)
```

### Reshape Data: Pivot
Q: Write a solution to pivot the data so that each row represents temperatures for a specific month, and each city is a separate column.

```python
return weather.pivot(index='month', columns='city', values='temperature')
```

`df.pivot` is used to pivot a DataFrame with 3 columns. This function is used to reshape to a simpler, smaller DataFrame that the same meaning can be deduced from it. With this function, the index and columns of a DataFrame can be set, and the new DataFrame can be filled with desired values.

### Reshape Data: Melt
Q: Write a solution to reshape the data so that each row represents sales data for a product in a specific quarter.

```python
return pd.melt(report, id_vars=['product'], value_vars=['quarter_1', 'quarter_2', 'quarter_3', 'quarter_4'], var_name='quarter', value_name='sales')
```

`pd.melt` reshapes a DataFrame to be more computer-friendly. In this problem, `pd.melt` is used to merge values of multiple columns into a single column. The names of the columns are also used as variable names for the values.

### Method Chaining
Q:Write a solution to list the names of animals that weigh strictly more than 100 kilograms. Return the animals sorted by weight in descending order.

```
return animals[animals['weight'] > 100].sort_values(['weight'], ascending=False)[['name']]
```

Method chaining is a newer approach to data manipulation, allowing for the execution of multiple operations in a single line of code. With method chaining, each operation is chained together using the dot notation.

Well, that was the last problem in the plan. I hope you enjoyed reading and it was useful for you. I will share more stories when I solve other study plans in LeetCode. Thanks for reading!