Appendix A — First Steps in Python

Chapter Learning Objectives

Installing Python
Simple Calculations
Print Function
Script Files
ipython Notebook
Graph Functions
Production Functions
Utility Functions
FRED Macro Data

This section provides you with a short introduction to the Python programming language. This is a very popular programming language that is used widely in various scientific fields, economics being one of them.

If you are interested more in how to use {python} to solve problems in economics I would like to refer you to my computational economics course Econ 431. You can find information about this course on my teaching website

What I show you in the next couple of sections is how to install {python} on your computer, how to use {python} as a pocket calculator, how to make graphs out of data and how I made some of the Chapter 5 GDP graphs in this book.

A.1 Installing Python

In order to get started you have to download Python. If you are running Linux or Apple, some version of {python} is already installed. However, these basic {python} versions miss some of the important scientific packages that you will still have to install. The most important ones are numpy, scipy, and matplotlib. If you "google" these packages you should be able to find them on the internet. They need to be installed.

I also recommend that you install an IDE for Python. One that is very amenable for scientific computation is called Spyder. Spyder is part of most Linux repositories and can easily be installed from there.

The easiest way to install Python and Spyder and all sorts of other useful packages for scientific computing is to install {python} via the Anaconda distribution from: https://www.anaconda.com/download/ This is a simple one click installation process which works for Linux/Windows/Mac and it installs everything! Download and install version Python 3.9 or higher for your system and use the 64 bit version (and not the 32 bit version).

A.2 Simple Calculations

After installation, open Spyder and try some of the following in the command line:

x = 2.5
y = 3.0
x + y

5.5

print("x= ", x)

x=  2.5

print("y= ", y)

y=  3.0

print("x + y = ", x + y)

x + y =  5.5

Then try the following:

Operation	Expression
Subtraction:	`x - y`
Division:	`x / y`
Multiplication:	`x * y`
Power:	`x ** y`
Square root:	`m.sqrt(x)`

Note that the power function is not ^ but **. Also in {python} we need to import the math-module in order to use certain math functions like sqrt() etc. When importing a module, we actually import a library of functions that all start with the module name. By typing import math at the beginning of your script you can then call all the functions of the math-module (or library) by typing math.functionName(). So if you want to take the square root of number 9, you would then simply call math.sqrt(9). You can also abbreviate the name of the module by typing import math as m in which case you can now take the square root with m.sqrt(9) as in the following script.

import math as m
x = 2.455555
y = 3.12344

print(" --- OUTPUT: --- ")
print(x + y)
print(x * y)
print(x / y)
print(x ** y)
print(m.sqrt(x))

 --- OUTPUT: --- 
5.578995
7.6697787092
0.7861700560920011
16.542802038492464
1.5670210592075653

If you want to see a list of all the functions in the math module you can type: dir(math) or dir(m) and you will get a list of all methods/functions embedded in the module.

A.3 The Print Function

If you want to format your print output and combine text with numbers you need to use the .format method of the print function. You will learn more about objects and methods in a later chapter. Just hang in there fore now.

If you want to format the numbers (e.g., round etc.) that print will output you need to type the double brackets {} in your text string as a placeholder for where the number will be inserted.

import math as m
x = 2.455555
y = 3.12344

print(" --- OUTPUT: --- ")
# Unformatted
print("x+y", x+y)
# Still unformatted but using the .format() method
print("x + y  = {}".format(x+y))

# Formatted, finally ...
print("x + y  = {:5.2f}".format(x+y))
print("x * y  = {:5.2f}".format(x*y))
print("x / y  = {:5.2f}".format(x/y))
print("x ** y = {:5.2f}".format(x**y))
print("sqrt(x)= {:5.2f}".format(m.sqrt(x)))

 --- OUTPUT: --- 
x+y 5.578995
x + y  = 5.578995
x + y  =  5.58
x * y  =  7.67
x / y  =  0.79
x ** y = 16.54
sqrt(x)=  1.57

You can write more complex output with more than one number embedded in a text as follows:

print(" --- OUTPUT: --- ")
print("""We want to use variable x = {0:4.2f} \n and divide by
variable y = {1:4.2f},\n so that we end up with expression
x/y = {2:4.2f}""".format(x, y, x/y))

 --- OUTPUT: --- 
We want to use variable x = 2.46 
 and divide by
variable y = 3.12,
 so that we end up with expression
x/y = 0.79

A.4 Script Files

Before we go on, let's save all our commands in a so called Script file. These are basically text files that contain all commands in one big "laundry list" that we can then execute all at once. In order to open such a script file in Spyder simply click on File $\rightarrow$ New. Copy/paste the above commands into this script file and save it under a name of your choosing. Note that the file has the extension .py which indicates that it is a {python} script file. You can then edit this file at will and add commands etc.

If you want to run or execute the script file simply click the Source button on top of your editor window. You can also execute the script file line by line. Simply mark the line, right click, and choose to execute selection or click on the Run icon on top of your editor window. This is the green button with the "running man symbol" on top of your editor window. If you'd like to execute just one line, mark the line and click on the "running man symbol" to the right of the first green button.

For the remainder of the class I highly recommend that you always use script files. This will help you to quickly run your code and evaluate your results.

A.5 ipython Notebook

A different way to write your codes is via the ipython Notebook. Read the instructions carefully, it should be pretty self explanatory. All you need to do is you open a terminal window.

Windows: Go to the start button and type cmd in the search box. This will open a black terminal window.

Mac: Open a terminal by clicking on the terminal symbol in the dashboard at the bottom.

In this window, after the dollar prompt, you simply type ipython-notebook. This will start your browser and get you to the ipython-Notebook dashboard. You can start a new notebook from there and start typing code into the input boxes. You can immediately evaluate Python code pressing: shift-enter. There are many tutorials about the ipython Notebook on the internet.

A.6 Plotting using `matplotlib`

In this section we explore some of the graphical functionality of Python. We first import the required libraries for plotting.

import numpy as np
import matplotlib.pyplot as plt
# The seaborn package makes your plots look nicer
import seaborn as sns
# Imports system time module to time your script
import time

plt.close('all')  # close all open figures
tic = time.time()

A.7 Plotting Vectors and Arrays

A.7.1 Plotting Simple Vectors

We first define a grid vector xv. We then plot the first vector using the plot() command in FigAutos.

xv = np.array([1, 2, 3, 4, 5])
carsv = np.array([1, 3, 6, 4, 9])

plt.plot(xv, carsv, 'b-', linewidth=2)
plt.show()

print("Time passed in seconds is = {:4.4f}".format(time.time() - tic))

Time passed in seconds is = 0.1422

A.7.2 Plotting Two Vectors

We first define a couple of vectors.

# Define vectors with 5 values each
xv     = np.array([1, 2, 3, 4, 5])
carsv   = np.array([1, 3, 6, 4, 9])
trucksv = np.array([2, 5, 4, 5, 12])
suvsv   = np.array([4, 4, 6, 6, 16])

We then plot the carsv and the trucksv vector into one graph.

fig, ax = plt.subplots()
ax.plot(xv,carsv, 'k-o', xv,trucksv,'b-.')
# Create a title with a red, bold/italic font
ax.set_title('Autos')
ax.legend(['cars','trucks'],loc='best')
plt.show()

A.7.3 Graph 3 Car Types

Finally, we graph all three car types into one figure. This time we save the graph as fig1.pdf into subfolder Graphs.

fig, ax = plt.subplots()
ax.plot(xv, carsv, 'b-o', xv, trucksv,'r-^', xv, suvsv, 'g:s')
ax.set_title('Autos')
ax.set_xlabel('Days')
ax.set_ylabel('Total')
ax.set_xlim([0.5,5.5])
#ylim(min(cars,trucks),max(cars,trucks))
# Create a legend
ax.legend(['cars', 'trucks', 'suvs'], loc = 'best')
# Save graphs in subfolder Graphs under name: fig1.pdf
plt.savefig('./Graphs/fig1.pdf')
plt.show()

A.8 Plotting Functions

