Python 3

This is a summary of Udemy - Python Bootcamp.

Enable Javascript for TOC.

Basics

Here comes a list of the basics which needs to be known, to understand advanced examples:

Python has a styleguide
Booleans are True and False
Text can be formatted with print("Test: 0x%08x %d %s" % (27, 12, "test"))
E.g. for translation, use the following pattern: print("Test: 0x{hex:08x} {dec:5d} {name:12s}".format(hex=27, dec=12, name="test"))
Functions to convert data are str(5), int("12") and float("13.4")
Operators and Loops:
- if "a" in "Hallo": - Performs the block when the letter "a" exists in the word "Hallo"
- if cnt < 5: - Performs the block when the variable cnt is less than 5
- while "Caro" in teachers: - Performs the block as long as the string "Caro" exists in the variable students
- for cnt in range(0,10): - Performs the block with the values 0 to 9
time.sleep(7.2) will sleep for 7.2 seconds

With the datetime module you can insert/print the current time formatted:

import datetime
# Will print "Current time is 2020-03-01 19:46:00"
print("Current time is %s" % datetime.now().strftime("%Y-%m-%d %H:%M:%S"))

Functions
- are defined with def functionname(para1, para2, para3="hallo"):, where para3 is an optional parameter with the default value "Hello"
- use call-by-value for primitive data types
- use call-by-reference for lists, etc
- can get lists where originally different parameters are expected:
```
params = [ 27, -12, 'huhu']
functionname(*params)
```
  This code fills the content of the list params into the parameters of the function functionname
- can get dictionaries where originally different parameters are expected:
```
params = { para1: 27, para3: 'huhu', para2: -12 }
functionname(**params)
```
  This code fills the content of the dictionary params into the parameters of the function functionname
- def functionname(*para): writes all parameters in a tuple named para
- def functionname(**para): writes all parameters in a dictionary named para
Files are opened in a block (for reading) with with open("myfile.txt", "r") as myfile:
With for line in myfile: you can read a file line by line. A line break must be removed with print(line.strip("\n"))
Files can be written with myfile.write("mytext\n"). But now we must open the file with open("myfile.txt", "w") or open("myfile.txt", "a")

Lists, Dictionaries, etc

Functions on Lists:
- [1, 2, 3, 4].pop() - Removes and returns the last element
- [1, 2, 3, 4].pop(0) - Removes and returns the first element
- [1, 2, 3, 4].append(6) - Appends the element to the end of the list
- list = [1, 2, 3, 4]; del list[2] - Deletes the third element from the list
- 5 in [1, 2, 3, 4] - The operator in returns True when the given value exists in the list
- len([1, 2, 3, 4]) - Returns the length of the list
Tuples are read-only lists, e.g. contact = ("Mustermann", "Max", 123456)
- name, surname, phone = contact - convert tuple to variables in one line
Dictionaries are associated lists, e.g. {"Musterman":222332, "Mueller":45542554}
- for key in mydict: - receive key in for-loop
- for name, phone in mydict.items(): - receive key and value in for-loop
Priority-Queues are dictionaries which are automatically sorted by their key
- ```
import queue
q = queue.PriorityQueue()
q.put( (7, 'hallo') )
```
- q.get() - returns and removes the key-value tuple with the lowest 'priority'
- for prio, value in q.queue: - iterates over the priority queue (the smallest value first)

List Slicing - list[START:END] - Returns a list which starts at START and ends before END:

mylist = ["a", "b", "c", "d", "e", "f", "g"]
print(mylist)        # prints ["a", "b", "c", "d", "e", "f", "g"]
print(mylist[:])     # prints ["a", "b", "c", "d", "e", "f", "g"]
print(mylist[2:])    # prints ["c", "d", "e", "f", "g"]
print(mylist[2:4])   # prints ["c", "d", "e"]
print(mylist[1:-1])  # prints ["b", "c", "d", "e", "f"]

List Comprehensions - list = [CODE for VAR in LIST] - Performs the code CODE with variable VAR for each entry in list LIST:

# list of indexes
xs = [x / 10 for x in range(-100,101)]
# list of values
ys = [x*x for x in xs]
# index where the value is two
are_two = [index for index, value in enumerate(ys) if value == 2]

Dictionary Comprehensions - list = [CODE1 : CODE2 for VAR in LIST] - Performs the code CODE1 and CODE2 with variable VAR for each entry in list LIST:
```
# creates {0: 10, 1: 11, 2: 12, 3: 13}
mydict = {i : i+10 for i in range(4)}
```

Classes

def __init__(self, para): declares the constructor
def __str__(self): returns what shall be printed when the object is converted into string. Best pattern is to return return "ClassName(surname=" + self.surname + ")"
def __repr__(): similar as __str__ but returns a dictionary with the values
def __len__(): returns the number when the object is passed to the len() method
type() returns the classname of the object
isinstance(object, class) returns True when the object is of type class or derived from it
Static member variables are written to the body of the class
Regular member variables are declared in the constructor
Private member variables are declared with two underscores: self.__surname

Exceptions

See at page templates.

Generators

Generators behave like methods which return a list - but with the big difference, that the list entries are generated on demand. So the method runs till the first call of yield, returns the result and supsends. When the next result is read, the method resumes. When no futher result is accessed, also no further result is generated.

def FunctionWithYield():
	sum = 0
	for counter in range(7,99):
		sum = sum + counter
		yield sum

# will print "7, 15, 24..." but not over 100
for result in FunctionWithYield():
	if result > 100:
		break
	print(result)