5 Best Ways to Convert a Python DataFrame Row to a List

by 
import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = [value for value in df.iloc[0]]
print(row_as_list)

Output: [1, 3]

The usage of list comprehension provides a Pythonic and often faster way to iterate over row data and construct the list manually. The expression [value for value in df.iloc[0]] does precisely this for the first row of our DataFrame.

Method 4: Using iloc and to_numpy()

Another method is to use iloc[] to select the row and to_numpy() to convert it into a numpy array, then casting the array to a list with the standard Python list() constructor.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = list(df.iloc[0].to_numpy())
print(row_as_list)

Output: [1, 3]

This method prefers using to_numpy() directly instead of values, which can sometimes be clearer and is explicitly designed to convert pandas objects to Numpy arrays. After conversion, the list() constructor creates a list from the numpy array.

Bonus One-Liner Method 5: Using a Lambda Function

For those who like concise code, a lambda function can be used in combination with the apply() method to convert a row to a list with a one-liner code sequence.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = df.apply(lambda row: row.tolist(), axis=1)[0]
print(row_as_list)

Output: [1, 3]

The lambda function lambda row: row.tolist() is applied across the rows of the DataFrame (specifying axis=1) which converts each row to a list. We then select the first element of the result array to get the first row as a list.

Summary/Discussion

  • Method 1: iloc with values and tolist(). Straightforward and easy to understand. However, relies on integer-based indexing.
  • Method 2: loc with label index. Useful when you have labeled indices. It’s similar to Method 1 but slightly less efficient if labels are not needed.
  • Method 3: Use of list comprehension. Pythonic and efficient. Might be less readable to those unfamiliar with list comprehensions.
  • Method 4: iloc with to_numpy(). More explicit than using values. Suitable for when you are already working with numpy arrays.
  • Bonus Method 5: Lambda with apply(). Extremely concise, but may be slower for large DataFrames and could be considered “less readable” due to its compactness.
import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]}, index=['row1', 'row2'])
row_as_list = df.loc['row1'].values.tolist()
print(row_as_list)

Output: [1, 3]

This snippet specifies an index (‘row1’, ‘row2’) for the DataFrame. Using loc['row1'], the row labeled ‘row1’ is selected, and similar to Method 1, values and tolist() methods convert the row to a list.

Method 3: Using iloc with list comprehension

This method employs Python’s list comprehension to iterate over a row’s values, accessed through iloc[], and convert each value to a list element explicitly.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = [value for value in df.iloc[0]]
print(row_as_list)

Output: [1, 3]

The usage of list comprehension provides a Pythonic and often faster way to iterate over row data and construct the list manually. The expression [value for value in df.iloc[0]] does precisely this for the first row of our DataFrame.

Method 4: Using iloc and to_numpy()

Another method is to use iloc[] to select the row and to_numpy() to convert it into a numpy array, then casting the array to a list with the standard Python list() constructor.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = list(df.iloc[0].to_numpy())
print(row_as_list)

Output: [1, 3]

This method prefers using to_numpy() directly instead of values, which can sometimes be clearer and is explicitly designed to convert pandas objects to Numpy arrays. After conversion, the list() constructor creates a list from the numpy array.

Bonus One-Liner Method 5: Using a Lambda Function

For those who like concise code, a lambda function can be used in combination with the apply() method to convert a row to a list with a one-liner code sequence.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = df.apply(lambda row: row.tolist(), axis=1)[0]
print(row_as_list)

Output: [1, 3]

The lambda function lambda row: row.tolist() is applied across the rows of the DataFrame (specifying axis=1) which converts each row to a list. We then select the first element of the result array to get the first row as a list.

Summary/Discussion

  • Method 1: iloc with values and tolist(). Straightforward and easy to understand. However, relies on integer-based indexing.
  • Method 2: loc with label index. Useful when you have labeled indices. It’s similar to Method 1 but slightly less efficient if labels are not needed.
  • Method 3: Use of list comprehension. Pythonic and efficient. Might be less readable to those unfamiliar with list comprehensions.
  • Method 4: iloc with to_numpy(). More explicit than using values. Suitable for when you are already working with numpy arrays.
  • Bonus Method 5: Lambda with apply(). Extremely concise, but may be slower for large DataFrames and could be considered “less readable” due to its compactness.
import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = df.iloc[0].values.tolist()
print(row_as_list)

Output: [1, 3]

This code snippet first imports the pandas library, then creates a simple DataFrame with two rows and two columns. The iloc[0] selects the first row, values converts it to a numpy array, and tolist() converts this array to a list, giving us the elements of the first row as a list.

Method 2: Using loc with a label index

When selecting rows by label index, loc[] comes in handy. Combined with values and tolist(), this method retrieves a row as a list based on the row’s index label.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]}, index=['row1', 'row2'])
row_as_list = df.loc['row1'].values.tolist()
print(row_as_list)

Output: [1, 3]

This snippet specifies an index (‘row1’, ‘row2’) for the DataFrame. Using loc['row1'], the row labeled ‘row1’ is selected, and similar to Method 1, values and tolist() methods convert the row to a list.

Method 3: Using iloc with list comprehension

This method employs Python’s list comprehension to iterate over a row’s values, accessed through iloc[], and convert each value to a list element explicitly.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = [value for value in df.iloc[0]]
print(row_as_list)

Output: [1, 3]

The usage of list comprehension provides a Pythonic and often faster way to iterate over row data and construct the list manually. The expression [value for value in df.iloc[0]] does precisely this for the first row of our DataFrame.

Method 4: Using iloc and to_numpy()

Another method is to use iloc[] to select the row and to_numpy() to convert it into a numpy array, then casting the array to a list with the standard Python list() constructor.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = list(df.iloc[0].to_numpy())
print(row_as_list)

Output: [1, 3]

This method prefers using to_numpy() directly instead of values, which can sometimes be clearer and is explicitly designed to convert pandas objects to Numpy arrays. After conversion, the list() constructor creates a list from the numpy array.

Bonus One-Liner Method 5: Using a Lambda Function

For those who like concise code, a lambda function can be used in combination with the apply() method to convert a row to a list with a one-liner code sequence.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = df.apply(lambda row: row.tolist(), axis=1)[0]
print(row_as_list)

Output: [1, 3]

The lambda function lambda row: row.tolist() is applied across the rows of the DataFrame (specifying axis=1) which converts each row to a list. We then select the first element of the result array to get the first row as a list.

