## Introduction to Ogive in Python

If you’re working with data values, an ogive is an important graph to have in your toolkit. An ogive, also known as a cumulative frequency graph, is used to display the cumulative frequency of a dataset.

This graph can help you to quickly and accurately understand the distribution of your data. In this article, we will introduce you to the definition and purpose of an ogive, and provide you with step-by-step instructions on how to create an ogive in Python.

We will also provide examples of how to create a simple dataset and view the first ten values of the dataset. 1.

## Definition and Purpose of an Ogive

An ogive is a graph that displays the cumulative frequency of a dataset. The cumulative frequency is the sum of the frequencies up to a certain point in the dataset.

The purpose of an ogive is to help you understand the distribution of your data. An ogive can help you answer questions like “how many data values are less than or equal to a certain value?” and “what is the percentage of data values that fall within a certain range?”

To create an ogive in Python, there are a few steps that you need to follow.

### 2. Steps to Create an Ogive in Python

#### Step 1: Create a Dataset

To create an ogive in Python, you first need to create a dataset.

You can create a dataset using the numpy library. Numpy provides a function called “randint” that generates random integers within a specified range.

To create a simple dataset, you can use the following code:

```
import numpy as np
dataset = np.random.randint(low=0, high=100, size=50)
```

This will create a dataset of 50 random integers between 0 and 100. Step 2: Sort the Dataset

Next, you need to sort the dataset in ascending order.

This is necessary for creating the ogive.

```
dataset = np.sort(dataset)
```

#### Step 3: Calculate the Cumulative Frequency

After sorting the dataset, you need to calculate the cumulative frequency.

You can do this using a loop that adds up all the frequencies from the beginning of the dataset up to each data value.

```
cumulative_frequency = []
cumulative_sum = 0
for freq in dataset:
cumulative_sum += freq
cumulative_frequency.append(cumulative_sum)
```

#### Step 4: Create the Ogive

Now that you have the cumulative frequency, you can plot the ogive using the matplotlib library.

```
import matplotlib.pyplot as plt
plt.plot(dataset, cumulative_frequency)
plt.title("Ogive of Dataset")
plt.ylabel("Cumulative Frequency")
plt.xlabel("Data Values")
plt.show()
```

This will create a graph that displays the cumulative frequency of the dataset. 3.

## Creating a Dataset

To create a simple dataset, you can use the numpy library. The “randint” function generates random integers within a specified range.

Here’s an example:

```
import numpy as np
dataset = np.random.randint(low=0, high=100, size=50)
```

This will create a dataset of 50 random integers between 0 and 100. To view the first ten values of the dataset, you can use the following code:

```
print(dataset[:10])
```

This will print the first ten values of the dataset.

## Conclusion

In this article, we introduced you to the definition and purpose of an ogive, and provided you with step-by-step instructions on how to create an ogive in Python. We also provided examples of how to create a simple dataset and view the first ten values of the dataset.

By following these instructions, you will be able to create an ogive that will help you to understand the distribution of your data. With this information, you can make informed decisions about how to analyze your data and communicate your findings to others.

### 3. Creating an Ogive

Creating an ogive using Python is a simple process that involves using the numpy and matplotlib libraries.

Numpy is used to create a dataset and matplotlib is used to plot the ogive. In this section, we’ll explore how to create an ogive using numpy and matplotlib.

#### 3.1 How to create an ogive using numpy and matplotlib

First, we need to create a dataset. We can do this using the numpy library’s “histogram” function.

This function generates histogram values which can be used to create the ogive graph. The code to create a dataset of 50 random integers between 1 and 100 is as follows:

```
import numpy as np
rng = np.random.default_rng()
dataset = rng.integers(1, 101, size=50)
```

With this dataset, we can now create the histogram values using the “histogram” function:

```
hist_vals, bin_edges = np.histogram(dataset, bins=20)
cumulative_sums = np.cumsum(hist_vals)
```

The “histogram” function takes the dataset and the number of bins as inputs. In this example, we’re using 20 bins.

The function returns two arrays: the histogram values and the bin edges. We then use the “cumsum” function to calculate the cumulative sums of the histogram values.

