Problem and Solution Overview

Problem: When presenting data, the color that you assign to a plot is very important; a bad color choice can make your data difficult to understand or even less interesting.

However, it is not easy to choose the right colors or the optimal color combinations for the cases in which we have to plot multiple functions at the same time.

Solution: A solution to this problem is to check the Matplotlib color palette and choose from there, the color that best fits your needs.

We’ll write a script for generating the Matplotlib color palette inside our script, just before plotting our graphs.

In this way, we will be able to check for the name of the color that is most suited for our needs and assign it to a second plot.

We write the code for generating the color palette as a function; to make it possible to call it every time we need to decide on a particular color to assign to the plots.

Code Overview

We’ll discuss the following code in this tutorial, in a simple to understand, step-by-step manner:

import matplotlib.pyplot as plt
from matplotlib import colors as mcolors
import numpy as np


def sel_color():

    colors = dict(mcolors.BASE_COLORS, **mcolors.CSS4_COLORS)
    
    # sort colors by hue, saturation and value
    by_hsv = []
    for name, color in colors.items():
        t = tuple(mcolors.rgb_to_hsv(mcolors.to_rgba(color)[:3]))
        by_hsv.append((t, name))
    by_hsv.sort()
    sorted_names = [name for hsv, name in by_hsv]

    n = len(sorted_names)
    ncols = 4
    nrows = n // ncols
    
    # Create the matplotlib window
    fig, ax = plt.subplots()
    
    # Get height and width of the figure
    X, Y = fig.get_dpi() * fig.get_size_inches()
    
    # height of a cell
    h = Y / (nrows + 1)
    
    # width of a cell
    w = X / ncols
    
    # using an index for accessing all the color names
    k = 0
    
    # inserting the colors in the palette by column
    for i in range(ncols):
        for j in range(nrows, 0, -1):
            
            # current row
            row = j * h
            
            # current column
            col = i
            
            # height level for the colors' labels
            y = row
            
            # position of the initial corner of the color box
            xi = w * (col + 0.05)
            
            # position of the final corner of the color box
            xf = w * (col + 0.25)
            
            # initial position of the labels
            xi_text = w * (col + 0.3)

            ax.text(xi_text, y, sorted_names[k], fontsize=(h * 0.8),
                    horizontalalignment='left', verticalalignment='center')

            ax.hlines(y, xi, xf, color=sorted_names[k], linewidth=(h * 0.8))
            k += 1

    ax.set_xlim(0, X)
    ax.set_ylim(0, Y)
    ax.set_axis_off()

    fig.subplots_adjust(left=0, right=1,
                        top=1, bottom=0,
                        hspace=0, wspace=0)
    plt.show()
    selected_c = str(input('Enter the name of the color for your graph: '))
    return selected_c


# x and y array to plot
x = np.linspace(0, 50, 100)
y = x**3 + 3*x - 5

# Plotting
current_c = sel_color()
fig = plt.figure()
ax = fig.subplots()
ax.plot(x, y, color=current_c)
plt.show()

If you run this code snippet, you’ll get the following output:

You can resize it accordingly to get a more pretty output using Python’s internal display window tool.

Let’s dive into the code!

Importing Libraries and Packages

For this example, we just need Matpotlib and Numpy.

In addition to .pyplot(), which is used for plotting, we also need the module colors that contains functions and classes for color specification and conversion. We then call it “mcolors”.

Link: You can find the full documentation here

Numpy is used just for generating two random arrays that will be then plotted, after choosing the color that we choose from the generated palette.

import matplotlib.pyplot as plt
from matplotlib import colors as mcolors
import numpy as np

Generating the Matplotlib Color Palette

As anticipated in the introduction, the aim of this section is to generate the Matplotlib color palette and display it in a Matplotlib window.

For those who are not familiar with the color palettes that can be used in Python, the following figure shows the Matplotlib color palette that we want to recreate in our script:

Defining the Function and Sorting the Colors by HSV Values

As anticipated in the introduction, we write this script as a portable function to generate the color palette. Portability means that you can reuse the same function in other scripts just by calling the function name!

We start by calling the function sel_col().

Within the body of the function, we create a dictionary that contains all the names of the colors (the basic ones and the CSS colors) and the tuple or the hexadecimal codes that univocally describe a particular color, as key:value pairs; we assign the dictionary to the variable colors.

def sel_color():
  colors = dict(mcolors.BASE_COLORS, **mcolors.CSS4_COLORS)

As you might see by printing the variable colors, the basic colors are defined by a tuple of three values while the other colors are represented by a hexadecimal code.

In order to adopt a uniform nomenclature for the description of each color, we will convert this representation first to an RGBA.

Info: RGBA is a possible way to describe a color with 4 numbers, the first three correspond to the amount of Red, Green, and Blue. The fourth one stands for intensity.

Next, we convert it to an hexadecimal.

The first step can be done by exploiting the function mcolors.to_rgba(), which takes as input the array containing all the tuples representing the different colors.

The second step instead, can be done with the function mcolors.rgb_to_hsv() that takes as input the tuples corresponding to the RGB description of the colors and converts it into HSV format, which stands for Hue, Saturation, and Value (or Brightness).

We select just the first three values since we do not want to apply any change to the intensity, which moreover, is not provided in the RGB color code.

We store each HSV combination of numbers into a tuple, together with the respective color name and then extend this procedure to all the colors listed in colors and hence generate a list of these tuples.

Since colors is a dictionary, to access both its keys and values we write: for name, color in colors.items() in this way the variables name and color refer to the dictionary keys and values, respectively.

To conclude, we sort the list by using the function list.sort(), passing as input the whole list and we store all of the HSV color tuples into the variable by_hsv.

The following code lines display all the aforementioned procedures.

    # sort colors by hue, saturation and value
    by_hsv = []
    for name, color in colors.items():
        t = tuple(mcolors.rgb_to_hsv(mcolors.to_rgba(color)[:3]))
        by_hsv.append((t, name))
    by_hsv.sort()

If we now print the variable by_hsv, we can see that all the colors have been sorted by their HSV values, from the lowest to the highest.

We finish this section by creating a list containing all the names of the colors. To do that, we exploit list comprehension and we store in the list sorted_names just the name of the colors present in the tuples of the by_hsv list.

  sorted_names = [name for hsv, name in by_hsv]

Creating the Color Palette Framework

At this point, we create the palette that will be displayed in the Matplotlib window.

We start by defining the number of rows and columns. As you can see from the previous figure, we want to have four columns; the number of rows is defined by the ratio between the total number of colors (equal to the length of the list sorted_names) and the number of columns.

  n = len(sorted_names)
  ncols = 4
  nrows = n // ncols

At this point we create the Matplotlib window, exploiting the Matplotlib function subplots().

  # Create the matplotlib window
  fig, ax = plt.subplots()

As you can see from Figure 1, the colors appear in a grid-like framework that uniformly occupies the window.

In order to do that, we have to extract the size of our window and thus define the size that each colored box and its respective label should occupy.

To obtain the height and the width of the figure, we combine together the methods .get_dpi() returning the resolution in dots per inch as a float number and .get_size_inches() returning the size of the figure in inches.

Resources: Documentation of those two methods can be found here and here.

By multiplying them together, we hence obtain the size of the figure in dots.

We assign the width and the height values to the variables X and Y.

After that, we calculate the height and width of each row and column (h and w, respectively) by dividing Y and X by the total number of rows and columns (note that for h, we divide Y by nrows +1 to obtain a little more space on the upper and lower corners of the window).

  X, Y = fig.get_dpi() * fig.get_size_inches()
  # height of a cell
  h = Y / (nrows + 1)
  # width of a cell
  w = X / ncols

Inserting the Colored Boxes in the Palette

Position and size of the colored boxes and labels

Now that we calculated the height and width of the cells of our palette, we can proceed further by inserting in each position the colored boxes and their respective names.

Before accessing the cells in which the figure is “divided” — actually, the figure is not divided into cells, it is just a way of thinking about that, each cell corresponds to a colored box plus its label — we define a parameter k for indexing the names of the colors in the sorted_names list.

  # using an index for accessing all the color names
  k = 0

At this point, we can access each position of the figure and create all the colored boxes.

In order to do that, we exploit two nested for loops that will allow us to insert each color in its position.

We start by first filling the first column, then we proceed with the second one, and so on till the fourth one.

The first for loop refers to the columns and will iterate throughout all of them. We specify this by setting the end value ncols equal to four.

On the other hand, the nested for loop is responsible for the rows. Since we want to start creating our boxes from the upper corner, this for loop has to iterate in the reversed order, so the first index will correspond to the last row (specified by the value nrows) and the final index will be 0, which identifies the row at the bottom of the figure.

Within this second for loop, we firstly define two parameters: row and col, which identify the row and the column we are currently working on, respectively.

As you can see, col is equal to the index of the outer for loop while row is defined by multiplying the height of a single cell, h, by the index of the inner for loop (which is iterating through all the rows).

The parameter row will be also responsible for the height level of the colors’ labels.

  # inserting the colors in the palette by column
  for i in range(ncols):
      for j in range(nrows, 0, -1):
          # current row
          row = j * h
          # current column
          col = i
          # height level for the colors' labels
          y = row

Now that we can access each position of the figure in the correct order, we start to create the colored boxes.

The first thing to do is to specify the size of the boxes, we do that by defining the initial and final horizontal coordinate of the boxes, we call them “xi” and “xf”, respectively.

