1_First_steps_SOLVED.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. First steps with *Python* on *Jupyter*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Goal\n",
    "\n",
    "Here we will dive into the basics of the *Python* syntax and learn the usage of *Jupyther* notebooks. Besides other exercises you will make your computer speak to you."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.1 Usage of ```jupyter notbook```\n",
    "\n",
    "- To execute a cell press \"SHIFT-RETURN\"\n",
    "- Use the tool bar to add, delete, copy, or insert cells\n",
    "\n",
    "### *1.1 TASKS*\n",
    "- Execute the cell to print the encrypted message."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "message = \"ssliata )oeo e(    ecotd ecroPsn-  id hfbesretrogi.noes js  nc  hsedae d iloyaanea oenr n iiiottthasfoeoe,cug osaRsovf lehv,mTolt trpuntaaemyexuitah adcmtisahoonnrr s o tc ualm   Gbdo  lr  bhlr a sctd  eoe scenhnfidlt oa\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Use your programming intuition and decrypyt the message by using the function ```decrypt(...)```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def encrypt(message):\n",
    "    \"\"\"Encrypt the string message\"\"\"\n",
    "    import numpy\n",
    "    numpy.random.seed(0)\n",
    "    L1 = numpy.arange(len(message))\n",
    "    numpy.random.shuffle(L1)\n",
    "    message_encr = \"\"\n",
    "    for i in L1:\n",
    "        message_encr += message[i]\n",
    "    print message_encr\n",
    "    return message_encr\n",
    "\n",
    "def decrypt(message):\n",
    "    \"\"\"Decrypt the string message\"\"\"\n",
    "    import numpy\n",
    "    numpy.random.seed(0)\n",
    "    L0 = numpy.arange(len(message))\n",
    "    L1 = numpy.arange(len(message))\n",
    "    numpy.random.shuffle(L1)\n",
    "    order = [L0[L1==i][0] for i in L0]\n",
    "    message_decr = \"\"\n",
    "    for i in order:\n",
    "        message_decr += message[i]\n",
    "    print message_decr\n",
    "    return message_decr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The joy of coding Python should be in seeing short, concise, readable classes that express a lot of action in a small amount of clear code - not in reams of trivial code that bores the reader to death. (Guido van Rossum)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'The joy of coding Python should be in seeing short, concise, readable classes that express a lot of action in a small amount of clear code - not in reams of trivial code that bores the reader to death. (Guido van Rossum)'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# TYPE YOUR CODE ERE\n",
    "decrypt(message)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.2 Variables\n",
    "\n",
    "A variable is something that holds a value that may change. In simplest terms, a variable is just a box that you can put stuff in. You can use variables to store all kinds of stuff. For example the integer number 123456:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "variable_0 = 123456"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Data types\n",
    "\n",
    "A selection of Python data types is given here:\n",
    "\n",
    "|Data type   | Examples                                                 |\n",
    "|------------|----------------------------------------------------------|\n",
    "|```bool```  |either ```True``` or ```False```                          |\n",
    "|```int```   |1, 6, -1, 0, 3244, ...                                    |\n",
    "|```float``` |3.14, -43535.345, 0.0, ...                                |\n",
    "|```str```   |\"Hello world!\", \"nothing\", ...                            |\n",
    "|```list```  |[```True```, 1, 3.14, \"Hello!\", [1,2,34]], ...            |\n",
    "|```dict```  |{\"some key\": 1.24233, \"another key\": \"anything\"}, ...     |\n",
    "\n",
    "*Examples:*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# bool \n",
    "a = True\n",
    "b = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# int\n",
    "c = -2\n",
    "d = 24389"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# float\n",
    "e = 3.1\n",
    "f = -2342.4324"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# str\n",
    "g = \"Hello!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# list\n",
    "h = [1,5,23,-1]\n",
    "j = [a,b,c,d,e,f,g,h,\"I can put anything in a list! :)\"]\n",
    "k = range(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# dict\n",
    "l = {\"key1\": \"any content\", \"key2\": 13, \"key1000\": [1,4,6]}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Operators\n",
    "\n",
    "- Comparisons: \"==\", \">\", \"<\", \">=\", \"<=\", ...\n",
    "- Calculations: \"+\", \"-\", \"*\", \"/\", ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Comparisons\n",
    "a == b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b == False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c < d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c >= c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'g' does not equal the string \"Hello!\".\n"
     ]
    }
   ],
   "source": [
    "# If statements\n",
    "if g == \"Bye!\":\n",
    "    print \"\\'g\\' equals the string \\\"Hello!\\\"\"\n",
    "else:\n",
    "    print \"\\'g\\' does not equal the string \\\"Hello!\\\".\"    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-7261.540440000001"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Calculations\n",
    "e * f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1,\n",
       " 5,\n",
       " 23,\n",
       " -1,\n",
       " True,\n",
       " False,\n",
       " -2,\n",
       " 24389,\n",
       " 3.1,\n",
       " -2342.4324,\n",
       " 'Hello!',\n",
       " [1, 5, 23, -1],\n",
       " 'I can put anything in a list! :)']"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h + j"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### *1.2 TASKS*\n",
    "\n",
    "- Define a list ```names``` that contains the names of you and the students who sit next to you.\n",
    "- Add all items of the list ```teachers``` to ```names``` using a calculation operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# TYPE YOUR CODE HERE\n",
    "names = [\"Max\", \"Filipe\", \"Benedikt\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.3 Loops\n",
    "\n",
    "Using _for_-loops allow you to run repeated tasks on a sequence of data. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "b\n",
      "c\n",
      "d\n",
      "e\n"
     ]
    }
   ],
   "source": [
    "# Example 1\n",
    "for bla in \"abcde\":\n",
    "    print bla"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "5\n",
      "23\n",
      "-1\n"
     ]
    }
   ],
   "source": [
    "# Example 2\n",
    "for h_i in h:\n",
    "    print h_i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1\n",
      "1 5\n",
      "2 23\n",
      "3 -1\n"
     ]
    }
   ],
   "source": [
    "# Example 3\n",
    "for i in range(len(h)):\n",
    "    print i, h[i]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "key2 13\n",
      "key1 any content\n",
      "key1000 [1, 4, 6]\n"
     ]
    }
   ],
   "source": [
    "# Example 4\n",
    "for key in l.keys():\n",
    "    print key, l[key]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### *1.3 TASKS*\n",
    "\n",
    "Use a ```for``` loop to print items of your list ```names``` in inverse order (without changing the list ```names``` itself)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Benedikt\n",
      "Filipe\n",
      "Max\n"
     ]
    }
   ],
   "source": [
    "# TYPE YOU CODE HERE\n",
    "for i in [2,1,0]:\n",
    "    print names[i]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Benedikt\n",
      "Filipe\n",
      "Max\n",
      "Benedikt\n",
      "Filipe\n",
      "Max\n",
      "Benedikt\n",
      "Filipe\n",
      "Max\n"
     ]
    }
   ],
   "source": [
    "# ALTERNATIVE SOLUTIONS\n",
    "for i in range(len(names))[::-1]:\n",
    "    print names[i]\n",
    "\n",
    "for i in range(len(names)):\n",
    "    print names[-1-i]\n",
    "    \n",
    "for i in range(len(names)-1, -1, -1):\n",
    "    print names[i]    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.4 Using external packages\n",
    "\n",
    "There is a huge amount of useful Python packages. Many packages are already shipped with your Python installation, others you need to install for example with the command line package manager _pip_.\n",
    "\n",
    "Before using them in your code you must \"_import_\" the package."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# We import the standard \"os\" package (https://docs.python.org/2/library/os.html).\n",
    "import os"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Look up the help message for the function _os.system(...)_ by executing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function system in module posix:\n",
      "\n",
      "system(...)\n",
      "    system(command) -> exit_status\n",
      "    \n",
      "    Execute the command (a string) in a subshell.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(os.system)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### *1.4 TASKS*\n",
    "\n",
    "Use _os.system(...)_ to call the command line tool _say_. Let your computer read out loud the above quote by Guido van Rossum."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Example\n",
    "command = \"say \" + \"something\"\n",
    "os.system(command)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The joy of coding Python should be in seeing short, concise, readable classes that express a lot of action in a small amount of clear code - not in reams of trivial code that bores the reader to death. (Guido van Rossum)\n",
      "The joy of coding Python should be in seeing short, concise, readable classes that express a lot of action in a small amount of clear code - not in reams of trivial code that bores the reader to death. \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# TYPE YOUR CODE HERE\n",
    "decrypted_message = decrypt(message)\n",
    "# Remove the brackets in the end of string\n",
    "decrypted_message = decrypted_message[:-len(\"(Guido van Rossum)\")]\n",
    "print decrypted_message\n",
    "os.system(\"say\" + \" \" + decrypted_message)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}