Intro to Python.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "import numpy as np\n",
    "from scipy import stats"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy is a general-purpose array-processing package. It provides a high-performance multidimensional array object, and tools for working with these arrays. It is the fundamental package for scientific computing with Python. Besides its obvious scientific uses, Numpy can also be used as an efficient multi-dimensional container of generic data. <- Linear Algebra\n",
    "\n",
    "SciPy is a python library that is useful in solving many mathematical equations and algorithms. It is designed on the top of Numpy library that gives more extension of finding scientific mathematical formulae like Matrix Rank, Inverse, polynomial equations, LU Decomposition, etc. Using its high level functions will significantly reduce the complexity of the code and helps in better analyzing the data. SciPy is an interactive Python session used as a data-processing library that is made to compete with its rivalries such as MATLAB, Octave, R-Lab,etc. It has many user-friendly, efficient and easy-to-use functions that helps to solve problems like numerical integration, interpolation, optimization, linear algebra and statistics.\n",
    "\n",
    "STATS This module contains a large number of probability distributions as well as a growing library of statistical functions.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.98665019, 0.85276585, 0.88432904, 0.79321027, 0.49616478],\n",
       "       [0.45970564, 0.29062256, 0.30077848, 0.5091533 , 0.14933602],\n",
       "       [0.21247773, 0.84172067, 0.1289289 , 0.6603362 , 0.4442086 ],\n",
       "       [0.14538278, 0.63920298, 0.70999043, 0.64522057, 0.33881822],\n",
       "       [0.40218848, 0.62593894, 0.6318676 , 0.79426559, 0.67752046]])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from numpy import random \n",
    "# uniform random numbers in [0,1]\n",
    "dataOne = np.random.rand(5,5)\n",
    "dataOne"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.12892890234665322"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataOne.min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9866501921852119"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataOne.max()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5448313711560681"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataOne.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5448313711560681"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mean(dataOne)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13.6207842789017"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(dataOne)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.45970564, 0.29062256, 0.30077848, 0.5091533 , 0.14933602],\n",
       "       [0.21247773, 0.84172067, 0.1289289 , 0.6603362 , 0.4442086 ]])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataOne[1:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5, 5)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.shape(dataOne)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.size(dataOne)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that numpy.array is not the same as the Standard Python Library class array.array, which only handles one-dimensional arrays and offers less functionality. The more important attributes of an ndarray object are:\n",
    "\n",
    "ndarray.ndim the number of axes (dimensions) of the array.\n",
    "ndarray.shapethe dimensions of the array. This is a tuple of integers indicating the size of the array in each dimension. For a matrix with n rows and m columns, shape will be (n,m). The length of the shape tuple is therefore the number of axes, ndim.\n",
    "ndarray.sizethe total number of elements of the array. This is equal to the product of the elements of shape.\n",
    "ndarray.dtypean object describing the type of the elements in the array. One can create or specify dtype’s using standard Python types. Additionally NumPy provides types of its own. numpy.int32, numpy.int16, and numpy.float64 are some examples.\n",
    "ndarray.itemsizethe size in bytes of each element of the array. For example, an array of elements of type float64 has itemsize 8 (=64/8), while one of type complex32 has itemsize 4 (=32/8). It is equivalent to ndarray.dtype.itemsize.\n",
    "ndarray.datathe buffer containing the actual elements of the array. Normally, we won’t need to use this attribute because we will access the elements in an array using indexing facilities."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I Love data Science\n"
     ]
    }
   ],
   "source": [
    "print('I Love data Science')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50.0\n"
     ]
    }
   ],
   "source": [
    "varOne = 25\n",
    "\n",
    "varTwo = 25.0\n",
    "\n",
    "varThree = varOne + varTwo\n",
    "\n",
    "print(varThree)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'int' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-22-b3dcd030aac8>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[0mvarTwo\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m'Hello'\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m \u001b[0mvarThree\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mvarOne\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mvarTwo\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      6\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      7\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mvarThree\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'"
     ]
    }
   ],
   "source": [
    "varOne = 25\n",
    "\n",
    "varTwo = 'Hello'\n",
    "\n",
    "varThree = varOne + varTwo\n",
    "\n",
    "print(varThree)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numbers that don't have a decimal point are integers and are called \"int\" in python. You can't add a str and an int. But you can turn a number into a string if you use the str() function.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25 Hello\n"
     ]
    }
   ],
   "source": [
    "varOne = 25\n",
    "\n",
    "varTwo = ' Hello'\n",
    "\n",
    "varThree = str(varOne) + varTwo\n",
    "\n",
    "print(varThree)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define a variable that represents a dictionary with 5 INT elements\n",
    "\n",
    "Use functions from the math module to perform three different math operations on three of the five elements; you may find it easier to define variables for the elements. Feel free to combine elements as needed. Lastly, print out you results separately."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 5, 8, 4, 12]\n"
     ]
    }
   ],
   "source": [
    "new_dict = [2,5,8,4,12]\n",
    "print(new_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use functions from the math module to perform three different math operations on three of the five elements; you may find it easier to define variables for the elements. Feel free to combine elements as needed. Lastly, print out you results separately."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2.,  5.,  8.,  4., 12.])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ceil(new_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2.,  5.,  8.,  4., 12.])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.floor(new_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **ceil(x)**\tReturns the smallest integer greater than or equal to x.\n",
    "* **copysign(x, y)**\tReturns x with the sign of y\n",
    "* **fabs(x)**\tReturns the absolute value of x\n",
    "* **factorial(x)**\tReturns the factorial of x\n",
    "* **floor(x)**\tReturns the largest integer less than or equal to x\n",
    "* **fmod(x, y)**\tReturns the remainder when x is divided by y\n",
    "* **frexp(x)**\tReturns the mantissa and exponent of x as the pair (m, e)\n",
    "* **fsum(iterable)**\tReturns an accurate floating point sum of values in the iterable\n",
    "* **isfinite(x)**\tReturns True if x is neither an infinity nor a NaN (Not a Number)\n",
    "* **isinf(x)**\tReturns True if x is a positive or negative infinity\n",
    "* **isnan(x)**\tReturns True if x is a NaN\n",
    "* **ldexp(x, i)**\tReturns x * (2**i)\n",
    "* **modf(x)**\tReturns the fractional and integer parts of x\n",
    "* **trunc(x)**\tReturns the truncated integer value of x\n",
    "* **exp(x)**\tReturns e**x\n",
    "* **expm1(x)**\tReturns e**x - 1\n",
    "* **log(x[, base])**\tReturns the logarithm of x to the base (defaults to e)\n",
    "* **log1p(x)**\tReturns the natural logarithm of 1+x\n",
    "* **log2(x)**\tReturns the base-2 logarithm of x\n",
    "* **log10(x)**\tReturns the base-10 logarithm of x\n",
    "* **pow(x, y)**\tReturns x raised to the power y\n",
    "* **sqrt(x)**\tReturns the square root of x\n",
    "* **acos(x)**\tReturns the arc cosine of x\n",
    "* **asin(x)**\tReturns the arc sine of x\n",
    "* **atan(x)**\tReturns the arc tangent of x\n",
    "* **atan2(y, x)**\tReturns atan(y / x)\n",
    "* **cos(x)**\tReturns the cosine of x\n",
    "* **hypot(x, y)**\tReturns the Euclidean norm, sqrt(x*x + y*y)\n",
    "* **sin(x)**\tReturns the sine of x\n",
    "* **tan(x)**\tReturns the tangent of x\n",
    "* **degrees(x)**\tConverts angle x from radians to degrees\n",
    "* **radians(x)**\tConverts angle x from degrees to radians\n",
    "* **acosh(x)**\tReturns the inverse hyperbolic cosine of x\n",
    "* **asinh(x)**\tReturns the inverse hyperbolic sine of x\n",
    "* **atanh(x)**\tReturns the inverse hyperbolic tangent of x\n",
    "* **cosh(x)**\tReturns the hyperbolic cosine of x\n",
    "* **sinh(x)**\tReturns the hyperbolic cosine of x\n",
    "* **tanh(x)**\tReturns the hyperbolic tangent of x\n",
    "* **erf(x)**\tReturns the error function at x\n",
    "* **erfc(x)**\tReturns the complementary error function at x\n",
    "* **gamma(x)**\tReturns the Gamma function at x\n",
    "* **lgamma(x)**\tReturns the natural logarithm of the absolute value of the Gamma function at x\n",
    "* **pi**\tMathematical constant, the ratio of circumference of a circle to it's diameter (3.14159...)\n",
    "* **e**\tmathematical constant e (2.71828...)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1> More Control Flow Tools <h1/>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter an integer: 1\n"
     ]
    }
   ],
   "source": [
    "x = int(input(\"Please enter an integer: \"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Single\n"
     ]
    }
   ],
   "source": [
    "if x < 0:\n",
    "...     x = 0\n",
    "...     print('Negative changed to zero')\n",
    "... elif x == 0:\n",
    "...     print('Zero')\n",
    "... elif x == 1:\n",
    "...     print('Single')\n",
    "... else:\n",
    "...     print('More')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cat 3\n",
      "window 6\n",
      "defenestrate 12\n"
     ]
    }
   ],
   "source": [
    " # Measure some strings:\n",
    "... words = ['cat', 'window', 'defenestrate']\n",
    ">>> for w in words:\n",
    "...     print(w, len(w))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    ">>> for i in range(5):\n",
    "...     print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for i in range(5, 10):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "3\n",
      "6\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for i in range(0, 10, 3):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 Mary\n",
      "1 had\n",
      "2 a\n",
      "3 little\n",
      "4 lamb\n"
     ]
    }
   ],
   "source": [
    "a = ['Mary', 'had', 'a', 'little', 'lamb']\n",
    ">>> for i in range(len(a)):\n",
    "...     print(i, a[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 is a prime number\n",
      "3 is a prime number\n",
      "4 equals 2 * 2\n",
      "5 is a prime number\n",
      "6 equals 2 * 3\n",
      "7 is a prime number\n",
      "8 equals 2 * 4\n",
      "9 equals 3 * 3\n"
     ]
    }
   ],
   "source": [
    "for n in range(2, 10):\n",
    "...     for x in range(2, n):\n",
    "...         if n % x == 0:\n",
    "...             print(n, 'equals', x, '*', n//x)\n",
    "...             break\n",
    "...     else:\n",
    "...         # loop fell through without finding a factor\n",
    "...         print(n, 'is a prime number')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found an even number 2\n",
      "Found a number 3\n",
      "Found an even number 4\n",
      "Found a number 5\n",
      "Found an even number 6\n",
      "Found a number 7\n",
      "Found an even number 8\n",
      "Found a number 9\n"
     ]
    }
   ],
   "source": [
    "for num in range(2, 10):\n",
    "...     if num % 2 == 0:\n",
    "...         print(\"Found an even number\", num)\n",
    "...         continue\n",
    "...     print(\"Found a number\", num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fib(n):    # write Fibonacci series up to n\n",
    "...     \"\"\"Print a Fibonacci series up to n.\"\"\"\n",
    "...     a, b = 0, 1\n",
    "...     while a < n:\n",
    "...         print(a, end=' ')\n",
    "...         a, b = b, a+b\n",
    "...     print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 \n"
     ]
    }
   ],
   "source": [
    "fib(3400)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):\n",
    "    print(\"-- This parrot wouldn't\", action, end=' ')\n",
    "    print(\"if you put\", voltage, \"volts through it.\")\n",
    "    print(\"-- Lovely plumage, the\", type)\n",
    "    print(\"-- It's\", state, \"!\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-- This parrot wouldn't voom if you put 1000 volts through it.\n",
      "-- Lovely plumage, the Norwegian Blue\n",
      "-- It's a stiff !\n"
     ]
    }
   ],
   "source": [
    "parrot(1000)   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-- This parrot wouldn't jump if you put a million volts through it.\n",
      "-- Lovely plumage, the Norwegian Blue\n",
      "-- It's bereft of life !\n"
     ]
    }
   ],
   "source": [
    "parrot('a million', 'bereft of life', 'jump')   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-- This parrot wouldn't voom if you put a thousand volts through it.\n",
      "-- Lovely plumage, the Norwegian Blue\n",
      "-- It's pushing up the daisies !\n"
     ]
    }
   ],
   "source": [
    "parrot('a thousand', state='pushing up the daisies')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cheeseshop(kind, *arguments, **keywords):\n",
    "    print(\"-- Do you have any\", kind, \"?\")\n",
    "    print(\"-- I'm sorry, we're all out of\", kind)\n",
    "    for arg in arguments:\n",
    "        print(arg)\n",
    "    print(\"-\" * 40)\n",
    "    for kw in keywords:\n",
    "        print(kw, \":\", keywords[kw])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-- Do you have any Limburger ?\n",
      "-- I'm sorry, we're all out of Limburger\n",
      "It's very runny, sir.\n",
      "It's really very, VERY runny, sir.\n",
      "----------------------------------------\n",
      "shopkeeper : Michael Palin\n",
      "client : John Cleese\n",
      "sketch : Cheese Shop Sketch\n"
     ]
    }
   ],
   "source": [
    "cheeseshop(\"Limburger\", \"It's very runny, sir.\",\n",
    "           \"It's really very, VERY runny, sir.\",\n",
    "           shopkeeper=\"Michael Palin\",\n",
    "           client=\"John Cleese\",\n",
    "           sketch=\"Cheese Shop Sketch\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']\n",
    ">>> fruits.count('apple')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']\n",
    ">>> fruits.count('apple')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['apple', 'apple', 'banana', 'banana', 'kiwi', 'orange', 'pear']"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fruits.sort()\n",
    ">>> fruits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['3.1', '3.14', '3.142', '3.1416', '3.14159']"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " from math import pi\n",
    ">>> [str(round(pi, i)) for i in range(1, 6)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    " matrix = [\n",
    "...     [1, 2, 3, 4],\n",
    "...     [5, 6, 7, 8],\n",
    "...     [9, 10, 11, 12],\n",
    "... ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 5, 9), (2, 6, 10), (3, 7, 11), (4, 8, 12)]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(zip(*matrix))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [-1, 1, 66.25, 333, 333, 1234.5]\n",
    ">>> del a[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 66.25, 333, 333, 1234.5]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "del a[2:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 66.25, 1234.5]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = 12345, 54321, 'hello!'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(12345, 54321, 'hello!')"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u = t, (1, 2, 3, 4, 5)\n",
    "u"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12345"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x, y, z = t\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'jack': 4098, 'sape': 4139, 'guido': 4127}"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " tel = {'jack': 4098, 'sape': 4139}\n",
    ">>> tel['guido'] = 4127\n",
    ">>> tel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'jack': 4098, 'guido': 4127, 'irv': 4127}"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "del tel['sape']\n",
    ">>> tel['irv'] = 4127\n",
    ">>> tel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2: 4, 4: 16, 6: 36}"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{x: x**2 for x in (2, 4, 6)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "gallahad the pure\n",
      "robin the brave\n"
     ]
    }
   ],
   "source": [
    " knights = {'gallahad': 'the pure', 'robin': 'the brave'}\n",
    "for k, v in knights.items():\n",
    "     print(k, v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 tic\n",
      "1 tac\n",
      "2 toe\n"
     ]
    }
   ],
   "source": [
    "for i, v in enumerate(['tic', 'tac', 'toe']):\n",
    "     print(i, v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "What is your name?  It is lancelot.\n",
      "What is your quest?  It is the holy grail.\n",
      "What is your favorite color?  It is blue.\n"
     ]
    }
   ],
   "source": [
    "questions = ['name', 'quest', 'favorite color']\n",
    ">>> answers = ['lancelot', 'the holy grail', 'blue']\n",
    ">>> for q, a in zip(questions, answers):\n",
    "     print('What is your {0}?  It is {1}.'.format(q, a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[56.2, 51.7, 55.3, 52.5, 47.8]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "raw_data = [56.2, float('NaN'), 51.7, 55.3, 52.5, float('NaN'), 47.8]\n",
    "filtered_data = []\n",
    "for value in raw_data:\n",
    "    if not math.isnan(value):\n",
    "         filtered_data.append(value)\n",
    "filtered_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>ID</th>\n",
       "      <th>LIMIT_BAL</th>\n",
       "      <th>SEX</th>\n",
       "      <th>EDUCATION</th>\n",
       "      <th>MARRIAGE</th>\n",
       "      <th>AGE</th>\n",
       "      <th>SeptemberPay</th>\n",
       "      <th>AugustPay</th>\n",
       "      <th>JulyPay</th>\n",
       "      <th>JunePay</th>\n",
       "      <th>...</th>\n",
       "      <th>JuneBill</th>\n",
       "      <th>MayBill</th>\n",
       "      <th>AprilBill</th>\n",
       "      <th>SeptemberPayment</th>\n",
       "      <th>AugustPayment</th>\n",
       "      <th>JulyPayment</th>\n",
       "      <th>JunePayment</th>\n",
       "      <th>MayPayment</th>\n",
       "      <th>AprilPayment</th>\n",
       "      <th>default payment next month</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>20000</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>24</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>-1</td>\n",
       "      <td>-1</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>689</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>120000</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>26</td>\n",
       "      <td>-1</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>3272</td>\n",
       "      <td>3455</td>\n",
       "      <td>3261</td>\n",
       "      <td>0</td>\n",
       "      <td>1000</td>\n",
       "      <td>1000</td>\n",
       "      <td>1000</td>\n",
       "      <td>0</td>\n",
       "      <td>2000</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "      <td>90000</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>34</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>14331</td>\n",
       "      <td>14948</td>\n",
       "      <td>15549</td>\n",
       "      <td>1518</td>\n",
       "      <td>1500</td>\n",
       "      <td>1000</td>\n",
       "      <td>1000</td>\n",
       "      <td>1000</td>\n",
       "      <td>5000</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>4</td>\n",
       "      <td>50000</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>37</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>28314</td>\n",
       "      <td>28959</td>\n",
       "      <td>29547</td>\n",
       "      <td>2000</td>\n",
       "      <td>2019</td>\n",
       "      <td>1200</td>\n",
       "      <td>1100</td>\n",
       "      <td>1069</td>\n",
       "      <td>1000</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>5</td>\n",
       "      <td>50000</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>57</td>\n",
       "      <td>-1</td>\n",
       "      <td>0</td>\n",
       "      <td>-1</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>20940</td>\n",
       "      <td>19146</td>\n",
       "      <td>19131</td>\n",
       "      <td>2000</td>\n",
       "      <td>36681</td>\n",
       "      <td>10000</td>\n",
       "      <td>9000</td>\n",
       "      <td>689</td>\n",
       "      <td>679</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>5 rows × 25 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "   ID  LIMIT_BAL  SEX  EDUCATION  MARRIAGE  AGE  SeptemberPay  AugustPay  \\\n",
       "0   1      20000    2          2         1   24             2          2   \n",
       "1   2     120000    2          2         2   26            -1          2   \n",
       "2   3      90000    2          2         2   34             0          0   \n",
       "3   4      50000    2          2         1   37             0          0   \n",
       "4   5      50000    1          2         1   57            -1          0   \n",
       "\n",
       "   JulyPay  JunePay  ...  JuneBill  MayBill  AprilBill  SeptemberPayment  \\\n",
       "0       -1       -1  ...         0        0          0                 0   \n",
       "1        0        0  ...      3272     3455       3261                 0   \n",
       "2        0        0  ...     14331    14948      15549              1518   \n",
       "3        0        0  ...     28314    28959      29547              2000   \n",
       "4       -1        0  ...     20940    19146      19131              2000   \n",
       "\n",
       "   AugustPayment  JulyPayment  JunePayment  MayPayment  AprilPayment  \\\n",
       "0            689            0            0           0             0   \n",
       "1           1000         1000         1000           0          2000   \n",
       "2           1500         1000         1000        1000          5000   \n",
       "3           2019         1200         1100        1069          1000   \n",
       "4          36681        10000         9000         689           679   \n",
       "\n",
       "   default payment next month  \n",
       "0                           1  \n",
       "1                           1  \n",
       "2                           0  \n",
       "3                           0  \n",
       "4                           0  \n",
       "\n",
       "[5 rows x 25 columns]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "credit = pd.read_csv('default_credit_card_clients.csv', header =0)\n",
    "credit.head()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}