Add more on variables

Author: macdems

04 More on Variables/1 Operations on sequences.md

@@ -0,0 +1,96 @@
+# Operations on sequences
+
+So far, we have introduced two types that are sequences (containing ordered data): tuple (`tuple`) and string (`str`). You can iterate over each element with a for loop. Below is a description of other useful operations that we can perform on each sequence (not only on the two above, but also on the others, which will be introduced soon).
+Sequence length
+
+The first operation that may be useful is to know the sequence length. This is done by a function `len(sequence)` that returns the number of elements in the sequence given as its argument (i.e. in parentheses). E.g:
+
+```python
+data = (1, 2, 3, 10)
+print(len(data))
+
+length = len("To be of not to be?")
+print("Sentence has", length, "letters.")
+```
+
+As an exercise, I propose to modify the Password task from the previous topic (without sending it) and add an additional security test for the password you entered: it must be at least 8 letters long.
+
+> **Warning!**
+> When using a for loop, do not iterate over the element indexes as follows `for i in range(len(sequence)):`. Instead, you should use simple syntax `for element in sequence:`. If you need element numbers, or you want to iterate over several sequences simultaneously, the appropriate methods are described separately.
+
+## Does the sequence contain an element?
+
+Another useful operation is checking if a given element is present in the sequence. The operator is for this **`in`**, or **`not in`**. E.g:
+
+```python
+if 'a' in 'Alice':
+    print("The word 'Alice' contains the letter 'a'")
+
+if 4 not in (2, 3, 5, 7, 11, 13, 17, 19): 
+    print("Four is not a prime less than 20")
+```
+
+## Access to individual sequence elements
+
+Since sequences are an ordered collection of elements, it is necessary to be able to access the element with a specific number. For this, in Python, square brackets are used immediately after the sequence, or (more commonly) the name of the variable representing it:
+
+```python
+data = ('A', 'B', 'C') 
+print(data[0])   # prints the first element of the tuple ('A')
+print(data[2])   # prints the third element of the tuple ('C')
+
+word = "Kalambur" 
+for i in (1, 3, 6):
+    # print second, fourth and seventh letters
+    print(word[i])
+```
+
+Inside the square brackets there must be an integer (or a variable that represents such a number) called the index. It indicates the element number in the sequence, with the first element numbered 0. This is somewhat counterintuitive and is due to the fact that in most older programming languages this convention has been used historically. Please note that this behavior is consistent with the function of the previously discussed function `range`:  **Python always counts from 0!**
+
+In Python it is also possible to use negative numbers as indices. Then the countdown starts from the end. So `sequence[-1]` means the last element of the sequence, `sequence[-2]` the penultimate one, etc. Example:
+
+```python
+name = input("Enter your name:")
+
+if name[-1] == 'a':   # in Polish, female names end with "a"
+     print("You are a woman") 
+else: 
+    print("You are a man ")
+```
+
+As a simple exercise, please modify the example above so that each Kuba is treated like a man ☺.
+
+
+## Range slices
+
+You can use square brackets to dereference not only individual sequence elements, but also slices of them. Such slices have the following form `sequence[start:stop:step]`, where `start` is the index of the first element entering the slice, `stop` the index of the first element that does not enter the slice, and the `step` is the step with which subsequent elements are taken (please note that there is some similarity to the arguments of the `range` the function). Each of the `start`, `stop` and `step` numbers can be omitted.
+
+The operation of the slices is best illustrated by an example. Please rewrite them in the interactive console and try to understand exactly how the successive elements of each slice are counted.
+
+```python
+digits = tuple(range(10))  # (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
+
+digits[2:7]                # (2, 3, 4, 5, 6)
+digits[2:7:2]              # (2, 4, 6)
+digits[:5]                 # (0, 1, 2, 3, 4)
+digits[5:]                 # (5, 6, 7, 8, 9)
+digits[::3]                # (0, 3, 6, 9)
+digits[7:2:-1]             # (7, 6, 5, 4, 3)
+digits[-1:3:-2]            # (9, 7, 5)
+digits[6::-2]              # (6, 4, 2, 0)
+digits[::-1]               # ( 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
+digits[:-4:-1]             # (9, 8, 7)
+```
+
+**Important!** Please note that the element with the stop index is no longer part of the slice.
+
+Example for text strings:
+
+```python
+text = input("Enter text:")
+print("Your text backwards is:", text[::-1])
+```
+
+<hr/>
+
+Published under [Creative Commons Attribution-NonCommercial-ShareAlike](https://creativecommons.org/licenses/by-nc-sa/4.0/) license.

04 More on Variables/1.md

@@ -0,0 +1,165 @@
+# Lists
+
+There is a data type very similar to tuples in Python. These are  lists (`list`). Unlike tuples, which are constants, lists are structures that can change: you can add new elements to them, delete or change them.
+
+Lists with specific items are created similar to tuples, however, instead of parentheses, square brackets are used:
+
+```python
+list = ["first", 2, 2.5, 3-1j]
+```
+
+As with tuples, the list items don't have to be of the same type. All the previous operations shown for tuples, such as iterating over them in a **for** loop, indexing elements, slices, and so on, work exactly the same for lists.
+
+However, the list items can be changed. Please enter the following commands in the interactive console
+
+```python
+list = [1, 2, 3] 
+
+list[0] = 10
+
+print(list)     # [ 10 , 2, 3]
+```
+
+If I did such an assignment for a tuple, it would cause a `TypeError`.
+
+List items can also be removed with a command **`del`**. E.g:
+
+```python
+list = ['A', 'B', 'C', 'D'] 
+
+del list[1]     # delete the second element
+
+print (list)     # ['A', 'C', 'D']
+```
+
+It is also possible to insert and add items to the list. They are used to this  method  with names `insert` and `append`. These methods are specific operations related to a variable of a given type. They are similar to a function, but affect only one specific object. They are called as follows `object.method(arguments...)`, where object is usually a variable name, and the method name is separated from the object by a period. Adding an item to the list will look like this:
+
+```python
+list = ['A', 'B', 'C']
+
+list.append('D')
+```
+
+The method append puts the element given as its argument to the end of the list. So in the example above, the list would be `['A', 'B', 'C', 'D']`. In contrast, the method `insert` takes two arguments: the place where the element should be inserted (i.e. the index of the inserted element) and its value:
+
+```python
+list = ['A', 'B', 'C'] 
+
+list.insert(1, 'X')
+
+print(list)     # ['A', 'X', 'B', 'C']
+```
+
+Below is an example of creating a names list. Please run it and analyze it:
+
+```
+names = []     # this creates an empty list 
+
+# The following loop will run infinitely 
+# it can only be ended with break
+while True:
+    name = input("Enter name or write a dot to end:")
+    if name == '.':
+        break
+    names.append(name) 
+
+print(names)
+```
+
+## Converting lists and other types
+
+You can convert lists to tuples and vice versa without any restrictions. This way, you can work around the restriction not allowing tuples to be modified:
+
+```python
+my_tuple = (1, 2, 3)
+my_list = list(my_tuple)
+list[0] = 10 
+my_tuple = tuple(my_list)
+print(my_tuple)
+```
+
+However, keep in mind that tuples are more efficient and run faster, so avoid this conversion unless absolutely necessary.
+
+Similarly, you can convert strings into lists, but not the other way around: check what the following command will do `str(['a', 'b', 'c'])`. However, there are two very useful methods defined for strings: `split` and `join`. The method `split` is used to split a text string into words, and join to concatenate list items. Please try to split the text yourself in the interactive console:
+
+```python
+text = "one two three"
+
+list = text.split()
+
+print(list)     # ['one', 'two', 'three']
+```
+
+There is also an alternate way of calling the method `split` that allows you to split text not into words (that is, at spaces and newlines), but selected strings. For example, let's see how to split a text containing words separated by a comma followed by a space:
+
+```python
+text = "one, two, three"
+
+list = text.split(', ')
+
+print(list)     # ['one', 'two', 'three']
+```
+
+The method `join` (which works on text strings) is used to concatenate the elements of a list (or a tuple) given as its arguments. The hyphen is the text that this method works on. This is best illustrated by an example:
+
+```python
+list = ['Kacper', 'Melchior', 'Balthazar'] 
+
+hyphen = "+"
+
+text = hyphen.join(list)
+
+print(text)     # "Kacper+Melchior+Baltazar
+```
+
+The methods also work directly for text values:
+
+```python
+list = ['Kacper', 'Melchior', 'Balthazar'] 
+
+text = "+".join(list)
+
+print(text)     # "Kacper+Melchior+Baltazar
+```
+
+### Elegant list creation
+
+The method `append` is used to add items to the list. If it can be avoided, it is better not to use it to build entire lists, repeating it inside a for loop. Python offers an elegant method of creating lists called **list comprehension**. Above is an example of creating a list by listing its elements separated by a comma and placed in square brackets `[...]`. Instead of listing the items manually, you can use a for loop  with the following syntax:
+
+```python
+list = [expression for counter in sequence]
+```
+
+This expression comes before the **`for`** command and there is no colon anywhere. This expression can use a loop counter to compute successive values to insert into the list. It is best to illustrate this with an example. Suppose we want to create a list containing squares of numbers in the range 1-10:
+
+```python
+squares = [i**2 for i in range(1, 11)]
+
+print(squares)
+```
+
+Please note that this is very similar to the natural language: "let the list of squares consist of the values i² for i in the range 1 to 10".
+
+In a more advanced version, we can add an additional condition that the loop counter must satisfy in order for the corresponding expression to be included in the list:
+
+```python
+list = [expression for counter in sequence if condition]
+```
+
+For example, if we do not want to include the squares of 3 and 7 in our list of squares, we can write:
+
+```python
+squares = [i**2 for i in range(1, 11) if i not in (3, 7)]
+```
+
+## Exercise
+
+Please write the shortest possible program, which will create a list containing the lengths of individual words in the sentence "To be or not to be" (for the sake of simplicity, punctuation marks have been omitted).
+
+
+
+
+
+<hr/>
+
+Published under [Creative Commons Attribution-NonCommercial-ShareAlike](https://creativecommons.org/licenses/by-nc-sa/4.0/) license.

04 More on Variables/2 Lists.md

@@ -0,0 +1,115 @@
+# Dictionaries
+
+Normal lists (arrays) are usually a collection of numbered elements, so to refer to any list element you must enter its number. But identifying elements by numbers aren't always convenient. For example, flight numbers are identified by an alpha-numeric code. Similarly, bus numbers in Łódź may contain letters.
+
+A data structure that allows any type of index (called a key) to be used instead of a number is called a dictionary. In Python, the corresponding data structure is called `dict`. Like a list, it is a variable structure: after you create a dictionary, you can change it. Just like tuples are made with parentheses, lists with square brackets, dictionaries are made with curly braces:
+
+```python
+dictionary = { key1: value1, key2: value2, key3: value3 }
+```
+
+Consider a simple example. Let's create a dictionary where the key is the name of the country, and the value the name of the capital of that country:
+
+```python
+capitals = {       # after opening the parenthesis, you can go to a new line
+     'Poland': 'Warsaw',
+     'Germany': 'Berlin',
+     'USA': 'Washington 
+}
+```
+
+Thus, each dictionary element consists of two objects: a key and a value. In our example, the key is the name of the country and the value is the name of the capital. A key identifies an element of a dictionary, value is the data corresponding to the given key. The key values ​​must be unique, i.e. there cannot be two identical keys in the dictionary.
+
+The phone book is another example of the dictionary data structure. In this case the name is the key and the value is the phone number. For both a dictionary and a phone book, it is easy to find an item for a given key (e.g., if the records are stored in alphabetical order), but if the key is unknown and only the value is known, searching for an item with the given value may require you to browse the entire dictionary.
+
+Access to the dictionary elements is done using square brackets. The key value is given inside the parentheses, e.g.:
+
+```python
+print(capitals['Poland']
+```
+
+Attempting to retrieve a value for a key that is not in the dictionary in this way will result in a `KeyError`.
+
+As stated above, the dictionary can be changed. Adding new items and changing existing ones is very simple:
+
+```python
+capitals['France'] = 'Paris'
+```
+
+If the key "France" was not previously in the dictionary, it will be added and assigned the value "Paris". If it already existed, it will simply be assigned a new value.
+
+Removing items from the dictionary is possible with the command **`del`**:
+
+```python
+del capitals['USA']
+```
+
+In Python, the key can be any immutable data type: integers and real numbers, strings, tuples. It cannot be lists or other dictionaries. The value of a dictionary item can be any data type.
+
+In addition to the use of square brackets to access the dictionary elements it is possible using the method `get`: `dictionary.get(key)`. If the given key is in the dictionary, the corresponding element will be returned. Otherwise, the method will return None. This method also has a version with two arguments `dictionary.get(key, default_value)`, which — if the given key is missing from the dictionary — returns the given default value. In both cases, this method (unlike retrieving the item using square brackets), will not generate an exception (error).
+
+To check if a key is in the dictionary, you can use operators **`in`** and **`not in`**, similarly to sequences.
+
+```python
+letters = {'ab': 'ba', 'aa': 'aa', 'bb': 'bb', 'ba': 'ab'} 
+
+key = 'ac' 
+if key in letters: 
+    del letters[key]
+```
+
+## More about creating dictionaries
+
+Just as it is possible to create lists elegantly with list comprehensions, it is possible to construct dictionaries as follows:
+
+```python
+dictionary = { expression_for_key: expression_for_value for item in sequence }
+```
+
+E.g:
+
+```python
+words = "Ala has a cat".split()     # ['Ala', 'has', 'a', 'cat']
+
+word_lengths = {word: len(word) for word in words}
+```
+
+This will create a dictionary `{'Ala': 3, 'has': 3, 'a': 1, 'cat': 3}`.
+
+## Iteration through dictionaries
+
+Although dictionaries are not sequences, you can iterate over them with a **for** loop:
+
+<pre>
+<b>for</b> <i>key</i> <b>in</b> <i>dictionary</i><b>:</b>
+    loop block
+</pre>
+
+This loop will be performed for each  key in the dictionary. Unlike sequences, the iteration order is undefined (i.e. the loop will be executed for each key, but we cannot predict in what order). E.g:
+
+```python
+word_lengths = {'Ala': 3, 'has': 3, 'a': 1, 'cat': 3} 
+
+for word in word_lengths: 
+    print("Word", word, "has", word_lengths[word], "letters")
+```
+
+If we want to iterate over dictionary values only, we can use the method `dictionary.values()`:
+
+```python
+capitals = { 'United Kingdom': 'London', 'Germany', 'Berlin', 'USA' 'Washington} 
+
+for city in capitals.values(): 
+   print("There is no such city as", city, "in Poland")
+```
+
+It is also possible to iterate through keys and values simultaneously using the method `dictionary.items()`:
+
+```python
+for country, city in capitals.items(): 
+   print("Capital of", country, "is", city)
+```
+
+<hr/>
+
+Published under [Creative Commons Attribution-NonCommercial-ShareAlike](https://creativecommons.org/licenses/by-nc-sa/4.0/) license.