Summary/Discussion

  • Method 1: iloc with values and tolist(). Straightforward and easy to understand. However, relies on integer-based indexing.
  • Method 2: loc with label index. Useful when you have labeled indices. It’s similar to Method 1 but slightly less efficient if labels are not needed.
  • Method 3: Use of list comprehension. Pythonic and efficient. Might be less readable to those unfamiliar with list comprehensions.
  • Method 4: iloc with to_numpy(). More explicit than using values. Suitable for when you are already working with numpy arrays.
  • Bonus Method 5: Lambda with apply(). Extremely concise, but may be slower for large DataFrames and could be considered “less readable” due to its compactness.
import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = list(df.iloc[0].to_numpy())
print(row_as_list)

Output: [1, 3]

This method prefers using to_numpy() directly instead of values, which can sometimes be clearer and is explicitly designed to convert pandas objects to Numpy arrays. After conversion, the list() constructor creates a list from the numpy array.

Bonus One-Liner Method 5: Using a Lambda Function

For those who like concise code, a lambda function can be used in combination with the apply() method to convert a row to a list with a one-liner code sequence.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = df.apply(lambda row: row.tolist(), axis=1)[0]
print(row_as_list)

Output: [1, 3]

The lambda function lambda row: row.tolist() is applied across the rows of the DataFrame (specifying axis=1) which converts each row to a list. We then select the first element of the result array to get the first row as a list.

Summary/Discussion

  • Method 1: iloc with values and tolist(). Straightforward and easy to understand. However, relies on integer-based indexing.
  • Method 2: loc with label index. Useful when you have labeled indices. It’s similar to Method 1 but slightly less efficient if labels are not needed.
  • Method 3: Use of list comprehension. Pythonic and efficient. Might be less readable to those unfamiliar with list comprehensions.
  • Method 4: iloc with to_numpy(). More explicit than using values. Suitable for when you are already working with numpy arrays.
  • Bonus Method 5: Lambda with apply(). Extremely concise, but may be slower for large DataFrames and could be considered “less readable” due to its compactness.
import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = df.iloc[0].values.tolist()
print(row_as_list)

Output: [1, 3]

This code snippet first imports the pandas library, then creates a simple DataFrame with two rows and two columns. The iloc[0] selects the first row, values converts it to a numpy array, and tolist() converts this array to a list, giving us the elements of the first row as a list.

Method 2: Using loc with a label index

When selecting rows by label index, loc[] comes in handy. Combined with values and tolist(), this method retrieves a row as a list based on the row’s index label.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]}, index=['row1', 'row2'])
row_as_list = df.loc['row1'].values.tolist()
print(row_as_list)

Output: [1, 3]

This snippet specifies an index (‘row1’, ‘row2’) for the DataFrame. Using loc['row1'], the row labeled ‘row1’ is selected, and similar to Method 1, values and tolist() methods convert the row to a list.

Method 3: Using iloc with list comprehension

This method employs Python’s list comprehension to iterate over a row’s values, accessed through iloc[], and convert each value to a list element explicitly.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = [value for value in df.iloc[0]]
print(row_as_list)

Output: [1, 3]

The usage of list comprehension provides a Pythonic and often faster way to iterate over row data and construct the list manually. The expression [value for value in df.iloc[0]] does precisely this for the first row of our DataFrame.

Method 4: Using iloc and to_numpy()

Another method is to use iloc[] to select the row and to_numpy() to convert it into a numpy array, then casting the array to a list with the standard Python list() constructor.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = list(df.iloc[0].to_numpy())
print(row_as_list)

Output: [1, 3]

This method prefers using to_numpy() directly instead of values, which can sometimes be clearer and is explicitly designed to convert pandas objects to Numpy arrays. After conversion, the list() constructor creates a list from the numpy array.

Bonus One-Liner Method 5: Using a Lambda Function

For those who like concise code, a lambda function can be used in combination with the apply() method to convert a row to a list with a one-liner code sequence.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = df.apply(lambda row: row.tolist(), axis=1)[0]
print(row_as_list)

Output: [1, 3]

The lambda function lambda row: row.tolist() is applied across the rows of the DataFrame (specifying axis=1) which converts each row to a list. We then select the first element of the result array to get the first row as a list.

Summary/Discussion

  • Method 1: iloc with values and tolist(). Straightforward and easy to understand. However, relies on integer-based indexing.
  • Method 2: loc with label index. Useful when you have labeled indices. It’s similar to Method 1 but slightly less efficient if labels are not needed.
  • Method 3: Use of list comprehension. Pythonic and efficient. Might be less readable to those unfamiliar with list comprehensions.
  • Method 4: iloc with to_numpy(). More explicit than using values. Suitable for when you are already working with numpy arrays.
  • Bonus Method 5: Lambda with apply(). Extremely concise, but may be slower for large DataFrames and could be considered “less readable” due to its compactness.
import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = [value for value in df.iloc[0]]
print(row_as_list)

Output: [1, 3]

The usage of list comprehension provides a Pythonic and often faster way to iterate over row data and construct the list manually. The expression [value for value in df.iloc[0]] does precisely this for the first row of our DataFrame.

Method 4: Using iloc and to_numpy()

Another method is to use iloc[] to select the row and to_numpy() to convert it into a numpy array, then casting the array to a list with the standard Python list() constructor.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = list(df.iloc[0].to_numpy())
print(row_as_list)

Output: [1, 3]

This method prefers using to_numpy() directly instead of values, which can sometimes be clearer and is explicitly designed to convert pandas objects to Numpy arrays. After conversion, the list() constructor creates a list from the numpy array.

Bonus One-Liner Method 5: Using a Lambda Function

For those who like concise code, a lambda function can be used in combination with the apply() method to convert a row to a list with a one-liner code sequence.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = df.apply(lambda row: row.tolist(), axis=1)[0]
print(row_as_list)

Output: [1, 3]

The lambda function lambda row: row.tolist() is applied across the rows of the DataFrame (specifying axis=1) which converts each row to a list. We then select the first element of the result array to get the first row as a list.

Summary/Discussion

  • Method 1: iloc with values and tolist(). Straightforward and easy to understand. However, relies on integer-based indexing.
  • Method 2: loc with label index. Useful when you have labeled indices. It’s similar to Method 1 but slightly less efficient if labels are not needed.
  • Method 3: Use of list comprehension. Pythonic and efficient. Might be less readable to those unfamiliar with list comprehensions.
  • Method 4: iloc with to_numpy(). More explicit than using values. Suitable for when you are already working with numpy arrays.
  • Bonus Method 5: Lambda with apply(). Extremely concise, but may be slower for large DataFrames and could be considered “less readable” due to its compactness.
import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = df.iloc[0].values.tolist()
print(row_as_list)

Output: [1, 3]