As you can see in the code below, “xi” is defined by the cell width, multiplied by the current column position (“col”) to which we also add a small offset (0.05); for “xf”, the procedure is similar, its position has just a different offset, 0.25 instead of 0.05.

From this, you can clearly understand that the width of our boxes will be 0.20. The starting position of the labels, “xi_text” is defined in the same way, just with another offset, this time 0.3.

         # position of the initial line of the colored square
         xi = w * (col + 0.05)
         # position of the final line of the colored square
         xf = w * (col + 0.25) 
         # initial position of the text
         xi_text = w * (col + 0.3)

Once we defined the initial and final position of the edges of the boxes and of the text labels, we can finally create them.

To generate the labels, we exploit the function ax.text(), which generates some axes in which we can insert a text.

We have to specify, as input parameter, the horizontal and vertical position (“xi_text” and “y”, respectively), the label (sorted_names[k]).

We can also specify some other less important and optional parameters, like the font size and the position of the labels with respect to the initial coordinates.

Properties of the Colored Boxes and Their Labels

       ax.text(xi_text, y, sorted_names[k], fontsize=(h * 0.8),
               horizontalalignment='left', verticalalignment='center')

To create the boxes, we exploit the function ax.hlines(), which generates an horizontal line.

This time we first specify the vertical coordinate “y”, then the starting and ending point of the line, “xi” and “xf”, respectively; we also specify the color of the line by accessing the name of the colors (using “sorted_names[k]”) and the line width, which corresponds to the height of the box ( ̴ 80% of the cell height).

We end this for loop by incrementing the value of the index “k”; in this way, in the next iteration, we will change row and hence we will be addressing the next color name in the list “sorted_names”.

       ax.hlines(y, xi, xf,
                 color=sorted_names[k], linewidth=(h * 0.8))
       k += 1

We are almost done with our function sel_color(), we just conclude by specifying some details regarding the size of the axes in the Matplotlib window and by disabling their visibility.

We also adjust the position of the figure within the Matplotlib window.

In the end, we show the created palette and ask (by using a print statement) to select the name of a color in the palette. The function will return the typed color name, stored in the variable “selected_c”.

  ax.set_xlim(0, X)
  ax.set_ylim(0, Y)
  ax.set_axis_off()

  fig.subplots_adjust(left=0, right=1,
                      top=1, bottom=0,
                      hspace=0, wspace=0)
  plt.show()
  selected_c = str(input('Enter the name of the color for your graph: '))
  return selected_c

The palette will be shown as represented in Figure 2, which is very similar to the one we had in Figure 1.

Plotting a Graph with the Selected Color

After having completed the sel_color() function, we create two arrays “x” and “y” and we plot them in another Matplotlib window.

However, before doing that, we call the function sel_color() and assign its returning value (the name of the color that we selected and typed in the terminal, I typed “olivedrab” as an example) to the variable “current_c” which will be inserted as the value of the parameter color, within the ax.plot() function.

The ending result is shown in Figure 3, i.e., a plot that has the color that we chose after checking the just created color palette.

Conclusions

In this article, we defined a function for creating and displaying the Matplotlib color palette.

We first defined the size of the palette, its rows and columns.

Then we calculated the size of each cell and by accessing their position (exploiting two nested for loops) we created the colored boxes and their labels.

Finally, we entered in the terminal the name of the color that we selected and called the function in order to assign that specific color to the plot that we wanted to plot. 

The post Matplotlib Color Palette appeared first on Be on the Right Side of Change.

The method .subplots() can easily generate multiple subplots within the same plotting figure. But as you may have already noticed, all the subplots have the exact same size and moreover, their size will be adjusted automatically, depending on how many of them you want to display in the same figure.

Quick Solution Overview

To change the size of subplots in Matplotlib, use the plt.subplots() method with the figsize parameter (e.g., figsize=(8,6)) to specify one size for all subplots — unit in inches — and the gridspec_kw parameter (e.g., gridspec_kw={'width_ratios': [2, 1]}) to specify individual sizes.

Here’s a quick overview:

# Set one size for all subplots
fig, ax = plt.subplots(2, 2, figsize=(8,6))

# Set individual sizes for specific subplots
fig, ax = plt.subplots(1, 2, gridspec_kw={'width_ratios': [2, 1]})

In the next sections, you’ll learn how to change the size of each individual subplot. This is useful for tailoring the layout of your graphs and data presentations according to the relevance that you want to assign to each subplot.

Simple Example figsize Argument

In the following example, I’ll show you how to use the figsize argument of the plt.subplots() method to change the size of a subplot:

import matplotlib.pyplot as plt

# define subplots with subplot size
fig, ax = plt.subplots(2, 2, figsize=(8,6))

# define data
x = [0, 1, 2, 3, 4, 5]
y = [i**2 for i in x]

# create subplots
ax[0, 0].plot(x, y, color='black')
ax[0, 1].plot(x, y, color='green')
ax[1, 0].plot(x, y, color='red')
ax[1, 1].plot(x, y, color='blue')

# display the plot
plt.show()

Output:

Let’s change the figsize argument to a smaller tuple value:

• Original subplot: fig, ax = plt.subplots(2, 2, figsize=(8,6))
• Changed size: fig, ax = plt.subplots(2, 2, figsize=(3,12))

import matplotlib.pyplot as plt

# define subplots
fig, ax = plt.subplots(2, 2, figsize=(3,12))

# define data
x = [0, 1, 2, 3, 4, 5]
y = [i**2 for i in x]

# create subplots
ax[0, 0].plot(x, y, color='black')
ax[0, 1].plot(x, y, color='green')
ax[1, 0].plot(x, y, color='red')
ax[1, 1].plot(x, y, color='blue')

# display the plot
plt.show()

Output — this strange looking beast:

This is if you want to change the size of all subplots at once.

Simple Solution: Specifying Width Ratios Using subplots() gridspec_kw

The gridspec_kw parameter of the plt.subplot() function allows you to define a width relationship between individual subplots columns:

• plt.subplots(2, 2, gridspec_kw={'width_ratios': [2, 1]}) sets the first column to double the size of the second column.
• plt.subplots(2, 2, gridspec_kw={'width_ratios': [1, 2]}) sets the first column to half the size of the second column.

Here’s an example that draws from the previous code snippet:

import matplotlib.pyplot as plt

# define subplots
fig, ax = plt.subplots(2, 2, gridspec_kw={'width_ratios': [2, 1]})

# define data
x = [0, 1, 2, 3, 4, 5]
y = [i**2 for i in x]

# create subplots
ax[0, 0].plot(x, y, color='black')
ax[0, 1].plot(x, y, color='green')
ax[1, 0].plot(x, y, color='red')
ax[1, 1].plot(x, y, color='blue')

# display the plot
plt.show()

Output:

You can see how the second column of subplots has only half the size of the first column of subplots as controlled by the gridspec_kw parameter.

Advanced Considerations

The usual .subplots() method is really practical for creating multiple subplots but it is not able to access and change the size of these subplots.

On the other hand, the method .add_gridspec() results to be more time-consuming for just creating multiple subplots of the same size but, it constitutes a powerful solution when we want to change the size of individual subplots.

After subdividing the space in a grid-like fashion, you can use the method .add_subplot(), to change the size of each subplot by simply exploiting Python indexing and slicing.  

Slow Guide to Creating the Matplotlib Figure

In this example, we will only use the Matplotlib library for plotting the axes and for changing their size; for this reason, we will just import that specific package as shown before:

import matplotlib.pyplot as plt

We start our code by generating the plotting window, i.e. a figure, and then we will add some subplots to it.

If you are already familiar with the creation of multiple subplots, you can skip this section and go directly to the following one. If you instead do not know how to do that, or you simply forgot, it just takes a single code line.

The matplotlib function that is exploited for this aim is called .figure().

This time, we also enter a property called constrained_layout and we set it equal to True.

This property can be used to fit the plots within the figure cleanly, meaning that they will automatically be nicely distributed in your plotting window, independently of their number.

We finally assign the figure to the variable “fig”.

fig = plt.figure(constrained_layout=True)

.subplots() vs .add_gridspec()

At this point, we have to create multiple subplots that we will then modify.

One of the most widely used methods for doing that is  .subplots(), which generates an array of axes, depending on the numbers that we enter as input parameters.

Suppose we want to create 9 subplots; it is sufficient to type:

# Creating the subplots with .subplots() 
ax = fig.subplots(3,3)

These lines will yield 9 subplots, distributed in a 3×3 grid fashion, like the ones displayed in Figure 1.

Achieving the same result using the method .add_gridspec() is a lot more tedious and time-consuming.

Indeed, in this latter case, we have to initialize each subplot individually, specifying also the location in which we want it to be created.

More precisely, we have to enter the number of rows and columns of the grid, as input parameters of .add_gridspec() and then create each subplot, by using the method add_subplot() and specifying for each plot its coordinates on the ax grid.

The following code lines describe this procedure.

# Creating the subplots with .add_gridspec()
ax = fig.add_gridspec(3, 3)
ax1 = fig.add_subplot(ax[0, 0])
ax1.set_title('[0, 0]')
ax1 = fig.add_subplot(ax[0, 1])
ax1.set_title('[0, 1]')
ax1 = fig.add_subplot(ax[0, 2])
ax1.set_title('[0, 2]')
ax1 = fig.add_subplot(ax[1, 0])
ax1.set_title('[1, 0]')
ax1 = fig.add_subplot(ax[1, 1])
ax1.set_title('[1, 1]')
ax1 = fig.add_subplot(ax[1, 2])
ax1.set_title('[1, 2]')
ax1 = fig.add_subplot(ax[2, 0])
ax1.set_title('[2, 0]')
ax1 = fig.add_subplot(ax[2, 1])
ax1.set_title('[2, 1]')
ax1 = fig.add_subplot(ax[2, 2])
ax1.set_title('[2, 2]')

