index.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### preliminary steps (ignore this)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from misc_tools import plotSeries\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Juypter Notebook Overview\n",
    "\n",
    "This is a `Jupyter` notebook. It allows us to use the `Python` programming language and\n",
    "see our results in real time. The notebook is split into `cells`. Each cell will either have\n",
    "some text in it, which is called a `Markdown` cell, or some `Python` code in it, called a\n",
    "`Code` cell. You can toggle the cell type using the dropdown menu above:\n",
    "\n",
    "![cell type menu 1](menu1.png \"Change Cell Type\")\n",
    "\n",
    "To execute the commands in a given cell, click the `Run` button above:\n",
    "\n",
    "![run_button](menu3.png \"Run\")\n",
    "\n",
    "After you \"run\" a cell, if there is any output to display, it will be shown directly below that cell:\n",
    "\n",
    "![output](output.png \"Output\")\n",
    "\n",
    "The `Jupyter` notebook keeps track of all the cells that have been run so far. So,\n",
    "if a cell references results or output from another cell, you have to make sure they are\n",
    "run in order. In this notebook, if you run each cell of code in order, you will be okay.\n",
    "To help keep track of things, `Jupyter` puts a number next to each cell after it is run\n",
    "telling you in what order it was run. If you get out of order, you can reset the cells by \n",
    "clicking on the `Kernel` menu above and `Restart & Clear Output`.\n",
    "\n",
    "You won't have to edit any of the `Markdown` cells to complete the exercises below, but you can\n",
    "use new `Markdown` cells to write notes to yourself."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Overview\n",
    "\n",
    "`Python` is a an `object oriented` programming language. Objects are, as they\n",
    "sound, things that we can use to hold numbers, to carry out commands, etc.\n",
    "Types of objects include variables, lists, class objects, and so on. Objects\n",
    "sometimes have attributes, which are themselves types of objects. Think\n",
    "of these as a sort of \"sub-object\" or a family. One object may be the parent\n",
    "object, and other objects are dependent on the parent. For example if we have\n",
    "and object `mom` and `son` is an attribute, then we would access\n",
    "`son` by calling `mom.son`. This will make more sense in a minute.\n",
    "\n",
    "More documentation for `Python` is [here](https://docs.python.org/3/tutorial/)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simple Commands\n",
    "\n",
    "We can do simple commands in `Python`. For example, here are some calculations.\n",
    "To evaluate the calculations, highlight the cell and click the `Run` button above."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Addition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2 + 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Multiplication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2 * 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Raising to a Power"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2**3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Division"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2/3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables\n",
    "\n",
    "We can also assign values to variables using the `=` sign. We can assign\n",
    "variables to be numbers or strings of text. Listing the variable by itself\n",
    "will display it's current value. Again, highlight a cell and\n",
    "click the `Run` button to see the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 3\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 'hello world'\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 1\n",
    "\n",
    "Create two variables. Assign them numeric values, and then multiply them by\n",
    "each other. Display the results.\n",
    "\n",
    "Next, create two new variables. Assign one to be an integer and the other to be\n",
    "a string that is one letter. Multiply these two variables and display the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists\n",
    "\n",
    "Another useful type of object is a `list`. A list is an ordered collection\n",
    "of elements, each of which is itself some type of object. We create\n",
    "a list by using brackets and commas `[a,b,c,d]`. This list has four\n",
    "elements. The elements are indexed by position, starting at 0. So element\n",
    "`0` is `a` and element `3` is `d`. We can also index using negative numbers.\n",
    "Element `-1` is `d` and element `-3` is `b`.\n",
    "\n",
    "Below is a list of numbers, a list of strings, and a list of lists.\n",
    "\n",
    "We can add lists together and multiply them by integers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myList = [1,2,3,4]\n",
    "myList[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myNewList = ['a','b','c','d']\n",
    "myList[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "listOfList = [myList,myNewList]\n",
    "listOfList[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myWholeList = myList + myNewList\n",
    "myWholeList"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myDoubleList = 2 * myList\n",
    "myDoubleList"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Warning:** When we create a new object using an existing object, the\n",
    "new object may become an `alias` for the old object. It \"points\" back to\n",
    "the previous object, and any changes to the new placeholder also affect\n",
    "the old placeholder. The way around that is to use the `deepcopy` command,\n",
    "but we won't cover that here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myAlias = myList\n",
    "myAlias[1] = 'x'\n",
    "myList"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 2\n",
    "\n",
    "Create a list with the letters of your first name. Change all of the\n",
    "vowels in the list to the number 3. Use a different cell for each step. To\n",
    "add a new cell, use the `Insert` menu or the `+` button above. Display\n",
    "the final list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions\n",
    "\n",
    "We use functions to define a set of commands that we want to repeat. The\n",
    "syntax for defining a function includes using the `def` command, then a name \n",
    "for the function, and a list of arguments that the function will use. \n",
    "We can also put comments inside the function to let ourselves (and others) \n",
    "know what is going on, using the sequence `'''` above and below the comment. \n",
    "`Python` ignores whatever is in these comments.\n",
    "\n",
    "The function then performs some operations, and we close\n",
    "the definition with a `return` line, which tells the function what to return\n",
    "to us. We can define new variables within the function definition that\n",
    "will only exist while the function is performing its operations. Note\n",
    "the use of indentation to let `Python` know we are inside of the function\n",
    "definition.\n",
    "\n",
    "**Note:** We let `Python` know what is a part of the function by\n",
    "indenting each line by 4 spaces (or a tab) relative to the `def` command.\n",
    "To exit a definition of a function, we start a new line that is\n",
    "not indented."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def multBy2(x):\n",
    "    '''\n",
    "    Function that multiples x by 2.\n",
    "    '''\n",
    "    \n",
    "    y = x * 2\n",
    "    \n",
    "    return y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "multBy2(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note:** The function doesn't truly restrict the argument `x` to be a scalar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "multBy2('a')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note:** If we want to only allow scalars, we can use the `assert` command\n",
    "along with the `isinstance()` operator to check for scalars and stop the \n",
    "function if the argument is not a scalar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def multScalarBy2(x):\n",
    "    '''\n",
    "    Function that multiples x by 2. The argument x must be a scalar.\n",
    "    '''\n",
    "    assert isinstance(x, (int,long,float)), 'Argument x must be a scalar'\n",
    "    \n",
    "    y = x * 2\n",
    "    \n",
    "    return y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "multScalarBy2(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "multScalarBy2('a')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classes\n",
    "\n",
    "Another type of tool we will use is a `class`. A class can be thought of\n",
    "as a recipe or a blueprint. It sets the structure and rules for an object.\n",
    "After that, we can create multiple instances of the same `class`. Each instance\n",
    "is its own object, and can have specific attributes and features, but it\n",
    "will follow the general rules of the class.\n",
    "\n",
    "A `class` can specify what will happen each time an instance of a `class` is\n",
    "created or \"initialized.\" It can also define specific attributes that an\n",
    "instance of the class will have. Think of these as sub-objects. The `class`\n",
    "can also specify `methods` which are functions attached to a class.\n",
    "\n",
    "Below we will create a general class of multiplier. Then we will create two\n",
    "instances of the class, which will be different, but will follow the same\n",
    "general set of rules.\n",
    "\n",
    "**Note:** We are using indentation to indicate everything that is a part\n",
    "of the `class` and then indenting again to note what is a subpart\n",
    "of each `method`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class multiplier:\n",
    "    '''\n",
    "    A class for multiplying numbers by a specific scalar\n",
    "    '''\n",
    "    \n",
    "    className = 'multiplier'\n",
    "    \n",
    "    def __init__(self, a = 1):\n",
    "        '''\n",
    "        Initialization rules for a multiplier.\n",
    "        '''\n",
    "        self.a = a\n",
    "    \n",
    "    def mult(self, x):\n",
    "        '''\n",
    "        A method (function) used by the multiplier to multiply numbers.\n",
    "        '''\n",
    "        \n",
    "        y = x * self.a\n",
    "        \n",
    "        return y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Discussion\n",
    "\n",
    "We started off with the `class` command, and then the name of the `class`, in this case `multiplier`, and then colon.\n",
    "\n",
    "````Python\n",
    "class multiplier:\n",
    "````\n",
    "\n",
    "The first type of attribute we created `className` is the same for all\n",
    "instance of the class.\n",
    "\n",
    "````Python\n",
    "    className = 'multiplier'\n",
    "````\n",
    "\n",
    "The next method `__init__` is a special method (function)\n",
    "that gets called when a new instance of the class is created. Note that\n",
    "the first argument of the method is `self`, which lets the function access\n",
    "features unique to a given instance of a class.\n",
    "\n",
    "````Python\n",
    "    def __init__(self, a = 1):\n",
    "````\n",
    "\n",
    "We create an instance-specific\n",
    "attribute `self.a` that could be difference for each instance.\n",
    "\n",
    "````Python\n",
    "        self.a = a\n",
    "````\n",
    "\n",
    "Finally,\n",
    "the method `mult` performs multiplication on an argument `x`. It also has\n",
    "`self` as its first argument so that it can access `self.a`.\n",
    "\n",
    "````Python\n",
    "    def mult(self, x):\n",
    "        \n",
    "        .\n",
    "        .\n",
    "        .\n",
    "        \n",
    "        y = x * self.a\n",
    "````\n",
    "\n",
    "Below we create two distinct instances of the `multiplier` class. Notice we feed\n",
    "a value for `a` when we first create the instance. If we leave the argument\n",
    "unspecified, the default value for `a` would have been 1, which we have\n",
    "specified above when we put `a = 1` in the `__init__` method above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "multA = multiplier(a = 4)\n",
    "multA.a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "multA.className"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "multA.mult(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "multB = multiplier(a = 5)\n",
    "multB.a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "multB.className"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "multB.mult(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List Comprehensions\n",
    "\n",
    "The final tool we will use is a list comprehension. In many programming languages,\n",
    "including `Python`, you can use a `for` loop to cycle through a series of repetitive\n",
    "actions. In `Python` another option is to use a \"list compression.\" This operates\n",
    "like a `for` loop, but also collects the outcome of each loop as an element of a list.\n",
    "\n",
    "Here is an example of a list comprehension that goes from 0 to 10, multiplies each number by 5,\n",
    "using our command above, and then creates a list with the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "multList = [multB.mult(x) for x in [0,1,2,3,4,5,6,7,8,9,10]]\n",
    "multList"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note:** Instead of listing every number from 1 to 10, we can use the `range()`\n",
    "command to create a list for us. Note, if you type `range(n)`, you will get\n",
    "a set of nubmers from 0 to `n-1`. You can also use the command `range(n,m)` to get\n",
    "a set of numbers from `n` to `m-1`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "multList2 = [multB.mult(x) for x in range(11)]\n",
    "multList2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 3\n",
    "\n",
    "Create a list using a list comprehension, that takes the integers 4 through 12,\n",
    "multiplies them by 4 using the `multA` multiplier, and also adds the number 2\n",
    "to each element. Then display the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Structural Economic Modeling\n",
    "\n",
    "We will now see how we can use the programming tools above to do structural economic modeling.\n",
    "What this means is that we will first theoretical lay out a model of economic behavior. This could\n",
    "be a model of how firms set prices, how people choose how much to work, or how\n",
    "anti-discrimination laws affect black-white wage gaps, for example. \n",
    "\n",
    "Once we have a theoretical\n",
    "model, we can program up a general case of the model, that depends on a set of parameters, which\n",
    "we will call $\\theta$. These parameters could be the income different people have, the\n",
    "cost of producing goods, or the taxes paid for each dollar earned, for example. The model then \n",
    "can be used to predict outcomes, which we will call $X\\left(\\theta\\right)$. The outcome $X$ will \n",
    "depend on the chosen value of $\\theta$. \n",
    "\n",
    "Once we have our model up an running, we have the ability to\n",
    "predict outcomes $X$ given parameters $\\theta$, we can do some estimation. If there are\n",
    "some parts of $\\theta$ that are unknown, but we have data from the real world, call that\n",
    "$X_{real}$, we can ask what values of the unknown parts of $\\theta$ are needed to get our\n",
    "predicted values of $X$ to match the real world."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example: Consumer Demand\n",
    "\n",
    "We will model, program, and simulate a simple example of consumer demand. First, we need some theory.\n",
    "\n",
    "We have a consumer that chooses between two goods $x$ and $y$. The prices of the two goods are\n",
    "$p_{x}$ and $p_{y}$. The consumer has a total income of $I$ to spend on these two goods. Finally,\n",
    "the consumer gets `utility` or happiness from consuming these goods. Here is their utility function:\n",
    "\n",
    "$$\n",
    "U\\left(x,y\\right) \\equiv x^{a} \\cdot y^{1-a}\n",
    "$$\n",
    "\n",
    "As you can see from this example, the utilty function has several standard features. It is increasing\n",
    "in each argument, $x$ and $y$. The more, the merrier. Also, the `marginal utility` of each good, i.e.\n",
    "the additional utility from consuming another unit, is diminishing. The first unit of a good \n",
    "has a greater impact on utilty than the 10th good.\n",
    "\n",
    "We can now present the `consumer demand problem`. The consumer will choose an amount of $x$ and $y$\n",
    "to maximize utility, while staying within their `budget constraint`. That is, they solve:\n",
    "\n",
    "$$\n",
    "\\max_{x,y} x^{a} \\cdot y^{1-a} \\\\\n",
    "\\text{such that } p_{x}x + p_{y}y = I\n",
    "$$\n",
    "\n",
    "Can you solve for the optimal $x$ and $y$? \\[Hint: you can use the Lagrange method.\\]\n",
    "\n",
    "After doing some simple constrained optimization, we have the following `demand functions`:\n",
    "\n",
    "$$\\begin{eqnarray}\n",
    "x(p_{x}) &=& \\frac{aI}{p_{x}} \\\\\n",
    "y(p_{y}) &=& \\frac{(1-a)I}{p_{y}} \\\\\n",
    "\\end{eqnarray}$$\n",
    "\n",
    "You can verify yourself that these levels of demand do satisfy the budget set.\n",
    "\n",
    "Below, we will model this consumer, their choices, and then graph their choices over a variety\n",
    "of price levels, i.e. we will draw a demand curve."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 1: Create the Consumer\n",
    "\n",
    "Start by creating a `class` called `consumer`. Also, give the consumer a `__init__`\n",
    "method that takes as an input the parameter `a` and the income level `I`. Save\n",
    "each of these inputs as attributes of the `consumer`. Also, make is so that\n",
    "the `consumer` `class` only accepts values of `a` between 0 and 1.\n",
    "\n",
    "**Hint:** look above for tips. To access an attribute of the `class` object\n",
    "you have to make use of the `self` object. Also, be mindful of your indentation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create an instance of the `consumer` `class` that has a value of `a = 0.2` and\n",
    "`I = 10` Show that consumer you've created indeed has the right value\n",
    "for those two parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 2: Add the utility function\n",
    "\n",
    "Using the equation above, add a method to your `consumer` `class` \n",
    "that takes as arguments `x` and `y` and returns the value of the utility function.\n",
    "\n",
    "You can cut and paste the code you used above to create the `consumer` `class`.\n",
    "\n",
    "**Hint:** See above for how to raise a term to an exponent. Also, remember\n",
    "the role that `self` plays in the `method` of a `class`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create an instance of this new `class` with `a = 0.2` and\n",
    "`I = 10` and show what the level of utility is when `x = 3`\n",
    "and `y = 2`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 3: Add the x demand function\n",
    "\n",
    "Now add a new `method` to your consumer `class`. You can paste the code from above and continue\n",
    "here with new features. This `method` will take as an argument `px` and will return\n",
    "the level of `x` demanded. Use the equations above for demand."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create another instance of this new `consumer` class with `a = 0.2` and `I = 10`. Show\n",
    "how much of `x` will be demanded with `px = 4`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 4: Add the y demand function\n",
    "\n",
    "Using similar steps, add a `method` that returns the level of `y` demanded given\n",
    "a price `py`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create an instance of this `consumer` class with `a = 0.2` and `I = 10` and\n",
    "show how much of much of `y` will be demanded when `py = 3`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 5: Show that your demand functions satisfy the budget constraint\n",
    "\n",
    "Now that you have coded up demand. Show that at given prices for `x` and `y`, the demand at those\n",
    "prices indeeds satisfies the budget constraint. See above in our theory section for the budget constraint\n",
    "formula."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 6: Graph the demand curve for x\n",
    "\n",
    "For our grand finale, we are going to graph the `inverse demand curve`.\n",
    "This plots for a given amount of `x`, the price that the consumer is willing \n",
    "to pay for the next unit of the good. To do this, we collect demand `x` for\n",
    "values of price `px`, and then plot them with `px` on the y-axis and `x` on\n",
    "the x-axis.\n",
    "\n",
    "To do this, we are going to borrow a tool I've\n",
    "already created that will graph data. The command is called `plotSeries` and\n",
    "it takes two arguments, `d1` and `d2`. These should be two lists that have the same\n",
    "lenght. The function will then plot the points using `d1` as the x-coordinates\n",
    "and `d2` as the y-coordinates. Simply type this command:\n",
    "\n",
    "````Python\n",
    "plotSeries(d1, d2)\n",
    "````\n",
    "\n",
    "We are going to plot the inverse demand, that is, the price `px` that\n",
    "the consumer is willing to pay for given a level of consumption `x`. \n",
    "\n",
    "To start, we need a list of prices. Let create a list of prices in integers \n",
    "from 1 to 8.\n",
    "\n",
    "**Hint:** Use a list comprehension to create this list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, create a list with the amount `x` demanded for each value of `px` in our first list.\n",
    "\n",
    "**Hint:** Once again, use a list compression to create the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, use the `plotSeries` command to plot the demand curve."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bonus: Spice up your graph\n",
    "\n",
    "The `plotSeries` function can take additional arguments. For example\n",
    "to specify a title for the graph, you can use:\n",
    "\n",
    "````\n",
    "plotSeries(d1, d2, title = 'Title Here')\n",
    "````\n",
    "\n",
    "Also, you can put labels on the x-axis and the y-axis using additional\n",
    "arguments `xTitle` and `yTitle`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": true,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}