This code snippet first imports the pandas library, then creates a simple DataFrame with two rows and two columns. The iloc[0] selects the first row, values converts it to a numpy array, and tolist() converts this array to a list, giving us the elements of the first row as a list.

Method 2: Using loc with a label index

When selecting rows by label index, loc[] comes in handy. Combined with values and tolist(), this method retrieves a row as a list based on the row’s index label.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]}, index=['row1', 'row2'])
row_as_list = df.loc['row1'].values.tolist()
print(row_as_list)

Output: [1, 3]

This snippet specifies an index (‘row1’, ‘row2’) for the DataFrame. Using loc['row1'], the row labeled ‘row1’ is selected, and similar to Method 1, values and tolist() methods convert the row to a list.

Method 3: Using iloc with list comprehension

This method employs Python’s list comprehension to iterate over a row’s values, accessed through iloc[], and convert each value to a list element explicitly.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = [value for value in df.iloc[0]]
print(row_as_list)

Output: [1, 3]

The usage of list comprehension provides a Pythonic and often faster way to iterate over row data and construct the list manually. The expression [value for value in df.iloc[0]] does precisely this for the first row of our DataFrame.

Method 4: Using iloc and to_numpy()

Another method is to use iloc[] to select the row and to_numpy() to convert it into a numpy array, then casting the array to a list with the standard Python list() constructor.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = list(df.iloc[0].to_numpy())
print(row_as_list)

Output: [1, 3]

This method prefers using to_numpy() directly instead of values, which can sometimes be clearer and is explicitly designed to convert pandas objects to Numpy arrays. After conversion, the list() constructor creates a list from the numpy array.

Bonus One-Liner Method 5: Using a Lambda Function

For those who like concise code, a lambda function can be used in combination with the apply() method to convert a row to a list with a one-liner code sequence.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = df.apply(lambda row: row.tolist(), axis=1)[0]
print(row_as_list)

Output: [1, 3]

The lambda function lambda row: row.tolist() is applied across the rows of the DataFrame (specifying axis=1) which converts each row to a list. We then select the first element of the result array to get the first row as a list.

Summary/Discussion

  • Method 1: iloc with values and tolist(). Straightforward and easy to understand. However, relies on integer-based indexing.
  • Method 2: loc with label index. Useful when you have labeled indices. It’s similar to Method 1 but slightly less efficient if labels are not needed.
  • Method 3: Use of list comprehension. Pythonic and efficient. Might be less readable to those unfamiliar with list comprehensions.
  • Method 4: iloc with to_numpy(). More explicit than using values. Suitable for when you are already working with numpy arrays.
  • Bonus Method 5: Lambda with apply(). Extremely concise, but may be slower for large DataFrames and could be considered “less readable” due to its compactness.
import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]}, index=['row1', 'row2'])
row_as_list = df.loc['row1'].values.tolist()
print(row_as_list)

Output: [1, 3]

This snippet specifies an index (‘row1’, ‘row2’) for the DataFrame. Using loc['row1'], the row labeled ‘row1’ is selected, and similar to Method 1, values and tolist() methods convert the row to a list.

Method 3: Using iloc with list comprehension

This method employs Python’s list comprehension to iterate over a row’s values, accessed through iloc[], and convert each value to a list element explicitly.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = [value for value in df.iloc[0]]
print(row_as_list)

Output: [1, 3]

The usage of list comprehension provides a Pythonic and often faster way to iterate over row data and construct the list manually. The expression [value for value in df.iloc[0]] does precisely this for the first row of our DataFrame.

Method 4: Using iloc and to_numpy()

Another method is to use iloc[] to select the row and to_numpy() to convert it into a numpy array, then casting the array to a list with the standard Python list() constructor.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = list(df.iloc[0].to_numpy())
print(row_as_list)

Output: [1, 3]

This method prefers using to_numpy() directly instead of values, which can sometimes be clearer and is explicitly designed to convert pandas objects to Numpy arrays. After conversion, the list() constructor creates a list from the numpy array.

Bonus One-Liner Method 5: Using a Lambda Function

For those who like concise code, a lambda function can be used in combination with the apply() method to convert a row to a list with a one-liner code sequence.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = df.apply(lambda row: row.tolist(), axis=1)[0]
print(row_as_list)

Output: [1, 3]

The lambda function lambda row: row.tolist() is applied across the rows of the DataFrame (specifying axis=1) which converts each row to a list. We then select the first element of the result array to get the first row as a list.

Summary/Discussion

  • Method 1: iloc with values and tolist(). Straightforward and easy to understand. However, relies on integer-based indexing.
  • Method 2: loc with label index. Useful when you have labeled indices. It’s similar to Method 1 but slightly less efficient if labels are not needed.
  • Method 3: Use of list comprehension. Pythonic and efficient. Might be less readable to those unfamiliar with list comprehensions.
  • Method 4: iloc with to_numpy(). More explicit than using values. Suitable for when you are already working with numpy arrays.
  • Bonus Method 5: Lambda with apply(). Extremely concise, but may be slower for large DataFrames and could be considered “less readable” due to its compactness.
import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = df.iloc[0].values.tolist()
print(row_as_list)

Output: [1, 3]

This code snippet first imports the pandas library, then creates a simple DataFrame with two rows and two columns. The iloc[0] selects the first row, values converts it to a numpy array, and tolist() converts this array to a list, giving us the elements of the first row as a list.

Method 2: Using loc with a label index

When selecting rows by label index, loc[] comes in handy. Combined with values and tolist(), this method retrieves a row as a list based on the row’s index label.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]}, index=['row1', 'row2'])
row_as_list = df.loc['row1'].values.tolist()
print(row_as_list)

Output: [1, 3]

This snippet specifies an index (‘row1’, ‘row2’) for the DataFrame. Using loc['row1'], the row labeled ‘row1’ is selected, and similar to Method 1, values and tolist() methods convert the row to a list.

Method 3: Using iloc with list comprehension

This method employs Python’s list comprehension to iterate over a row’s values, accessed through iloc[], and convert each value to a list element explicitly.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = [value for value in df.iloc[0]]
print(row_as_list)

Output: [1, 3]

The usage of list comprehension provides a Pythonic and often faster way to iterate over row data and construct the list manually. The expression [value for value in df.iloc[0]] does precisely this for the first row of our DataFrame.

Method 4: Using iloc and to_numpy()

Another method is to use iloc[] to select the row and to_numpy() to convert it into a numpy array, then casting the array to a list with the standard Python list() constructor.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = list(df.iloc[0].to_numpy())
print(row_as_list)

Output: [1, 3]

