## Getting Head and Tail of a Pandas DataFrame or Series

If you are involved in data analysis and work with large datasets, chances are that you are using the Pandas library in Python. Pandas provides a powerful and efficient way to manipulate and analyze data, and it is one of the most widely used libraries for data analysis in Python.

## Importance of getting head and tail

Before we dive into how to get the head and tail of a Pandas DataFrame or Series, let’s explore why this operation is important. When you are working with a new dataset, the first step is to understand the structure of the data.

You need to determine how many rows and columns the dataset has, what the column names are, and what the data in each column represents. The head and tail of a dataset provide a quick and easy way to get this information.

By looking at the first few rows of a dataset, you can get a sense of what the data looks like and how it is structured. You can see what the column names are and what kind of data is in each column.

Similarly, by looking at the last few rows of a dataset, you can see if there are any patterns or trends in the data, such as missing values or outliers.

## Creating a sample pandas DataFrame object

To demonstrate how to get the head and tail of a Pandas DataFrame, let’s start by creating a sample dataset. We can use the Pandas library to create a DataFrame object.

Here’s an example:

```
import pandas as pd
data = {'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Emily'],
'Age': [25, 32, 18, 47, 22],
'Gender': ['Female', 'Male', 'Male', 'Male', 'Female']}
df = pd.DataFrame(data)
```

This creates a DataFrame object with three columns: Name, Age, and Gender. Each column contains data for five individuals.

### Using pandas.DataFrame.head() to get the first N rows of a pandas DataFrame

Now that we have created our sample dataset, let’s explore how to get the head of a Pandas DataFrame. To get the first five rows of a DataFrame, we can use the pandas.DataFrame.head() method.

Here’s an example:

```
print(df.head())
```

### This will print the first five rows of the DataFrame:

```
Name Age Gender
0 Alice 25 Female
1 Bob 32 Male
2 Charlie 18 Male
3 David 47 Male
4 Emily 22 Female
```

The pandas.DataFrame.head() method takes an optional argument, n, which specifies the number of rows to return. For example, if we want to return the first three rows of the DataFrame, we can use the following:

```
print(df.head(3))
```

### This will print:

```
Name Age Gender
0 Alice 25 Female
1 Bob 32 Male
2 Charlie 18 Male
```

### Using pandas.DataFrame.tail() to get the last N rows of a pandas DataFrame

Similarly, we can use the pandas.DataFrame.tail() method to get the last few rows of a Pandas DataFrame. Here’s an example:

```
print(df.tail())
```

### This will print the last five rows of the DataFrame:

```
Name Age Gender
0 Alice 25 Female
1 Bob 32 Male
2 Charlie 18 Male
3 David 47 Male
4 Emily 22 Female
```

The pandas.DataFrame.tail() method also takes an optional argument, n, which specifies the number of rows to return. For example, if we want to return the last three rows of the DataFrame, we can use the following:

```
print(df.tail(3))
```

### This will print:

```
Name Age Gender
2 Charlie 18 Male
3 David 47 Male
4 Emily 22 Female
```

### Using pd.option_context() to display both head and tail of a pandas DataFrame

If you want to display both the head and tail of a Pandas DataFrame, you can use the pd.option_context() method. This method allows you to temporarily modify the options of a Pandas DataFrame or Series.

Here’s an example:

```
with pd.option_context('display.max_rows', None, 'display.max_columns', None):
print(df)
```

This will print the entire DataFrame. The pd.option_context() method sets the maximum number of rows and columns to display to None, which means that all rows and columns will be displayed.

## Getting Head and Tail of a Pandas Series

In addition to Pandas DataFrame, we can also get the head and tail of a Pandas Series. A Pandas Series is a one-dimensional array-like object that can hold any data type, including integers, floats, and strings.

### Creating a sample pandas Series object

To create a sample Pandas Series, we can use the Pandas library. Here’s an example:

```
import pandas as pd
data = [1, 2, 3, 4, 5]
s = pd.Series(data)
```

This creates a Pandas Series object containing the values 1, 2, 3, 4, and 5. Using pandas.Series.head() to get the first N values of a pandas Series

To get the first few values of a Pandas Series, we can use the pandas.Series.head() method.

Here’s an example:

```
print(s.head())
```

### This will print the first five values of the Series:

```
0 1
1 2
2 3
3 4
4 5
dtype: int64
```

