Lesson 2. More Fun with Functions and Variables.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# More Fun with Variables\n",
    "\n",
    "So far, we've been focusing on working with just numbers in Python, but Python can work with lots of different *data types*. For example, we can assign letters and words to variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "dog\n"
     ]
    }
   ],
   "source": [
    "a = 'a'\n",
    "print(a)\n",
    "\n",
    "dog = \"dog\"\n",
    "print(dog)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Groups of letters and words are called *strings* in Python. Strings always have to be surrounded by apostraphes (**'**) or quotation marks (**\"**). We can add and multiply strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ab\n",
      "bbbbb\n"
     ]
    }
   ],
   "source": [
    "a = 'a'\n",
    "b = 'b'\n",
    "\n",
    "print(a + b)\n",
    "print(b * 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can convert a number into a string using the built-in \"str\" function. Notice that adding strings together is different than adding numbers together:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12.2\n"
     ]
    }
   ],
   "source": [
    "one = str(1)\n",
    "two_point_two = str(2.2)\n",
    "\n",
    "print(one + two_point_two)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can convert strings into whole-numbers using the \"int\" function, or into decimals with the \"float\" function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.2\n"
     ]
    }
   ],
   "source": [
    "one = int('1')\n",
    "two_point_two = float('2.2')\n",
    "\n",
    "print(one + two_point_two)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are lots of cool things you can do with strings, but we'll talk more about the later. For now, just remember that strings are different from numbers, and you can assign strings to variables.\n",
    "\n",
    "You can also assign functions to variables in Python. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "1.23\n"
     ]
    }
   ],
   "source": [
    "r = round\n",
    "print(r(3.3))\n",
    "print(r(1.2345, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises\n",
    "\n",
    "Try to figure out what the value of $x$ will be after running the following Python code. Then actually run the code to check your work:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = 'x'\n",
    "x = x * 5 + x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = 3\n",
    "x = 3 * str(x) + str(2 * x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# More Fun with Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The print Function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One of the nice things about Python is that there are a lot of built-in functions that have already been written for us. One built-in function we have already seen is \"print\". We've already seen that \"print\" can be used to show values of variable on the screen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "num = 5\n",
    "print(num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "print can actually take arguments and show all of their values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 10 15\n"
     ]
    }
   ],
   "source": [
    "num1 = 5\n",
    "num2 = 10\n",
    "print(num1, num2, num1 + num2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default, print will put a space between each value, but you can change this by specifying the \"sep\" argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5_10_15\n",
      "5/10/15\n",
      "51015\n",
      "5 10 15\n"
     ]
    }
   ],
   "source": [
    "print(num1, num2, num3, sep='_')\n",
    "print(num1, num2, num3, sep='/')\n",
    "print(num1, num2, num3, sep='')\n",
    "print(num1, num2, num3, sep=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sidenote: Optional Arguments and Default Values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The \"sep\" argument for the print function is an optional argument, and if you do not specify its value, it will default to a space. You can also create optional arguments with default values for your own functions like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def my_function(a, b=10, c=2):\n",
    "    answer = a + b / c\n",
    "    return answer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This function takes three arguments, $a$, $b$, and $c$, and it returns $a + b \\div c$. $a$ is a required argument, but $b$ and $c$ are optional, with the default values of $5$ and $10$ respectively. You can call it just by giving $a$ as an argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.0\n"
     ]
    }
   ],
   "source": [
    "print(my_function(0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can call it by just giving $a$ and $b$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8.0\n"
     ]
    }
   ],
   "source": [
    "print(my_function(0, 16))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can call it with $a$, $b$, and $c$: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0\n"
     ]
    }
   ],
   "source": [
    "print(my_function(0, 16, 8))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or if you just want to specify $c$ and leave $b$ with its default value, you can refer to $c$ by name:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0\n"
     ]
    }
   ],
   "source": [
    "print(my_function(0, c=5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You always have to give it $a$, though:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "my_function() missing 1 required positional argument: 'a'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-23-b1f86d361518>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmy_function\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mc\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m5\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: my_function() missing 1 required positional argument: 'a'"
     ]
    }
   ],
   "source": [
    "print(my_function(c=5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Other Built-in Functions\n",
    "\n",
    "One of the nice things about Python is that it has many useful built-in functions besides just \"print\". \"input\" is another useful function that allows you to assign the value of the variable while the program is running:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 5\n",
      "Your number is:  5\n"
     ]
    }
   ],
   "source": [
    "num = input('Enter a number: ')\n",
    "print('Your number is:', num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some other useful functions include \"abs\" which returns the absolute value of a number:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "num = -1\n",
    "abs_num = abs(num)\n",
    "print(abs_num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\"round\" which takes two arguments. The first argument is the number you want to round, and the second is an optional argument that tells it how many decimals to round to (if you don't give this argument, it defaults to rounding to the nearest whole number)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.33\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "num = 3.3333333333333\n",
    "round1 = round(num, 2)\n",
    "round2 = round(num)\n",
    "\n",
    "print(round1)\n",
    "print(round2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and \"min\" and \"max\" which return the minimum and maximum of two numbers, respectively:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n",
      "1000\n"
     ]
    }
   ],
   "source": [
    "num1 = 100\n",
    "num2 = 1000\n",
    "\n",
    "mymin = min(num1, num2)\n",
    "mymax = max(num1, num2)\n",
    "\n",
    "print(mymin)\n",
    "print(mymax)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise\n",
    "\n",
    "Write a Python script that takes two numbers from the user as input. Then it prints the maximum of the two numbers, rounded to three decimal places."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Getting Values as Input"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What if we wanted to write some code that greets the user when they run the program? For example, if the user's name was \"Luigi\", the program would say \"Hello, Luigi!\", We can do this with the built-in variable \"input\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Type in your name: Luigi\n",
      "Hello, Luigi!\n"
     ]
    }
   ],
   "source": [
    "name = input(\"Type in your name: \")\n",
    "print(\"Hello, \", name, '!', sep='')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\"input\" always returns a string, so if you want a number, you'll need to convert it to one:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Type in your first number: 1\n",
      "Type in your second number: 2\n",
      "The sum of your numbers is: 12\n"
     ]
    }
   ],
   "source": [
    "#This way will treat the input as strings\n",
    "number1 = input('Type in your first number: ')\n",
    "number2 = input('Type in your second number: ')\n",
    "print(\"The sum of your numbers is:\", number1+number2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Type in your first number: 1\n",
      "Type in your second number: 2\n",
      "The sum of your numbers is: 3.0\n"
     ]
    }
   ],
   "source": [
    "#This way will treat the input as numbers\n",
    "number1 = input('Type in your first number: ')\n",
    "number2 = input('Type in your second number: ')\n",
    "\n",
    "number1 = float(number1)\n",
    "number2 = float(number2)\n",
    "\n",
    "print(\"The sum of your numbers is:\", number1+number2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to hide what the user is typing (like when you type in a password), you can use the \"getpass\" function from the \"getpass\" module:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Type in your password: ········\n",
      "hunter2\n"
     ]
    }
   ],
   "source": [
    "import getpass\n",
    "\n",
    "password = getpass.getpass(\"Type in your password: \")\n",
    "print(password)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise\n",
    "\n",
    "Write a Python script that asks for the user's name and favorite number as input, and then prints out \"Hello, name, the square of your number is $x^2$!\", where x is the number given by the user."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Many more functions can be found inside of *modules*. Modules are collections of pre-written functions and variables. Python comes with many different kinds of modules. For example, let's look at the the *math* module. To load a module you need to use the \"import\" statement:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To use functions and variables from this module, we need to use the \"dot\" (**.**) operator like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.141592653589793\n"
     ]
    }
   ],
   "source": [
    "print(math.pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The \"dot\" operator tells Python to go inside of \"math\" and look for something called \"pi\". \"pi\" is one of the variables that can be found in the math module. Some other useful variables include \"inf\" for infinity, and \"e\" for Euler's number:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inf\n",
      "2.718281828459045\n"
     ]
    }
   ],
   "source": [
    "print(math.inf)\n",
    "print(math.e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The math module has a lot of useful functions, too. It has functions to calculate square roots and logarithms:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.4142135623730951\n",
      "3.0\n"
     ]
    }
   ],
   "source": [
    "print(math.sqrt(2)) #print the square root of 2\n",
    "print(math.log10(1000)) #print the logarithm of 1000, base 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It also has trigonmetric functions like sin, and cos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.2246467991473532e-16\n",
      "-1.0\n"
     ]
    }
   ],
   "source": [
    "print(math.sin(math.pi))\n",
    "print(math.cos(math.pi))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To see everything the math module can do, you can read the documentation: https://docs.python.org/3/library/math.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scientific Notation , Numerical Precision, and Binary\n",
    "\n",
    "Notice that Python said $\\sin(\\pi) = 1.2246467991473532e-16$. You might be wondering what the \"e-16\" at the end means. This is Python's way of writing *scientific notation*. This is the same thing as $1.2246467991473532 \\times 10 ^{-16}$, or $0.00000000000000012246467991473532$.\n",
    "\n",
    "If you've taken Trigonometry, you might recall that $\\sin(\\pi) = 0$, so why isn't that the answer that Python gave you? The reason is because of *numerical precision*. $\\pi$ is an irrational number, which means that it has an infinite number of digits. Python does not have infinite memory, though, so it can only remember a certain number of digits. That means that when it does calculations with $\\pi$, there are going to be rounding errors.\n",
    "\n",
    "Sometimes Python makes rounding errors even when there are only a few digits involved. For example, look what happens when you calculate $0.1 \\times 3$. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.30000000000000004\n"
     ]
    }
   ],
   "source": [
    "print(0.1 * 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Why does Python behave this way? You might have heard before that computers represent everything as $1$'s and $0$'s. This is called *binary representation*. The number system that you are used to is called *decimal representation*. Here are some conversions between decimal and binary representations:\n",
    "\n",
    "$0 = 0$\n",
    "\n",
    "$1 = 1$\n",
    "\n",
    "$2 = 10$\n",
    "\n",
    "$3 = 11$\n",
    "\n",
    "$4 = 100$\n",
    "\n",
    "There is actually a built-in function in Python called \"bin\" that converts integers from decimal to binary. (The actual answer comes after the \"0b\"; the \"0b\" is just letting you know the number is in binary)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0b10\n",
      "0b100000000\n",
      "0b11000000111001\n"
     ]
    }
   ],
   "source": [
    "print(bin(2))\n",
    "print(bin(256))\n",
    "print(bin(12345))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just like some numbers cannot be represented in a finite number of digits in decimal (like $\\frac{1}{3}$) some numbers cannot be represented in a finite number of digits in binary (like $0.1$), and this causes rounding errors.\n",
    "\n",
    "Make sure you keep these rounding errors in mind when you do calculations in Python! Fortunately, most of the time they're small enough to not matter that much. You can usually get the answer you want by making use of the \"round\" function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "0.3\n"
     ]
    }
   ],
   "source": [
    "print(round(math.sin(math.pi)))\n",
    "print(round(0.1*3, 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a function that takes two arguments $x$ and $y$ and makes the following calculation:\n",
    "$\\sqrt x + 2\\pi \\times y$\n",
    "\n",
    "Round your answer to 4 decimal places."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Random Numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can have Python create random numbers using the \"random\" module. It oftens several diffent functions for generating different kinds of random numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.5590779414067718\n",
      "2.002585263541958\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "a = 1\n",
    "b = 10\n",
    "\n",
    "print(random.random()) #prints a random number between 0 and 1\n",
    "print(random.uniform(a, b)) #prints a random number between a and b\n",
    "print(random.randint(a, b)) #prints a random integer between a and b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Try running the code a bunch of different times. You should get different results every time.\n",
    "\n",
    "## Exercise\n",
    "\n",
    "Write a function that takes two arguments $x$ and $y$ and makes the following calculation:\n",
    "$\\sqrt x + 2\\pi \\times y + z$\n",
    "\n",
    "Where $z$ is a random integer between $x$ and $y$. Round your answer to 4 decimal places."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [default]",
   "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}