This method prefers using to_numpy() directly instead of values, which can sometimes be clearer and is explicitly designed to convert pandas objects to Numpy arrays. After conversion, the list() constructor creates a list from the numpy array.

Bonus One-Liner Method 5: Using a Lambda Function

For those who like concise code, a lambda function can be used in combination with the apply() method to convert a row to a list with a one-liner code sequence.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = df.apply(lambda row: row.tolist(), axis=1)[0]
print(row_as_list)

Output: [1, 3]

The lambda function lambda row: row.tolist() is applied across the rows of the DataFrame (specifying axis=1) which converts each row to a list. We then select the first element of the result array to get the first row as a list.

Summary/Discussion

  • Method 1: iloc with values and tolist(). Straightforward and easy to understand. However, relies on integer-based indexing.
  • Method 2: loc with label index. Useful when you have labeled indices. It’s similar to Method 1 but slightly less efficient if labels are not needed.
  • Method 3: Use of list comprehension. Pythonic and efficient. Might be less readable to those unfamiliar with list comprehensions.
  • Method 4: iloc with to_numpy(). More explicit than using values. Suitable for when you are already working with numpy arrays.
  • Bonus Method 5: Lambda with apply(). Extremely concise, but may be slower for large DataFrames and could be considered “less readable” due to its compactness.
import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = list(df.iloc[0].to_numpy())
print(row_as_list)

Output: [1, 3]

This method prefers using to_numpy() directly instead of values, which can sometimes be clearer and is explicitly designed to convert pandas objects to Numpy arrays. After conversion, the list() constructor creates a list from the numpy array.

Bonus One-Liner Method 5: Using a Lambda Function

For those who like concise code, a lambda function can be used in combination with the apply() method to convert a row to a list with a one-liner code sequence.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = df.apply(lambda row: row.tolist(), axis=1)[0]
print(row_as_list)

Output: [1, 3]

The lambda function lambda row: row.tolist() is applied across the rows of the DataFrame (specifying axis=1) which converts each row to a list. We then select the first element of the result array to get the first row as a list.

Summary/Discussion

  • Method 1: iloc with values and tolist(). Straightforward and easy to understand. However, relies on integer-based indexing.
  • Method 2: loc with label index. Useful when you have labeled indices. It’s similar to Method 1 but slightly less efficient if labels are not needed.
  • Method 3: Use of list comprehension. Pythonic and efficient. Might be less readable to those unfamiliar with list comprehensions.
  • Method 4: iloc with to_numpy(). More explicit than using values. Suitable for when you are already working with numpy arrays.
  • Bonus Method 5: Lambda with apply(). Extremely concise, but may be slower for large DataFrames and could be considered “less readable” due to its compactness.
import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]}, index=['row1', 'row2'])
row_as_list = df.loc['row1'].values.tolist()
print(row_as_list)

Output: [1, 3]

This snippet specifies an index (‘row1’, ‘row2’) for the DataFrame. Using loc['row1'], the row labeled ‘row1’ is selected, and similar to Method 1, values and tolist() methods convert the row to a list.

Method 3: Using iloc with list comprehension

This method employs Python’s list comprehension to iterate over a row’s values, accessed through iloc[], and convert each value to a list element explicitly.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = [value for value in df.iloc[0]]
print(row_as_list)

Output: [1, 3]

The usage of list comprehension provides a Pythonic and often faster way to iterate over row data and construct the list manually. The expression [value for value in df.iloc[0]] does precisely this for the first row of our DataFrame.

Method 4: Using iloc and to_numpy()

Another method is to use iloc[] to select the row and to_numpy() to convert it into a numpy array, then casting the array to a list with the standard Python list() constructor.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = list(df.iloc[0].to_numpy())
print(row_as_list)

Output: [1, 3]

This method prefers using to_numpy() directly instead of values, which can sometimes be clearer and is explicitly designed to convert pandas objects to Numpy arrays. After conversion, the list() constructor creates a list from the numpy array.

Bonus One-Liner Method 5: Using a Lambda Function

For those who like concise code, a lambda function can be used in combination with the apply() method to convert a row to a list with a one-liner code sequence.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = df.apply(lambda row: row.tolist(), axis=1)[0]
print(row_as_list)

Output: [1, 3]

The lambda function lambda row: row.tolist() is applied across the rows of the DataFrame (specifying axis=1) which converts each row to a list. We then select the first element of the result array to get the first row as a list.

Summary/Discussion

  • Method 1: iloc with values and tolist(). Straightforward and easy to understand. However, relies on integer-based indexing.
  • Method 2: loc with label index. Useful when you have labeled indices. It’s similar to Method 1 but slightly less efficient if labels are not needed.
  • Method 3: Use of list comprehension. Pythonic and efficient. Might be less readable to those unfamiliar with list comprehensions.
  • Method 4: iloc with to_numpy(). More explicit than using values. Suitable for when you are already working with numpy arrays.
  • Bonus Method 5: Lambda with apply(). Extremely concise, but may be slower for large DataFrames and could be considered “less readable” due to its compactness.
import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = df.iloc[0].values.tolist()
print(row_as_list)

Output: [1, 3]

This code snippet first imports the pandas library, then creates a simple DataFrame with two rows and two columns. The iloc[0] selects the first row, values converts it to a numpy array, and tolist() converts this array to a list, giving us the elements of the first row as a list.

Method 2: Using loc with a label index

When selecting rows by label index, loc[] comes in handy. Combined with values and tolist(), this method retrieves a row as a list based on the row’s index label.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]}, index=['row1', 'row2'])
row_as_list = df.loc['row1'].values.tolist()
print(row_as_list)

Output: [1, 3]

This snippet specifies an index (‘row1’, ‘row2’) for the DataFrame. Using loc['row1'], the row labeled ‘row1’ is selected, and similar to Method 1, values and tolist() methods convert the row to a list.

Method 3: Using iloc with list comprehension

This method employs Python’s list comprehension to iterate over a row’s values, accessed through iloc[], and convert each value to a list element explicitly.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = [value for value in df.iloc[0]]
print(row_as_list)

Output: [1, 3]

The usage of list comprehension provides a Pythonic and often faster way to iterate over row data and construct the list manually. The expression [value for value in df.iloc[0]] does precisely this for the first row of our DataFrame.

Method 4: Using iloc and to_numpy()

Another method is to use iloc[] to select the row and to_numpy() to convert it into a numpy array, then casting the array to a list with the standard Python list() constructor.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = list(df.iloc[0].to_numpy())
print(row_as_list)

Output: [1, 3]