#### Then we can create the ogive plot using matplotlib:

```
import matplotlib.pyplot as plt
plt.plot(bin_edges[1:], cumulative_sums, label='cumulative sums')
plt.title('Cumulative Frequency Graph')
plt.xlabel('Data')
plt.ylabel('Cumulative Frequency')
plt.legend()
plt.show()
```

This script creates the ogive graph. The bin edges array has one more element than the histogram values which is why we use “bin_edges[1:]” to slice the first element off, as it is just the lower bound of the first bin.

#### 3.2 Example of creating an ogive with 10 bins

Using the same dataset as before but with 10 bins, the script would be:

```
import numpy as np
import matplotlib.pyplot as plt
rng = np.random.default_rng()
dataset = rng.integers(1, 101, size=50)
hist_vals, bin_edges = np.histogram(dataset, bins=10)
cumulative_sums = np.cumsum(hist_vals)
plt.plot(bin_edges[1:], cumulative_sums, label='cumulative sums')
plt.title('Cumulative Frequency Graph')
plt.xlabel('Data')
plt.ylabel('Cumulative Frequency')
plt.legend()
plt.show()
```

The output would be a graph with 10 bins, displaying the cumulative frequency of the dataset. 3.3 Example of creating an ogive with 30 bins

Similarly, we can change the number of bins to 30 by modifying the “bins” parameter to 30 in the histogram function:

```
import numpy as np
import matplotlib.pyplot as plt
rng = np.random.default_rng()
dataset = rng.integers(1, 101, size=50)
hist_vals, bin_edges = np.histogram(dataset, bins=30)
cumulative_sums = np.cumsum(hist_vals)
plt.plot(bin_edges[1:], cumulative_sums, label='cumulative sums')
plt.title('Cumulative Frequency Graph')
plt.xlabel('Data')
plt.ylabel('Cumulative Frequency')
plt.legend()
plt.show()
```

This will output a graph with 30 bins, displaying the cumulative frequency of the dataset. 4.

## Customizing the Ogive Chart

The aesthetics of the ogive chart can be customized using the options available in the matplotlib library. The previous examples only use the basic options of the library but there are plenty of customization options available.

#### 4.1 How to change the aesthetics of the chart

We can change, among other things, the color, linewidth, and linestyle of the graph’s lines and also add grid lines. Here’s an example, using the same dataset as before:

```
import numpy as np
import matplotlib.pyplot as plt
rng = np.random.default_rng()
dataset = rng.integers(1, 101, size=50)
hist_vals, bin_edges = np.histogram(dataset, bins=20)
cumulative_sums = np.cumsum(hist_vals)
plt.plot(bin_edges[1:], cumulative_sums, label='cumulative sums', color='orange',
linewidth=1.5, linestyle='--')
plt.title('Cumulative Frequency Graph')
plt.xlabel('Data')
plt.ylabel('Cumulative Frequency')
plt.legend()
plt.grid(True)
plt.show()
```

This script creates an ogive graph with the color orange for the lines. The line width is set to 1.5 and the line style is set to “–“.

Grid lines are also added to the graph.

Using these customization options, we can create a unique and visually appealing ogive graph that delivers the data’s information clearly and concisely.

In conclusion, creating an ogive using Python is a straightforward process that involves using the numpy and matplotlib libraries. By creating a dataset and finding the cumulative sums, we can easily plot the cumulative frequency graph.

Additionally, with the wide range of customization options that matplotlib provides, we can adjust and personalize the aesthetics of the chart to suit our needs. In this article, we explored the creation of an ogive using Python, which is a simple process that involves using the numpy and matplotlib libraries.

We discussed the importance of the ogive and how it can be used to understand the distribution of the dataset. We also provided step-by-step instructions on how to create an ogive with customization options to suit our needs.

By following these instructions, we can create a unique and visually appealing ogive graph that delivers the data’s information clearly and concisely. In conclusion, understanding how to create and customize an ogive is an essential skill for data analysts, and with Python’s libraries, it has become an easy and accessible task.