Sem-Python-1.ipynb

{
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3.6",
      "name": "python36",
      "language": "python"
    },
    "language_info": {
      "mimetype": "text/x-python",
      "nbconvert_exporter": "python",
      "name": "python",
      "pygments_lexer": "ipython3",
      "version": "3.6.6",
      "file_extension": ".py",
      "codemirror_mode": {
        "version": 3,
        "name": "ipython"
      }
    }
  },
  "nbformat_minor": 2,
  "nbformat": 4,
  "cells": [
    {
      "cell_type": "markdown",
      "source": "# Seminar Python 1\n## 1. Getting started with Python\nPython is an interpreted, object-oriented programming language;\n-\tIt was created in 1991 by Guido van Rossum;\n-\tTwo major versions are available: Python 2 and Python 3 (programs are not directly compatible between version). This course focuses on Python 3 syntax.\n-\tIt is easy to learn due to its simplified syntax;\n-\tPython code allows solving tasks in fewer lines of code;\n-\tIt runs on different platforms: Windows, Mac, Linux, Raspberry Pi etc.;\n-\tA number of code editors are available (IDEs – Integrated Development Environments): Eclipse, PyCharm, Thonny, Netbeans etc.;\n-\tNumerous Python packages (code libraries) are available for specific processing (e.g. data science, AI, graphics etc.)\n-\tPyhton programs can access files and databases in various formats;\n-\tThey can be used to perform big data processing and complex math operations efficiently.\n\nInstalling Python\nPython is available for download at: https://www.python.org/downloads/. \n\nInstalling the IDE:\n-\tInstall the Eclipse IDE on www.eclipse.org. Then configure it as a Python IDE, as described here: https://www.ics.uci.edu/~pattis/common/handouts/pythoneclipsejava/eclipsepython%20neon.html (this version may also be used);\n-\tor, for PyCharm, see: https://www.jetbrains.com/pycharm/download/#section=windows. \n\nUseful links:\n\nLanguage documenation,\ntutorials:\thttps://www.python.org/about/gettingstarted/\nhttps://www.tutorialspoint.com/python/index.htm \nhttps://www.w3schools.com/python/default.asp \n\nExamples:\thttps://www.programiz.com/python-programming/examples\n\nPackages:\thttps://pip.pypa.io/en/stable/installing/\n\nSolutions:\thttps://stackoverflow.com",
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": "**Console output with the print() function,** expressions with the + operator  \nThe `print()` function displays one or more values on screen.\nThe + operator can be used to concatenate two strings:",
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": "**_Select each code cell and press Shift+Enter to run the code !_**",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 1\nx = \"Software Packages\"\nprint(\"Seminar \" + x)",
      "metadata": {
        "collapsed": true,
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": "#Example 2\nx = \"Seminar \"\ny = \"Software Packages\"\nz =  x + y\nprint(z)",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "For numeric variables, + works as addition operator:",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 3\nx = 5\ny = 10\nprint(x + y)",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "Adding a number to a string causes an error:",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 4\nx = 5\ny = \"Python\"\nprint(x + y)",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "When using `print()` with more than one argument, the values are separated by a space. A newline character is inserted after the output.\n  These default delimiters can be changed by using the keyword arguments `sep`, `end`. Default values are `sep=' '` (space), `end='\\n'` (newline).",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 5\nprint('Python', 'version', 3.8)\nprint('Second line of text.')",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": "#Example 6\nprint('Python', 'version', 3.8, sep='_', end='|')\nprint('Second line of text.')",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "## 2. Basic programming elements: data types, variables, expressions. operators, lists (vectors), alternative structures, loops.\n### 2.1 Data types\n#### 2.1.1 Basic built-in types:\n* int\n* float\n* complex\n* bool\n* str\n\nVariables in Python are created by assigning a value to the variable. The data type of the variable is set according to the value. \nNo declaration is needed !",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 7\nx = 1    # int\ny = 2.8  # float\nz = 2+3j   # complex\nb = True # bool\ns = 'Python' #string",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "To check the data type of a variable, the `type()` function can be used:",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 8\nprint(type(x))\nprint(type(y))\nprint(type(z))\nprint(type(b))\nprint(type(s))",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "**int**  (integer) is an integer number (with no decimals); it can be positive or negative and has unlimited length.",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 9\nx = 1\ny = 35656222554887711\nz = -3255522\nprint(type(x))\nprint(type(y))\nprint(type(z))",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "**float** is a real number value (it includes a decimal part).",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 10\nx = 1.10\ny = 1.0\nz = -35.59\nprint(type(x))\nprint(type(y))\nprint(type(z))",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": "#Example 11\nx = 35e3\ny = 12E4\nz = -87.7e100\nprint(type(x))\nprint(type(y))\nprint(type(z)) ",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "The complex data type (**complex**) contains a \"j\" for the imaginary part. ",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 12\nx = 3+5j\ny = 5j\nz = -5j\nprint(type(x))\nprint(type(y))\nprint(type(z))",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "** Data type conversion functions (type constructors):**  \nWhen we need to convert a value to a specific type, the following functions can be used:\n* `int()` – returns an int value based on the supplied argument, which can be an integer, float or string value. (the string values must contain a valid number, otherwise the code results in an error);  \n* `float()` – similar, returns a float value;  \n* `str()` – converts other data types (like int, float) into strings;  \n* `bool()` – converts other types to True or False (for rules see this [link](https://docs.python.org/3/library/stdtypes.html#truth))",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 13\nx = int(1)   # 1\ny = int(2.8) # 2\nz = int(\"3\") # 3\nprint(x, y, z, sep='\\n')",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": "#Example 14\nx = float(1)     # 1.0\ny = float(2.8)   # 2.8\nz = float(\"3\")   # 3.0\nw = float(\"4.2\") # 4.2\nprint(x, y, z,w, sep='\\n')",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": "#Example 15\nx = str(\"s1\") # 's1' \ny = str(2)    # '2'\nz = str(3.0)  # '3.0'\nprint(x, y, z, sep='\\n')",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": "#Example 16\nb1 = bool(22)\nb2 = bool(0)\nb3 = bool('Text')\nb4 = bool('')\nprint(b1, b2, b3, b4, sep='\\n')",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "#### 2.1.2 Strings and string delimiters – \"…\" or '...'.\nString literals can be written between single or double quotes.  \nIf the string contains a quote character (e.g. single quote), the other kind of quote (double) must be used as delimiter.  Alternatively, an escape sequence ( \\\\' or \\\\\" ) can be used. Other useful escape characters are \\n (newline) and \\t (tab).  \nTriple quotes ''' ... ''' can be used for multiline strings.",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 17\ns1 = 'Jerry's Pizza' # error; mark this line as comment and run the script again\ns2 = \"Jerry's Pizza\"\ns3 = 'She said \"OK\".'\ns4 = \"He said \\\"Fine\\\".\"\ns5 = '''Triple quotes can contain ' and \",\nand separate multiline strings.'''\nprint(s2, s3, s4, s5, sep='\\n')",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "Similar to other languages, Python strings are vectors of characters. The characters can be accesed via an index (position) between 0 and string length – 1.  \nThe square brackets `[ ]` are used for indexing.  \nNegative indexes are allowed, where `string[-1]` is the last character in the string.  \nThe slice notation `[m:n]` allows extracting substrings. A slice starts with position m and end with position n-1. If m is missing `[:n]`, the slice starts with the first character; similarly if n is missing `[m:]`, the slice ends with the last character.",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 18\na = \"Software Packages seminar\"\nprint(a[1])\nprint(a[4:8])\nprint(a[-1])\nprint(a[:4])\nprint(a[-7:])\nprint(a[:])\nprint(a[::2]) #slice notation with step 2",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "Strings are objects and therefore have methods for processing. Methods are called as `string_var.method( args )`  \nThe `strip()` method eliminates spaces left and right of the string:",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 19\na = \"            Software Packages seminar  \"\nprint(a.strip())# returns \"Software Packages seminar\" \nprint(a)",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "Other string methods:  \nThe function `len()` returns the string length.  \nChanging to lower case : `lower()`  \nChanging to lower case: `upper()`  \nSubstring replacement: `replace()`  \nSplitting a string based on a separator: `split()`",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 20\na = \"Software Packages seminar\"\nprint(len(a))\nprint(a.lower()) \nprint(a.upper())\nprint(a.replace(\" \", \"\"))\nprint(a.split(\" \")) # a list of words is generated: ['Software', 'Packages', 'seminar']",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "### 2.2 Variables\nPython code is case-sensitive. This includes variable names.  \nAccepted names contain only alphanumeric characters (A-Z, a-z, 0-9 and underscore) and must start with a letter or underscore.  \nPython variables are not explicitly declared; they are creating by assigning a value. No data type is given explicitly.",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 21\nx = 5\ny = \"Python\"\nprint(x)\nprint(y)",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "The data type of a variable can be changed by assigning a value of another type to it (!)",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 22\nx = 4 # x of type int\nprint(x, type(x))\nx = \"Python\" # x is now of type str\nprint(x, type(x))",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "### 2.3 Data structures (data collections)\n#### 2.3.1 Lists\nLists are ordered data collections. They are mutable (can be modified). The elements can be identical. They may have different data types. Lists are defined by brackets [ ] enclosing the elements, separated by commas.",
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": "Creating and printing lists:",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 23\nlist1 = [\"laptop\", \"pen\", \"flipchart\"]\nlist2 = [ 1, 'abc', 2.5 ]\nlist3 = [] #empty list\nprint(list1) ",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "Indexing can be used to access single elements:",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 24\nmylist = [\"laptop\", \"pen\", \"flipchart\"]\nprint(mylist[1])",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "Changing a list element:",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 25\nmylist[1] = \"marker\"\nprint(mylist)",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "The `len()` function returns the number of list elements.",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 26\n#mylist = [\"laptop\", \"pen\", \"flipchart\"]\nprint(len(mylist))",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "To add an element at the end, use the `append()` method.",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 27\n#mylist = [\"laptop\", \"pen\", \"flipchart\"]\nmylist.append(\"backpack\")\nprint(mylist)",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "To insert an element at a specific position, use the `insert()` method.",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 28\n#mylist = ['laptop', 'marker', 'flipchart', 'backpack']\nmylist.insert(1, \"phone\")\nprint(mylist)",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "Deleting a list element:  `remove()`",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 29\n#mylist = ['laptop', 'phone', 'marker', 'flipchart', 'backpack']\nmylist.remove(\"laptop\")\nprint(mylist) ",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "The `pop()` method removes and returns the last element, or an element specified by its index. Together with `append()` can be used to implement the stack (LIFO) logic.",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 30\n#mylist = ['phone', 'marker', 'flipchart', 'backpack']\nprint(mylist.pop())\nprint(mylist)",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "The `del` __statement__ removes the element with the specified index:",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 31\n#mylist = ['phone', 'marker', 'flipchart']\ndel mylist[0]\nprint(mylist)",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "`del` can also remove the entire list:",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 32\n#mylist = [\"laptop\", \"pen\", \"flipchart\"]\ndel mylist\nprint(mylist) #error: the variable is not defined",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "The `clear()` method empties the list:",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 33\nmylist = [\"laptop\", \"pen\", \"flipchart\"]\nmylist.clear()\nprint(mylist)",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "The `list()` constructor can be used to create a list from another kind of object (e.g. string, tuple, set etc.)",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 34\nmylist = list((\"laptop\", \"pen\", \"flipchart\")) #create list from tuple\nprint(mylist)",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "**Summary of list methods**\n\n|Method|Description|\n|:---|:---|\n|append()|Append an item at the end|\n|clear()|Remove all list items|\n|copy()|Create a copy of the list|\n|count()|Return the number of times a given value appears in the list.|\n|extend()|Extend the list by appending all the items from another iterable object.|\n|index()|Return the index of the first item with the specified value.\n|insert()|Insert an item at a given position.|\n|pop()|Remove a list item at a given position / last item.|\n|remove()|Remove the first item with a given value.|\n|reverse()|Reverse the elements of the list.|\n|sort()|Sorts the list items \"in place\". The sorted() function returns a sorted version of a list (the original list is not changed).|",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Exercise 0.a: sort the list (mylist) using list.sort() and sorted();\n#How can you change the sorting direction (ascending / descending) ?\n#Check the online documentation.\n\n#...your code here...#",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "#### 2.3.2 Tuples \nTuples are ordered, immutable data colections. Tuple items can be identical. The tuple notation uses parentheses ( ).",
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": "Create and print a tuple, accesing tuple elements by index:",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 35\ntup = (\"laptop\", \"pen\", \"flipchart\")\nprint(tup) \nprint(tup[1])",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "Trying to modify a tuple element results in an error:",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 36\ntup[1] = \"marker\" # error !",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "Tuple methods:  \n`count()` - returns the number of times a given value appears in a tuple.  \n`index()` - returns the index of the first item with the specified value.",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 37\n#tup = (\"laptop\", \"pen\", \"flipchart\")\ntup = tup + ('pen',) #concatenate with a one-element tuple\nprint(tup)\nprint(tup.count('pen'))\nprint(tup.index('flipchart'))",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "#### 2.3.3 Sets\nSets are unordered collection with no duplicate elements. The set notation uses curly braces { }. A set can also be created with the set constructor `set()`.  \nSet objects support operations like union, intersection, difference, and symmetric difference.",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 38\nset1 = {\"laptop\", \"pen\", \"flipchart\"}\nprint(set1)\n\nlist1 = [2, 7, 3, 2]\nset2 = set(list1)\nprint(set2)",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "Accessing individual set elements is not possible, but the set can be iterated in a `for` statement; the existence of an item in a set can be verified with the `in` operator.  \nSet elements cannot be changed, but new elements can be inserted with the `add()` method.\n\n**Set methods:**\n\n\n|Method|Description|\n|---|---|\n|add()|Add an element|\n|clear()|Remove all set elements|\n|copy()|Returns a copy of the set|\n|difference()|Return a new set with elements in the set that are not in he other set(s)|\n|difference_update()|Removes items of one set that are also members of another set|\n|discard()|Remove a specified element|\n|intersection()|Returns a set with the intesection (common elements) of two elements|\n|intersection_update()|Removes items of one set that are not members of another set|\n|isdisjoint()|Returns True if two sets are disjoint (have no common elements).|\n|issubset()|Returns True if a set is included in another set|\n|issuperset()|Returns True if a set contains another set|\n|pop()|Extracts a set element|\n|remove()|Removes the specified element|\n|symmetric_difference()|Returns a set with the elements in elements that are in one or the other set, but not in both|\n|symmetric_difference_update()|Update the set, keeping only elements found in either set, but not in both|\n|union()|Returns a new set with the elements found in the set and the other set(s)|\n|update()|Update the set, adding elements from all others|",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Exercise 0.b: use a few set operation methods of your choice\n\n#your code here ... #",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "#### 2.3.4 Dictionaries\nDictionaries are unordered, mutable and indexed collections. They are sets of key: value pairs, with the requirement that the keys are unique. The notation for dictionaries uses braces { }.",
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": "Create and print a dictionary:",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 39\ndict = {\"laptop\":\"IBM\", \"pencil\":\"Faber Castell\", \"flipchart\":\"M3\"}\nprint(dict)",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "Access elements by key or using the `get()` method:",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 40\n#dict = {\"laptop\":\"IBM\", \"pencil\":\"Faber Castell\", \"flipchart\":\"M3\"}\nprint(dict[\"laptop\"])\nprint(dict.get(\"laptop\"))",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "Modify an element by key:",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 41\n#dict = {\"laptop\":\"IBM\", \"pencil\":\"Faber Castell\", \"flipchart\":\"M3\"}\ndict[\"laptop\"] = \"HP\"\nprint(dict)",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "**Dictionary methods:**\n\n|Method|Description|\n|---|---|\n|clear()|Remove all dictionary elements|\n|copy()|Returns a copy of the dictionary|\n|fromkeys()|Create a new dictionary with the specified keys and values (optional)|\n|get()|Return the value for key if key is in the dictionary, else returns None.|\n|items()|Returns a list of the dictionary's (key, value) pairs (list of tuples).|\n|keys()|Returns a list of the keys.|\n|pop()|Removes and returns the element for the specified key.|\n|popitem()|Removes and returns an arbitrary (key, value) pair from the dictionary.|\n|setdefault()|Return the value for key if key is in the dictionary; else it adds the key with the specified value (or None).|\n|update()|Update the dictionary with the specified key/value pairs, overwriting existing keys.|\n|values()|Returns a list of the dictionary's values.|\n",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Exercise 0.c: use a few dictionary operation methods of your choice\n\n#your code here ... #",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "### 2.4 Operators and expressions\n\nArithmetic operators:\n\n\n|Operator|Description|Example|\n|---|---|---|\n|+|Addition (sum)|x + y|\n|-|Subtraction|x - y|\n|*|Multiplication|x * y|\n|/|Division|x / y|\n|%|Remainder (modulo)|x % y|\n|**|Power|x ** y|\n|//|Integer division (quotient)|x // y|\n\n\nAssignment, combined assignment\n\n\n|Operator|Example|Equivalent|\n|---|---|---|\n|= |x = 5 |x = 5|\n|+= |x += 3 |x = x + 3|\n|-= |x -= 3 |x = x - 3|\n|*= |x *= 3 |x = x * 3|\n|/= |x /= 3 |x = x / 3|\n|%= |x %= 3 |x = x % 3|\n|//= |x //= 3 |x = x // 3|\n|**= |x **= 3 |x = x ** 3|\n\n\nComparison \n\n|    Operator    |    Name                        |    Example    |\n|----------------|--------------------------------|---------------|\n|    ==          |    Equal to                    |    x == y     |\n|    !=          |    Different from              |    x != y     |\n|    >           |    Greater than                |    x > y      |\n|    <           |    Lower than                  |    x < y      |\n|    >=          |    Greater than or equal to    |    x >= y     |\n|    <=          |    Lower than or equal to      |    x <= y     |\n\nLogical\n\n|    Operator    |    Description                                          |    Example                     |\n|----------------|---------------------------------------------------------|--------------------------------|\n|    and         |    Returns True if both expressions are True            |    x < 5 and  x < 10           |\n|    or          |    Returns True   if at least one expression is True    |    x < 5 or x < 4              |\n|    not         |    Negates the truth value                              |    not(x < 5 and x   < 10)     |\n\nIdentity\n\n|    Operator    |    Description                                            |    Example       |\n|----------------|-----------------------------------------------------------|------------------|\n|    is          |    Returns True if both variables are the same object     |    x is y        |\n|    is not      |    Returns True if the variables are different objects    |    x is not y    |\n\nMembership \n\n|    Operator    |    Description                                       |    Example       |\n|----------------|------------------------------------------------------|------------------|\n|    in          |    True if a value   is a member of an object        |    x in y        |\n|    not in      |    True if a   value is not a member of an object    |    x not in y    |",
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": "### 2.5 Control flow statements\nThe _indentation_ is essential in Python for delimiting code blocks. Typically, an indent has four spaces or one tab. \n\n#### 2.5.1 The alternative (conditional) structure - **`if`**",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 42\nx=-100\n#x = int(input (\"Enter a number x: \"))\nif x<0:\n    print('x is negative')\nelif x==0:\n    print('x is zero')\nelse:\n    print('x is positive')",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "Errors in indentation can modify the program logic or even cause syntax errors !",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 43\na = 1\nb = 3\nif a<b:\nprint('a is lower than b')",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "#### 2.5.2 Repetitive structures (loops)\n**The `for` loop:**",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 44\nmylist = [\"laptop\", \"pencil\", \"flipchart\"]\nfor w in mylist:\n    print (w)",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": "#Example 45\n#mylist = [\"laptop\", \"pencil\", \"flipchart\"]\nfor w in mylist:\n    print (w[0], len(w))",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "`break` exits (terminates) the loop:",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 46\nmylist = [\"laptop\", \"pencil\", \"flipchart\"]\nfor x in mylist:\n    print(x)\n    if x == \"pencil\":\n        break",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": "#Example 47\n#mylist = [\"laptop\", \"pencil\", \"flipchart\"]\nfor x in mylist:\n    if x == \"pencil\":\n        break\n    print(x)",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "`continue` jumps to the next iteration in the loop.",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 48\n#mylist = [\"laptop\", \"pencil\", \"flipchart\"]\nfor x in mylist:\n    if x == \"pencil\":\n        continue\n    print(x)",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "The `range()` function returns a sequence of numbers that can be used in `for` loops.\nNotice how sequences are generated:",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 49\nfor x in range(6):\n    print(x, end=' ')\nprint()\n\nfor x in range(2, 6):\n    print(x, end=' ')\nprint()\n\nfor x in range(2, 30, 3):\n    print(x, end=' ')\nprint()",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "Create lists from range():",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 50\n# create list from range\nprint(list(range(6))) \nprint(list(range(2, 6))) \nprint(list(range(2, 30, 3)))",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "The optional `else` clause is executed after finishing the `for` iterations.",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 51\nfor x in range(6):\n    print(x)\nelse:\n    print(\"Program ended.\")",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "Nested loop:",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 52\nmylist = [\"laptop\", \"pencil\", \"flipchart\"]\ncolors = [\"red\", \"yellow\", \"green\"]\nfor x in mylist:\n    if x =='pencil' or x =='flipchart':\n        for y in colors:\n            print(y, x)",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "**The `while` loop:**",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 53\ni = 1\nwhile i < 6:\n    print(i)\n    i += 1",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "`break` exits the loop.",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 54\ni = 1\nwhile i < 6:\n    print(i)\n    if i == 3:\n        break\n    i += 1",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "`continue` interrupts the current block execution; the loop continues with the next iteration.",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 55\ni = 0\nwhile i < 6:\n    i += 1 \n    if i == 3:\n        continue\n    print(i)",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "## 3. Functions\n\n\nFunctions are subprograms that take arguments and return a value.  \nFunctions can be called independently or in an expression.  \n`var = function_name( arg1, arg2, ...)`  \nThe return value may be ignored:  \n`function_name( arg1, arg2, ...)`  \nArguments can be positional or keyword arguments. \nPositional arguments must be specified in the same order as expected by the function definition.  \nIn a function call, keyword arguments must follow positional arguments:\n`function_name(arg1, arg2, kwarg1=value1, kwarg2=value2)`\n\nDepending on where they are defined, Python functions can be:\n* **Built-in functions:** are part of the Python standard language and are directly available. Examples: `print(), input(), len()`.\n* **Functions defined in modules.** To be accessible, the corresponding module must be imported.\n* **User-defined functions** (using the `def` keyword). A special case are the lambda functions (`lambda` keyword).\n\n### 3.1. Built-in functions\nSome categories of built-in functions:\n* I/O: `input(), print()`\n* Data type conversion / constructors: `int(), float(), bool(), str(), list(), dict(), tuple(), set()`\n* Math functions: `abs(), pow(), round(), bin(), oct(), hex()`\n* List (iterable) functions: `len(), max(), min(), sum(), sorted(), reversed()`\n* Files: `open()`\n* Character functions: `chr(), ord()`\n* Misc.: `type(), help(), dir()`\nSee all built-in functions [here](https://docs.python.org/3/library/functions.html#built-in-funcs).\n\nConsole input  \n`input()` is used for keyboard (console) input. It returns a string. Numeric values should be converted as required (`int, float` etc.).",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 56\nstr = input(\"Enter your name: \");\nprint (\"Hello,\", str, \"!\")",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": "#Example 57\nx=int(input('Enter a number:'))\nif x>0:\n    print(x,'is positive.')\nelse:\n    print(x,'is negative or zero.')",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "### 3.2 Functions defined in modules (libraries)\n\nThere is a vast number of modules available for various purposes.  \nSome modules are considered as part of the **standard python library** and are documented in the [Python Library Reference](https://docs.python.org/3/library/index.html). In addition to this, there is a large number of modules and packages available from the [Python Package Index](https://pypi.org/) (see also the [list of modules by function](https://wiki.python.org/moin/UsefulModules)).\n\nBefore using the module elements (functions, variables, classes etc.), the entire module or parts of it must be **imported**:",
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": "Importing the entire module:",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 58\nimport math             #import entire module;\n\nprint(math.sqrt(25))    #the names must be qualified, \n                        #e.g. module.function()\nprint(math.pi)",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "Importing specific items from a module:",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 59\nfrom math import pi, sin, cos        #import specific items;\nprint(sin(pi/2), round(cos(pi/2),2)) #no qualification required !",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "The import statement can also define aliases for modules:",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 60\nimport math as m, platform as p\nprint(round(m.pi, 5))\nprint(p.platform())",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "The `dir()` built-in function shows the names of items that are defined in a module.",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 61\nimport math\ndir(math)",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "### 3.3 User-defined functions\n\nThe functions are defined using the `def` keyword followed by the function name and the list of arguments. The body of the function is indented.  \nTo return a value (result), use the `return` keyword. By default (if return is not executed) the function returns a `None` value.\nSee [this link](https://docs.python.org/3/tutorial/controlflow.html#defining-functions) for more on defining functions.",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 62\ndef my_function1(x): #function definition\n    result = x**2\n    print (result)\n    return result\n\n#calling the function - correct the error !\nmy_function1()",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "Using an argument with a default value of 100:",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 63\ndef my_function2(x=100):\n    result = x**2\n    print (result)\n    return result\n\n#calling the function\nmy_function2()\ny=my_function2(5)\nprint(y)",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": "#Example 64\ndef my_function3(x,n):\n    result = x**n\n    return result\n\nprint(my_function3(4,3))",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "Defining a recursive function:",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 65\ndef recursive_f(k):\n    if(k>0):\n        result = k + recursive_f(k-1)\n        print(result)\n    else:\n        result = 0\n    return result\n\nprint(\"Calling the recursive function:\")\nrecursive_f(6)",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "### 3.4 Lambda functions\nA lambda function is a simple, anonymous function with one or more arguments and an expression – the expression result is returned.",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Example 66\nx = lambda a : a + 10\nprint(x(5))",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": "#Example 67\nx = lambda a, b : a * b\nprint(x(5, 6))",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": "#Example 68\nx = lambda a, b, c : a + b + c\nprint(x(5, 6, 2)) ",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "## Exercises\n\n1) Write the expressions in the following script to calculate the ending time of an activity. The starting time is given as hh, mm (hours, minutes) and the duration is given in minutes.  \n**Hint:** in the template code, the str.format() method is used for formatting the output as hh:mm (e.g. 09:35, 11:05). [See documentation here](https://docs.python.org/3/tutorial/inputoutput.html#the-string-format-method).",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "# Exercise 1: Arithmetic operators\n# Write the expressions to calculate the ending time of an activity.\n# The starting time is given as hh, mm (hours, minutes) and the duration \n# is given in minutes.\n\nhh = 9 #starting time; test also for hh=23\nmm = 35\nd = 90 # duration\n\nmm2 =   #write an expression for ending time(minutes)\nhh2 =   #write an expression for ending time(hour)\n\nprint('Activity starts: {:02d}:{:02d} and takes {} minutes.'.format(hh,mm,d))\nprint('Activity ending time: {:02d}:{:02d}.'.format(hh2,mm2))",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "2) Write a program that reads n (n<=10) integer values from console input and creates a list with these values as items. The list should then be sorted (ascending) and shown on screen.",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Your code here:\n",
      "metadata": {},
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "3) Write a program that creates a list of 5 items – cities entered by the user. \nUse a function that returns the length of each city name as a sorting key in the sort() method, to sort the cities list in descending order by length of city name. Print the sorted list.\n\n_Documentation for list.sort():\nlist.sort(reverse=True|False, key=myFunc) \nreverse Optional. reverse=True will sort the list descending. Default is reverse=False\nkey Optional. A function to specify the sorting criteria(s)_",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Your code here:\n",
      "metadata": {
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "4) Create an equipment list, whose elements are lists with 3 elements: device name, price and quantity. Calculate the value for each item and store it in the list, then sort the list by value and print it. (hint: use the list.sort() method and a lambda function as sorting key).",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Your code here:\n",
      "metadata": {},
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "5) Create two lists: emp_list with employee names and surnames, and  cust_list with customer names and surnames.\na. Print the name of the employee(s) which are also customers.\nb. Solve the exercise using sets and set operations.",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Your code here:\n",
      "metadata": {},
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "6) Create a list of dictionaries with the following keys: id, name and salary, for the employees Johnson, May and Cameron.\nIncrease the salary by 10% for employees with a salary lower than 5000.",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#Your code here:\n",
      "metadata": {},
      "execution_count": null,
      "outputs": []
    }
  ]
}