Pythonicx

a

Yes

0.1 == 0.10000000000000001 —> True

The absence of a value

• Triple double quotes “““-”””

• with \ in the str

‘!’

No, a Python tuple is an immutable, heterogeneous, ordered sequence of elements, but we can concat tuples with + operator

With the | operator. Be careful because same keys will be overwritten with the latter one.

dict.update() (order matters again!)

• | union (alles)

• & intersec (mitte)

• - diff (nur links)

• ^ sym diff (alles ohne mitte)

• ['a', 'b']

• ('a', 'b')

^Cool^

B

__innit__ method

specify its superclass in the class statement

Override it in the subclass.

with super()

From the Python installation directory, from the system path, and from the working directory.

A “regular” package contains an __init__.py file. This file is supposed to contain the initialization logic

Its always executed as the last task before the try statement completes

a = 1

b = [2, 3, 4, 5]

Cool Cool

wow

ALAAARM

criss cross

beep

buup

formatzZ

At runtime

Choco

double linked list.

It hast the attributes append(app-left) and pop(pop-left)

Indexing, slicing, concat, sort

iter invokes __iter__ which returns an iterator obj

damn daniel

An iterator is an object representing a stream of data. Iterators are required to implement two methods: __next__ and __iter__. The __iter__ method should return the iterator object itself to allow using an iterator with a for...in loop.

Why would we want to create a custom iterator instead of just putting numbers from zero to nine in a list? This example is indeed trivial! 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.

yes you CAN! just like bob the baumeischter

Cordola grün

Implementing the __str__ method allows us to tune casting an object to a string. Implementing the __repr__ method allows us to change the way an object is represented (used as fallback when str not available)

a callable is something we can call, invoke, execute using parenthesis ();

functions are callables;

classes are callables;

instances of a class that defines a __call__ method are callables.

let us skip to the good part. AAAAAAAAAAAAAAAAAAAAAA

authentication / authorization;

logging;

benchmarking;

validating input;

sanitizing input;

changing function’s output;

registering functions.

By convention put a _ in front of them:

_private = “deutschland”

classmethod decorator

staticmethod decorator

property and {property_name}.setter decorator

the magic is the return of the __enter__ method (in terms of with open context managers)

yyyye

enumerate, zip, map, filter

advice advice advist

Stupor

A closure isn’t just a nested (inner) function. The closure mechanism allows the inner function to keep access to its environment as it was when the closure was created. In other words:

1. The outer function defines the inner function and returns it.

2. The nested (inner) function can access all the variables of the outer function (that means the outer_param and the outer_var).

3. The inner function keeps access to the variable of the outer function even after the outer function has finished its execution.

Used in:

data hiding/protection (not bulletproof)

implementing function factories (creating functions at runtime)

decorators

Junior High

with :

age: int = ‘too young’ (type hints are just hints)

height: float = 1.41

names: list[str] = [‘Tiffany’, ‘Action Jackson’, ‘Carmen’]

__init__, __repr__, __eq__ the rest can be added in the decorator

With the frozen argument we can make our class read-only sheesh