## How to Get the First N Rows in Pandas DataFrame

Pandas is a powerful data analysis library that provides a range of functionalities to manipulate data. One of the essential operations when working with data frames is selecting specific rows from a data frame.

In this article, we will focus on the different ways to extract the first N rows of a data frame and exclude the last N rows of a data frame.

### Using df.head() to Get the First N Rows

One of the simplest ways to extract the first N rows of a data frame is to use the “df.head()” method.

This method returns the first N rows of a data frame. For example, suppose we have a data frame that contains information about sales of different products.

We can use the following code to extract the first 5 rows of the data frame.

```
import pandas as pd
data = pd.read_csv('sales.csv')
first_5_rows = data.head(5)
```

The “head()” method takes an integer argument which indicates the number of rows to return. In this case, we passed 5, which means we want to return the first five rows of the data frame.

### Using Negative Number in df.head() to Get All Rows Excluding Last N Rows

Sometimes, we may need to extract all the rows from a data frame, except for the last N rows. In this case, we can make use of negative numbers in the “head()” method.

For instance, suppose we have a data frame that contains sales data for 12 months. We can use the following code to extract all the rows except the last three rows.

```
last_3_months_excluded = data.head(-3)
```

In this code, we passed “-3” as an argument to the “head()” method, which indicates that we want to exclude the last three rows of the data frame.

### Complete Example to Get the First N Rows

Now let’s look at a complete example of how to create a data frame and extract the first N rows. For this example, let’s create a data frame that contains information about fruit sales.

#### Creating a DataFrame

```
import pandas as pd
data = {'Fruit': ['Apple', 'Orange', 'Banana', 'Mango', 'Pineapple', 'Strawberry', 'Kiwi'],
'Sales': [100, 200, 150, 300, 400, 250, 350]}
df = pd.DataFrame(data)
```

The above code creates a data frame with two columns, “Fruit” and “Sales.” The “Fruit” column contains the names of fruits, and the “Sales” column contains the corresponding sales figures.

#### Getting the First N Rows and Excluding Last N Rows

Now that we have created the data frame, let’s extract the first three rows and exclude the last two rows using the “head()” method.

```
first_3_rows = df.head(3)
last_2_rows_excluded = df.head(-2)
```

The “first_3_rows” variable will contain the first three rows of the data frame, while the “last_2_rows_excluded” variable will contain all the rows except the last two rows.

## Conclusion

In conclusion, extracting specific rows from a data frame is an essential operation in data analysis. In this article, we discussed two ways to extract the first N rows and exclude the last N rows of a data frame using the “head()” method in Pandas.

By understanding these techniques, you can manipulate data frames effectively and extract the information you need for your analysis.

## Getting the First N Rows in Pandas DataFrame – A Step-by-Step Guide

Pandas is a Python library used for data manipulation and analysis, and it provides many useful methods for extracting and manipulating data. This article covers a step-by-step guide on how to get the first N rows in a pandas DataFrame.

We will also cover a technique to get all the rows except the last N rows.

### Step 1: Creating DataFrame

The first step in getting the first N rows in pandas DataFrame is to create a DataFrame.

This can be done in many ways, but the most common way is to read data from a file like CSV or Excel. For this example, we will create a DataFrame manually.

In this DataFrame, we will store information about different cars, such as make, model, year, and price.

```
import pandas as pd
data = {'Make': ['Toyota', 'Ford', 'Chevrolet', 'Honda', 'Nissan'],
'Model': ['Camry', 'F-150', 'Silverado', 'Civic', 'Altima'],
'Year': [2018, 2017, 2015, 2019, 2016],
'Price': [22000, 28000, 25000, 19000, 21000]}
df = pd.DataFrame(data)
```

The above code creates a DataFrame called “df” with four columns: “Make,” “Model,” “Year,” and “Price.”

### Step 2: Getting the First N Rows

The second step is to get the first N rows in the DataFrame. In pandas, this can be done using the “head()” method.

Let’s say we want to get the first three rows of the car DataFrame. We can do this by calling the “head()” method with an argument of 3, like this:

```
first_three_rows = df.head(3)
```

The “head()” method returns the first N rows of the DataFrame, where N is the argument passed to the method.

In this case, it returns the first three rows of the car DataFrame to the variable “first_three_rows.”