If we want to plot a more general function like the $y = sin(x)$ we first need to define a grid of x values using the linspace function from the numpy library. We then calculate the sin(x) at each one of the x grid-points and record them in a yv vector. We then plot the xv "against" the yv vector.

xv = np.linspace(0, 10, 200)
yv = np.sin(xv)

fig, ax = plt.subplots()
ax.plot(xv, yv, 'r-', linewidth=2, label='sine function', alpha=0.6)
ax.set_title('Plotting the sin() function')
ax.legend(loc='best')
plt.show()

Here is another example with some more functions. We again first define the input vector xv with the values we want to evaluate the function at and then specify the "output" vector yv as $y = f(x)$. We use the following examples:

$f(x) = 50*sin(x)$,

$f(x) = x^2$,

$f(x) = 3*(x^2)/2 - 5$, and finally

$f(x) = 5*(x^2)/2 - \sqrt{x}$.

xv = np.arange(1, 10, 0.1)
y1v = 50*np.sin(xv)
y2v = xv**2
y3v = 3.0*(xv**2)/2 - 5
y4v = 5.0*(xv**2)/2 - np.sqrt(xv)

We have now two columns of values: x and y that we can plot against each other into a coordinate system.

fig, ax = plt.subplots()
ax.plot(xv, y1v, \
        xv, y2v, \
        xv, y3v, \
        xv, y4v)
ax.legend(['sin(x)', r'$x^2$', 'y3', 'y4'], loc = 'best')
plt.show()

A.9 Plotting Constants

If we have a constant function such as $f(x) = c$ where constant $c=5$ and we want to plot this in the domain of function $f$ of $0 leq x leq 20$ then we have to do

c = 5
xv = np.linspace(0, 20, 100)
yv = np.ones(100)*5

This generates a vector of length $100$ where each entry is the number $5$. You can now plot this with the usual plot command.

fig, ax = plt.subplots()
ax.plot(xv, yv)
ax.set_title('Constant function')
plt.show()

Note

If you simply did

c = 5
xv = np.linspace(0, 20, 100)
yv = c

and then tried to plot this you would get an error. The error is the result of you trying to plot two vectors of different lengths "against" each other. The first vector xv has length $100$ whereas the second vector yv has length $1$.

A.10 Plotting Production Functions

In economics we often deal with multivariate functions such as utilty functions with more than one consumption input or production functions with more than just one factor of production. How can we plot such functions?

A.10.1 Simple Production Function with one Input

Let's try to plot production functions first. A production function relates economic inputs to economic outputs. Here is a simple production function relating labor hours with number of services produced:

\[y = F(n) = A \times n^{0.5}\]

The letter $y$ is output and the letter $n$ is labor measured in work hours. The letter $A$ is total factor productivity (TFP) and is the "level of technology" that you have. Let's assume that the level of technology is $A=1$. Now, let's plot this.

A = 1
nv = np.linspace(0,5,10)
yv = A * nv**0.5

fig, ax = plt.subplots()
ax.plot(nv, yv, '-o')
ax.set_title('Output as function of labor input')
ax.set_xlabel('Labor $n$')
ax.set_ylabel('Output $y$')
plt.show()

Let us now calculate and then plot, the marginal product of labor (MPN), i.e., the extra output that one gets from adding a labor input. Mathematically, this means we take the derivative of the production function with respect to labor $n$. This results in