We also set a title for each plot, containing the coordinates of its respective location in the grid. The result is then displayed in Figure 2.

The huge advantage of using .add_gridspec() comes into play when we want to customize the size of each individual subplot. This task cannot be performed by .subplots() in any way.

For this reason, if you want to just create some subplots and you are not interested in changing their size, I would recommend using .subplots(), because it is more intuitive and faster.

On the other hand, if you are interested in changing the layout of the subplots that are displayed in the figure, go with .add_gridspec().

In the next section, we will see how to do that in detail.

Changing the Size of Each Subplot with .add_gridspec() and .add_subplot()

Changing the size of each subplot using .add_gridspec() is easier than you may think.

Once we have initialized a 3×3 grid by using .add_gridspec(3, 3), we can adjust the size and hence the number of the subplots simply by varying the input coordinates in the method .add_subplot().

The coordinates of the axis that we enter as input parameters in the .add_subplot() method indicate the initial and final position of the plot (for both rows and columns). It is hence sufficient to know how indexing and slicing work, for tuning the height and the width of each subplot.

As an example, we will now create a plot that is located in the first row and has a width of 2/3 of the entire grid.

Another one that is just one column wide but has a height that spans the entire grid and is placed in the last column.

Lastly, a third plot occupies a 2×2 grid in the remaining space (i.e. last two rows and first two columns). The following code lines describe the procedure for obtaining the aforementioned result.

ax = fig.add_gridspec(3, 3)
ax1 = fig.add_subplot(ax[0, 0:2])
ax1.set_title('[0, 0:2]')
ax1 = fig.add_subplot(ax[0:, -1])
ax1.set_title('[0:, -1]')
ax1 = fig.add_subplot(ax[1:, 0:2])
ax1.set_title('[1:, 0:2]')

The final result is displayed in Figure 3; the titles above each plot simply show the indexing/slicing that was given as input parameter in order to obtain that specific plot.

As you can see, we customized the size of the subplots by simply changing their initial and final coordinates; the only tricky part remembering how indexing and slicing work in Python.

Conclusions

In this example, we saw how to customize the size of individual subplots while keeping all of them plotted in the same figure.

While the method .subplots() is faster and easier for creating multiple subplots of the same size, the method .add_gridspec() is more tedious and time-consuming.

However, when it comes to changing the size of individual subplots, the first method is useless; on the other hand, it is in these situations that .add_gridspec() shows its power.

By subdividing the figure space in a grid-like fashion, it is possible to change the initial and final coordinates of a plot by just passing them as slicing parameters within the method .add_subplot().

In this way, it is sufficient to specify the coordinate at which we want a plot to start and the one at which we want it to end.   

Programmer Humor

The post Matplotlib – How to Change Subplot Sizes appeared first on Be on the Right Side of Change.

In this article, you will learn how to convert a Pandas DataFrame into a list and vice versa.

This operation can be useful whenever you just want to focus on a specific column of a DataFrame and you would like to have it as a simple list. Sometimes you might be interested in converting a list into a Pandas DataFrame, in order to exploit the numerous functions dedicated to DataFrames and easily access/edit their content. 

Long story short

Converting a DataFrame into a list represents a relatively easy and quick procedure.

• Exploiting Pandas in order to correctly access specific columns or DataFrame subsets we are interested in, it is then sufficient to use the function .values.tolist() in order to convert the selected elements into a list.
• The opposite function, which allows converting a list into a DataFrame is the Pandas function .DataFrame().

In the remaining article, we’ll go over this code snippet of different methods to convert a DataFrame to a list and back:

import pandas as pd


url = "my_table.csv"
doc = pd.read_csv(url, sep=',')
df = pd.DataFrame(doc)

# convert a column of the DF into a list
new_list = df[('State')].values.tolist()

# convert multiple columns of the DF into a list
new_list = df.loc[:, ('Year', 'State')].values.tolist()

# convert a row of DF into a list
new_list = df.loc[3].values.tolist()

# convert a list into a DF
new_df = pd.DataFrame(new_list)

This is how the first couple of lines of the sample data looks like:

Import and Read Data as a Pandas DataFrame

We start our script by importing Pandas, which allows using DataFrames and performing numerous operations with them.

After that, we read a set of data from a .csv file using the Pandas function .read_csv(), which accepts as only mandatory input parameter the path of the .csv file.

We also specify the type of separator that is used in the file by adding the optional parameter sep = ",".

After this step, we use the Pandas function .DataFrame() to convert the content of the .csv file into a Pandas DataFrame and we assign it to the variable df.

import pandas as pd

url = r"path of the .csv file"
doc = pd.read_csv(url, sep=',')
df = pd.DataFrame(doc)

What’s a DataFrame?

DataFrames describe heterogeneous table-like data structures, consisting of multiple rows and columns, each of which is labeled.

The rows and columns hence identify a table, whose cells can be used to store data.

Compared to lists and arrays, DataFrames are more versatile structures when it comes to modifying the content of their cells (actually the data stored in each cell). Indeed, it is possible to point to specific columns/rows by just referring to their label. For a detailed description of DataFrames, please refer to this and this tutorial.

The imported .csv file contains information regarding the tobacco consumption in different states and is subdivided into seven different columns which contain data on the state, year etc.

In particular, the first column refers to the year and the second one to the State in which the data have been collected. It is possible to find out all the headings of a certain DataFrame by exploiting the Pandas function .columns() which gives as output all the names of the headers featured in the DataFrame. In order to display all the headers of our .csv file, we call this function in our script and we print its value.

print(df.columns)

The result of this command will be:

You can clearly see that our DataFrame presents seven columns, each of which contains specific information.

Converting a Single Column of the DataFrame into a List

Let’s now suppose we are interested in creating a list containing all those elements that are stored under the header ‘State’; in order to do that, we proceed as follow:

# convert a column of the data frame into a list
new_list = df[('State')].values.tolist()

As you can see from the script, we used the combination of two different functions for achieving the objective: .values() and .tolist().

The first one is used to convert the column presenting “State” as header of the DataFrame into a Numpy array, consisting of a single column and n rows; the function .tolist() is then used to convert the array into a list.

The procedure can be used irrespectively of the type of data contained within the DataFrame; whether you have strings or floats, the final result is the same.

Converting Multiple Columns of the DataFrame into a List

It is also possible to create multidimensional lists by converting multiple columns of our initial DataFrame.

This can be easily achieved by indexing in the correct way the subset of data we are interested in.

Suppose now we are interested in converting into a list the data contained in the columns “Year” and “State”.

We can employ the Pandas function .loc[] in order to access a subset of the DataFrame; after that, we use the same procedure as before, i.e., .values.tolist().

The result will be a list containing other n lists, whose elements are the n-th “Year” and “State”.

The following lines display the procedure.

# convert more columns of the data frame into a list
new_list = df.loc[:, ('Year', 'State')].values.tolist()

As you can see, in order to index all the elements of the columns “Year” and “State”, we used the following nomenclature: .loc[:, (‘Year’, ‘State’)], which means that from our DataFrame we want to index all the rows (using the colon) and the columns identified by the headers “Year” and “State”.

If you are interested in more details about the DataFrame.loc[] function, please refer to the docs.

Converting a DataFrame Row into a List

So far we have seen how to convert single and/or multiple columns of a DataFrame into a list; however, you might be wondering whether it is possible to do the same with the rows of a DataFrame.

The answer is of course yes, and it turns out to be quite simple!

If you remember the previous paragraph, when we used the function .loc[ ], we indexed all the rows and the two columns of interest. If we are now interested in just a single specific row of the DataFrame, it will be sufficient to just specify the number of the row we want to convert and then use again the function values.tolist(). The following code lines describe the procedure:

# convert a line of the data frame into a list
new_list = df.loc[3].values.tolist()

The result will be a list containing all the elements of the fourth (just in this case, since we typed the number 3) row; each element of the list will correspond to a single element of the row.

Convert a List into a DataFrame

Let’s suppose we are now interested in the opposite task, i.e., converting a list into a DataFrame.

Also in this case, the solution to the problem is very simple; it will be sufficient to use the Pandas function .DataFrame() with the list as input parameter.

In order to illustrate the procedure, let’s convert the list obtained from the previous parts back into a DataFrame called “new_df”.

# convert list into data frame
new_df = pd.DataFrame(new_list)

Keep in mind that this new DataFrame will not have the headers of the original one since we obtained it just from the elements of an independent list.

Conclusion

In this article, we saw different options to convert entire or parts of DataFrames into lists and vice versa.

Depending on what you are doing with your script, a DataFrame or a list can represent a more versatile structure to work with. As you saw, the conversion is extremely easy and takes just a couple of code lines.  

The post Pandas DataFrame to Python List – and Vice Versa appeared first on Be on the Right Side of Change.

In this article, we will see one of the most widely used filters, the so-called Savitzky-Golay filter.

To illustrate its functioning and its main parameters, we herein apply a Savitzky-Golay filter to a data set and see how the generated fitting function changes when we change some of the parameters.

Long Story Short

The Savitzky-Golay filter is a low pass filter that allows smoothing data. To use it, you should give as input parameter of the function the original noisy signal (as a one-dimensional array), set the window size, i.e. n° of points used to calculate the fit, and the order of the polynomial function used to fit the signal.