The pandas.Series.head() method takes an optional argument, n, which specifies the number of values to return. For example, if we want to return the first three values of the Series, we can use the following:

```
print(s.head(3))
```

### This will print:

```
0 1
1 2
2 3
dtype: int64
```

### Using pandas.Series.tail() to get the last N values of a pandas Series

Similarly, we can use the pandas.Series.tail() method to get the last few values of a Pandas Series. Here’s an example:

```
print(s.tail())
```

### This will print the last five values of the Series:

```
0 1
1 2
2 3
3 4
4 5
dtype: int64
```

The pandas.Series.tail() method also takes an optional argument, n, which specifies the number of values to return. For example, if we want to return the last three values of the Series, we can use the following:

```
print(s.tail(3))
```

### This will print:

```
2 3
3 4
4 5
dtype: int64
```

## Conclusion

In this article, we explored how to get the head and tail of a Pandas DataFrame or Series. The head and tail of a dataset provide a quick and easy way to get a sense of the structure and content of the data.

By using the pandas.DataFrame.head() and pandas.DataFrame.tail() methods, we can get the first and last few rows of a Pandas DataFrame. Similarly, by using the pandas.Series.head() and pandas.Series.tail() methods, we can get the first and last few values of a Pandas Series.

By mastering these techniques, you can quickly understand and analyze large datasets with Pandas.

## Using the Head and Tail of a Pandas DataFrame

As we discussed earlier, the head and tail of a Pandas DataFrame provide a quick way to understand the structure and content of a dataset. Let’s take a closer look at these two methods and their various options.

The pandas.DataFrame.head() method returns the first N rows of a DataFrame, with N being 5 by default. This can be changed by passing the desired number of rows as an argument to the method.

For example, to return the first 10 rows of a DataFrame, you can use the following code:

```
df.head(10)
```

The pandas.DataFrame.tail() method returns the last N rows of a DataFrame, with N being 5 by default. This can also be changed by passing a different number of rows as an argument.

For example, to return the last 10 rows of a DataFrame, you can use the following code:

```
df.tail(10)
```

## The Head and Tail of a Pandas Series

Similar to a Pandas DataFrame, a Pandas Series also has its own head() and tail() methods. These methods operate in the same way as their DataFrame counterparts.

The pandas.Series.head() method returns the first N values of a Series, and the default value of N is 5. The number of rows can be changed by passing the desired number of values as an argument to the method.

For example, to return the first 10 values of a Series, you can use the following code:

```
s.head(10)
```

The pandas.Series.tail() method returns the last N values of a Series, and the default value of N is also 5. Again, the number of values can be changed by passing a different value as an argument.

For example, to return the last 10 values of a Series, you can use the following code:

```
s.tail(10)
```

### Using pd.option_context()

Earlier, we showed how to use the pd.option_context() method to display both the head and tail of a Pandas DataFrame. This can be useful when you want to get a full picture of the dataset you are working with.

However, it’s important to keep in mind that this method can be quite memory-intensive, especially for large datasets.

To use pd.option_context() with the DataFrame in question, we used the following code:

```
with pd.option_context('display.max_rows', None, 'display.max_columns', None):
print(df)
```

In this code, we set the maximum number of rows and columns to be displayed to None.

This means that all rows and columns in the DataFrame will be displayed in the console output. However, this can be memory-intensive for larger datasets, so it’s important to use this method judiciously.

## Conclusion

In conclusion, the head and tail of a Pandas DataFrame or Series are useful tools for quickly understanding the structure and content of a dataset. We explored how to use the pandas.DataFrame.head() and pandas.DataFrame.tail() methods to get the first and last few rows of a DataFrame, as well as the pandas.Series.head() and pandas.Series.tail() methods to get the first and last few values of a Series.

We also showed how to use the pd.option_context() method to display both the head and tail of a Pandas DataFrame at the same time. With these techniques in your toolkit, you can more easily explore and analyze large datasets with Pandas.

In this article, we discussed the importance of getting the head and tail of a Pandas DataFrame or a Pandas Series. By using the pandas.DataFrame.head() and pandas.DataFrame.tail() methods, we can quickly understand the structure and content of a dataset.

Similarly, using the pandas.Series.head() and pandas.Series.tail() methods, we can get the first and last few values of a Pandas Series. We also explored how to use the pd.option_context() method to display both the head and tail of a Pandas DataFrame at the same time.

With these techniques, we can more easily explore and analyze large datasets with Pandas, making them powerful tools for data analysis.