Python

String, List, Tupel, Range

FIFO, LIFO

stack: undo&redo functions, browser history(when navigating back, last visited page is accessed first)

queue: message queues, network data packets

Double Ended Queue

allows efficient append and pop operations at the ends of the container

O(1) vs List O(n)

Accessing elements, cos List uses elements whilst deque has to use next method multiple times

Iterable: Object, that is capable of returning its elements one by one and implements __iter__ method

Iterator: Object, that represents a stream of data and implements an __iter__ and __next__ method

create them by creating a class and defining dunder methods mentioned above

Iterator -> Iterable but Iterable -/-> Iterator

A class with __enter__ and __exit__ methods can be used as a context manager

To establish a connection to something (such as database or file) and want to be sure that this connection get closed properly in all cases

methods, that start and end with a double underscore (also known as dunder)

Implementing such methods allows us to use standard python functions and operators with our custom classes

Use when you want to define the behaviour of objects in response to certain actions, such as when to define the string representation of an object (e.g. __str__ -> print())

You can’t, there’s no such thing as fully private function or variable in python

double underscore at the start helps a bit (__method() prevents accidental overriding)

combines multiple iterables (list, tuple ,..) into tuples

zipped = zip([1,2,3], [a,b,c]) => ((1, a), (2,b), (3,c))

helps us keep original names and docstrings of wrapped functions

Expressions that return a generator object, contains a yield keyword

difference: uses lazy evaluation

A function that remembers how it was when the function was defined

e.g.

closure = function(“Hello world”) # would print Hello world

closure() # prints Hello world

Allows to hide/protect data

dataclass: A dataclass is a decorator(@dataclass) that automatically generates special methods such as __init__ and __repr__

pros: less boilerplate code

cons: mutable by default

class:

pros: full control

cons: more boilerplate

named tuples: (e.g. namedtuple(“Person”, [“name”, “age”, “city”]))

pros: lightweight and fast

cons: less functionality

strongly typed language doesn’t allow implicit type conversions.

Dynamic language means type checking happens at runtime.

Like python

variables and functions: lowercase and underscore

classes: CamelCase

int, float, str

a module is a python file containing code that can be imported

system path, python installation directory, working directory

The finally block will always be executed even if there’s an error or return

This can be useful to close objects and clean up resources

No, the default values in parameters have to appear after the non-default values

keyword arguments(city=”unknown”) allow us to pass in any order when calling a function

positional arguments first, then keyword arguments (e.g. function(name, age, city=”unknown” => function(“Alice”, city=”Munich”, 25) doesn’t work)

def average(*args)

• value of args is treated as a tuple with positional arguments

• does not have to be args necessarily

def my_date(year, month, day):

pass

my_values = [2021, 12, 31]

my_date(*my_values)

strings = sorted(strings, key = lambda x: x[2])

append: add an element

extend: add every elements of another list

[x:y:z] x: start index, y: end index, z: step(how many to skip)

[x:y]: every element from x to y (excluding y)

[:y:z]: starts from the beginning

[x::z] til the end with the step z

[x:] til the end

[:y] til excluding y

[x] x-th index

[::z] take every element with step z

- namedtuple: to group variables together

- counter: to count collections items

- OrderedDict: remembers the insertion order

variable: int = 3

def function() -> int:

pass

wrapper functions (called with @ before definining function)

list: mutable, ordered

tuple: heterogeneous, immutable

set: no duplicates, unordered

dict: unordered, key-value pairs

list, tuple are sequences

.format()

fstrings