Table 1 sums up the mandatory parameters that you need to choose in order to make your Savitzky-Golay filter working properly.

These are just the mandatory parameters that you need to know in order to make the function work; for further details, have a look at the official documentation.

How Does the Savitzky-Golay Filter Work?

We might be interested in using a filter, when we want to smooth our data points; that is to approximate the original function, only keeping the important features and getting rid of the meaningless fluctuations. In order to do this, successive subsets of points are fitted with a polynomial function that minimizes the fitting error.

The procedure is iterated throughout all the data points, obtaining a new series of data points fitting the original signal. If you are interested in knowing the details of the Savitzky-Golay filter, you can find a comprehensive description here.

Smoothing a data set using a Savitzky-Golay filter

Generating a noisy data set

As explained above, we use a filter whenever we are interested in removing noise and/or fluctuations from a signal. We hence start our example by generating a data set of points that contains a certain amount of noise. To do that, we use Numpy and exploit the function .random() (see the documentation).

import numpy as np

# Generating the noisy signal 
x = np.linspace(0, 2*np.pi, 100)
y = np.sin(x) + np.cos(x) + np.random.random(100)

Applying the Savitzky-Golay Filter

In order to apply the Savitzky-Golay filter to our signal, we employ the function savgol_filter(), from the scipy.signal package. This function takes as first input the array containing the signal that we want to filter, the size of the “window” that is used on each iteration for smoothing the signal, and the order of the polynomial function employed for fitting the original dataset.

As we will see, the larger the window the less accurate the fitting and the smoothing procedures because we will force the function to average a greater portion of the signal. In the following code lines, we import the savgol_filter() function and apply it to the previously defined “y” array.

from scipy.signal import savgol_filter
# Savitzky-Golay filter
y_filtered = savgol_filter(y, 99, 3)

In this first example, we start with a window size of 99, which means that the function will take 99 points (almost all the points) of the initial signal to compute an average; for this reason, we do not expect to obtain good results; please also note that the order of the polynomial functions used in the fitting procedure is three.

We can now use Matplotlib to plot both the original signal and the one filtered with the Savitzky-Golay filter. If you want to become a Matplotlib expert and data visualization wizard, check out our course on the Finxter Computer Science Academy. It’s free for all premium members!

import matplotlib.pyplot as plt

# Plotting
fig = plt.figure()
ax = fig.subplots()
p = ax.plot(x, y, '-*')
p, = ax.plot(x, y_filtered, 'g')
plt.subplots_adjust(bottom=0.25)

The final result is displayed in Figure 1.

Varying the sampling window size and the order of the polynomial function

In the previous section we set the size of the sampling window to 99, which means that the filter takes as input 99 points “at a time” to compute the fitting function. Since the total number of points in the original signal is 100, the result is not really accurate (as you can also see in Figure 1). We will now create a Slider button, with which we will be able to change the size of the sampling window and see its effects immediately in the plotted graph, in order to get a better understanding of the filter working principle.

To introduce a Slider button in the plot, we exploit the Matplotlib.widget library and start by defining the properties of the button like its size and position on the matplotlib window and also the numerical values accessible through it.

# Defining the Slider button
ax_slide = plt.axes([0.25, 0.1, 0.65, 0.03]) #xposition, yposition, width and height

# Properties of the slider
win_size = Slider(ax_slide, 'Window size', valmin=5, valmax=99, valinit=99, valstep=2)

At this point, we have to define a function that will update the plot with the current value indicated by the Slider. We call the function “update”, it will get the current slider value (“win_size.val”), filter the original signal again with the new window size and plot the new filtered signal in the graph. The following code lines describe the procedure.

# Updating the plot
def update(val):
    current_v = int(win_size.val)
    new_y = savgol_filter(y, current_v, 3)
    p.set_ydata(new_y)
    fig.canvas.draw() #redraw the figure

If you are looking for a more detailed description about how to incorporate sliders and other widgets in Python, have a look at this video:

If we now plot the resulting figure, we would get the output displayed in Figure 2.

The last thing to do now, is to specify when the function “update” is triggered; we want it to be activated every time the value of the slider button gets changed.

# calling the function "update" when the value of the slider is changed
win_size.on_changed(update)
plt.show()

If we now try to reduce the size of the sampling window, we will appreciate a visible improvement in the fitting signal; this is because the Savitzky-Golay filter is called multiple times for fitting a lower amount of points at a time, hence improving the result of the fitting function. Figure 3 shows the result obtained by setting the size of the sampling window at 5 points.

As can be seen in Figure 3, by reducing the size of the sampling window, the filtering step allows to better follow the fluctuations of the signal; in this way, the resulting signal will appear less smoothed and more detailed.

General guidelines for filtering your data

As you saw in the article, by tuning the size of the sampling window, the result of the filtering step changes quite drastically. In common practice, you should always try to keep the order of the polynomial fitting functions as low as possible in order to introduce as little distortion of the original signal as possible. Regarding the size of the sampling window, you should adjust its value in order to obtain a filtered signal which preserves all the meaningful information contained in the original one but with less noise and/or fluctuations as possible.

Keep in mind that in order to have your Savitzky-Golay filter working properly, you should always choose an odd number for the window size and the order of the polynomial function should always be a number lower than the window size.

Conclusions

In this article, we learned about the Savitzky-Golay filter, which is one of the most widely used signal filter in Python. We started by plotting a noisy signal and we then introduced the Savitzky-Golay filter with which we were able to get rid of the noise. By employing a slider button, we were also able to appreciate the variations in the fitting function as a consequence of the reduction of the sampling window size.   

The post Smoothing Your Data with the Savitzky-Golay Filter and Python appeared first on Be on the Right Side of Change.

Long Story Short

The datetime module in Python allows you to deal with date and time expressions. By exploiting classes like .time() and/or .datetime() you can express times and dates in a dedicated format.

The class .timedelta() allows you to define a specific time duration interval and add it to a datetime expression.

The method .today() can be then used to extract the current time or/and datetime. You can then convert a specific time interval expressed with the .timedelta() class into seconds y exploiting the method .total_seconds().

Finally, if you want to extract the microseconds amount from a time expression, you can easily achieve the result by using the method .microsecond().

The datetime Module

The datetime module contains multiple classes, the most famous and used are:

• .time – it gives as output an idealized time in the format hours : minutes : seconds
• .datetime – gives as output a combination of a date and a time in the format year - month - day hour : minutes : seconds
• .timedelta – expresses a duration, indicated as the difference between two dates, times or datetimes.

The following code lines provide an example of these three classes.

import datetime

# express a time
print(datetime.time(10, 23, 45))
# 10:23:45

# express a date and time
print(datetime.datetime(2019, 2, 3, 10, 23, 45))
# 2019-02-03 10:23:45

# add to a date and time a specific duration
time1 = datetime.datetime(2019, 2, 3, 10, 23, 45)
delta = datetime.timedelta(days=4, hours=3)
time2 = time1 + delta
print(time2)
# 2019-02-07 13:23:45

As you can see in the example, it is possible to express times and dates in a dedicated format by exploiting the module datetime and its two classes time and datetime, respectively.

We then defined a specific date and time and assigned their values to the variable “time1”. We then define a time duration (i.e. 4 days and 3 hours) and assign it to the variable “delta”; finally, we obtain the expression for the date and time corresponding to “time1” after an amount of time equal to “delta” has passed.

Please note when defining the .timedelta(), we used the arguments days and hours; in a similar way, we could have also specified other intervals by using all the available arguments for this function (see the official documentation).

Get the Current Date and Time with .today()

In the case we want to get the current time and/or the current date, we can exploit the method .today(); it can be applied to both the date and datetime classes and it will return the current date and the current date and time (at the microsecond precision), respectively. The following code lines show an example of how it works.

#get current date
current_date = datetime.date.today()
print(current_date)
# 2021-04-10

#get current date and time
current_dt = datetime.datetime.today()
print(current_dt)
# 2021-04-10 15:17:12.641393

Express a Duration in Seconds with .total_seconds()

In some applications it might be useful to express a specific amount of time in seconds, without using the hours : minutes : seconds notation.

Let’s take, for example the duration that we applied in the previous section: it was 4 days and 3 hours in total. If we want to obtain the respective number of seconds that corresponds to this period of time, we will just have to type:

# Get the duration in seconds
print(delta.total_seconds())
# 356400.0

You can also verify that 356400.0 is the correct answer by making the conversion manually, which would be: 4(days) * 24(hours) * 60(minutes) * 60(seconds) + 3(hours) * 60(minutes) * 60(seconds) = 356400.

Extract the Microseconds Value from the Time Notation with the .microsecond Attribute

Sometimes we might be interested in obtaining the number of microseconds that have passed from a specific instant of time. In this case, we would have to extract from the whole time expression, just the part that is indicating the microseconds. In order to do that, we can use the attribute .microsecond, which gives as output an integer number, corresponding to the microseconds elapsed in the indicated time.

# extract the microseconds from the current time
current_microsec = datetime.datetime.today().microsecond
print(current_microsec)
# 641393

Please note that the method .microsecond just extracts the corresponding microseconds number from a specific time definition; it does not convert a time duration into microseconds.

Now that we have familiarized with some of the functions for handling the date and time in Python, we will see through a practical example, how to exploit the above explained features to perform time-controlled operations within a Python script.

Put Your Script Asleep and Wake It Up Every Three Seconds