This method prefers using to_numpy() directly instead of values, which can sometimes be clearer and is explicitly designed to convert pandas objects to Numpy arrays. After conversion, the list() constructor creates a list from the numpy array.

Bonus One-Liner Method 5: Using a Lambda Function

For those who like concise code, a lambda function can be used in combination with the apply() method to convert a row to a list with a one-liner code sequence.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = df.apply(lambda row: row.tolist(), axis=1)[0]
print(row_as_list)

Output: [1, 3]

The lambda function lambda row: row.tolist() is applied across the rows of the DataFrame (specifying axis=1) which converts each row to a list. We then select the first element of the result array to get the first row as a list.

Summary/Discussion

  • Method 1: iloc with values and tolist(). Straightforward and easy to understand. However, relies on integer-based indexing.
  • Method 2: loc with label index. Useful when you have labeled indices. It’s similar to Method 1 but slightly less efficient if labels are not needed.
  • Method 3: Use of list comprehension. Pythonic and efficient. Might be less readable to those unfamiliar with list comprehensions.
  • Method 4: iloc with to_numpy(). More explicit than using values. Suitable for when you are already working with numpy arrays.
  • Bonus Method 5: Lambda with apply(). Extremely concise, but may be slower for large DataFrames and could be considered “less readable” due to its compactness.
import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = [value for value in df.iloc[0]]
print(row_as_list)

Output: [1, 3]

The usage of list comprehension provides a Pythonic and often faster way to iterate over row data and construct the list manually. The expression [value for value in df.iloc[0]] does precisely this for the first row of our DataFrame.

Method 4: Using iloc and to_numpy()

Another method is to use iloc[] to select the row and to_numpy() to convert it into a numpy array, then casting the array to a list with the standard Python list() constructor.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = list(df.iloc[0].to_numpy())
print(row_as_list)

Output: [1, 3]

This method prefers using to_numpy() directly instead of values, which can sometimes be clearer and is explicitly designed to convert pandas objects to Numpy arrays. After conversion, the list() constructor creates a list from the numpy array.

Bonus One-Liner Method 5: Using a Lambda Function

For those who like concise code, a lambda function can be used in combination with the apply() method to convert a row to a list with a one-liner code sequence.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = df.apply(lambda row: row.tolist(), axis=1)[0]
print(row_as_list)

Output: [1, 3]

The lambda function lambda row: row.tolist() is applied across the rows of the DataFrame (specifying axis=1) which converts each row to a list. We then select the first element of the result array to get the first row as a list.

Summary/Discussion

  • Method 1: iloc with values and tolist(). Straightforward and easy to understand. However, relies on integer-based indexing.
  • Method 2: loc with label index. Useful when you have labeled indices. It’s similar to Method 1 but slightly less efficient if labels are not needed.
  • Method 3: Use of list comprehension. Pythonic and efficient. Might be less readable to those unfamiliar with list comprehensions.
  • Method 4: iloc with to_numpy(). More explicit than using values. Suitable for when you are already working with numpy arrays.
  • Bonus Method 5: Lambda with apply(). Extremely concise, but may be slower for large DataFrames and could be considered “less readable” due to its compactness.
import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]}, index=['row1', 'row2'])
row_as_list = df.loc['row1'].values.tolist()
print(row_as_list)

Output: [1, 3]

This snippet specifies an index (‘row1’, ‘row2’) for the DataFrame. Using loc['row1'], the row labeled ‘row1’ is selected, and similar to Method 1, values and tolist() methods convert the row to a list.

Method 3: Using iloc with list comprehension

This method employs Python’s list comprehension to iterate over a row’s values, accessed through iloc[], and convert each value to a list element explicitly.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = [value for value in df.iloc[0]]
print(row_as_list)

Output: [1, 3]

The usage of list comprehension provides a Pythonic and often faster way to iterate over row data and construct the list manually. The expression [value for value in df.iloc[0]] does precisely this for the first row of our DataFrame.

Method 4: Using iloc and to_numpy()

Another method is to use iloc[] to select the row and to_numpy() to convert it into a numpy array, then casting the array to a list with the standard Python list() constructor.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = list(df.iloc[0].to_numpy())
print(row_as_list)

Output: [1, 3]

This method prefers using to_numpy() directly instead of values, which can sometimes be clearer and is explicitly designed to convert pandas objects to Numpy arrays. After conversion, the list() constructor creates a list from the numpy array.

Bonus One-Liner Method 5: Using a Lambda Function

For those who like concise code, a lambda function can be used in combination with the apply() method to convert a row to a list with a one-liner code sequence.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = df.apply(lambda row: row.tolist(), axis=1)[0]
print(row_as_list)

Output: [1, 3]

The lambda function lambda row: row.tolist() is applied across the rows of the DataFrame (specifying axis=1) which converts each row to a list. We then select the first element of the result array to get the first row as a list.

Summary/Discussion

  • Method 1: iloc with values and tolist(). Straightforward and easy to understand. However, relies on integer-based indexing.
  • Method 2: loc with label index. Useful when you have labeled indices. It’s similar to Method 1 but slightly less efficient if labels are not needed.
  • Method 3: Use of list comprehension. Pythonic and efficient. Might be less readable to those unfamiliar with list comprehensions.
  • Method 4: iloc with to_numpy(). More explicit than using values. Suitable for when you are already working with numpy arrays.
  • Bonus Method 5: Lambda with apply(). Extremely concise, but may be slower for large DataFrames and could be considered “less readable” due to its compactness.
import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = df.iloc[0].values.tolist()
print(row_as_list)

Output: [1, 3]

This code snippet first imports the pandas library, then creates a simple DataFrame with two rows and two columns. The iloc[0] selects the first row, values converts it to a numpy array, and tolist() converts this array to a list, giving us the elements of the first row as a list.

Method 2: Using loc with a label index

When selecting rows by label index, loc[] comes in handy. Combined with values and tolist(), this method retrieves a row as a list based on the row’s index label.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]}, index=['row1', 'row2'])
row_as_list = df.loc['row1'].values.tolist()
print(row_as_list)

Output: [1, 3]

This snippet specifies an index (‘row1’, ‘row2’) for the DataFrame. Using loc['row1'], the row labeled ‘row1’ is selected, and similar to Method 1, values and tolist() methods convert the row to a list.

Method 3: Using iloc with list comprehension

This method employs Python’s list comprehension to iterate over a row’s values, accessed through iloc[], and convert each value to a list element explicitly.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = [value for value in df.iloc[0]]
print(row_as_list)

Output: [1, 3]

The usage of list comprehension provides a Pythonic and often faster way to iterate over row data and construct the list manually. The expression [value for value in df.iloc[0]] does precisely this for the first row of our DataFrame.

