Data Scientist With Python/Introduction to Python/Module 3 - Functions and Packages.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "3f162d7c",
   "metadata": {},
   "source": [
    "# Chapter - 3 Functions and Packages\n",
    "\n",
    "### To leverage the code that brilliant Python developers have written, you'll learn about using functions, methods and packages. This will help you to reduce the amount of code you need to solve challenging problems!\n",
    "\n",
    "## Familiar functions\n",
    "Out of the box, Python offers a bunch of built-in functions to make your life as a data scientist easier. You already know two such functions: print() and type(). You've also used the functions str(), int(), bool() and float() to switch between data types. These are built-in functions as well.\n",
    "\n",
    "Calling a function is easy. To get the type of 3.0 and store the output as a new variable, result, you can use the following:\n",
    "\n",
    "result = type(3.0) The general recipe for calling functions and saving the result to a variable is thus:\n",
    "\n",
    "output = function_name(input)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "ed4ef96d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# Create variables var1 and var2\n",
    "var1 = [1, 2, 3, 4]\n",
    "var2 = True\n",
    "\n",
    "# Print out type of var1\n",
    "print(type(var1))\n",
    "\n",
    "# Print out length of var1\n",
    "print(len(var1))\n",
    "\n",
    "# Convert var2 to an integer: out2\n",
    "out2=int(var2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49d70282",
   "metadata": {},
   "source": [
    "## Help!\n",
    "Maybe you already know the name of a Python function, but you still have to figure out how to use it. Ironically, you have to ask for information about a function with another function: help(). In IPython specifically, you can also use ? before the function name.\n",
    "\n",
    "To get help on the max() function, for example, you can use one of these calls:\n",
    "\n",
    "help(max) ?max"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "559ff74f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on complex object:\n",
      "\n",
      "class complex(object)\n",
      " |  complex(real=0, imag=0)\n",
      " |  \n",
      " |  Create a complex number from a real part and an optional imaginary part.\n",
      " |  \n",
      " |  This is equivalent to (real + imag*1j) where imag defaults to 0.\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __abs__(self, /)\n",
      " |      abs(self)\n",
      " |  \n",
      " |  __add__(self, value, /)\n",
      " |      Return self+value.\n",
      " |  \n",
      " |  __bool__(self, /)\n",
      " |      True if self else False\n",
      " |  \n",
      " |  __divmod__(self, value, /)\n",
      " |      Return divmod(self, value).\n",
      " |  \n",
      " |  __eq__(self, value, /)\n",
      " |      Return self==value.\n",
      " |  \n",
      " |  __float__(self, /)\n",
      " |      float(self)\n",
      " |  \n",
      " |  __floordiv__(self, value, /)\n",
      " |      Return self//value.\n",
      " |  \n",
      " |  __format__(...)\n",
      " |      complex.__format__() -> str\n",
      " |      \n",
      " |      Convert to a string according to format_spec.\n",
      " |  \n",
      " |  __ge__(self, value, /)\n",
      " |      Return self>=value.\n",
      " |  \n",
      " |  __getattribute__(self, name, /)\n",
      " |      Return getattr(self, name).\n",
      " |  \n",
      " |  __getnewargs__(...)\n",
      " |  \n",
      " |  __gt__(self, value, /)\n",
      " |      Return self>value.\n",
      " |  \n",
      " |  __hash__(self, /)\n",
      " |      Return hash(self).\n",
      " |  \n",
      " |  __int__(self, /)\n",
      " |      int(self)\n",
      " |  \n",
      " |  __le__(self, value, /)\n",
      " |      Return self<=value.\n",
      " |  \n",
      " |  __lt__(self, value, /)\n",
      " |      Return self<value.\n",
      " |  \n",
      " |  __mod__(self, value, /)\n",
      " |      Return self%value.\n",
      " |  \n",
      " |  __mul__(self, value, /)\n",
      " |      Return self*value.\n",
      " |  \n",
      " |  __ne__(self, value, /)\n",
      " |      Return self!=value.\n",
      " |  \n",
      " |  __neg__(self, /)\n",
      " |      -self\n",
      " |  \n",
      " |  __pos__(self, /)\n",
      " |      +self\n",
      " |  \n",
      " |  __pow__(self, value, mod=None, /)\n",
      " |      Return pow(self, value, mod).\n",
      " |  \n",
      " |  __radd__(self, value, /)\n",
      " |      Return value+self.\n",
      " |  \n",
      " |  __rdivmod__(self, value, /)\n",
      " |      Return divmod(value, self).\n",
      " |  \n",
      " |  __repr__(self, /)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  __rfloordiv__(self, value, /)\n",
      " |      Return value//self.\n",
      " |  \n",
      " |  __rmod__(self, value, /)\n",
      " |      Return value%self.\n",
      " |  \n",
      " |  __rmul__(self, value, /)\n",
      " |      Return value*self.\n",
      " |  \n",
      " |  __rpow__(self, value, mod=None, /)\n",
      " |      Return pow(value, self, mod).\n",
      " |  \n",
      " |  __rsub__(self, value, /)\n",
      " |      Return value-self.\n",
      " |  \n",
      " |  __rtruediv__(self, value, /)\n",
      " |      Return value/self.\n",
      " |  \n",
      " |  __sub__(self, value, /)\n",
      " |      Return self-value.\n",
      " |  \n",
      " |  __truediv__(self, value, /)\n",
      " |      Return self/value.\n",
      " |  \n",
      " |  conjugate(...)\n",
      " |      complex.conjugate() -> complex\n",
      " |      \n",
      " |      Return the complex conjugate of its argument. (3-4j).conjugate() == 3+4j.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |  \n",
      " |  __new__(*args, **kwargs) from builtins.type\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  imag\n",
      " |      the imaginary part of a complex number\n",
      " |  \n",
      " |  real\n",
      " |      the real part of a complex number\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(complex())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "6c319d6c",
   "metadata": {},
   "outputs": [],
   "source": [
    "complex?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62ba0ac5",
   "metadata": {},
   "source": [
    "## Multiple arguments\n",
    "In the previous exercise, the square brackets around imag in the documentation showed us that the imag argument is optional. But Python also uses a different way to tell users about arguments being optional.\n",
    "\n",
    "Have a look at the documentation of sorted() by typing help(sorted).\n",
    "\n",
    "You'll see that `sorted()` takes three arguments: `iterable`, `key` and `reverse`.\n",
    "\n",
    "`key=None` means that if you don't specify the key argument, it will be None. `reverse=False` means that if you don't specify the reverse argument, it will be False.\n",
    "\n",
    "In this exercise, you'll only have to specify iterable and reverse, not key. The first input you pass to sorted() will be matched to the iterable argument, but what about the second input? To tell Python you want to specify reverse without changing anything about key, you can use =:\n",
    "\n",
    "`sorted(___, reverse = ___)`\n",
    "Two lists have been created for you . Can you paste them together and sort them in descending order?\n",
    "\n",
    "Note: For now, we can understand an iterable as being any collection of objects, e.g. a List."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "2a0624a4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[20.0, 18.0, 11.25, 10.75, 9.5]\n"
     ]
    }
   ],
   "source": [
    "# Create lists first and second\n",
    "first = [11.25, 18.0, 20.0]\n",
    "second = [10.75, 9.50]\n",
    "\n",
    "# Paste together first and second: full\n",
    "full=first+second\n",
    "\n",
    "# Sort full in descending order: full_sorted\n",
    "\n",
    "full_sorted=sorted(full,reverse=True)\n",
    "# Print out full_sorted\n",
    "print(full_sorted)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6dbd626",
   "metadata": {},
   "source": [
    "## String Methods\n",
    "Strings come with a bunch of methods. Follow the instructions closely to discover some of them. If you want to discover them in more detail, you can always type help(str)\n",
    "\n",
    "A string place has already been created for you to experiment with."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "5fd15d1c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "poolhouse POOLHOUSE\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "# string to experiment with: place\n",
    "place = \"poolhouse\"\n",
    "\n",
    "# Use upper() on place: place_up\n",
    "place_up=place.upper()\n",
    "\n",
    "# Print out place and place_up\n",
    "print(place,place_up)\n",
    "\n",
    "# Print out the number of o's in place\n",
    "print(place.count('o'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "038f109d",
   "metadata": {},
   "source": [
    "Nice! Notice from the printouts that the upper() method does not change the object it is called on. This will be different for lists in the next exercise!\n",
    "\n",
    "## List Methods\n",
    "Strings are not the only Python types that have methods associated with them. Lists, floats, integers and booleans are also types that come packaged with a bunch of useful methods. In this exercise, you'll be experimenting with:\n",
    "\n",
    "- index(), to get the index of the first element of a list that matches its input and\n",
    "- count(), to get the number of times an element appears in a list.  \n",
    "\n",
    "You'll be working on the list with the area of different parts of a house: areas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "85191973",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "# Create list areas\n",
    "areas = [11.25, 18.0, 20.0, 10.75, 9.50]\n",
    "\n",
    "# Print out the index of the element 20.0\n",
    "print(areas.index(20.0))\n",
    "\n",
    "# Print out how often 9.50 appears in areas\n",
    "print(areas.count(9.5))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01ee8495",
   "metadata": {},
   "source": [
    "Nice! These were examples of list methods that did not change the list they were called on.\n",
    "\n",
    "## List Methods (2)\n",
    "Most list methods will change the list they're called on. Examples are:\n",
    "\n",
    "- append(), that adds an element to the list it is called on,\n",
    "- remove(), that removes the first element of a list that matches the input, and\n",
    "- reverse(), that reverses the order of the elements in the list it is called on.  \n",
    "\n",
    "You'll be working on the list with the area of different parts of the house: areas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "308f96d9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[11.25, 18.0, 20.0, 10.75, 9.5, 24.5, 15.45]\n",
      "[15.45, 24.5, 9.5, 10.75, 20.0, 18.0, 11.25]\n"
     ]
    }
   ],
   "source": [
    "# Create list areas\n",
    "areas = [11.25, 18.0, 20.0, 10.75, 9.50]\n",
    "\n",
    "# Use append twice to add poolhouse and garage size\n",
    "areas.append(24.5)\n",
    "areas.append(15.45)\n",
    "\n",
    "\n",
    "# Print out areas\n",
    "print(areas)\n",
    "\n",
    "\n",
    "# Reverse the orders of the elements in areas\n",
    "areas.reverse()\n",
    "\n",
    "# Print out areas\n",
    "print(areas)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31b655a7",
   "metadata": {},
   "source": [
    "## Import package\n",
    "As a data scientist, some notions of geometry never hurt. Let's refresh some of the basics.\n",
    "\n",
    "For a fancy clustering algorithm, you want to find the circumference, C, and area, A, of a circle. When the radius of the circle is r, you can calculate C and A as:\n",
    "\n",
    "To use the constant pi, you'll need the math package."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "efbf0e7f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Circumference: 2.701769682087222\n",
      "Area: 0.5808804816487527\n"
     ]
    }
   ],
   "source": [
    "# Definition of radius\n",
    "r = 0.43\n",
    "\n",
    "# Import the math package\n",
    "import math\n",
    "\n",
    "# Calculate C\n",
    "C = 2*math.pi*r\n",
    "\n",
    "# Calculate A\n",
    "A = math.pi*r**2\n",
    "\n",
    "# Build printout\n",
    "print(\"Circumference: \" + str(C))\n",
    "print(\"Area: \" + str(A))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8fbd0059",
   "metadata": {},
   "source": [
    "Nice! If you know how to deal with functions from packages, the power of a lot of Python programmers is at your fingertips!\n",
    "\n",
    "## Selective import\n",
    "General imports, like import math, make all functionality from the math package available to you. However, if you decide to only use a specific part of a package, you can always make your import more selective:\n",
    "\n",
    "```python\n",
    "from math import pi\n",
    "```\n",
    "Let's say the Moon's orbit around planet Earth is a perfect circle, with a radius r (in km) that is defined. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "fcf2f6dd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "40317.10572106901\n"
     ]
    }
   ],
   "source": [
    "# Definition of radius\n",
    "r = 192500\n",
    "\n",
    "# Import radians function of math package\n",
    "\n",
    "from math import radians\n",
    "# Travel distance of Moon over 12 degrees. Store in dist.\n",
    "dist=r*radians(12)\n",
    "\n",
    "# Print out dist\n",
    "\n",
    "print(dist)"
   ]
  }
 ],
 "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}