### Step 3 (Optional): Getting All Rows Excluding Last N Rows

If we want to get all the rows in the DataFrame except for the last N rows, we can use the same “head()” method with a negative argument. Let’s say we want to exclude the last two rows of the car DataFrame.

We can do this by calling the “head()” method with an argument of -2.

```
exclude_last_two_rows = df.head(-2)
```

The “head()” method with a negative argument returns all the rows in the DataFrame except for the last N rows, where N is the absolute value of the negative argument passed to the method.

In this case, it returns all the rows except the last two rows to the variable “exclude_last_two_rows.”

### Complete Example

Let’s look at a complete example that demonstrates how to create a DataFrame, get the first four rows, and exclude the last four rows.

#### Creating DataFrame

```
import pandas as pd
data = {'City': ['New York', 'Los Angeles', 'Chicago', 'Houston', 'Phoenix', 'Philadelphia'],
'Population': [8398748, 3990456, 2705994, 2325502, 1660272, 1584064],
'State': ['NY', 'CA', 'IL', 'TX', 'AZ', 'PA']}
```df = pd.DataFrame(data)

```
```The above code creates a DataFrame with three columns: "City," "Population," and "State."

#### Getting First 4 Rows

Next, let's get the first four rows of the DataFrame using the "head()" method.

```
first_four_rows = df.head(4)
```

```
```This code will return the first four rows of the DataFrame to the variable "first_four_rows."

#### Getting All Rows Excluding Last 4 Rows

Finally, let's exclude the last four rows of the DataFrame using the "head()" method with a negative argument.

Copy
```
exclude_last_four_rows = df.head(-4)
```

This code will return all the rows in the DataFrame except for the last four rows to the variable "exclude_last_four_rows."

## Conclusion

In this article, we covered a step-by-step guide on how to get the first N rows in a pandas DataFrame. We also covered a technique to get all the rows in a DataFrame except for the last N rows.

These techniques can be very useful when working with large datasets and need to extract specific rows from them.

## Conclusion: Why Getting the First N Rows in a Pandas DataFrame is Important

In this article, we covered the different techniques to extract the first N rows of a Pandas DataFrame. We explained how to use the "df.head()" method to get the first N rows and how to exclude the last N rows by using a negative number in the "df.head()" method.

Additionally, we provided a step-by-step guide to demonstrate how to extract the first N rows of a DataFrame while also sharing the importance and usefulness of this technique.

### Summary of Steps to Get First N Rows

To summarize the steps to extract the first N rows of a Pandas DataFrame:

- Create a DataFrame
- Use the "df.head(N)" method to get the first N rows.
- For excluding the last N rows, pass "-N" as an argument to "df.head()" method.

Following these steps, you can easily retrieve the first N rows of the DataFrame and use it for further analysis.

### Importance and Usefulness of Getting First N Rows

Getting the first N rows is an essential part of data analysis. It allows us to explore our dataset and understand the structure and format of the data.

By extracting the first few rows, we can gain a quick summary of the entire dataset, which can help in selecting the relevant columns for analysis or identifying any missing or corrupted values. Also, when working with a massive dataset, extracting all the rows can be time-consuming and computationally expensive.

Extracting the first N rows is a quick and efficient way to get a glimpse of the data without loading the entire dataset into memory. Furthermore, when working with a large data set, extracting only a few rows, or the first N rows can improve the performance of our analysis.

This is because it reduces the size of the data set, which allows us to perform operations and computations more quickly. In conclusion, getting the first N rows is an essential operation when analyzing data using Pandas.

By following the steps outlined in this article, and understanding the importance and usefulness of this technique, you can extract the necessary information from your data set quickly and efficiently, and begin analyzing your data in no time. In this article, we covered different techniques and a step-by-step guide to extract the first N rows of a Pandas DataFrame.

We used the "df.head()" method to get the first N rows and showed how to exclude the last N rows by using a negative number in the "df.head()" method. Furthermore, we highlighted the importance and usefulness of getting the first N rows in data analysis, and how it can improve performance and help understand data structures.

We hope that this article provides you with a comprehensive understanding of how to extract the necessary rows in Pandas DataFrame, and highlights the relevance and need for this process when performing effective data analysis.

` `

```
```