## Converting Pandas DataFrame Columns to NumPy Arrays

NumPy and Pandas are two of the most popular libraries for data processing and analysis in Python. Pandas is a powerful tool for handling tabular data, while NumPy provides tools for working with numerical arrays.

In many cases, you may need to convert a Pandas DataFrame column to a NumPy array in order to take advantage of NumPy’s mathematical functions. In this article, we’ll explore different methods of converting Pandas DataFrame columns to NumPy arrays.

### Method 1: Convert One Column to NumPy Array

If you only want to convert one column of a Pandas DataFrame to a NumPy array, the simplest way to do so is through the `to_numpy()`

function. Here’s an example:

```
import pandas as pd
import numpy as np
# create a sample DataFrame
df = pd.DataFrame({'points': [10, 20, 30, 40, 50]})
# convert 'points' column to NumPy array
points_array = df['points'].to_numpy()
# display the NumPy array
print(points_array)
```

In this code, we first create a sample DataFrame with one column named “points”. We then use the `to_numpy()`

function to convert this column to a NumPy array, and store the result in the `points_array`

variable.

Finally, we print out the contents of the `points_array`

variable, which should display the following output:

```
[10 20 30 40 50]
```

As you can see, the `to_numpy()`

function converted the “points” column to a one-dimensional NumPy array.

### Method 2: Convert Multiple Columns to NumPy Array

In some cases, you may need to convert multiple columns of a Pandas DataFrame to a NumPy array.

In this case, you can use the `to_numpy()`

function along with NumPy’s `stack()`

function to create a multidimensional NumPy array. Here’s an example:

```
import pandas as pd
import numpy as np
# create a sample DataFrame with two columns
df = pd.DataFrame({'points': [10, 20, 30, 40, 50], 'durations': [1.2, 3.4, 2.5, 4.3, 2.1]})
# convert multiple columns to a NumPy array
combined_array = np.stack((df['points'].to_numpy(), df['durations'].to_numpy()), axis=-1)
# display the NumPy array
print(combined_array)
```

In this code, we create a sample DataFrame with two columns named “points” and “durations”. We then use the `to_numpy()`

function to convert each column to a one-dimensional NumPy array, and use NumPy’s `stack()`

function to combine the two arrays into a two-dimensional NumPy array.

The `axis=-1`

parameter specifies that we want to stack the arrays horizontally (i.e., with the columns next to each other). Finally, we print out the contents of the `combined_array`

variable, which should display the following output:

```
[[10. 1.2]
[20. 3.4]
[30. 2.5]
[40. 4.3]
[50. 2.1]]
```

As you can see, the `stack()`

function combined the “points” and “durations” columns into a two-dimensional NumPy array, with each row corresponding to a single observation in the original DataFrame.

### Example 1: Convert One Column to NumPy Array

Let’s explore a real-world example of converting a Pandas DataFrame column to a NumPy array.

#### Suppose you have a DataFrame that contains information on the points scored by each player on a basketball team:

```
import pandas as pd
# create a sample DataFrame
df = pd.DataFrame({'player': ['John', 'Mary', 'Bill', 'Sarah'],
'points': [10, 20, 15, 18]})
```

This DataFrame has two columns: “player”, which contains the name of each player, and “points”, which contains the number of points scored by each player. Suppose you want to calculate the mean and standard deviation of the points scored by each player.

You can do this by converting the “points” column to a NumPy array, and then using NumPy’s statistical functions:

```
import pandas as pd
import numpy as np
# create a sample DataFrame
df = pd.DataFrame({'player': ['John', 'Mary', 'Bill', 'Sarah'],
'points': [10, 20, 15, 18]})
# convert 'points' column to NumPy array
points_array = df['points'].to_numpy()
# calculate mean and standard deviation using NumPy functions
mean = np.mean(points_array)
std = np.std(points_array)
# display the results
print('Mean:', mean)
print('Standard deviation:', std)
```

In this code, we first create the sample DataFrame. We then convert the “points” column to a NumPy array using the `to_numpy()`

function, and calculate the mean and standard deviation of the array using the NumPy `mean()`

and `std()`

functions.

Finally, we print out the results, which should display the following output:

```
Mean: 15.75
Standard deviation: 3.539028717299204
```