Method 4: Using iloc and to_numpy()

Another method is to use iloc[] to select the row and to_numpy() to convert it into a numpy array, then casting the array to a list with the standard Python list() constructor.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = list(df.iloc[0].to_numpy())
print(row_as_list)

Output: [1, 3]

This method prefers using to_numpy() directly instead of values, which can sometimes be clearer and is explicitly designed to convert pandas objects to Numpy arrays. After conversion, the list() constructor creates a list from the numpy array.

Bonus One-Liner Method 5: Using a Lambda Function

For those who like concise code, a lambda function can be used in combination with the apply() method to convert a row to a list with a one-liner code sequence.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = df.apply(lambda row: row.tolist(), axis=1)[0]
print(row_as_list)

Output: [1, 3]

The lambda function lambda row: row.tolist() is applied across the rows of the DataFrame (specifying axis=1) which converts each row to a list. We then select the first element of the result array to get the first row as a list.

Summary/Discussion

  • Method 1: iloc with values and tolist(). Straightforward and easy to understand. However, relies on integer-based indexing.
  • Method 2: loc with label index. Useful when you have labeled indices. It’s similar to Method 1 but slightly less efficient if labels are not needed.
  • Method 3: Use of list comprehension. Pythonic and efficient. Might be less readable to those unfamiliar with list comprehensions.
  • Method 4: iloc with to_numpy(). More explicit than using values. Suitable for when you are already working with numpy arrays.
  • Bonus Method 5: Lambda with apply(). Extremely concise, but may be slower for large DataFrames and could be considered “less readable” due to its compactness.
import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = list(df.iloc[0].to_numpy())
print(row_as_list)

Output: [1, 3]

This method prefers using to_numpy() directly instead of values, which can sometimes be clearer and is explicitly designed to convert pandas objects to Numpy arrays. After conversion, the list() constructor creates a list from the numpy array.

Bonus One-Liner Method 5: Using a Lambda Function

For those who like concise code, a lambda function can be used in combination with the apply() method to convert a row to a list with a one-liner code sequence.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = df.apply(lambda row: row.tolist(), axis=1)[0]
print(row_as_list)

Output: [1, 3]

The lambda function lambda row: row.tolist() is applied across the rows of the DataFrame (specifying axis=1) which converts each row to a list. We then select the first element of the result array to get the first row as a list.

Summary/Discussion

  • Method 1: iloc with values and tolist(). Straightforward and easy to understand. However, relies on integer-based indexing.
  • Method 2: loc with label index. Useful when you have labeled indices. It’s similar to Method 1 but slightly less efficient if labels are not needed.
  • Method 3: Use of list comprehension. Pythonic and efficient. Might be less readable to those unfamiliar with list comprehensions.
  • Method 4: iloc with to_numpy(). More explicit than using values. Suitable for when you are already working with numpy arrays.
  • Bonus Method 5: Lambda with apply(). Extremely concise, but may be slower for large DataFrames and could be considered “less readable” due to its compactness.
import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = [value for value in df.iloc[0]]
print(row_as_list)

Output: [1, 3]

The usage of list comprehension provides a Pythonic and often faster way to iterate over row data and construct the list manually. The expression [value for value in df.iloc[0]] does precisely this for the first row of our DataFrame.

Method 4: Using iloc and to_numpy()

Another method is to use iloc[] to select the row and to_numpy() to convert it into a numpy array, then casting the array to a list with the standard Python list() constructor.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = list(df.iloc[0].to_numpy())
print(row_as_list)

Output: [1, 3]

This method prefers using to_numpy() directly instead of values, which can sometimes be clearer and is explicitly designed to convert pandas objects to Numpy arrays. After conversion, the list() constructor creates a list from the numpy array.

Bonus One-Liner Method 5: Using a Lambda Function

For those who like concise code, a lambda function can be used in combination with the apply() method to convert a row to a list with a one-liner code sequence.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = df.apply(lambda row: row.tolist(), axis=1)[0]
print(row_as_list)

Output: [1, 3]

The lambda function lambda row: row.tolist() is applied across the rows of the DataFrame (specifying axis=1) which converts each row to a list. We then select the first element of the result array to get the first row as a list.

Summary/Discussion

  • Method 1: iloc with values and tolist(). Straightforward and easy to understand. However, relies on integer-based indexing.
  • Method 2: loc with label index. Useful when you have labeled indices. It’s similar to Method 1 but slightly less efficient if labels are not needed.
  • Method 3: Use of list comprehension. Pythonic and efficient. Might be less readable to those unfamiliar with list comprehensions.
  • Method 4: iloc with to_numpy(). More explicit than using values. Suitable for when you are already working with numpy arrays.
  • Bonus Method 5: Lambda with apply(). Extremely concise, but may be slower for large DataFrames and could be considered “less readable” due to its compactness.
import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]}, index=['row1', 'row2'])
row_as_list = df.loc['row1'].values.tolist()
print(row_as_list)

Output: [1, 3]

This snippet specifies an index (‘row1’, ‘row2’) for the DataFrame. Using loc['row1'], the row labeled ‘row1’ is selected, and similar to Method 1, values and tolist() methods convert the row to a list.

Method 3: Using iloc with list comprehension

This method employs Python’s list comprehension to iterate over a row’s values, accessed through iloc[], and convert each value to a list element explicitly.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = [value for value in df.iloc[0]]
print(row_as_list)

Output: [1, 3]

The usage of list comprehension provides a Pythonic and often faster way to iterate over row data and construct the list manually. The expression [value for value in df.iloc[0]] does precisely this for the first row of our DataFrame.

Method 4: Using iloc and to_numpy()

Another method is to use iloc[] to select the row and to_numpy() to convert it into a numpy array, then casting the array to a list with the standard Python list() constructor.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = list(df.iloc[0].to_numpy())
print(row_as_list)

Output: [1, 3]

This method prefers using to_numpy() directly instead of values, which can sometimes be clearer and is explicitly designed to convert pandas objects to Numpy arrays. After conversion, the list() constructor creates a list from the numpy array.

Bonus One-Liner Method 5: Using a Lambda Function

For those who like concise code, a lambda function can be used in combination with the apply() method to convert a row to a list with a one-liner code sequence.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = df.apply(lambda row: row.tolist(), axis=1)[0]
print(row_as_list)

Output: [1, 3]

The lambda function lambda row: row.tolist() is applied across the rows of the DataFrame (specifying axis=1) which converts each row to a list. We then select the first element of the result array to get the first row as a list.

