## Understanding the Normal Distribution and Modifying Plots

Data visualization has become an essential part of data analysis, and Python has emerged as a popular programming language for data visualization. Python offers versatility in data visualization and enables us to create beautiful and informative plots with ease.

In this article, we will explore how to plot a single normal distribution using Python syntax and learn how to modify plot parameters such as line color and width.

### Understanding the Normal Distribution

The normal distribution, also known as the Gaussian distribution, is a probability distribution that is widely used in statistics to model continuous data. Many natural phenomena, such as the heights of people, are normally distributed.

The normal distribution has a bell-shaped curve, with a peak at the average value, or mean, of the data. The standard deviation, which represents the spread of the data around the mean, determines the width of the curve.

The properties of the normal distribution make it an important distribution in statistics and data analysis.

### Plotting a Single Normal Distribution

To plot a single normal distribution in Python, we need to use the NumPy library. NumPy is a powerful library for scientific computing in Python, and it provides various functions for generating random numbers and creating arrays for data manipulation.

To plot a single normal distribution with mean 0 and standard deviation 1, we can use the following code snippet:

```
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(-5, 5, 100)
y = 1/(np.sqrt(2*np.pi)*1)*np.exp(-0.5*(x-0)**2/1**2)
plt.plot(x, y)
plt.xlabel('x')
plt.ylabel('Probability density')
plt.title('Normal Distribution')
plt.show()
```

In the code above, we first import the necessary libraries, Matplotlib and NumPy. We then create an array `x` using the `linspace` function from NumPy, which generates 100 evenly spaced points between -5 and 5. We use the formula for the normal distribution to compute the values of y for each value of x.

We plot the curve using `plt.plot(x, y)`, set the labels for the x and y axes using `plt.xlabel` and `plt.ylabel`, respectively, and give the plot a title using `plt.title`. Finally, we use `plt.show` to display the plot.

### Modifying Plots

Matplotlib provides various functions to modify the style, colors, and parameters of the plot to customize the appearance of the plot. In the example above, we plotted a normal distribution with the default parameters.

However, we can change the color and width of the line to make our plot more visually appealing.

#### Changing the Color and Width of the Line

To change the color and width of the line, we can use the `color` and `linewidth` parameters in the `plot` function. The `color` parameter accepts various color names or codes, such as `red`, `blue`, `green`, or hex codes like `#FF5733`.

The `linewidth` parameter accepts a numeric value to set the width of the line in points. Here is an example code snippet that changes the line color to red and the line width to 2:

```
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(-5, 5, 100)
y = 1/(np.sqrt(2*np.pi)*1)*np.exp(-0.5*(x-0)**2/1**2)
plt.plot(x, y, color='red', linewidth=2)
plt.xlabel('x')
plt.ylabel('Probability density')
plt.title('Normal Distribution')
plt.show()
```

In the code above, we pass `color=’red’` and `linewidth=2` as arguments to the `plot` function to change the color and width of the line. We can experiment with different values for these parameters to find an aesthetic that suits our preferences.

#### Example of Modifying a Normal Distribution Plot

Let’s look at another example of modifying a normal distribution plot by changing the background color. In the code below, we use the `subplots` function to create a figure with a dark-gray background and a light-blue line color:

```
import matplotlib.pyplot as plt
import numpy as np
fig, ax = plt.subplots(facecolor='#292929')
x = np.linspace(-5, 5, 100)
y = 1/(np.sqrt(2*np.pi)*1)*np.exp(-0.5*(x-0)**2/1**2)
ax.plot(x, y, color='#008B8B', linewidth=2)
ax.set_facecolor('#292929')
ax.set_xlabel('x')
ax.set_ylabel('Probability density')
ax.set_title('Normal Distribution')
plt.show()
```

In this example, we use `subplots` to create a figure and axes object with a dark-gray background color specified by `facecolor=’#292929’`. We then use `ax.plot` to plot the normal distribution curve with a line color set to light-blue (`color=’#008B8B’`) and the width of the line set to 2 using `linewidth`.

We set the same background color to the axis object by using `ax.set_facecolor(‘#292929’)`. Finally, we set the labels and a title using `ax.set_xlabel`, `ax.set_ylabel`, and `ax.set_title`.

## Conclusion

In summary, Python provides powerful libraries such as NumPy and Matplotlib that make it easy to create beautiful and informative plots. We’ve discussed how to plot a single normal distribution with mean 0 and standard deviation 1 and learned how to modify plot parameters such as line color and width.

Experimenting with different styles and parameters allows us to create personalized visualizations that are both informative and visually appealing.

## Plotting Data in Python: Understanding and Customizing Normal Distribution Plots

In the world of data visualization, Python has become a popular language for creating and customizing plots.

In this article, we’ll dive deeper into normal distribution plots, exploring how to define multiple normal distributions and customize plots to better suit our needs.

### Syntax for Defining Multiple Normal Distributions

In many data analysis projects, we may want to plot multiple normal distribution curves on the same plot. To do so, we can define the parameters for multiple curves, and plot each curve individually using different colors and labels.

To define multiple curves, we can use NumPy’s `mean` and `std` functions to generate arrays of normal distribution parameters. Here’s an example code snippet:

```
import matplotlib.pyplot as plt
import numpy as np
mu_1, sigma_1 = 0, 1
mu_2, sigma_2 = 2, 0.5
x = np.linspace(-5,5,100)
y1 = 1/(sigma_1*np.sqrt(2*np.pi)) * np.exp(-0.5*((x-mu_1)/sigma_1)**2)
y2 = 1/(sigma_2*np.sqrt(2*np.pi)) * np.exp(-0.5*((x-mu_2)/sigma_2)**2)
plt.plot(x, y1, label="Curve 1")
plt.plot(x, y2, label="Curve 2")
plt.legend()
plt.show()
```