As you can see, we were able to easily convert the “points” column of the DataFrame to a NumPy array, which allowed us to perform statistical calculations using NumPy’s functions.

### Example 2: Convert Multiple Columns to NumPy Array

Suppose we have a DataFrame that contains information on the assists and turnovers of a basketball team over a season:

```
import pandas as pd
# create a sample DataFrame
df = pd.DataFrame({'team': ['Heat', 'Lakers', 'Rockets', 'Bulls'],
'assists': [24, 27, 23, 18],
'turnovers': [12, 15, 16, 9]})
```

This DataFrame has three columns: “team”, which contains the name of each team, “assists”, which contains the number of assists made by each team in a game, and “turnovers”, which contains the number of times each team made a turnover in a game. Now, we want to calculate the ratio of assists to turnovers for each team over the season, and analyze the data using NumPy.

To start, we can extract the “assists” and “turnovers” columns as NumPy arrays and combine them into a single two-dimensional array using the `stack()`

function:

```
import pandas as pd
import numpy as np
# create a sample DataFrame
df = pd.DataFrame({'team': ['Heat', 'Lakers', 'Rockets', 'Bulls'],
'assists': [24, 27, 23, 18],
'turnovers': [12, 15, 16, 9]})
# convert 'assists' and 'turnovers' columns to NumPy arrays and combine into one array
assists_array = df['assists'].to_numpy()
turnovers_array = df['turnovers'].to_numpy()
combined_array = np.stack((assists_array, turnovers_array), axis=-1)
```

Next, we can use NumPy’s array operations to calculate the ratio of assists to turnovers for each team:

```
import pandas as pd
import numpy as np
# create a sample DataFrame
df = pd.DataFrame({'team': ['Heat', 'Lakers', 'Rockets', 'Bulls'],
'assists': [24, 27, 23, 18],
'turnovers': [12, 15, 16, 9]})
# convert 'assists' and 'turnovers' columns to NumPy arrays and combine into one array
assists_array = df['assists'].to_numpy()
turnovers_array = df['turnovers'].to_numpy()
combined_array = np.stack((assists_array, turnovers_array), axis=-1)
# calculate ratio of assists to turnovers using NumPy's array operations
assists_turnovers_ratio = assists_array / turnovers_array
# display the results
print(assists_turnovers_ratio)
```

In this code, we first create the sample DataFrame. We then convert the “assists” and “turnovers” columns to NumPy arrays using the `to_numpy()`

function and combine them into a two-dimensional array using the `stack()`

function.

Finally, we calculate the ratio of assists to turnovers using NumPy’s array operations, which automatically performs the element-wise division of the two arrays, and store the result in the `assists_turnovers_ratio`

variable. When we print out this variable, we get the following output:

```
[2. 1.8 1.4375 2. ]
```

The output represents the ratio of assists to turnovers for each team in the DataFrame, i.e., the Heat had 2 assists for each turnover, the Lakers had 1.8 assists for each turnover, the Rockets had 1.4375 assists for each turnover, and the Bulls had 2 assists for each turnover.

## Conclusion

In this article, we covered different methods of converting Pandas DataFrame columns to NumPy arrays, including converting one column using the `to_numpy()`

function, and converting multiple columns using `to_numpy()`

and the `stack()`

function. We also provided a real-world example of using NumPy’s array operations to analyze data from a Pandas DataFrame.

By understanding these concepts, you can more easily work with Pandas and NumPy in your data analysis projects and take advantage of the powerful tools and functions that these libraries provide. Overall, this article explained how to convert Pandas DataFrame columns to NumPy arrays using two different methods: converting one column using the `to_numpy()`

function, and converting multiple columns using `to_numpy()`

and the `stack()`

function.

The article provided two real-world examples to illustrate these concepts, one involving calculating the mean and standard deviation of basketball player points, and the other involving calculating the ratio of assists to turnovers for a basketball team over a season. By understanding these methods, readers can more easily work with Pandas and NumPy in their data analysis projects and take advantage of the powerful tools and functions that these libraries provide.

Whether you are analyzing sports data or any other type of data, being able to convert Pandas DataFrame columns to NumPy arrays is a valuable skill that can save time, increase efficiency, and streamline the data processing and analysis pipeline.