Solution

import sympy

def elasticity(P1,P2,Q1,Q2):
    return ((Q2-Q1)/((Q2+Q1)/2))/((P2-P1)/((P2+P1)/2))

p = sympy.Symbol("Price")
DemandEquation = 11-p

for x in range(1,10):
    print(abs(elasticity(x,x+1,DemandEquation.subs(p,x),DemandEquation.subs(p,x+1))))

The only new code is the abs() function, it returns the absolute value, which is how we will present our demand elasticity (since otherwise it would be negative each time)

Our elasticity is highest when our price is high, and lowest when our price is low. At a higher price, if we were to cut the price we would get a much larger quantity increase than a lower price being cut even lower (on a percetange basis).

Before we move on in this we will introduce a new python concept, list comprehension. It is a way to create arrays in much less code than we have been doing. The set up of it is as follows:

[A for B in C]

A is the function that you want to apply to whatever variable you are getting, B is the way you denote the variable you are using the function on, and C is the array you are pulling variables. So if you had an array yourArray = [1,2,3,4] and wanted to double it you would write:

[x*2 for x in yourArray]

Now if we wanted to get a list of the numbers 1 through 10, we could do this:

[x for x in range(1,11)]

Let’s move onto revenue, which has an easy equation.

For revenue, you can draw a square from the point on the demand curve we are at, which will have area equal to this equation. Let’s create a function to draw over our plot. First initialize our demand equation as we have done in this past:

demandQ = [DemandEquation.subs(p,x) for x in range(0,12)]
prices = [x for x in range(0,12)]

To create our squares on the graph, we are going to need to import matplotlib.patches. Our equation to draw the square on the graph is:

import matplotlib.pyplot as plt
import matplotlib.patches as patches
def drawRevenue(P,Q):
    rect = patches.Rectangle((0,0),Q,P,linewidth=1,facecolor="blue")
    currentAxis = plt.gca()
    currentAxis.add_patch(rect)
    print("The revenue of the graph below is "+str(P*Q))

Let’s start with creating the rectangle. patches.Rectangle() creates a rectangle after we give it a few arguments. The first is a tuple (a data type we have not yet used which holds elements within a set of parentheses). This tuple is the origin point of our rectangle, so we feed it (x,y). The next argument is the width, so we put whatever the quantity is (since quantity is on the x axis). The argument after is height, so we put in the price. Finally, the last two decide the color and line width of our square.

The next line, plt.gca() gets our current axes. We need to do this so that we can add our rectangle to it. The line after adds a patch, and we specify that the patch to add is our rectangle. Finally, the last line outputs what the revenue is.