In this example we will see how to handle the time within a script and how to use the above-mentioned functions to put the script asleep for some seconds. This is a crucial thing in lots of applications where “heavy” tasks have to be performed or in cases where your script has to run for long periods of time and you do not want your system to be active for the whole script duration.

We start by obtaining the current date and time using the method .datetime.today(), then we define a time interval of three seconds by exploiting the method .timedelta(). After this, we define a future date and time instant, called “future”, which is obtained by summing the three seconds time interval to the initial time.

# make the script sleeping for some time
t = datetime.datetime.today()
delta = datetime.timedelta(seconds=3)
future = t + delta

Now we need to create a for loop, in order to perform multiple iterations (in this example we will iterate three times) in which we will “put the script asleep and wake it up” alternately.

We define the duration of the sleeping time by converting the 3 seconds time interval into seconds; it may sounds dumb (and in this case it is) but if we were to choose a longer time interval, like days, we would have had to obtain the interval duration expressed in seconds, and also, we need it to be an integer number, not expressed in time notation.

To put the script asleep, we exploit the method .sleep(), from the time module. This method accepts as input an integer, corresponding to the number of seconds we want our system to be asleep. When the 3 seconds have passed, we print the current time with a sentence saying that 3 seconds have actually passed from the previous iteration. 

import time

for i in range(3):
    # sleep for the time difference between the initial time and the future (in sec)
    time.sleep(delta.total_seconds())
    print("It's " + str(datetime.datetime.today()) + " 3 sec have passed")

'''
   It's 2021-04-11 11:42:33.767437 3 sec have passed
   It's 2021-04-11 11:42:36.777588 3 sec have passed
   It's 2021-04-11 11:42:39.787928 3 sec have passed
'''

Conclusion

In this article we learnt how to deal with time and date notations in Python and how to use these features within a script. We explored different modules and methods for obtaining the current time, date and also for calculating time intervals (and more!). In the end, we exploited these functions to write a short script which allowed putting asleep the system for a specific amount of time and waking it up at precise time intervals. This example can be extremely useful when designing scripts that have to run for long periods and we do not want to keep the system active for all that time.

The post Manipulating Dates and Times in Python appeared first on Be on the Right Side of Change.

This article will show you how to visualize, modify and save images in Python, more specifically in Matplotlib. In the following sections, we will see how to load images, how to modify some of their properties and finally how to save them.

Long story short

If you want to import an image and to display it in a Matplotlib window, the Matplotlib function imread() works perfectly. After importing the image file as an array, it is possible to create a Matplotlib window and the axes in which we can then display the image by using imshow(). By changing some of the properties available within imshow() we can  vary the color, the size and even decide to crop the displayed image. Once we are satisfied with the result from our modifications, the function savefig() allows to save the figure by specifying as input parameters the path in which we want the image to be stored. Exploiting some additional parameters of this latter function it is possible to decide whether to make the borders of the image transparent or even to delete them.

Main functions that are used:

More information here: https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.imshow.html.

More information here: https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.savefig.html.

Importing an Image into Your Script

We start the tutorial by importing the image in our script, in this way we will be able to take further actions and hence modify its appearance. To do this, we exploit the Matplotlib function imread(), which reads an image from a file into an array (official documentation: https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.imread.html).

The function takes as the only input parameter the path of the image file that we want to import.

The image file is converted into a M x N x 3 (in the case of a RGB image) array with M and N standing for the number of pixels for the width and height, respectively. In the case of a RGB image, each M_iN_j subarray will contain 3 numbers corresponding to the combination of Red Green Blue values that identify that specific color; in the case of RGBA images, we would have a M x N x 4 array.

In the following code lines, we import the Matplotlib library and we assig to the variable “pic” the array describing the image file that we wanted to import.

import matplotlib.pyplot as plt

url = r"file_path"
pic = plt.imread(url)
print(pic)

The result of the printing command will display in your terminal a 3D array describing the image file that you uploaded.

Obtaining the Image Size

It is possible to know how many pixels compose our image and what type of color code it uses, by just applying the method .shape() to the variable in which we stored the array describing the image file. Indeed, by getting the array shape, we will obtain the different dimensions of the array, since each subarray will represent a pixel with its color values, we will get an indication of the exact number of pixel that make up our image (i.e. each element corresponds to a pixel).

# get image pixels
print(pic.shape)
>> (2559, 4550, 3)

In our case, we have an image that is 2559 pixels high, 4550 pixels wide and is defined according to a RGB color scheme (from the 3 values in the last array dimension).

Display Images in Matplotlib

In this section we will see how to display an image file in a matplotlib window; the procedure is extremely easy and really similar to the one that is used for plotting a normal graph. We start by creating the matplotlib figure and the axes.

# display the image in a mpl figure
fig = plt.figure()
ax = fig.subplots()

At this point, we use the Matplotlib function imshow() to display the image within the just created axes. The imshow() function accepts as its main input parameter the variable referring to the image file, which in our case, is “pic”. The result from the following code lines is then displayed in Figure 1.

ax.imshow(pic)
plt.show()

Changing the Properties of the Displayed Image

By specifying other input parameters within the imshow() function it is possible to modify some of the properties of the displayed image, like the size, the color and its transparency.

To be able to modify the just mentioned properties, we have to index the pixels on which we want to apply any changes, if we want to modify the entire image, we just have to index all the pixels (in this case, this means writing pic[:, :, 1]). The first property that we will change is the transparency of the image; we can do this by changing the value of the alpha parameter (from to 0 to 1).

