python exercises.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n",
      "1\n",
      "7\n",
      "4\n",
      "6\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "x = np.array([[9, 1, 7],\n",
    "              [4, 6, 9]])\n",
    "for j in np.nditer(x):\n",
    "    print(j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Element 0 - 3.41\n",
      "Element 1 - 15.13\n",
      "Element 2 - 6.74\n",
      "Element 3 - 10.5\n"
     ]
    }
   ],
   "source": [
    "q = [3.41, 15.13, 6.74, 10.5]\n",
    "for j, x in enumerate(q):\n",
    "    print('Element ' + str(j) + ' -', str(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "40\n"
     ]
    }
   ],
   "source": [
    "from functools import reduce\n",
    "product = [10, 1, 4]\n",
    "result = reduce(lambda x, y: x * y, product)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 1, 1, 0]\n"
     ]
    }
   ],
   "source": [
    "x = ['regulation', 'authorize', 'precaution', 'myth']\n",
    "count_vowel = list(map(lambda word: word.count('e'), x))\n",
    "print(count_vowel)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Which command unpacks and prints all values of the iterator y_it?\n",
    "# print(*y_it)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Aug': 39, 'May': 80, 'Mar': 44}\n"
     ]
    }
   ],
   "source": [
    "x = ['Aug', 'Mar', 'May']\n",
    "y = [39, 44, 80]\n",
    "lists = zip(x,y)\n",
    "new_dict = dict(lists)\n",
    "print(new_dict)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   sepal_length  sepal_width  petal_length  petal_width     species\n",
      "0           7.0          3.2           4.7          1.4  versicolor\n",
      "1           6.4          3.2           4.5          1.5  versicolor\n",
      "2           6.9          3.1           4.9          1.5  versicolor\n",
      "3           5.5          2.3           4.0          1.3  versicolor\n"
     ]
    }
   ],
   "source": [
    "# Import the csv file located at the url \"link_to_df\" in small dataframe chunks of size 4\n",
    "# Print the second chunk of this dataframe\n",
    "import pandas as pd\n",
    "link_to_iris = 'https://goo.gl/BR8npa'\n",
    "iris = pd.read_csv(link_to_iris, chunksize = 4)\n",
    "next(iris)\n",
    "print(next(iris))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Felicity Smoak is The Overwatch\n",
      "Laurel Lance is The Black Canary\n"
     ]
    }
   ],
   "source": [
    "characters_names = ['Felicity Smoak', 'Laurel Lance']\n",
    "code_names = ['Overwatch', 'Black Canary']\n",
    "\n",
    "team_arrow = zip(characters_names, code_names)\n",
    "for i, j in team_arrow:\n",
    "    print(i + ' is The ' + j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 1, 2: 4, 3: 9, 5: 25}\n"
     ]
    }
   ],
   "source": [
    "x = [2, 3, 1, 5]\n",
    "cubes = { j: j ** 2 for j in x }\n",
    "print(cubes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[8, 3, 1]\n"
     ]
    }
   ],
   "source": [
    "x = [8, 'M', 'N', 3, 1, 'A']\n",
    "integers = [j for j in x if type(j) == int]\n",
    "print(integers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(4, 2)\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "x = np.array([22, 1, 19, 14])\n",
    "y = np.array([10, 26, 6, 6])\n",
    "z = np.column_stack([x, y])\n",
    "print(z.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[19, 15, 15, 9, 6, 5]\n"
     ]
    }
   ],
   "source": [
    "p = [5, 15, 9, 15, 19, 6]\n",
    "print(sorted(p, reverse=True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'mars': 0.45, 'mercury': 0.384}\n"
     ]
    }
   ],
   "source": [
    "escape_velocity = {\n",
    "    'earth': 1, \n",
    "    'mercury': 0.384,\n",
    "    'mars': 0.450\n",
    "}\n",
    "del(escape_velocity['earth'])\n",
    "print(escape_velocity)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'cost': 5, 'units': 500}\n"
     ]
    }
   ],
   "source": [
    "fruits = { \n",
    "    'apples': {'cost': 3, 'units': 100}, \n",
    "    'bananas': {'cost': 1, 'units': 80},\n",
    "    'grapes': {'cost': 5, 'units': 500}\n",
    "}\n",
    "print(fruits['grapes'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value of a is 16\n",
      "The value of b is 12\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(None, None)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def easy_print(**x):\n",
    "        for key, value in x.items():\n",
    "            print('The value of ' + str(key) + \" is \" + str(value))\n",
    "(easy_print(a = 16), easy_print(b = 12))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 1, 2: 4, 4: 16, 5: 25}\n"
     ]
    }
   ],
   "source": [
    "x = [2, 4, 1, 5]\n",
    "squares = {i: i ** 2 for i in x }\n",
    "print(squares)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0: Gorilla Grodd\n",
      "1: Leonard Snart\n",
      "2: Mick Rory\n"
     ]
    }
   ],
   "source": [
    "flash_vil = ['Gorilla Grodd', 'Leonard Snart', 'Mick Rory']\n",
    "for x, y in enumerate(flash_vil):\n",
    "    print(str(x) + ': ' + y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.         -0.66212219]\n",
      " [-0.66212219  1.        ]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "x = np.array([6, 4, 5, 7, 4, 7, 7, 6])\n",
    "y = np.array([1, 7, 4, 3, 3, 2, 2, 2])\n",
    "print(np.corrcoef(x, y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "# Print the number of occurences of the string \"e\" in list x\n",
    "x = ['c', 'c', 'c', 'a', 'b', 'b']\n",
    "print(x.count('c'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "r+gulation\n"
     ]
    }
   ],
   "source": [
    "z = \"regulation\"\n",
    "print(z.replace(\"e\", \"+\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "68.0\n"
     ]
    }
   ],
   "source": [
    "temp = 20\n",
    "def convert_temp(x):\n",
    "    \"\"\"Converts the temperature from Celsius to Fahrenheit\"\"\"\n",
    "    global temp\n",
    "    temp = (x * 1.8) + 32\n",
    "convert_temp(temp)\n",
    "print(temp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s can not be a string\n"
     ]
    }
   ],
   "source": [
    "def square(s):\n",
    "    \"\"\"Returns the area and perimeter of a square\"\"\"\n",
    "    try:\n",
    "        a = s * s\n",
    "        p = 4 * s \n",
    "        return a, p\n",
    "    except TypeError:\n",
    "        print('s can not be a string')\n",
    "square('4')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 8, 3]\n"
     ]
    }
   ],
   "source": [
    "x = [4, 8, -2, -6, 3]\n",
    "greater_than_zero = filter(lambda n: (n > 0), x)\n",
    "print(list(greater_than_zero))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[12, 20, 14, 4, 16, 1]\n"
     ]
    }
   ],
   "source": [
    "x = [12, 20, '14', 4, '16', '1']\n",
    "to_int = [n if type(n) == int else int(n) for n in x]\n",
    "print(to_int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[13, 14, 15, 16, 17]\n"
     ]
    }
   ],
   "source": [
    "x = list(range(13,18))\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not(33 > 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 6, 7, 8, 9, 12]\n"
     ]
    }
   ],
   "source": [
    "p = [6, 9, 12, 7, 0, 8]\n",
    "print(sorted(p, reverse=False))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0: Gorilla Grodd\n",
      "1: Mick Rory\n",
      "2: Leonard Snart\n"
     ]
    }
   ],
   "source": [
    "flash_vil = ['Gorilla Grodd', 'Mick Rory', 'Leonard Snart']\n",
    "for x, y in enumerate(flash_vil):\n",
    "    print(str(x) + ': ' + y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwatch: Felicity Smoak\n",
      "Black Canary: Laurel Lance\n"
     ]
    }
   ],
   "source": [
    "characters_names = ['Felicity Smoak', 'Laurel Lance']\n",
    "code_names = ['Overwatch', 'Black Canary']\n",
    "\n",
    "team_arrow = zip(characters_names, code_names)\n",
    "for x, y in team_arrow:\n",
    "    print(y + ': ' + x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<generator object to_upper at 0x000001E029F5C468>\n"
     ]
    }
   ],
   "source": [
    "superhero_list = ['thor', 'hulk']\n",
    "\n",
    "def to_upper(x):\n",
    "    for i in x:\n",
    "        yield i.upper()\n",
    "\n",
    "print(to_upper(superhero_list))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['z', 'x', 'f']\n",
      "['z', 'x', 'f']\n",
      "[19, 4, 8, 4, 1]\n"
     ]
    }
   ],
   "source": [
    "p = ['z', 'x']\n",
    "q = p + ['f']\n",
    "print(q)\n",
    "p.append('f')\n",
    "print(p)\n",
    "\n",
    "y = [19, 4, 8, 4]\n",
    "y.append(1)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2.75, -1.5, 'B', 'Thu', -7]\n"
     ]
    }
   ],
   "source": [
    "foo = [6.5, \"A\", \"B\", \"Thu\", -7]\n",
    "foo[0:2] = [2.75, -1.5]\n",
    "print(foo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['k', 'n', 'd', 'a', 'x']\n"
     ]
    }
   ],
   "source": [
    "p = ['k', 'n', 'd', 'v', 'a', 'x']\n",
    "del(p[3])\n",
    "print(p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'sales' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-8-0c6d6bda404d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mnumpy\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0msales\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mlogical_and\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0msales\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'product'\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;34m'B'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0msales\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'sold'\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m>\u001b[0m \u001b[1;36m100\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'sales' is not defined"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "sales[np.logical_and(sales['product'] == 'B', sales['sold'] > 100)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Room 1 - 3.8\n",
      "Room 2 - 15.36\n",
      "Room 3 - 17.5\n",
      "Room 4 - 15.8\n"
     ]
    }
   ],
   "source": [
    "width = [3.8, 15.36, 17.5, 15.8]\n",
    "for index, y in enumerate(width):\n",
    "    print('Room ' + str(index + 1) + ' -', str(y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(50, 54)\n"
     ]
    }
   ],
   "source": [
    "def rectangle(length, width):\n",
    "    \"\"\"Returns the area and perimeter of a rectangle\"\"\"\n",
    "    a = length * width\n",
    "    p = 2 * (length + width)\n",
    "    return a, p\n",
    "area, perimeter = rectangle(25, 2)\n",
    "print((area, perimeter))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.0 3.0\n"
     ]
    }
   ],
   "source": [
    "def nth_root(n):\n",
    "    \"\"\"Returns the actual_root function\"\"\"\n",
    "    def actual_root(x):\n",
    "        \"\"\"Returns the nth root of x\"\"\"\n",
    "        root = x ** (1/n)\n",
    "        return root\n",
    "    return actual_root\n",
    "square_root = nth_root(2)\n",
    "cube_root = nth_root(3)\n",
    "print(square_root(9), cube_root(27))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "y = 2\n",
    "def cube(x):\n",
    "    y = x ** 3\n",
    "    return y\n",
    "\n",
    "cube(y)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'Emre'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = ['EMRE']\n",
    "print(type(y[0]))\n",
    "y[0].capitalize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(['Rock'], ['Paper'])\n"
     ]
    }
   ],
   "source": [
    "x = ['ROCK', 'PAPER']\n",
    "def caps(li):\n",
    "    \"\"\"\"Returns a list, with all elements capitalized\"\"\"\n",
    "    def inner(w):\n",
    "        \"\"\"Returns a capitalized word\"\"\"\n",
    "        return w.capitalize()\n",
    "    return ([inner(li[0])], [inner(li[1])])\n",
    "print(caps(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def check_type(*args):\n",
    "    return type(args)\n",
    "\n",
    "check_type(1, 2, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "Within the function definition, the parameter **kwargs is turned into a dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "x = \"4\"\n",
    "print(int(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<zip object at 0x00000267BD287588>\n",
      "('Captain America', 'Steven Rogers') ('Thor', 'Thor Odison')\n"
     ]
    }
   ],
   "source": [
    "characters = ['Captain America', 'Thor']\n",
    "names = ['Steven Rogers', 'Thor Odison']\n",
    "\n",
    "avengers = zip(characters, names)\n",
    "print(avengers)\n",
    "print(*avengers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('John Diggle', 'Oliver Queen')\n"
     ]
    }
   ],
   "source": [
    "code_names = ['Spartan', 'Green Arrow']\n",
    "characters_names = ['John Diggle', 'Oliver Queen']\n",
    "\n",
    "team_arrow = zip(code_names, characters_names)\n",
    "cnames, names = zip(*team_arrow)\n",
    "print(names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 0, 1, 2, 4, 6]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1, 0, 1] + [2, 4, 6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "4\n",
      "3\n",
      "7\n",
      "1\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "x = np.array([[7, 4, 3],\n",
    "              [7, 1, 9]])\n",
    "for j in np.nditer(x):\n",
    "    print(j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3.5, 35.0)\n"
     ]
    }
   ],
   "source": [
    "def mean(*x):\n",
    "    \"\"\"Returns the mean of all the numbers\"\"\"\n",
    "    total_sum = 0 # Intial sum\n",
    "    n = len(x) # Number of arguments\n",
    "    for i in x:\n",
    "        total_sum = total_sum + i\n",
    "    return total_sum/n\n",
    "print((mean(3, 4), mean(30, 35, 40)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['3A', '4A', '3B', '4B']\n",
      "['3A', '3B', '4A', '4B']\n"
     ]
    }
   ],
   "source": [
    "str1 = 'AB'\n",
    "str2 = '34'\n",
    "\n",
    "print([y + x for x in str1 for y in str2])\n",
    "print([y + x for y in str2 for x in str1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2: Isabel Rochev\n",
      "3: Sebastian Blood\n",
      "4: Slade Wilson\n"
     ]
    }
   ],
   "source": [
    "arrow_vil = ['Isabel Rochev', 'Sebastian Blood', 'Slade Wilson']\n",
    "for p, j in enumerate(arrow_vil, start = 2):\n",
    "    print(str(p) + ': ' + j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('The Hulk', 'Bruce Banner'), ('Iron Man', 'Tony Stark')]\n"
     ]
    }
   ],
   "source": [
    "characters = ['The Hulk', 'Iron Man']\n",
    "names = ['Bruce Banner', 'Tony Stark']\n",
    "\n",
    "ave_1 = zip(characters, names)\n",
    "avengers = list(ave_1)\n",
    "print(avengers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def find_type(*x):\n",
    "    return type(x)\n",
    "\n",
    "find_type('a', 'b', 'c')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('2.3000', '12.340')"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def add_zeros(string):\n",
    "    \"\"\"Returns a string padded with zeros to ensure consistent length\"\"\"\n",
    "    updated_string = string + '0'\n",
    "    def add_more():\n",
    "        \"\"\"Adds more zeros if necessary\"\"\"\n",
    "        nonlocal updated_string\n",
    "        updated_string = updated_string + '0'\n",
    "    \n",
    "    while len(updated_string) < 6:\n",
    "        add_more()\n",
    "    return updated_string\n",
    "(add_zeros('2.3'), add_zeros('12.34'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Spartan', 'Green Arrow')\n"
     ]
    }
   ],
   "source": [
    "code_names = ['Spartan', 'Green Arrow']\n",
    "characters_names = ['John Diggle', 'Oliver Queen']\n",
    "\n",
    "team_arrow = zip(code_names, characters_names)\n",
    "cnames, names = zip(*team_arrow)\n",
    "print(cnames)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print('four' < 'two')\n",
    "print('a' < 'b')\n",
    "print('ca' < 'b')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n"
     ]
    }
   ],
   "source": [
    "add_squares = (lambda x, y: x**2 + y**2)\n",
    "print(add_squares(2, 4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'tue': 2, 'wed': 3, 'mon': 3}\n"
     ]
    }
   ],
   "source": [
    "x = ['tue', 'tue', 'wed', 'mon', 'wed', 'mon', 'wed', 'mon']\n",
    "counts = {}\n",
    "for val in x:\n",
    "        if val in counts.keys():            \n",
    "            counts[val] += 1\n",
    "        else:\n",
    "            counts[val] = 1\n",
    "print(counts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "auth_ntication\n"
     ]
    }
   ],
   "source": [
    "z = \"authentication\"\n",
    "print(z.replace(\"e\", \"_\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "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
}