Summary/Discussion

  • Method 1: iloc with values and tolist(). Straightforward and easy to understand. However, relies on integer-based indexing.
  • Method 2: loc with label index. Useful when you have labeled indices. It’s similar to Method 1 but slightly less efficient if labels are not needed.
  • Method 3: Use of list comprehension. Pythonic and efficient. Might be less readable to those unfamiliar with list comprehensions.
  • Method 4: iloc with to_numpy(). More explicit than using values. Suitable for when you are already working with numpy arrays.
  • Bonus Method 5: Lambda with apply(). Extremely concise, but may be slower for large DataFrames and could be considered “less readable” due to its compactness.
import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = df.iloc[0].values.tolist()
print(row_as_list)

Output: [1, 3]

This code snippet first imports the pandas library, then creates a simple DataFrame with two rows and two columns. The iloc[0] selects the first row, values converts it to a numpy array, and tolist() converts this array to a list, giving us the elements of the first row as a list.

Method 2: Using loc with a label index

When selecting rows by label index, loc[] comes in handy. Combined with values and tolist(), this method retrieves a row as a list based on the row’s index label.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]}, index=['row1', 'row2'])
row_as_list = df.loc['row1'].values.tolist()
print(row_as_list)

Output: [1, 3]

This snippet specifies an index (‘row1’, ‘row2’) for the DataFrame. Using loc['row1'], the row labeled ‘row1’ is selected, and similar to Method 1, values and tolist() methods convert the row to a list.

Method 3: Using iloc with list comprehension

This method employs Python’s list comprehension to iterate over a row’s values, accessed through iloc[], and convert each value to a list element explicitly.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = [value for value in df.iloc[0]]
print(row_as_list)

Output: [1, 3]

The usage of list comprehension provides a Pythonic and often faster way to iterate over row data and construct the list manually. The expression [value for value in df.iloc[0]] does precisely this for the first row of our DataFrame.

Method 4: Using iloc and to_numpy()

Another method is to use iloc[] to select the row and to_numpy() to convert it into a numpy array, then casting the array to a list with the standard Python list() constructor.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = list(df.iloc[0].to_numpy())
print(row_as_list)

Output: [1, 3]

This method prefers using to_numpy() directly instead of values, which can sometimes be clearer and is explicitly designed to convert pandas objects to Numpy arrays. After conversion, the list() constructor creates a list from the numpy array.

Bonus One-Liner Method 5: Using a Lambda Function

For those who like concise code, a lambda function can be used in combination with the apply() method to convert a row to a list with a one-liner code sequence.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = df.apply(lambda row: row.tolist(), axis=1)[0]
print(row_as_list)

Output: [1, 3]

The lambda function lambda row: row.tolist() is applied across the rows of the DataFrame (specifying axis=1) which converts each row to a list. We then select the first element of the result array to get the first row as a list.

Summary/Discussion

  • Method 1: iloc with values and tolist(). Straightforward and easy to understand. However, relies on integer-based indexing.
  • Method 2: loc with label index. Useful when you have labeled indices. It’s similar to Method 1 but slightly less efficient if labels are not needed.
  • Method 3: Use of list comprehension. Pythonic and efficient. Might be less readable to those unfamiliar with list comprehensions.
  • Method 4: iloc with to_numpy(). More explicit than using values. Suitable for when you are already working with numpy arrays.
  • Bonus Method 5: Lambda with apply(). Extremely concise, but may be slower for large DataFrames and could be considered “less readable” due to its compactness.

💡 Problem Formulation: In data analysis using Python’s pandas library, a common operation is to convert a row of a DataFrame into a list. This could be required for data manipulation, processing, or when interfacing with APIs that expect list inputs. Consider a DataFrame with multiple columns, and from this, we aim to convert a specific row into a list ideally preserving the order of elements as they appear in the row.

Method 1: Using iloc with values and tolist()

Selecting a row by its integer location using iloc[], accessing its values with values, and then converting to a list with tolist() is a clear and straightforward approach.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = df.apply(lambda row: row.tolist(), axis=1)[0]
print(row_as_list)

Output: [1, 3]

The lambda function lambda row: row.tolist() is applied across the rows of the DataFrame (specifying axis=1) which converts each row to a list. We then select the first element of the result array to get the first row as a list.

Summary/Discussion

  • Method 1: iloc with values and tolist(). Straightforward and easy to understand. However, relies on integer-based indexing.
  • Method 2: loc with label index. Useful when you have labeled indices. It’s similar to Method 1 but slightly less efficient if labels are not needed.
  • Method 3: Use of list comprehension. Pythonic and efficient. Might be less readable to those unfamiliar with list comprehensions.
  • Method 4: iloc with to_numpy(). More explicit than using values. Suitable for when you are already working with numpy arrays.
  • Bonus Method 5: Lambda with apply(). Extremely concise, but may be slower for large DataFrames and could be considered “less readable” due to its compactness.
import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = list(df.iloc[0].to_numpy())
print(row_as_list)

Output: [1, 3]

This method prefers using to_numpy() directly instead of values, which can sometimes be clearer and is explicitly designed to convert pandas objects to Numpy arrays. After conversion, the list() constructor creates a list from the numpy array.

Bonus One-Liner Method 5: Using a Lambda Function

For those who like concise code, a lambda function can be used in combination with the apply() method to convert a row to a list with a one-liner code sequence.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = df.apply(lambda row: row.tolist(), axis=1)[0]
print(row_as_list)

Output: [1, 3]

The lambda function lambda row: row.tolist() is applied across the rows of the DataFrame (specifying axis=1) which converts each row to a list. We then select the first element of the result array to get the first row as a list.

Summary/Discussion

  • Method 1: iloc with values and tolist(). Straightforward and easy to understand. However, relies on integer-based indexing.
  • Method 2: loc with label index. Useful when you have labeled indices. It’s similar to Method 1 but slightly less efficient if labels are not needed.
  • Method 3: Use of list comprehension. Pythonic and efficient. Might be less readable to those unfamiliar with list comprehensions.
  • Method 4: iloc with to_numpy(). More explicit than using values. Suitable for when you are already working with numpy arrays.
  • Bonus Method 5: Lambda with apply(). Extremely concise, but may be slower for large DataFrames and could be considered “less readable” due to its compactness.
import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = [value for value in df.iloc[0]]
print(row_as_list)

Output: [1, 3]

The usage of list comprehension provides a Pythonic and often faster way to iterate over row data and construct the list manually. The expression [value for value in df.iloc[0]] does precisely this for the first row of our DataFrame.

Method 4: Using iloc and to_numpy()

Another method is to use iloc[] to select the row and to_numpy() to convert it into a numpy array, then casting the array to a list with the standard Python list() constructor.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = list(df.iloc[0].to_numpy())
print(row_as_list)