We can also change the color map that is used in the image, for example using a “gray” color map will turn our color image into a black and white picture. This thing can be done by modifying the parameter cmap (here you can find all the possible color maps available for Matplotlib: https://matplotlib.org/stable/tutorials/colors/colormaps.html).

If we want to change the color range used within the selected color map, we could modify the values of the parameters vmin and vmax for tuning the highest and lowest values of the color range. If we don’t specify these two parameters, the whole color range will be used for displaying the image.

In addition to changing the color properties, we can also modify the aspect ratio of the image pixels; this is an important topic to keep in mind, especially if we want to change the size of the axes of the figure. This can be done by exploiting the parameter aspect; we can choose between two different options auto or equal. Using auto will keep the axes fixed and the aspect ratio of the pixels is adjusted accordingly, generally resulting in non-square pixels. On the other hand, equal ensures an aspect ratio of 1 for the pixels in the image, meaning square pixels.

You can find additional information about the imshow() function and all its properties in the official documentation page: https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.imshow.html. In the following code line, we assign to the variable f the image file and we change all the above-mentioned properties.

f = ax.imshow(pic[:, :, 1], alpha=0.5, cmap='gray',  vmin=0, vmax=500, aspect='auto')

It is also possible to add a color bar next to the image by applying the method colorbar() to the figure.

f = ax.imshow(pic[:, :, 1], alpha=0.5, cmap='gray',  vmin=0, vmax=500, aspect='auto')

The final result is displayed in Figure 2; notice that since we set aspect = ‘auto’, the aspect ratio of the pixels has changed hence producing an image whose shape is slightly different (see the video for a better example) from the one in Figure 1.

Changing the Axes Range and Visibility

As you can see from the previous figures, all the axes and the tick labels are still present and visible in the plotting window. In the case we would like to remove them and hence have just the image plotted within the Matplotlib window, we can disable the axes by using .axis(‘off’). If we are also interested in plotting just a portion of the image, we can do it by adjusting the value of the maximum x and y values to be displayed on each of the axes. All these commands are displayed in the following code lines:

# changing the axes properties
ax.set_xlim(0, 2500)
ax.set_ylim(2500, 0)
ax.axis('off')

You can notice that we chose to display the image for its entire height but with a width going from 0 to the value 2500. Also notice that the coordinates of the y-axis are given in the inverted order; this is because the y-axis of the image goes from the top to the bottom of the figure. If you gave the limits of the y-axis in the opposite order, the imaged will be flipped. The final result is displayed in Figure 3.

Saving the Image File

Once we finished to edit our image, we can save it by using the Matplotlib function savefig(). The only mandatory input parameter is the path to which we want to save the image. In the case we want to save the image without any white border, we can specify the two optional parameters bbox_inches (setting it to “tight”) and pad_inches (setting it equal to zero). With the first option we make the border of the figure to adapt to the size of the image, with the second one we set to zero the amount of border around the figure (we first have to set to “tight” the property bbox_inches).

plt.savefig(r"C:\Users\Andrea\Desktop\newimage.jpg", bbox_inches='tight', pad_inches=0)

Conclusions   

In this article, we just learned how to import and modify an image file by using Matplotlib. First of all, we imported the image file within a Matplotlib window; then by using the appropriate functions, it was possible to display the image, change its color, its size and aspect ratio. In the end we also saw how to save the modified image into a new image file. All these procedures represent a really easy and fast solution for a quick adjustment of images within a Python session.

Programmer Humor – Blockchain

The post How to Display, Modify and Save Images in Matplotlib appeared first on Be on the Right Side of Change.

This article will walk you through the different numerical systems that can be used to represent numbers in Python.

The system that we usually use in our daily life is the decimal system and, as the name suggests, it is based on 10 basic digits from which we can obtain all the numbers.

Out of our ordinary life, other numerical systems are used, especially in the computer world. As you may already know, all computers are based on a binary system; however, sometimes even the octal (which has 8 basic digits) and the hexadecimal (based on 16 digits) systems are used for specific applications.

In the following sections you will see how to use some Python built-in functions to convert from one numerical system to the other.

Long Story Short

Python provides some built-in functions for converting numbers from one numerical system to another. More specifically, these functions allow converting integer numbers to the:

• decimal system: int()
• binary system: bin()
• octal system: oct()
• hexadecimal system: hex()

In addition to these, the function float.hex() allows converting floating-point numbers from the decimal to the hexadecimal system.

The Decimal System

The Decimal system is the numerical system that we use the most in our ordinary life (no coincidence with the fact that we have precisely ten fingers); it is based on 10 different digits that are 1, 2, 3, 4, 5, 6, 7, 8, 9 and 10, from which it is possible to obtain all the possible numbers that we need. Even if all the computer-based systems are based on the binary system (and later we will see why), the user interface of most programs like Python, uses the decimal system to store values and perform mathematical operations.

The Binary System

The binary system represents the foundation of all the computer-based systems that are in use nowadays; as the name suggest, it exploits two different digits, 1 and 0, to build up all the possible number combinations. The choice of the two digits simply derives from how a system like a computer ultimately works; if you think about it, all the tasks that your computer is able to perform can be linked to a series of ON/OFF signals from which the digits 1 and 0, respectively. In this way, just by using zeroes and ones, the binary system represents all the available numbers.

Do you know how the Binary to Decimal conversion works?

Converting from binary to decimal is pretty easy, this section will show you, using an example, how this can be done manually (if you are not interested, just skip it and go directly to the code part). Since the binary system is based on two digits, to convert a binary number into a decimal number we will have to exploit powers of 2. As an example, let’s see how to convert the binary number 11011 into its decimal representation.

First of all, each digit position will represent the power of two that will be used in the conversion:

 1  1  0  1  1
 24 23 22 21 20 

At this point, each power of two should be multiplied by the respective binary digit (either 1 or 0) and summed with the others, in this case we get:

1 * 24 +  1 * 23 + 0 * 22 + 1 *21 + 1 *20 = 16 + 8 + 2 + 1 = 27

How to convert from Binary to Decimal and vice versa in Python

To convert from one numerical system to another in Python is extremely easy, we just have to remember which function should be used and what to pass as input parameter. To represent a binary number in Python, we have to use the prefix “0b” which tells the system that the digits that follows, actually represent a binary number. You can try this by printing the following code lines:

num = 10
num_bin = 0b10
print(num, num_bin)
# 10 2

in the binary system, 10 represents the number 2; the output of the printing command on the variable num_bin will be “2”; this is because Python, by default, prints the result using the decimal system. However, if we want to perform some mathematical operations, we have to first convert the number into a decimal number and this can be done by using the function int().

bin_to_dec = int(0b10)  
print(bin_to_dec)
# 2

On the other hand, to convert a decimal number to the binary notation, the appropriate function is bin(), you can try to check personally if the result of the following code lines is correct.

dec_to_bin = bin(2234)
print(dec_to_bin)
# 0b100010111010

The Octal System

As suggested by the name, the Octal system is based on eight basic digits, from 0 to 7. A curious fact is that some Native Americans tribes adopt  the Octal system because they count using the spaces between the fingers or the knuckles of their closed fists (if you want to know more about this: Yuki language (spaces between fingers), Pamean languages (knuckles of closed fists)). The procedure used to convert a number in the Octal system is similar to the one used above. In Python, octal numbers are identified by the prefix “0o” and the function that is used to do the conversion is called oct(); the input, of course, is the decimal number that we want to convert.

dec_to_oct = oct(57)
print(dec_to_oct)
# 0o71

The opposite operation can still be performed by using again the int() function.

oct_to_dec = int(0o71)
print(oct_to_dec)
# 57

As you may imagine, it is also possible to convert directly from binary to octal and vice versa. The functions at play are always the same, let’s see how to convert the binary 0b100010111010 in the octal system:

bin_to_oct = oct(0b100010111010)
print(bin_to_oct)
# 0o4272

Do you remember which was the equivalent for this number in the decimal notation? We can use Python to get the answer instantaneously; however, the results that we get from functions like bin() or oct() are expressed in the string format, this means that if we enter them as input parameters of the function int(), we get an error, stating that Python cannot convert a string into a number. To solve this issue we can specify the format of the input parameter in the following way:

oct_to_dec = int(bin_to_oct, 8)
print(bin_to_oct, oct_to_dec)
# 0o4272 2234

In the binary case, we would have used “2”.

The Hexadecimal System

The Hexadecimal system is based on 16 digits, since we only have 9 different numbers in our decimal system, also letters are employed, namely:

The conversion to the hexadecimal system is analogous to the one illustrated for the octal system, the only difference is that this time the powers will have base 16. In this way, 17 becomes 11 in the hexadecimal notation. To denote a hexadecimal number in Python, we have to use the prefix “0x”. The function that allows us converting from one numeric system to the hexadecimal one is called hex() and accepts as input parameter any integer number expressed in one of the aforementioned numeric systems.

dec_to_hex = hex(2234)
print(dec_to_hex)
# 0x8ba

bin_to_hex = hex(0b100010111010)
print(bin_to_hex)
# 0x8ba

oct_to_hex = hex(0o4272)
print(oct_to_hex)
# 0x8ba

What about floating numbers?

As you may have noticed, all the mentioned functions do accept as input for the conversion only integer numbers; this is because the expression of floating-point numbers is not unique, there are different notations which could be dependent on the computing system that we are using.

However, for the case of Hexadecimal numbers, Python provides a built-in function to convert floating numbers from the decimal system to the hexadecimal system. The function is called float.hex() and accepts as input parameter the floating number in the decimal notation. The following code lines provide an example of its use.

float_dec_to_hex = float.hex(416.8)
print(float_dec_to_hex)
# 0x1.a0ccccccccccdp+8

As you can see, the notation that is used to express the answer is quite different from the one used for the integer numbers; this is because in these cases Python uses the scientific notation. The letter “p” stands for “times 2 to the power of” and “+8” is the exponent, while the bullet is then the decimal point. This is just one of the possible notation for expressing floating-point numbers in different notations; if you are interested in how it works, here are some useful links:

• i) https://en.wikipedia.org/wiki/Hexadecimal,
• ii)  https://stackoverflow.com/questions/54947861/32-bit-ieee-754-single-precision-floating-point-to-hexadecimal .

Conclusions

In the article, we took a tour through the most widely used numerical systems and the functions that Python offers for converting from one notation to the other. When programming, it is good practice to be able at least to recognize the employed numerical system, in order to decide which of the above-mentioned functions to use for converting into the numerical system that is currently in use.

The post Python Conversions: Decimal + Binary + Octal + Hex appeared first on Be on the Right Side of Change.

In the following sections, we will see how to use the Matplotlib function .subplots() for generating multiple subplots and how to define properties like the labels of the axes, the title, and the grid of each of them both separately and simultaneously.

I explained this article in the following video tutorial:

Importing Libraries

Since we will just create some subplots and modify some of their properties, the only library that will be used throughout the entire example is Matplotlib; more specifically, we import the Matplotlib.pyplot package to be able to plot and modify our plotting windows.

import matplotlib.pyplot as plt

Creating the Plotting Window and Defining the Subplots

The first step towards the creation of a Matplotlib plot is the definition of a plotting window, i.e. the window that will be displayed after running the code and that will contain all the subsequently defined plots. To do this, we use the matplotlib function .figure() and we assign its value to the variable “fig”. We do not specify any input parameter; however, it is possible to modify the size of the figure, its color, and some other properties; you can find the official documentation at this link.

fig = plt.figure()

Once created the plotting window, we have to define the subplots; this can be done by using the function .subplots(), applied to the previously defined figure (i.e. the variable “fig”). If we do not pass any input parameter, this function will generate a single subplot while if we want it to display multiple subplots, we have to specify the number of rows and columns in which we want to divide the plotting window. These input parameters are called “nrows” and ”ncols”; however, we can directly address them by simply typing the two respective numbers.

Other useful parameters are sharex and sharey, if we put them equal to True, the generated subplots will share the x and/or the y axes. For this example, we define four subplots, displayed along two rows and two columns; and we assign them to the variable “ax”. The following code line describes the procedure. We also use the function .subplots_adjust() for changing the separation between the four subplots, specifically by setting to 0.5 the value of the parameters hspace and wspace (corresponding to the vertical and horizontal separation, respectively).

ax = fig.subplots(2, 2)
fig.subplots_adjust(hspace=0.5, wspace=0.5)

The obtained result is displayed in Figure 1, which shows the four subplots initialized in a 2×2 grid inside the matplotlib window.

Figure 1: Initialization of four subplots, distributed in a 2×2 grid within the matplotlib window.

Changing the Properties of Individual Subplots

Now that we created our four subplots, we proceed further and change some of the properties of individual plots. This is a really easy task; indeed, thanks to the strategy that we adopted for the definition of the subplots, now the variable “ax” is a 2×2 array and hence allows accessing each of its elements (each subplot) by simple indexing.

In our case, the subplot on the upper left corner is the element [0, 0], the one in the upper right corner the [0, 1], on the bottom left we have the [1, 0] and on the bottom right the [1, 1]. We can now try to add a title to the subplot in the bottom left corner, this can be done by applying the method .set_title() to the element ax[1, 0] and by passing as a string the title that we want to add:

ax[1, 0].set_title('Plot n° 3')

The final result is displayed in Figure 2; as you can see, we added a title solely to the bottom left subplot, while the others are still lacking it.

Figure 2: By applying the method .set_title() to the [1, 0] element of the ax array, we added a title solely to the subplot in the bottom left corner.

In an analogous way, we can access and change the properties of all the others individual subplots that make up our figure. To this purpose, some of the most frequently used methods are:

