Python

A strongly typed dynamic language.

Letters, digits, and underscore; cannot start with a digit.

Lowercase with words separated by underscores (e.g., do_it_like_this).

Upper CamelCase (e.g., ClassNameHere).

Use try-except blocks.

A file containing Python code, usually with a .py extension.

A namespace containing multiple modules, often with an init.py file.

Contains package initialization logic.

Use the venv module: python3 -m venv /path/to/new/virtual/environment.

Lists are mutable, tuples are immutable.

Use curly braces {} with key-value pairs.

An anonymous function expressed as a single statement.

Use .items() to get key-value pairs, .keys() for keys, and .values() for values.

Use pip: pip install package_name.

A compact way to process all or part of the elements in a collection and return a list of results.

An unordered collection of unique elements.

Use the open() function: open(filename, mode).

Opens a file for writing, creates the file if it does not exist.

Ensures that the file is properly closed after its suite finishes, even if an exception is raised.

append() adds its argument as a single element to the end of a list. extend() iterates over its argument adding each element to the list, extending the list.

Use the in keyword: 'key' in my_dict.

1-2-3 followed by a newline.

Use the + operator or the extend() method.

Generates a sequence of numbers.

Use the tuple() function: tuple(my_list).

It is a null statement used to define an empty block of code.

Use the remove() method for a specific value or pop() for an index.

Use the reverse() method or the slicing syntax list[::-1].

Performs exponentiation.

== checks if values are equal, is checks if objects are the same (identity).

Adds a counter to an iterable and returns it.

Use the copy() method or the slicing syntax list[:].

A copy where all objects are duplicated recursively, not just the top-level container.

Use f-strings or the format() method.

Returns an iterator of tuples, where the i-th tuple contains the i-th element from each of the argument sequences or iterables.

Use a tuple of exceptions in the except clause.

To declare that a variable inside a function is global (not local).

To throw an exception.

Using several 'except' clauses.

try: xxxx

except: (blaError1, blaError2) as error:

print(“oopsie”)

Code that should only be run when no exceptions have occurred.

good for readability

add a block of code that is allways executed

e.g close connection to server/database

x, y = y, x

a,b,c,d,e,f,g,… = “Hello World!”

For unpacking iterable objects into multiple variables.

To allow a function to accept a variable number of arguments.

*args

it is possible to combine *args with keyword arguments

*args, power =1

The math module.

ceil(5.6) -> 5

floor(5.6) -> 5

sqrt(81) -> 9

factorial(6) -> 720

comb(10,3) -> 120

perm(10,3) -> 720

cos(x)

degrees(x)

Using methods like append, extend, or insert.

Tuples are immutable.

Using methods like remove, discard, or pop.

A function that modifies the behavior of another function.

Class methods take a 'cls' parameter that points to the class, while static methods do not.

To manage resources like file streams with the 'with' statement.

By defining __iter__() and __next__() methods.

Special methods with double underscores used to emulate the behavior of built-in types.

__str__ is for readable output, __repr__ is for unambiguous output.

Using the @property decorator to define getter, setter, and deleter.

Caching the results of expensive function calls.

Using a decorator to check argument types.

To call methods of a parent class from the child class.

By prefixing the variable name with double underscores (__).

By subclassing Exception or a derived class.

Using the 'from' keyword to chain exceptions, providing context to the original exception.

By forcing some arguments to be specified by their names, improving readability.

Annotations provide a way to attach metadata to function parameters and return values, mainly for documentation purposes.

By implementing __iter__() to return an iterator object, which then implements __next__() to access elements one at a time.

__iter__ returns the iterator object itself, __next__ moves to the next item in the sequence.

To enable operators and built-in functions like + or len() to work with custom objects.

It allows an instance of a class to be called as a function.

By wrapping another function, allowing for the extension or modification of its behavior without directly modifying it.

The 'with' statement simplifies resource management by automatically handling setup and cleanup operations, using context managers.

allows us to achieve the same result with a one‐liner:

mushroom_growth = 'Good' if raining else 'Bad'