\[y' = \frac{\partial F(n)}{\partial n} = A \times 0.5 \times n ^{(0.5-1)}\]

Which can also be rewritten as

\[y' = \frac{\partial F(n)}{\partial n} = \frac{0.5 \times A}{n ^ {0.5}}\]

Next we again generate x and y values for this new function. Note that I start the x-grid at 0.5 and not at 0. Starting the grid at 0 would be problematic because you get a division by zero (which is infinity) error.

A = 1
nv = np.linspace(0.5,5,10)
yv = A * 0.5 * nv**(0.5 - 1)

fig, ax = plt.subplots()
ax.plot(nv, yv, '-o')
ax.set_title('Marginal product of labor')
ax.set_xlabel('Labor $n$')
ax.set_ylabel('Extra Output')
plt.show()

A.10.2 Cobb-Douglas Production Functions with 2 Inputs

Finally let's plot some Cobb-Douglas production functions. This is a very popular form of a production function in economics. It is a function that usually has two inputs, capital and labor.

\[y = F(k,n) = A \times k^\alpha n^{(1-\alpha)}\]

The letter $k$ is capital, the letter $n$ is labor, and $A$ is again total factor productivity (TFP) i.e., the level of technology. The Greek symbol $\alpha$ is the factor share of capital in production. Just treat it as a constant for now.

Now let's assume that you have the following given $A=1$, $k=10$, and $\alpha = 0.3$

Let us now plot this production with respect to changes in labor holding the above values constant.

A = 1
k = 10
alpha = 0.3
nv = np.linspace(0,5,10)
yv = A * k**alpha * nv**(1-alpha)

fig, ax = plt.subplots()
ax.plot(nv, yv, '-o')
ax.set_title('Cobb-Douglas function output')
ax.set_xlabel('Labor $n$')
ax.set_ylabel('Output $y$')
plt.show()

Let us again calculate and plot, the marginal product of labor, i.e., the extra output that one gets from adding a labor input. Mathematically, this means we take the derivative of the production function with respect to labor $n$. This results in

\[y' = \frac{\partial F(k,n)}{\partial n} = A \times (1-\alpha) \times k^{\alpha} \times n ^{(1-\alpha-1)}\]

Which can also be rewritten as

\[y' = \frac{\partial F(k,n)}{\partial n} = A \times (1-\alpha) \times k^{\alpha} \times n ^{-\alpha}\]

\[y' = \frac{\partial F(k,n)}{\partial n} = (1-\alpha) \times A \times \left(\frac{k}{n}\right)^{\alpha}\]

A = 1
alpha = 0.3
nv = np.linspace(0,5,10)
yv = (1-alpha) * A * k**alpha * nv**(-alpha)

fig, ax = plt.subplots()
ax.plot(nv, yv, '-o')
ax.set_title('Marginal product of labor')
ax.set_xlabel('Labor $n$')
ax.set_ylabel('Extra output')
plt.show()

/tmp/ipykernel_25658/3152989863.py:4: RuntimeWarning: divide by zero encountered in power
  yv = (1-alpha) * A * k**alpha * nv**(-alpha)

Here you see the divide by zero warning I get because I started the x-grid at value zero. So the computer only plots 9 points this time and suppresses the first one that it cannot calculate.

Finally, let's calculate the production function for different levels of capital. So we have, say, three different economies with capital stock $k_1=10$, $k_2=15$, and $k_3=20$, respectively. Then let's plot output into a graph.

A = 1
k1 = 10
k2 = 15
k3 = 20
alpha = 0.3
nv = np.linspace(0,5,10)
y1v = A * k1**alpha * nv**(1-alpha)
y2v = A * k2**alpha * nv**(1-alpha)
y3v = A * k3**alpha * nv**(1-alpha)

fig, ax = plt.subplots()
ax.plot(nv, y1v, '-o', \
        nv, y2v, '-o', \
        nv, y3v, '-o')
ax.set_title('Cobb-Douglas function output')
ax.set_xlabel('Labor $n$')
ax.set_ylabel('Output $y$')
ax.legend(['$k_1=10$', '$k_2=15$', '$k_3=20$'], loc = 'best')
plt.show()

And here are the marginal products of labor for the 3 economies. Note the warnings that Python spits out for the first point in the nv grid. This point is zero and the function itself has $nv^{(-alpha)}$ which is $\frac{1}{nv^\alpha}$ and therefore results in a division by zero.

A = 1
k1 = 10
k2 = 15
k3 = 20
alpha = 0.3
nv = np.linspace(0,5,10)
y1v = (1.-alpha)* A * k1**alpha * nv**(-alpha)
y2v = (1.-alpha)* A * k2**alpha * nv**(-alpha)
y3v = (1.-alpha)* A * k3**alpha * nv**(-alpha)

fig, ax = plt.subplots()
ax.plot(nv, y1v, '-o', \
        nv, y2v, '-o', \
        nv, y3v, '-o')
ax.set_title('Marginal product of labor in Cobb-Douglas')
ax.set_xlabel('Labor $n$')
ax.set_ylabel('Output $y$')
ax.legend(['$k_1=10$', '$k_2=15$', '$k_3=20$'], loc = 'best')
plt.show()

/tmp/ipykernel_25658/362966397.py:7: RuntimeWarning: divide by zero encountered in power
  y1v = (1.-alpha)* A * k1**alpha * nv**(-alpha)
/tmp/ipykernel_25658/362966397.py:8: RuntimeWarning: divide by zero encountered in power
  y2v = (1.-alpha)* A * k2**alpha * nv**(-alpha)
/tmp/ipykernel_25658/362966397.py:9: RuntimeWarning: divide by zero encountered in power
  y3v = (1.-alpha)* A * k3**alpha * nv**(-alpha)

If you do not want to see these warnings you can start the nv grid with a small number, close to---but not equal to---zero. Note the change in the linspace command below.

A = 1
k1 = 10
k2 = 15
k3 = 20
alpha = 0.3
nv = np.linspace(0.01,5,10)
y1v = (1.-alpha)* A * k1**alpha * nv**(-alpha)
y2v = (1.-alpha)* A * k2**alpha * nv**(-alpha)
y3v = (1.-alpha)* A * k3**alpha * nv**(-alpha)

fig, ax = plt.subplots()
ax.plot(nv, y1v, '-o', \
        nv, y2v, '-o', \
        nv, y3v, '-o')
ax.set_title('Marginal product of labor in Cobb-Douglas')
ax.set_xlabel('Labor $n$')
ax.set_ylabel(r'MPN $\rightarrow$ change in output')
ax.legend(['$k_1=10$', '$k_2=15$', '$k_3=20$'], loc = 'best')
plt.show()

Let us now derive the derivative function of the production function, i.e., we calculate the second derivative with respect to labor:

\[Y = A F(k,n) = A \times k^{\alpha} \times n ^{1-\alpha}\]

\[\frac{\partial F(k,n)}{\partial n} = (1-\alpha) \times A \times k^{\alpha} \times n ^{-\alpha} > 0\]

\[\frac{\partial^2 F(k,n)}{\partial n\partial n} = (-\alpha) (1-\alpha) \times A \times k^{\alpha} \times n ^{-\alpha-1} < 0\]

The first derivative is positive and the second derivative is negative. The negative second derivative tells you that the increments in production (as measured by the first derivative) decrease at a smaller and smaller rate.

A = 1
k1 = 10
k2 = 15
k3 = 20
alpha = 0.3
nv = np.linspace(0.1, 5, 10)
y1v = (-alpha) * (1.-alpha) * A * k1**alpha * nv**(-alpha-1.)
y2v = (-alpha) * (1.-alpha) * A * k2**alpha * nv**(-alpha-1.)
y3v = (-alpha) * (1.-alpha) * A * k3**alpha * nv**(-alpha-1.)

fig, ax = plt.subplots()
ax.plot(nv, y1v, '-o', \
        nv, y2v, '-o', \
        nv, y3v, '-o')
ax.set_title(r'Second Derivative of MPN: $\frac{\partial^2 F(k,n)}{(\partial n)^2}$')
ax.set_xlabel(r'Labor $n$')
ax.set_ylabel(r'$\frac{\partial^2F}{(\partial n)^2}$')
ax.legend([r'$k_1=10$', r'$k_2=15$', r'$k_3=20$'], loc = 'best')
plt.show()

A.11 Plotting Utility Functions

We next plot utility functions. Utility functions relate consumed consumption units to levels of satisfaction that can be reached by consuming said units. Utility is measured in 'utils', units of satisfaction.

Here is a simple utility function that shows the units of satisfaction for particular levels of consumption good $c$.

\[utils = u(c) = \sqrt{c}\]

The square root function can also be written as:

\[utils = u(c) = c^{0.5}\]

If we plot this utility function we get:

cv = np.linspace(0, 5, 100)  # Generates 100 point grid spanning from 0 to 5
uv = cv**(0.5)

fig, ax = plt.subplots()
ax.plot(cv, uv, '-o')
ax.set_title('Utility function')
ax.set_xlabel('Consumption $c$')
ax.set_ylabel('Utils $u(c)$')
plt.show()

The marginal utility measures the extra satisfaction (or utils) that we get from a small increase in consumption of good $c$.

The marginal utility function $MU$ can be calculated as the derivative $u'(c)$ of the original utility function $u(c)$.

We use the power rule to calculate this derivative. As a reminder, the power rule states that the derivative of a general function of the form:

\[f(x) = a \times x ^ n\]

is calculated as:

\[f'(x) = a \times n \times x ^ {n - 1}.\]

For our utility function

\[utils = u(c) = c^{0.5}\]

this now means that the marginal utility function is simply

\[u'(x) = 0.5 \times c^{0.5 - 1} = 0.5 \times c^{-0.5}\]

or somewhat cleaner:

\[u'(x) = \frac{0.5}{c^{0.5}}\]

This can of course be rewritten as

\[u'(x) = \frac{1}{2 \times \sqrt{c}}\]

Next we again generate $c$ and $u'(c)'$ values for this new function. Note that I start the c-grid at 0.2 and not at 0. Starting the grid at 0 would be problematic because you get a division by zero (which is infinity) error.

cv = np.linspace(0.2, 5, 100)
uprimev = 0.5/(cv**0.5)

fig, ax = plt.subplots()
ax.plot(cv, uprimev, '-o')
ax.set_title('Marginal utility of consumption')
ax.set_xlabel('Consumption $c$')
ax.set_ylabel('Marginal utility of consumption (MU)')
plt.show()

A.12 Using Data from FRED

I first downloaded data from the Federal Reserve database <FRED https://fred.stlouisfed.org/> and stored the data in a subfolder called Graphs. I downloaded GDP at annual, quarterly and monthly frequencies.

import os
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

titleSize = 16
sns.set_style("whitegrid", {'grid.linestyle': ':'})

# -----------------------------------------------------------------------------
# Load data
df_a = pd.read_csv('Graphs/Annual_FRED.csv', header=0, index_col=0, parse_dates=True)
df_q = pd.read_csv('Graphs/Quarterly_FRED.csv', header=0, index_col=0, parse_dates=True)
df_m = pd.read_csv('Graphs/Monthly_FRED.csv', header=0, index_col=0, parse_dates=True)

A.12.1 Converting Nominal to Real GDP

The following Table shows U.S. nominal GDP and U.S. real GDP at five-year intervals since 1960. Nominal GDP is in nominal dollars (that is, nominal GDP is measured using the actual market prices prevailing in each stated year) and real GDP is calculated in “2012 dollars”.

Note

Remember, for real GDP we need a base year. The base year chose was 2012. You can also see this in Figure A.3 below where the nominal and real GDP lines cross in year 2012.

# GDP Deflator
df_a['GDP_Deflator'] = df_a['GDP']/df_a['rGDP']*100

df1_a = df_a[['GDP', 'rGDP', 'GDP_Deflator']].copy()

print(df1_a.loc['1960'::])

                  GDP       rGDP  GDP_Deflator
year                                          
1960-01-01    540.197   3470.278     15.566390
1961-01-01    580.612   3692.289     15.724988
1962-01-01    612.280   3851.421     15.897509
1963-01-01    653.938   4050.147     16.146031
1964-01-01    697.319   4259.046     16.372657
...               ...        ...           ...
2019-01-01  21902.390  20951.088    104.540585
2020-01-01  22024.502  20724.128    106.274686
2021-01-01  24654.603  21847.602    112.848097
2022-01-01  26408.405  21989.981    120.092896
2023-01-01  27938.831  22672.859    123.225884

[64 rows x 3 columns]

These data are also shown in the following graph.

df_a[['GDP']].loc['1960'::].plot(style = ['-'])
plt.title('Nominal GDP', fontsize=titleSize)
plt.ylabel('in Billion US $')
plt.show()

If an unwary analyst compared nominal GDP in 1960 to nominal GDP in 2010, it might appear that national output had risen by a factor of twenty-seven over this time (that is, GDP of $14,958 billion in 2010 divided by GDP of $543 billion in 1960).

This conclusion would be highly misleading. Recall that nominal GDP is defined as the quantity of every good or service produced multiplied by the price at which it was sold, summed up for all goods and services. In order to see how much production has actually increased, we need to extract the effects of higher prices on nominal GDP. This can be easily done, using the GDP deflator.

df_a[['GDP_Deflator']].loc['1960'::].plot(style = ['-'])
plt.title('GDP-Deflator', fontsize=titleSize)
plt.show()

Figure A.2: GDP-Deflator is nominal GDP divided by real GDP

GDP deflator is a price index measuring the average prices of all goods and services included in the economy. We explore price indices in detail and how they are computed in Inflation, but this definition will do in the context of this chapter. The data for the GDP deflator are given in the table above and are shown graphically in Figure A.2.

Figure A.2 shows that the price level has risen dramatically since 1960. The price level in 2010 was almost six times higher than in 1960 (the deflator for 2010 was 110 versus a level of 19 in 1960). Clearly, much of the apparent growth in nominal GDP was due to inflation, not an actual change in the quantity of goods and services produced, in other words, not in real GDP. Recall that nominal GDP can rise for two reasons: an increase in output, and/or an increase in prices.

What is needed is to extract the increase in prices from nominal GDP so as to measure only changes in output. After all, the dollars used to measure nominal GDP in 1960 are worth more than the inflated dollars of 1990—and the price index tells exactly how much more. This adjustment is easy to do if you understand that nominal measurements are in value terms, where

\[Value = Price \times Quantity\]

\[Nominal\ GDP = GDP\ Deflator \times Real\ GDP\]

Note

MICRO EXAMPLE

Let’s look at an example at the micro level. Suppose the t-shirt company, Coolshirts, sells 10 t-shirts at a price of $9 each.

\[ nominal\ revenue\ from\ sale = Price \times Quantity \] \[ = \$9 \times 10 \] \[ = \$90 \]

Then Coolshirts real income is:

\[ real\ income = \frac{Nominal\ revenue}{Price} \] \[ = \frac{$90}{$9} = 10 \]

In other words, when we compute “real” measurements we are trying to get at actual quantities, in this case, 10 t-shirts.

With GDP, it is just a tiny bit more complicated. We start with the same formula as above:

\[Real\ GDP = \frac{Nominal\ GDP}{Price\ Index}\]

For reasons that will be explained in more detail below, mathematically, a price index is a two-digit decimal number like 1.00 or 0.85 or 1.25. Because some people have trouble working with decimals, when the price index is published, it has traditionally been multiplied by 100 to get integer numbers like 100, 85, or 125. What this means is that when we “deflate” nominal figures to get real figures (by dividing the nominal by the price index). We also need to remember to divide the published price index by 100 to make the math work.

So the formula becomes:

\[Real\ GDP = \frac{Nominal\ GDP}{Price\ Index /100} \] \[ = \frac{Nominal\ GDP}{Price\ Index} \times 100\]

df_q[['GDP', 'rGDP']].plot(style = ['-', '--'])
plt.title('Nominal and Real US-GDP (2012 Base Year)' , fontsize=titleSize)
plt.ylabel('in Billion US $')
plt.show()

Figure A.3: Nominal and real GDP. The base year for real GDP is 2012

A.1 Installing Python

A.2 Simple Calculations

A.3 The Print Function

A.4 Script Files

A.5 ipython Notebook

A.6 Plotting using matplotlib

A.7 Plotting Vectors and Arrays

A.7.1 Plotting Simple Vectors

A.7.2 Plotting Two Vectors

A.7.3 Graph 3 Car Types

A.8 Plotting Functions

A.9 Plotting Constants

A.10 Plotting Production Functions

A.10.1 Simple Production Function with one Input

A.10.2 Cobb-Douglas Production Functions with 2 Inputs

A.11 Plotting Utility Functions

A.12 Using Data from FRED

A.12.1 Converting Nominal to Real GDP

A.6 Plotting using `matplotlib`