• .grid() for enabling the grid on your plot and for changing its properties (like color and linewidth)
• .set_xlabel or set_ylabel() for setting the title of the x and y axes, respectively
• .set_facecolor() for changing the background color of each subplot

Automatically Setting the Properties of All Subplots

Let’s now suppose that we want to initialize some of the previously listed properties for all of the subplots present in our window. Even if it was not a difficult task, repeating that step for multiple properties and for multiple plots could be repetitive and time consuming (as well as annoying).

To solve this issue, it is possible to exploit for loops for defining and/or changing some of the properties of all the subplots automatically and rapidly. Indeed, since the variable ax has been initialized as a 2×2 array, we can hence use two nested for loops for accessing each subplot one at a time and changing all its properties in an iterative fashion. In the following code lines, we will use two nested for loops for accessing each of the subplots and changing properties like the title, the grid, the background color and the axes labels.

Before entering the for loops, we define the variables “rows” and “cols” which indicates the total number of rows and columns the window is divided into; they will be then used as escape value for stopping the iterations inside the loops. We also define an index “n”, which will be used for assigning the number to each plot title.

rows, cols = 2, 2
n = 1
for i in range(rows):
    for j in range(cols):
        ax[i, j].grid(color='w', linewidth=1)
        ax[i, j].set_ylabel('Y axis')
        ax[i, j].set_xlabel('X axis')
        ax[i, j].set_facecolor("grey")
        ax[i, j].set_title('Plot n° ' + str(n))
        n += 1
plt.show()

As you can see from the code lines, each of the subplots will have a white grid, two labels for the y and x axis, respectively, a grey background and a title stating “Plot n° (number of the plot)”, where the number of the plot is dictated by the value of the index “n”. The final result is displayed in Figure 3.

Figure 3: Using two nested for loops we were able to change the properties of all the four subplots automatically, without the need of repeating all the steps for each of them.

Full Code

Here’s the full code from this tutorial:

import matplotlib.pyplot as plt

fig = plt.figure()
rows, cols = 2, 2
ax = fig.subplots(nrows=rows, ncols=cols)
fig.subplots_adjust(hspace=0.5, wspace=0.5)
# adding a title to an individual subplot
ax[1, 0].set_title('Plot n° 3')
# automatically set the properties for all the subplots
n = 1
for i in range(rows):
    for j in range(cols):
        ax[i, j].grid(color='w', linewidth=1)
        ax[i, j].set_ylabel('Y axis')
        ax[i, j].set_xlabel('X axis')
        ax[i, j].set_facecolor('grey')
        ax[i, j].set_title('Plot n° ' + str(n))
        n += 1
plt.show()

Conclusions

In this article we saw how to access every single subplot present in a matplotlib window; in the first part we manually added a title to just one of the four subplots, in the second part we exploited two nested for loops to iterate through all the subplots and changing all of their properties simultaneously and automatically. 

The post How to Customize Multiple Subplots in Matplotlib appeared first on Be on the Right Side of Change.

What Are Percentiles?

Percentiles are statistical indicators that are often used to identify a certain part of a sample population. More precisely, we use a percentile in order to indicate the value (of the variable that is under consideration) below which a specific percentage of the sample population falls. For example, if we consider the height distribution of all the English people living in UK; by saying that the height value of 180 cm identifies the 65^th percentile, it means that the 65% of all the English people living in UK are shorter than 180 cm. As you can imagine, percentile are commonly used in lots of statistical studies and when reporting results of surveys or measurements on large populations.

How to Calculate Percentiles?

Let’s assume to have collected the height of n = 58 people; in order to evaluate the percentiles referred to this distribution, the first step is to sort all the values in ascending order. At this point, suppose we are asked to calculate the 75^th percentile of the distribution; we calculate the so-called rank k = percentile/100. In this case, k = 75/100 = 0.75. Now we have to multiply the rank for the total number of samples in the distribution (n, in this case 58); we hence obtain k x n = 0.75 x 58 = 43.5. Since the result is not a whole number, we approximate the value to the nearest whole number (44 in this case). The next step consists in finding the height value corresponding at the 44^th position within the sample distribution; that value corresponds to the 75^th percentile. In the case the result of k x n is a whole number, we proceed further by directly finding the corresponding value in the sample distribution; that is already our percentile.       

Calculate Percentiles in Python

Now that we know what percentiles are and how they can be calculated, we will see how Python makes this task very easy and quick. In the first part, we will solve the problem by defining a function that execute all the steps illustrated in the previous section while in the second part, we will exploit the Numpy built-in function .percentile().

Importing the Appropriate Libraries

We start our script by importing the libraries that will be used throughout the example.

We need to import

• math for being able to round floating numbers to the nearest integer,
• Numpy for the function .percentile(), and
• Matplotlib for the final part, in which we will plot the values of the percentiles on the distribution.

import numpy as np
import math
import matplotlib.pyplot as plt

Writing a Python Function for Calculating Percentiles

In this first section we will see how to build up a function for calculating the percentiles. The aim of this section is purely didactic, as you will see later on, Python offers built-in libraries that solve the task automatically. However, it’s always important to understand  how the problem gets solved and how a specific Python function works.

def my_percentile(data, percentile):
    n = len(data)
    p = n * percentile / 100
    if p.is_integer():
        return sorted(data)[int(p)]
    else:
        return sorted(data)[int(math.ceil(p)) - 1]

We start by calling our function my_percentile, it will take as input parameters the sample distribution and the percentile that we want to calculate. As detailed above, the first step is to evaluate the size of our distribution (n); then we compute the product “p” of the sample size and the rank.

At this point we have to instantiate an if statement, in order to separate the case in which k x n is a whole number from the case in which it is not. We exploit the Python method .is_integer() to evaluate whether p is a whole number; this method returns True in the positive case.

If p.is_integer() returns True, we have to search for the p-th values in our distribution (sorted in ascending order). To sort the distribution in ascending order, we used the function sorted() and pass as input parameter the distribution itself. The important thing to remember is to convert p from float (since it comes from the mathematical operation done in the previous line) to integer; otherwise you will get an error that says that the index value of the list should be an integer number.

We conclude by raising an else statement which covers the case in which the value of p is not a whole number; in this case, by using the function .ceil() (from the math library), we approximate the value of p to the nearest higher integer.

We then convert this number to an integer and subtract 1 in order to match the indexing used in the lists. The following code lines you can find all the steps explained so far, in this section.

Calculating percentiles using our function

To check whether our function works fine, we first have to define a distribution of values; to do that, we can exploit the Numpy function .random.randn(), which draws random values from the normal distribution, we just have to pass as input parameter the size of the array. We choose to create an array of 10000 values.   

dist = np.random.randn(10000)

Let’s now try to calculate the values of the 5^th, 25^th, 50^th, 75^th and 95^th percentiles. We can hence build a list, called “perc_func” that contains all those percentiles, evaluated through our function. Before doing that, we define a list called “index” that contains the values of the percentiles that we are interested in. After that, we exploit list comprehension, to call the function my_percentile() for each percentile defined in the list “index”.

index = [5, 25, 50, 75, 95]
perc_func = [my_percentile(dist, i) for i in index]

At this point, the list “perc_func” should contain the values corresponding to all the percentiles listed in the list “index”.

Calculating percentiles using Numpy.percentiles()

Now that we know how to calculate percentiles of a distribution, we can also exploit the Numpy built-in function, to do it more rapidly and efficiently.

The .percentile() function takes as input parameters the sample distribution and the percentile that we are interested in. It also allows us to decide which method should be used in the case the product n x k is not a whole number; indeed, there is not just a single correct way to do that, previously we decided to approximate the value to the nearest integer; however we could also choose to approximate it to the closest higher/lower integer or to take the mean value between the lower and higher nearest integers.