We can unpack collections and pass their values as arguments to a function

We can do the same with dictionaries and keyword arguments:

Lambdas allow us to create a function inline (in place) where it’s needed:

Fraction(1,2)

Fraction(1.5) = Fraction(3,2)

statistic

random

clear -> removes all items

copy -> creates a shallow copy (wenn man die Kopie verändert verändert sich auch das original da sie auf die gleichen elemente zeigen)

my_list[0:3] -> [a, b, c]

my_list[3:-1] -> [b, a]

my_list[:3] -> [a, b, c]

my_list[3:] -> [b, a, a]

my_list[1:8:2] -> [b, d, f, h]

my_list[::-1] -> ['i', 'h', 'g', 'f', 'e', 'd', 'c', 'b', 'a']

• f-strings

• str.format

to group variables (properties, attributes) together

to count collections’ items

most_common(3)

to make sure the insertion order is preserved and checked

to get efficient stack‐like and queue‐like functionality

deque allows us to efficiently add elements to both ends of the data structure as opposed to regular Python lists. However, keep in mind that there is no golden pill (or silver bullet, if you like), and gaining efficiency in some operations probably means losing efficiency with others. Which operations does a deque perform less efficiently than a regular list?

An iterator is an object representing a stream of data.

Iterators are required to implement two methods:

• __next__

• __iter__

  The __iter__ method should return the iterator object itself to allow using an iterator with a for...in loop.

Why custom iterator:

However, consider parsing a 10 GB FASTA file. We probably don’t want to load all the records in memory at once, so we might use an iterator (iterators are lazy). In other situations we might actually need an infinite number of values, or the iteration might have complex logic.

iterators, but how exactly are they created?

• The __iter__ method must return an iterator object.

• Oh, and by the way, objects that have the __iter__ method are iterables.

• an iterable is an object that is capable of returning its elements one by one and implements an __iter__ method;

• an iterator is an object that represents a stream of data and implements an __iter__ method and a __next__ method;

• when we use an iterable in a for...in loop, an iterator is automatically created and is used to produce values until exhaustion;

• an iterator SHOULD NOT change the corresponding iterable.

• __init__

• __iter__

• __next__

• __repr__ -> allows us to change the way an object is

  represented

• __str__ -> allows us to tune casting an object to a string.

• __eq__ -> wann sind elemente gleich

• __len__

• __abs__, __add__, __and__, __bool__, __ceil__

• __repr__ is used as a fallback method for casting to a string when __str__ is not available

• __str__, on the other hand, is not used as a fallback method for representation.

make instances of our classes callable like functions

To decorate a function means to modify its behaviour, to execute some code before or after the function itself is executed.

Vorteile:

• wiederholten COde vermeiden -> ABER wieso keine methoden (würde die Methode aufblähen)

• Decorator außen -> übersichtliche und intuitiver

Decorators allows us to create specialized reusable chunks that can be applied to other functions. They help us to avoid writing boilerplate code. When used correctly, they make reasoning about code easier.

We probably want to use decorators in the following cases:

• authentication / authorization

• logging

• benchmarking

• validating input;

• sanitizing input

• changing function’s output

• registering functions.

Single Leading Underscore

Double Leading Underscore

• to work with files, time benshmarking, database connection

• __enter__ and__exit__ methods

Keyword: yield

A generator is a function that returns a generator iterator:

enumerate(xx, 5) -> start index value 5

Increment

zip wraps two (or more) iterables with a lazy generator that yields tuples containing pairs of next values from each iterable.

zip macht nur so lange bis die kleiner liste aufgebraucht ist

we can create a context manager using a function that yields and acontextmanager decorator

use cases:

• data hiding/protection (not bulletproof)

• implementing function factories (creating functions at runtime)

• decorators

We can use closures to implement function factories that create functions at runtime

• type hints allow us to specify types for variables, function parameters, and function return values

• IDEs/editors and 3rd party tools can perform static type checking

• libraries like pydantic allow us to perform validation based on type hints