Output: [1, 3]

This method prefers using to_numpy() directly instead of values, which can sometimes be clearer and is explicitly designed to convert pandas objects to Numpy arrays. After conversion, the list() constructor creates a list from the numpy array.

Bonus One-Liner Method 5: Using a Lambda Function

For those who like concise code, a lambda function can be used in combination with the apply() method to convert a row to a list with a one-liner code sequence.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = df.apply(lambda row: row.tolist(), axis=1)[0]
print(row_as_list)

Output: [1, 3]

The lambda function lambda row: row.tolist() is applied across the rows of the DataFrame (specifying axis=1) which converts each row to a list. We then select the first element of the result array to get the first row as a list.

Summary/Discussion

  • Method 1: iloc with values and tolist(). Straightforward and easy to understand. However, relies on integer-based indexing.
  • Method 2: loc with label index. Useful when you have labeled indices. It’s similar to Method 1 but slightly less efficient if labels are not needed.
  • Method 3: Use of list comprehension. Pythonic and efficient. Might be less readable to those unfamiliar with list comprehensions.
  • Method 4: iloc with to_numpy(). More explicit than using values. Suitable for when you are already working with numpy arrays.
  • Bonus Method 5: Lambda with apply(). Extremely concise, but may be slower for large DataFrames and could be considered “less readable” due to its compactness.
import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]}, index=['row1', 'row2'])
row_as_list = df.loc['row1'].values.tolist()
print(row_as_list)

Output: [1, 3]

This snippet specifies an index (‘row1’, ‘row2’) for the DataFrame. Using loc['row1'], the row labeled ‘row1’ is selected, and similar to Method 1, values and tolist() methods convert the row to a list.

Method 3: Using iloc with list comprehension

This method employs Python’s list comprehension to iterate over a row’s values, accessed through iloc[], and convert each value to a list element explicitly.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = [value for value in df.iloc[0]]
print(row_as_list)

Output: [1, 3]

The usage of list comprehension provides a Pythonic and often faster way to iterate over row data and construct the list manually. The expression [value for value in df.iloc[0]] does precisely this for the first row of our DataFrame.

Method 4: Using iloc and to_numpy()

Another method is to use iloc[] to select the row and to_numpy() to convert it into a numpy array, then casting the array to a list with the standard Python list() constructor.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = list(df.iloc[0].to_numpy())
print(row_as_list)

Output: [1, 3]

This method prefers using to_numpy() directly instead of values, which can sometimes be clearer and is explicitly designed to convert pandas objects to Numpy arrays. After conversion, the list() constructor creates a list from the numpy array.

Bonus One-Liner Method 5: Using a Lambda Function

For those who like concise code, a lambda function can be used in combination with the apply() method to convert a row to a list with a one-liner code sequence.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = df.apply(lambda row: row.tolist(), axis=1)[0]
print(row_as_list)

Output: [1, 3]

The lambda function lambda row: row.tolist() is applied across the rows of the DataFrame (specifying axis=1) which converts each row to a list. We then select the first element of the result array to get the first row as a list.

Summary/Discussion

  • Method 1: iloc with values and tolist(). Straightforward and easy to understand. However, relies on integer-based indexing.
  • Method 2: loc with label index. Useful when you have labeled indices. It’s similar to Method 1 but slightly less efficient if labels are not needed.
  • Method 3: Use of list comprehension. Pythonic and efficient. Might be less readable to those unfamiliar with list comprehensions.
  • Method 4: iloc with to_numpy(). More explicit than using values. Suitable for when you are already working with numpy arrays.
  • Bonus Method 5: Lambda with apply(). Extremely concise, but may be slower for large DataFrames and could be considered “less readable” due to its compactness.
import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = df.iloc[0].values.tolist()
print(row_as_list)

Output: [1, 3]

This code snippet first imports the pandas library, then creates a simple DataFrame with two rows and two columns. The iloc[0] selects the first row, values converts it to a numpy array, and tolist() converts this array to a list, giving us the elements of the first row as a list.

Method 2: Using loc with a label index

When selecting rows by label index, loc[] comes in handy. Combined with values and tolist(), this method retrieves a row as a list based on the row’s index label.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]}, index=['row1', 'row2'])
row_as_list = df.loc['row1'].values.tolist()
print(row_as_list)

Output: [1, 3]

This snippet specifies an index (‘row1’, ‘row2’) for the DataFrame. Using loc['row1'], the row labeled ‘row1’ is selected, and similar to Method 1, values and tolist() methods convert the row to a list.

Method 3: Using iloc with list comprehension

This method employs Python’s list comprehension to iterate over a row’s values, accessed through iloc[], and convert each value to a list element explicitly.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = [value for value in df.iloc[0]]
print(row_as_list)

Output: [1, 3]

The usage of list comprehension provides a Pythonic and often faster way to iterate over row data and construct the list manually. The expression [value for value in df.iloc[0]] does precisely this for the first row of our DataFrame.

Method 4: Using iloc and to_numpy()

Another method is to use iloc[] to select the row and to_numpy() to convert it into a numpy array, then casting the array to a list with the standard Python list() constructor.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = list(df.iloc[0].to_numpy())
print(row_as_list)

Output: [1, 3]

This method prefers using to_numpy() directly instead of values, which can sometimes be clearer and is explicitly designed to convert pandas objects to Numpy arrays. After conversion, the list() constructor creates a list from the numpy array.

Bonus One-Liner Method 5: Using a Lambda Function

For those who like concise code, a lambda function can be used in combination with the apply() method to convert a row to a list with a one-liner code sequence.

Here’s an example:

import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
row_as_list = df.apply(lambda row: row.tolist(), axis=1)[0]
print(row_as_list)

Output: [1, 3]

The lambda function lambda row: row.tolist() is applied across the rows of the DataFrame (specifying axis=1) which converts each row to a list. We then select the first element of the result array to get the first row as a list.

Summary/Discussion

  • Method 1: iloc with values and tolist(). Straightforward and easy to understand. However, relies on integer-based indexing.
  • Method 2: loc with label index. Useful when you have labeled indices. It’s similar to Method 1 but slightly less efficient if labels are not needed.
  • Method 3: Use of list comprehension. Pythonic and efficient. Might be less readable to those unfamiliar with list comprehensions.
  • Method 4: iloc with to_numpy(). More explicit than using values. Suitable for when you are already working with numpy arrays.
  • Bonus Method 5: Lambda with apply(). Extremely concise, but may be slower for large DataFrames and could be considered “less readable” due to its compactness.