All these options can be selected by choosing among these key words for the option “interpolation” ['linear’, ‘lower’, ‘higher’, ‘midpoint’, ‘nearest’].

You can find the complete documentation on the .percentile() function here.

The different options may lead to slightly different results, we choose the option “nearest”, in order to match the method used in the function “my_percentile”. In a similar way to what we did in the previous section, we create a list called “perc_numpy” in which we store the values of the 5^th, 25^th, 50^th, 75^th and 95^th percentiles, evaluated using the Numpy. The following code lines describe the just-explained procedures.

# Using numpy for calculating percentiles
perc_numpy = [np.percentile(dist, i, interpolation='nearest') for i in index]

We can now print the two lists and check whether the obtained results are equal.

print(perc_func)
print(perc_numpy)

Plotting the Percentiles on the Distribution

At the beginning of the article, we defined what percentiles represent.

Since statistical definitions can be rather difficult to grasp, we can display our distribution of values and see where the calculated percentiles are located in the distribution.

To do that, we exploit Matplotlib and the function .axvline(), which allows plotting vertical lines on a plot. We place the function axvline() into a for loop in order to create a vertical line for each percentile contained in the list “perc_func”. To better highlight the percentile lines, we use the color red.

# Plotting 
plt.hist(dist, 50)
for i in range(len(index)):
    plt.axvline(perc_func[i], color='r')
plt.show()

The final result is displayed in Figure 1; as you can see, the 50^th percentile is located right in the middle of the distribution, while the 95^th percentile is the last line and corresponds to the value below which we can find the 95% of the sample population.

Figure 1: Representation of the normal distribution used in the example, with the vertical red lines corresponding (from left to right) to the 5^th, 25^th, 50^th, 75^th and 95^th percentiles.

Conclusions

In this article we learnt about percentiles, what they are, what they represent and how they can be used to describe a portion of a sample distribution. From their statistical definition, we developed a Python function for calculating the percentiles of a sample distribution.

After that, we explored the Numpy function .percentile() which allows calculating percentiles of a sample distribution in a super-fast and efficient way.

We then compared the results of the two methods and checked that they were identical.

In the end, we also showed graphically the percentiles, that we previously calculated, on the sample distribution, in order to have a better understanding of their actual meaning.

The post How to Calculate Percentiles in Python appeared first on Be on the Right Side of Change.

Since most of the basic functions, like the ones for initiating a Sympy session on your terminal or for defining a function/variable, will not be covered in here.

In this article we will explore how to calculate derivatives, integrals and limits with Sympy and also how to plot graphs directly from the terminal. As already said in the previous article and video, the commands and functions that will be described in the following sections can be typed both in the script and in the terminal; I’ll use the terminal since it offers more intuitive and clearer data representation.

We start our code by importing the Sympy and Matplotlib libraries; we will use the latter library to create plots from our data. If you do not know or you simply do not remember these procedures, just have a look at the first article on Sympy, where it is also described how to initiate a Sympy session and define variables and functions().

Derivatives and partial derivatives

Calculating the derivatives of mathematical functions is a really common practice in most science related fields; by doing that, it is possible to identify the location of the maxima and minima of a function, i.e. the points in which it starts to increase/decrease.

Sympy allows to solve this task in a very immediate way; the function that is used to this purpose is called diff(), from “differential”. The function diff(), takes as input parameter the function that we want to derivate. In the following code lines, we define a function, “f”, and we calculate its first derivative.

>>> f = 3*x**2 + 4*x + 5
>>> diff(f)
6⋅x + 4 

As you could see, in just one single line of code we managed to calculate the derivative of the function. In this case, it could be even possible to calculate the second derivative of “f” (it’s more correct to say that in this case the second derivative is not equal to zero), since it presents a second order term (x²).

To calculate the second or higher order derivatives of functions with Sympy, it is just sufficient to specify, after the function name, the variable with respect to which we want to make the derivation and the number of times we want to perform the differentiation (i.e. calculating the derivatives). In the following code lines, we calculate the second derivative of “f”, i.e. we differentiate the function twice.

>>> f
     2
3⋅x  + 4⋅x + 5
>>> diff(f, x, 2)
6

Also in this case, Sympy made the task awkwardly easy and immediate!

When we are dealing with multi-variable functions, we may be interested in calculating their partial derivatives; to do that, it is sufficient to specify the variable with respect to which we want to differentiate the function. In the following example, the function “g” is a three-variable function (x, y, z); we hence show how to calculate the partial derivatives with respect to each of three variables.

>>> g = 2*x + 4*y**2 - x*z
>>> diff(g, x)
2 - z
>>> diff(g, y)
8⋅y
>>> diff(g, z)
-x

Integrals

Integrating is the opposite operation compared to differentiating. From a graphical point of view, integrating a function means calculating the area between the function and the x-axis, but of course, the potential of Integral Calculus is not limited to just the areas beneath graphs.

In this section we will see firstly how to express an integral of a function in the terminal; as you will see, Sympy allows for a better representation of the function within the terminal.

To this purpose, we still use the “f” function defined at the beginning (you can find it also in the first lines of this code section) and we just define its integral, between the points -2 and 2. To do that, we exploit the function Integral() and pass as input parameters the function, the variable for which we want to integrate, followed by the lower and upper boundaries (these three latter parameters have to be put within parentheses).

>>> f
   2
3⋅x  + 4⋅x + 5
>>> Integral(f, (x, -2, 2))
  2
 ⌠
 ⎮       2                  
 ⎮  3⋅x  + 4⋅x + 5 dx
 ⌡
-2

At this stage, we have just expressed the integral that we want to solve, using the mathematical notation. However, what really interests us is how to actually solve the integral. To solve the integral, we use a function called integrate(); the input parameters are still the same; if you just want to solve the integral symbolically, you do not have to specify the integration limits. In the following code lines, we first solve the integral symbolically and then numerically by entering all the parameters already used with the function Integral().

>>> integrate(f)
  3        2
x  + 2⋅x  + 5⋅x
>>> integrate(f, (x, -2, 2))
36

As you can see, thanks to the integrate() function, it was possible to solve the integral both symbolically and numerically in a very immediate way. With a similar approach, it is also possible to solve double or triple integrals; we just have to specify the boundaries for each variable, in the same way we did for the x variable in the example above; in the next code lines, we calculate the double integral of the function “g”.

>>> g = x**2 + 5*y
>>> integrate(g, (x, -2, 2), (y, 3, 5))
512/3

If we wanted to solve the integral symbolically with respect to just one of the two variables, it would have been sufficient to give as input that variable, right after the name of the function to integrate (“g” in this case).

Limits

In math, limits are used to evaluate a function when it approaches “critical” points in which it could diverge or converge to a specific values, being them a finite number or  ± infinity. To calculate the limits of a mathematical function, we use the Sympy function limit(); it takes as input the function of interest, the variable to which the limit is referred to and the point in which we want to compute the limit, i.e. the point the independent variable “is approaching”. In the following example we evaluate the limit of the function sin(x)/x when x is approaching zero.

>>> limit(sin(x)/x, x, 0)
1

In some cases, the limits may assume different values whether the independent variable is approaching the critical point from higher or lower values; an example is the limit of the function 1/x, evaluated in the proximity of zero; as you will see, the result is different if we approach to zero from higher or lower numbers. To specify the direction from which we want to “approach” the critical point, we add another input parameter, that is “-“ or “+”, indicating that we are approaching that critical point from lower or higher values, respectively.

>>> limit(1/x, x, 0, '-')
-∞
>>> limit(1/x, x, 0, '+')
∞

As predicted, the result of the limit in the two cases varies from –∞ to +∞.

Plotting functions

In this last section, we will explore another really useful feature of Sympy, that is the possibility to plot and hence display functions by just typing their equations, directly in the terminal. To accomplish this task, we should have previously installed Matplotlib (strictly speaking, this is not mandatory, Sympy is also able to represent the entire plot by using dots and lines; however, the graphical output is not the best; I personally recommend installing and exploit matplotlib). In the following examples, we will see just some of the most significant functions; however, keep in mind that there are lots of other different possibilities and options.

If you are interested in them, have a look at the official documentation here: https://docs.sympy.org/latest/modules/plotting.html

We start by looking at how to plot a single function; we firstly assign the plot to the variable “p1”; to plot the function, we use the function plot(), entering, as input parameters, the function (expressed explicitly) and the boundaries of the independent variable (this is not mandatory, if we do not specify any boundaries, the function will be displayed from -5 to +5).

>>> p1 = plot(3*x + 4, (x, -3, 3))

At this point, we should be able to see in a separate matplotlib window, the plot of our function; Figure 1 reports the outcome of the example.

Figure 1: Plot of the function f(x) = 3x + 4, calculated for values of x from -3 to +3.

It is also possible to plot multiple graphs in the same plot, each of them with its own boundaries; to do that, we just have to exploit the function extend(). In the following code lines, we define a second plot, “p2”, we choose to not show it by specifying in the option “show=False” and through the extend() function, we add it to the initial plot, p1. We finally show p1. The final outcome is displayed in Figure 2.

>>> p2 = plot(x**2, (x, 3, 7), show=False)
>>> p1.extend(p2)
>>> p1.show()

Figure 2: The plot “p2” (defined from x=3 to x=7) has been added and displayed together with the initial one (p1).

Another interesting feature of Sympy is the possibility of plotting parametric functions like circumferences. To do that, we can exploit the function plot_parametric(), its input parameters are the “x” and “y” coordinates of the points defining the parametric curve, the parametric variable and its boundaries. The following code lines show how to plot a circumference centered at the origin of the axes, with its independent variable varying from -7 to 7. Figure 3 displays the matplotlib window with the plot hence generated.

>>> plot_parametric((cos(x), sin(x)), (x, -7, 7))

Figure 3: Parametric representation of a circumference centered at the origin of the x and y axes.

The last function that we will explore allows you to plot functions giving as input parameter the equation in the implicit form. This feature could be really useful when dealing with really complex and long functions, for which is often difficult to obtain the explicit version (i.e. the one in which one variable is expressed as a function of all the others). To solve this task, the appropriate function is plot_implicit(); the input parameters are the implicit function (i.e. the one that displays both the variables in its equation) and the boundaries for each of the variables. In the following code lines, we plot a parabolic function, giving as input its implicit equation and changing the boundaries for both the x and the y coordinates. The final result is then shown in Figure 4.

>>> plot_implicit(x**2 + 2*y, (x, -2, 2), (y, -3, 3))

Figure 4: Plot of a parabolic function obtained by passing as input parameter its equation in the implicit form.

Conclusions

This article showed how to use Sympy for solving mathematical tasks like derivatives, integrals and limits. In the final part, Sympy was used to obtain plots of the functions directly from the terminal. All the code that was shown in the different sections has been typed into the terminal; however, the same results can be obtained by writing the same functions within the script. This was just a very brief introduction to the amazing capacity of  the Sympy library, I strongly suggest you to check the official documentation page (https://www.sympy.org/en/index.html ), where you will find a plethora of other cool functions and options that could immediately offer an easy solution to most of your math problems.

The post Symbolic Math with SymPy: Advanced Functions and Plots appeared first on Be on the Right Side of Change.