In this code, we define two normal distributions with mean `mu_1` and `mu_2`, and standard deviations `sigma_1` and `sigma_2`, respectively. We then generate an array of x- values using `np.linspace`, and compute the corresponding y-values for each distribution using the normal distribution formula.

We plot each curve using `plt.plot`, specifying a label for each curve.

### Plotting Multiple Normal Distributions with Different Means and Standard Deviations

To create normal distribution curves with different means and standard deviations, we simply modify the parameters. In the example above, `mu_1` and `sigma_1` correspond to the first curve, and `mu_2` and `sigma_2` correspond to the second curve.

We can create as many curves as we’d like by defining additional `mu` and `sigma` values, and computing the corresponding y-values.

### Adding a Legend to a Plot

In our example, we specified a label for each curve using the `label` parameter in the `plt.plot` function. To add this information to the plot, we use the `plt.legend()` function.

This function automatically extracts the labels from each curve and adds them to the plot. If no label parameter is specified, the curve will not appear in the legend.

### Modifying Colors, Titles, and Axis Labels

Now that we’ve learned how to plot multiple normal distribution curves on the same chart, let’s look at how to customize plots to better convey information.

#### Modifying the Colors of Lines in a Plot

In the example above, we plotted two curves using the default colors. However, we may want to change the colors to better distinguish between the curves.

To do so, we simply add the `color` parameter to the `plt.plot` function. The `color` parameter accepts various color names or codes.

Here’s the modified code snippet with different line colors:

```
import matplotlib.pyplot as plt
import numpy as np
mu_1, sigma_1 = 0, 1
mu_2, sigma_2 = 2, 0.5
x = np.linspace(-5,5,100)
y1 = 1/(sigma_1*np.sqrt(2*np.pi)) * np.exp(-0.5*((x-mu_1)/sigma_1)**2)
y2 = 1/(sigma_2*np.sqrt(2*np.pi)) * np.exp(-0.5*((x-mu_2)/sigma_2)**2)
plt.plot(x, y1, color='red', label="Curve 1")
plt.plot(x, y2, color='blue', label="Curve 2")
plt.legend()
plt.show()
```

This code will plot the first curve in red and the second in blue. You can experiment with different colors to find an aesthetic that best suits your needs.

#### Adding a Title and Axes Labels to a Plot

To add a title to the plot, we use the `plt.title` function. Similarly, we can add labels to the x and y axes using the `plt.xlabel` and `plt.ylabel` functions, respectively.

Here’s the modified code snippet with added title and axis labels:

```
import matplotlib.pyplot as plt
import numpy as np
mu_1, sigma_1 = 0, 1
mu_2, sigma_2 = 2, 0.5
x = np.linspace(-5,5,100)
y1 = 1/(sigma_1*np.sqrt(2*np.pi)) * np.exp(-0.5*((x-mu_1)/sigma_1)**2)
y2 = 1/(sigma_2*np.sqrt(2*np.pi)) * np.exp(-0.5*((x-mu_2)/sigma_2)**2)
plt.plot(x, y1, color='red', label="Curve 1")
plt.plot(x, y2, color='blue', label="Curve 2")
plt.legend()
plt.xlabel('X')
plt.ylabel('Probability Density')
plt.title('Normal Distributions with Different Means and Standard Deviations')
plt.show()
```

This code will now display a title and axis labels that better describe the plot and help convey information to the viewer.

#### Full Example of Customizing a Normal Distribution Plot

Let’s take a look at an example that incorporates customizations based on the techniques we’ve covered. Here’s a code snippet that customizes a normal distribution plot with multiple normal distribution curves:

```
import matplotlib.pyplot as plt
import numpy as np
# Generating data for Normal Distributions:
x = np.linspace(-5,5,100)
y1 = 1/(np.sqrt(2*np.pi)*1) * np.exp(-0.5*(x)**2/1**2)
y2 = 1/(np.sqrt(2*np.pi)*1.5) * np.exp(-0.5*(x-2)**2/1.5**2)
y3 = 1/(np.sqrt(2*np.pi)*0.7) * np.exp(-0.5*(x+2)**2/0.7**2)
# Plotting Normal Distributions:
plt.plot(x, y1, '-.r', label="Curve 1")
plt.plot(x, y2, '-b', label="Curve 2")
plt.plot(x, y3, ':g', label="Curve 3")
plt.legend()
# Customizing Plot:
plt.xlabel('X')
plt.ylabel('Probability Density')
plt.title('Customized Normal Distributions Plot')
plt.grid(color='gray', linestyle='-', linewidth=0.5)
plt.show()
```

In this example, we plotted three normal distribution curves using different line styles and colors. We then added a legend to better describe each of the curves.

To customize the plot, we added a grid to the background with a gray color, increased the line width to make the curves more visible, and changed the title of the plot.

## Conclusion

In this article, we covered some techniques for defining multiple normal distribution curves and customizing normal distribution plots using Python and Matplotlib. By adding colors, titles, axis labels, and other customizations, we can make our plots more informative and visually appealing.

Whether you’re a data analyst looking to create coherent visualizations for your reports, or just a Python enthusiast looking to explore the nuances of data visualization, we hope this article provides a valuable resource for developing your skills.

This article covered the fundamentals of plotting normal distribution curves using Python and Matplotlib. We discussed how to define multiple curves using NumPy and how to plot them on the same chart with different colors and labels. Additionally, we explored how to customize plots by adding titles, axis labels, and grid lines.

By mastering the techniques outlined in this article, data analysts and Python enthusiasts alike can create informative and visually appealing plots, helping to convey important information in a clear and concise manner. Overall, the ability to customize and visualize data through these techniques is increasingly important in many fields and is a valuable skill to have.