Made some minor grammatical corrections till point when should we use lists...

Made some minor grammatical corrections till point when should we use lists and when should we use tuples

Made some minor grammatical corrections till point when should we use lists...
Made some minor grammatical corrections till point when should we use lists and when should we use tuples
5620e583 · Jöran Frey · 19055948 · 5620e583
Commit 5620e583 authored 4 months ago by Jöran Frey
--- a/unit-4/lecture.ipynb
+++ b/unit-4/lecture.ipynb
@@ -84,8 +84,8 @@
   "source": [
    "2. List items are ordered, changeable, and allow duplicate values\n",
    "    * Orders: Items have a defined order, and that order will not change unless we add or remove items\n",
-    "    * Changable: We can change, add, and remove items in a list after it has been created\n",
+    "    * Changeable: We can change, add, and remove items in a list after it has been created\n",
-    "3. We access list items by thier index (the position in the list, starting with 0)"
+    "3. We access list items by their index (the position in the list, starting at 0)"
   ]
  },
  {
@@ -158,7 +158,7 @@
    }
   },
   "source": [
-    "2. Instead of selecting a single item we can also select a subset of the list with the schema ```start-index:end-index```"
+    "2. Instead of selecting a single item, we can also select a subset of the list with the schema ```start-index:end-index```"
   ]
  },
  {
@@ -195,21 +195,21 @@
    "\n",
    "We have already seen the most important list methods (functions). Here is a complete table:\n",
    "\n",
-    "| Method    | Description                                                                  |\n",
+    "| Method    | Description                                                                 |\n",
-    "| :-------- | :--------------------------------------------------------------------------- |\n",
+    "| :-------- | :-------------------------------------------------------------------------- |\n",
-    "| append()  | Adds an element at the end of the list                                       |\n",
+    "| append()  | Adds an element at the end of the list                                      |\n",
-    "| clear()   | Removes all the elements from the list                                       |\n",
+    "| clear()   | Removes all elements from the list                                          |\n",
-    "| copy()    | Returns a copy of the list                                                   |\n",
+    "| copy()    | Returns a copy of the list                                                  |\n",
-    "| count()   | Returns the number of elements with the specified value                      |\n",
+    "| count()   | Returns the number of elements with the specified value                     |\n",
-    "| extend()  | Add the elements of a list (or any iterable), to the end of the current list |\n",
+    "| extend()  | Adds an element of a list (or any iterable), to the end of the current list |\n",
-    "| index()   | Returns the index of the first element with the specified value              |\n",
+    "| index()   | Returns the index of the first element with the specified value             |\n",
-    "| insert()  | Adds an element at the specified position                                    |\n",
+    "| insert()  | Adds an element at the specified position                                   |\n",
-    "| pop()     | Removes the element at the specified position                                |\n",
+    "| pop()     | Removes the element at the specified position                               |\n",
-    "| remove()  | Removes the item with the specified value                                    |\n",
+    "| remove()  | Removes the item with the specified value                                   |\n",
-    "| reverse() | Reverses the order of the list                                               |\n",
+    "| reverse() | Reverses the order of the list                                              |\n",
-    "| sort()    | Sorts the list                                                               |\n",
+    "| sort()    | Sorts the list                                                              |\n",
    "\n",
-    "See https://www.w3schools.com/python/python_lists_methods.asp for more details."
+    "See [this page](https://www.w3schools.com/python/python_lists_methods.asp) for more details."
   ]
  },
  {
@@ -222,10 +222,10 @@
   "source": [
    "## Tuples\n",
    "\n",
-    "* A tuple is a collection which is ordered and **unchangeable**.\n",
+    "* A tuple is a collection that is ordered and **unchangeable**.\n",
    "* Tuples are written with round brackets.\n",
-    "* Tuples are orded and allow duplicate values.\n",
+    "* Tuples are ordered and allow duplicate values.\n",
-    "* Items of tuples are accessed exactly the same way as lists with ```[]```"
+    "* tems in tuples are accessed in the same way as lists, using ```[]```"
   ]
  },
  {
@@ -273,7 +273,7 @@
   "source": [
    "* Tuples only know the methods ```count()```and ```index()```\n",
    "* We use tuples to make sure, our data will not be changed anywhere in the code\n",
-    "* Tuples are faster and more memory efficient than lists"
+    "* Tuples are faster and more memory-efficient than lists"
   ]
  },
  {
@@ -349,7 +349,7 @@
    "## Sets\n",
    "* A set is a collection which is unordered, and unindexed and its itmes are unchangeable.\n",
    "  * Once a set is created, you cannot change its items, but you can add new items.\n",
-    "  * Dublicate items will be treated as one item\n",
+    "  * Duplicated items will be treated as one item\n",
    "* Like lists and tuples, sets can contain multiple data types\n",
    "* You cannot access items in a set by referring to an index or a key (since they have no order)\n",
    "* Sets are written with curly brackets."

 %% Cell type:markdown id: tags:
 # Extended Data Types
 %% Cell type:markdown id: tags:
 # Agenda
 * Lists (repetition)
 * Tuples
 * Sets
 * Dictionaries
 %% Cell type:markdown id: tags:
 ## Introduction
 * We already know lists
 * Lists are only one of 4 built-in data types in Phython that store collections of data:
  * Lists
  * Tuples
  * Sets
  * Dictionaries
 * Collections are used to store multiple items in a single variable.
 * Working with collections is something that makes Python extremly powerful
 %% Cell type:markdown id: tags:
 ## Recap of what we know about Lists
 1. Lists are created with square brackets ```[ ]```
 %% Cell type:code id: tags:
 ``` python
 list = [1,2,5,3]
 ```
 %% Cell type:markdown id: tags:
 2. List items are ordered, changeable, and allow duplicate values
    * Orders: Items have a defined order, and that order will not change unless we add or remove items
-    * Changable: We can change, add, and remove items in a list after it has been created
+    * Changeable: We can change, add, and remove items in a list after it has been created
-3. We access list items by thier index (the position in the list, starting with 0)
+3. We access list items by their index (the position in the list, starting at 0)
 %% Cell type:code id: tags:
 ``` python
 list = [1,2,3,3,2]
 print(list[3])
 ```
 %% Output
    3
 %% Cell type:markdown id: tags:
 ## Accessing List Items
 Besides accessing list items with ```[index]``` Python offers some additional options:
 1. Negative Indexing: ```[-1]``` refers to the last item, ```[-2]``` refers to the second last item etc.
 %% Cell type:code id: tags:
 ``` python
 my_list = ['a','b','c','d']
 print(my_list[-1])
 print(my_list[-2])
 ```
 %% Output
    d
    c
 %% Cell type:markdown id: tags:
-2. Instead of selecting a single item we can also select a subset of the list with the schema ```start-index:end-index```
+2. Instead of selecting a single item, we can also select a subset of the list with the schema ```start-index:end-index```
 %% Cell type:code id: tags:
 ``` python
 my_list = ['a','b','c','d']
 print(my_list[1:3])
 ```
 %% Output
    ['b', 'c']
 %% Cell type:markdown id: tags:
 ## List Functions
 We have already seen the most important list methods (functions). Here is a complete table:
-| Method    | Description                                                                  |
+| Method    | Description                                                                 |
-| :-------- | :--------------------------------------------------------------------------- |
+| :-------- | :-------------------------------------------------------------------------- |
-| append()  | Adds an element at the end of the list                                       |
+| append()  | Adds an element at the end of the list                                      |
-| clear()   | Removes all the elements from the list                                       |
+| clear()   | Removes all elements from the list                                          |
-| copy()    | Returns a copy of the list                                                   |
+| copy()    | Returns a copy of the list                                                  |
-| count()   | Returns the number of elements with the specified value                      |
+| count()   | Returns the number of elements with the specified value                     |
-| extend()  | Add the elements of a list (or any iterable), to the end of the current list |
+| extend()  | Adds an element of a list (or any iterable), to the end of the current list |
-| index()   | Returns the index of the first element with the specified value              |
+| index()   | Returns the index of the first element with the specified value             |
-| insert()  | Adds an element at the specified position                                    |
+| insert()  | Adds an element at the specified position                                   |
-| pop()     | Removes the element at the specified position                                |
+| pop()     | Removes the element at the specified position                               |
-| remove()  | Removes the item with the specified value                                    |
+| remove()  | Removes the item with the specified value                                   |
-| reverse() | Reverses the order of the list                                               |
+| reverse() | Reverses the order of the list                                              |
-| sort()    | Sorts the list                                                               |
+| sort()    | Sorts the list                                                              |
-See https://www.w3schools.com/python/python_lists_methods.asp for more details.
+See [this page](https://www.w3schools.com/python/python_lists_methods.asp) for more details.
 %% Cell type:markdown id: tags:
 ## Tuples
-* A tuple is a collection which is ordered and **unchangeable**.
+* A tuple is a collection that is ordered and **unchangeable**.
 * Tuples are written with round brackets.
-* Tuples are orded and allow duplicate values.
+* Tuples are ordered and allow duplicate values.
-* Items of tuples are accessed exactly the same way as lists with ```[]```
+* tems in tuples are accessed in the same way as lists, using ```[]```
 %% Cell type:code id: tags:
 ``` python
 my_tuple = ("mia", "mio", 1)
 print(my_tuple[1])
 my_tuple[0] = "ciao"
 ```
 %% Output
    mio
    ---------------------------------------------------------------------------
    TypeError                                 Traceback (most recent call last)
 Cell     In[10], line 4
          1 my_tuple = ("mia", "mio", 1)
          2 print(my_tuple[1])
    ----> 4 my_tuple[0] = "ciao"
    TypeError: 'tuple' object does not support item assignment
 %% Cell type:markdown id: tags:
 * Tuples only know the methods ```count()```and ```index()```
 * We use tuples to make sure, our data will not be changed anywhere in the code
-* Tuples are faster and more memory efficient than lists
+* Tuples are faster and more memory-efficient than lists
 %% Cell type:markdown id: tags:
 ## When should we use lists and when should we use tuples?
 * Use Lists, when you want to change data in your collection
  * Lists are more flexible and have more built-in methods, making them ideal for dynamic collections.
 * Use Tuples, when your data is immutable
  * We use tuples to make sure, our data will not be changed anywhere in the code.
  * Tuples are faster and more memory efficient than lists (especially during iterations).
 %% Cell type:markdown id: tags:
 ## Nested Lists and Tuples
 Since lists, tuples, and sets can contain any datatype we can also nest them:
 %% Cell type:code id: tags:
 ``` python
 my_nested_list = [[1,2],[3,4]] # nested list (2D Array)
 my_nested_tuble = ((1,2),(3,4)) # nested tuble (2D Array)
 my_nested_3D_Matrix = ((1,2,5),
                       (3,4,2),
                       (3,3,3)) # Matrix
 print(my_nested_list[0][1])
 print(my_nested_tuble[0][1])
 print(my_nested_3D_Matrix[1][1])
 ```
 %% Output
    2
    2
    4
 %% Cell type:markdown id: tags:
 ## Sets
 * A set is a collection which is unordered, and unindexed and its itmes are unchangeable.
  * Once a set is created, you cannot change its items, but you can add new items.
-  * Dublicate items will be treated as one item
+  * Duplicated items will be treated as one item
 * Like lists and tuples, sets can contain multiple data types
 * You cannot access items in a set by referring to an index or a key (since they have no order)
 * Sets are written with curly brackets.
 %% Cell type:code id: tags:
 ``` python
 my_set = {1, 5, 3, 1} # last value will be ignored
 my_set.add(1) # will be ignored
 for x in my_set:
  print(x)
 print(my_set[2])
 ```
 %% Output
    1
    3
    5
    ---------------------------------------------------------------------------
    TypeError                                 Traceback (most recent call last)
 Cell     In[1], line 5
          3 for x in my_set:
          4   print(x)
    ----> 5 print(my_set[2])
    TypeError: 'set' object is not subscriptable
 %% Cell type:markdown id: tags:
 ## Example of using Sets
 * Sets are highly useful to efficiently remove duplicate values from a collection like a list and to perform common math operations like unions and intersections.
 * We can use **casting** (remember) between lists and sets to remove dublicats from a list
 %% Cell type:code id: tags:
 ``` python
 my_list = [1,2,3,4,5,1,2,3,3]
 my_set = set(my_list) # remove duplicates by converting to set
 print(my_set)
 my_list = list(my_set) # convert back to list to make it mutable
 print(my_list)
 ## Remove dublicates in one line
 my_list = [1,2,3,4,5,1,2,3,3]
 my_list = list(set(my_list))
 print(my_list)
 ```
 %% Output
    {1, 2, 3, 4, 5}
    [1, 2, 3, 4, 5]
    [1, 2, 3, 4, 5]
 %% Cell type:markdown id: tags:
 ## Dictionaries I
 * If we want to have a more dynamic and structured way to access information (especially nested information), dictionaries are a very useful concept.
 * Dictionaries to store data values in key:value pairs.
 * A dictionary is a collection which is ordered*, changeable and do not allow duplicates.
 * Dictionaries are written with curly brackets, and have keys and values, sepperated by a ```:```
 * Keys are allways a String, e.g. ```"title"```
 %% Cell type:code id: tags:
 ``` python
 song = {
    "title" : "Another brick in the wall",
    "artist" : "Pink Floyd",
    "album" : "The Wall",
    "year" : 1979
 }
 ```
 %% Cell type:markdown id: tags:
 ## Dictionaries II
 * Since the key must be unike (like in a set), dublicates are not allowed.
 * Dicitionaries are accessd by the key in ```[]```or with the ```get()```method.
 * Teh advantage of the get method: If the key is not found, we can define a default value.
 * With the ```keys()``` method, we can access all keys of a dictionary.
 %% Cell type:code id: tags:
 ``` python
 song = {
    "title" : "Another brick in the wall",
    "artist" : "Pink Floyd",
    "album" : "The Wall",
    "year" : 1979
 }
 print (song["title"])
 print (song.get("title"))
 print (song.get("duration", "unknown"))
 print (song.keys())
 ```
 %% Output
    Another brick in the wall
    Another brick in the wall
    unknown
    dict_keys(['title', 'artist', 'album', 'year'])
 %% Cell type:markdown id: tags:
 ## Important Methods of Dictionaries
 * ```update()``` : change or add an item in/to the dictionary
 * ```pop()``` : remove an item from the dictionary
 * ```copy()``` : creates a copy (not an object reference) of the dictionary
 %% Cell type:code id: tags:
 ``` python
 song = {
    "title" : "Another brick in the wall",
    "artist" : "Pink Floyd",
    "album" : "The Wall",
    "year" : 1979
 }
 song.update({"duration" : "3:30"}) # Add key-value pair
 song.update({"year" : 1976}) # Update value
 song["tempo"] = 105 # Alternative way to add key-value pair
 song.pop("album") # Remove key-value pair
 print (song)
 ```
 %% Output
    {'title': 'Another brick in the wall', 'artist': 'Pink Floyd', 'year': 1976, 'duration': '3:30', 'tempo': 105}
 %% Cell type:markdown id: tags:
 ## Iterations on Dictionaries
 * When we do a ```for x in dict``` iteration
 * x will be the key the key for each key:value pair in the dicitonary
 * If you prefer the values instead you can use the ```values()``` method of the dictionary
 * If you want both, keys and values: use the ``ìtems()``` method.
 %% Cell type:code id: tags:
 ``` python
 song = {
    "title" : "Another brick in the wall",
    "artist" : "Pink Floyd",
    "album" : "The Wall",
    "year" : 1979
 }
 for key in song:
    print(key, end = ": ")
    print(song[key], end = " | ")
 print()
 for value in song.values():
    print(value, end = ", " )
 for key, value in song.items():
    print(key, ": ", value)
 ```
 %% Output
    title: Another brick in the wall | artist: Pink Floyd | album: The Wall | year: 1979 |
    Another brick in the wall, Pink Floyd, The Wall, 1979, title :  Another brick in the wall
    artist :  Pink Floyd
    album :  The Wall
    year :  1979
 %% Cell type:markdown id: tags:
 ## Nestet Dictionaries
 * Link lists and tuples, dicitonaries can be nested
 * But in contrast to lists, we can explain with the key, what the value is about
 * Thus, with dicitionaries we can build meaningful data strctures that can be processed by human and computers
 %% Cell type:code id: tags:
 ``` python
 music_library = {
    "rock": {
        "band": "Led Zeppelin",
        "album": "IV",
        "year": 1971
    },
    "jazz": {
        "artist": "Miles Davis",
        "album": "Kind of Blue",
        "year": 1959
    },
    "pop": {
        "artist": "Taylor Swift",
        "album": "1989",
        "year": 2014
    }
 }
 print(music_library["rock"]["band"])
 ```
 %% Output
    Led Zeppelin
 %% Cell type:markdown id: tags:
 ## For Geeeks: What does copy() really do?
 * Copying objets is often useful, when we want to update an object without loosing the original.
 * But is copy just a shallow copy of the first level or a deep copy?
 %% Cell type:code id: tags:
 ``` python
 song = {
    "title" : "Another brick in the wall",
    "artist" : "Pink Floyd"
 }
 best_of_album = { "1" : song, "2" : { "title" : "Shine on you crazy diamond", "artist" : "Pink Floyd" }}
 other_album = best_of_album.copy()
 print(other_album)
 song["title"] = "Wish you were here" # change the reference
 print(other_album) # song title is changed in both dictionaries, thus copy is shallow copy
 ```
 %% Output
    {'1': {'title': 'Another brick in the wall', 'artist': 'Pink Floyd'}, '2': {'title': 'Shine on you crazy diamond', 'artist': 'Pink Floyd'}}
    {'1': {'title': 'Wish you were here', 'artist': 'Pink Floyd'}, '2': {'title': 'Shine on you crazy diamond', 'artist': 'Pink Floyd'}}
 %% Cell type:markdown id: tags:
 ## JSON
 * Dicitionaries in Phython are a representaiton of what we call a *data object*, more generally speaking
 * In Java Script programming language we use exactly the same notation to create objects.
 * This notation is call JSON (Java Script Object Notation)
 * If we use the kind on object notation as a means of communicaiton (e.g. in files or web communcation), we can very easily read these JSON strings an create data objects that can be processed directely in our code.
 * This is so convinient, that it has **become the standard in all kinds of data exchange**: RESTful Webservices, MQTT, Buisness-IT interfaces, Config files, ...
 * In Python we can use the JSON module to do that.
 %% Cell type:code id: tags:
 ``` python
 import json
 fileRow = '{"title" : "Another brick in the wall", "artist" : "Pink Floyd" }'
 song = json.loads(fileRow)
 ```