Klausurfragen

- String, List, Tuple, Range

- LIFO (last in first out, stack) and FIFO (first in first out, queue) - depending on use case

- Doubly Ended Queue - allows efficient append and pop operations at the ends of the container (0(1) vs list O(n))

- Accessing elements (especially close to the center) in lists is more efficient than when using deque

- Reason: Its more efficient because a list uses an index to access elements, and a dequeue needs to invoke the "next" method for all nodes up until to the desired node

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

- Iterator = Object, that represents a stream of data and implement an __iter__ method and a __next__ method

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

- Iterator is an iterable, but iterable is not an iterator

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

- Use them to establish a connection to something (like database or file) and want to be sure that this connections gets properly closed in all cases

- Magic methods = methods starting and ending with a double underscore (also called dunder)

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

- Use when you want to define the behavior of objects in response to certain actions, such as when to define the string representation of an object

- You cant, there is no suc hthing as fully private functions or variables

- Double underscore at the start helps a bit

- Zip wraps two or more iterables with a lazy generator that yields tuples containing pairs of next values from each iterable

- Helps us keep original names and docstrings of wrapped functions, since decorators usually lose this function (?)

- Expression that returns a generator object

- contains a yield keyword (needed for the generator class) Difference:

- Uses lazy evaluation -> Only the part that is needed right now is loaded into memory opposed to where the list comprehension loads everything into the memory, even if its not needed

- a closure is a function that keeps access to its environment as it was when the function was defined

- allows to hide/protect data, to generate function at runtime, to modify the behavior of other functions

- dataclass: decorator for automatically generating special methods such as __init__ and __repr__ to user defined classes

- class: allows us to create new data types, combining state and behavior

- named tuple: complex data type that allows us to group variables together under one name (use if you care about grouping attributes, but dont really care about modeling)

- strongly typed languages are languages where data types are fixed and aren't allowed to be changed (e.g. Java Integer a stays Integer a and can't be defined as String a later

- dynamic languages such as python allow for data type changes

- variables and functions: lowercase_and_underscore

- classes: CamelCase

int, str, float

file containing python code and having .py as extension

- system path, python installation directory, working directory

The finally block will be executed no matter if the try block raises an error or not. This can be useful to close objects and clean up resources.

No, default values have to appear afte rthe parameters that dont have default values (in the parameter list)

- keyword arguments allow us to pass arguments in any order when calling a function

- positional arguments must be specified in the right order (& before keyword arguments)

def average(*args)

- value of args is a tuple with positional arguments

def my_date(year, month, day):

pass

my_values = [2021, 12, 31]

my_date[*my_values]

strings = ["Annie","Jake","Paul"]

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

- append for single value

- extend for multiple values (like another list)

- Returns a list starting at the second element of my_list, with a step size of two, until element 9

- namedtuple: to group variables to gether

- counter: to count collections items

- OrderedDict: to make sure the insertion order is preserved and checked

var_name: int = 3

def my_func() -> int:

pass

wrapper functions (called with @ before function)

- list: mutable, ordered, heterogenous, can have duplicates - tuple: immutable, ordered, heterogeneous

- set: mutable, heterogenous, no duplicates, unordered

- dict: mutable, heterogenous, unordered seq of key-value pairs, doesn’t necessarily preserve order

- list, strings, and tuples are sequences

python lists: hold references to values they hold -> heterogeneity, but no guarantee that all values are copied in one operation

numpy: homogenous and store data in sequential chunks -> several values can be copied at once and don't need to explicitly loop over elements

- Check the number of dimensions, if they are not the same -> those dimensions that are there need to match (???)

Pros:

- Implemented in C (faster)

- loaded into memory consecutively (chunks)

- broadcasting

- already implemented operation (e.g. dotproduct)

Cons:

- lacks flexibility in lists

- loses efficiency with Object datatype

- immutable (when one element is added the whole array has to be re-created)

- type restrictions: all elements in a np array must be of the same type

- view = new array object that refers to the same data -> change of value leads to change of original value

- copy = new array object containing a copy of the data (deep copy) -> doesnt change original values

- We use copies if we want to modify the copied data, and views if we want to modificy the original data

- Fancy indexing

- example:

numbers[1:, [1, 0]] -> (1,1), (1,0), (2,1),(2,0) in a 3x3 matrix

- Vectorizations allows performing an operation on several values at once

- But the vectorize function is primarily for convenience, not for performance (essentially a for loop)

- Using python lists or tuples (np.array([x,y,z]), np.array((x,y,z)))

- using pre-built methods like np.zeroes(), np.ones(), np.eye(), np.full(), np.random.random()

numpy_array.dtype

- by tuple or indices: arr_2d[1, 1]

- via slicing: arr_2d[:2, 1:]

- via boolean indexing

- via fancy indexing

- Using the where method to get the indices, and the use those indices to get the elements indices = np.where(arr > 60) arr[indicies]

• int32

• int64

• object

- From an array

- from an dictionary

- list of tuples

- flexible handling of missing data

- many built-in methods

- higher performance than vanilla python while still flexible (data types dont need to be set)

- many routines known from other languages, lkike split, aggregate, reshape, melt, select, merge, ...

- an immutable array or an immutable ordered multi-set

- can be of any type

- built on top of np arrays

- Yes, because the type is automatically inferred, but it will then be stored as object type

- From a list (Series wil be a copy)

- from a np.array (behaves like a view, if copy=True is not set)

- from a dictionary

- head and tail return the first / last row

- nlargest and nsmallest return the largest/smallest values

- No

- e.g. pd.StringDtype, pd.CategoricalDtype

- df.apply(<function>, axis)

- function either pre-defined or lamda

- axis=0 all rows in one column at once

- axis=1 one row all columns each

- upper, lower, split, slice

- None: universal null type, can be converted to nan in Integer series

- NaN: same as np.nan, float

- pd.NA: represents nullable integers (Int64), booleans and strings

- to explore data fast -> quick and easy pot

- based on matplotlib but without the fancy stuff

Primary databases:

- Unprocessed "raw" data from experimental and observational studies

- Examples: GenBank, Uniprot, PDB Secondary databases:

- Collections that provide processed and structured data from primary databases - Examples: SCOP, PFAM, PROSITE

CAP: concept that states that it is impossible for a distributed system to satisfy:

- Consistency: All nodes in the system see the same data at the same time

- Availability: Every request to the system receives a timely response

- Partition tolerance: The system continues to function despite arbitrary partitioning due to network failures

Concept: Systems can provide at most 2 of these 3 guarantees

Used as a tool for understanding the trade-offs involved in designing distributed systems and for choosing the right architecture for a given problem

- Basically available

- Soft state

- Eventually consistent

- Scatter: used to display the relationship between two continous variables (identifying patters / correlation)

- Box: Compare distributions (in terms of percentiles, median, outliers)

- Line: Relationship between a continous independent variable and a continous dependent variable

- One continous variable and one discrete variable -> mainly use bar plots, box plots by cateogry and violine plots by category) - Histogram: Distributions

- Violine plots: like box plot + data density

- Minimum set of access functions

- create, reade, update, delete

- are used in databases to store semi-structured data

- NoSQL are used because they provide a flexible and scalable way to store and retrieve data that does not fit neatly into traditional, tabular data structures (for example many null values)

- Biological data is semi-structured -> SQL is better for structured data -> storing data with NoSQL: using document-oriented or graph-oriented storage)

- Biological database store very diverse data entries, sequences have different annotations, different lengths, etc -> flexible way to store this data is needed, no hard structure, many NAs -> NoSQL

- 10^12 residues GenBank, 109 sequences

10^13 residues WGS etc, 109 sequences

UniProtTrEMBL/Swissprot: 10^(10‑11)/2*10^8 residues , 10^8/5*10^5 sequences

PDB: 200k in total: 172k by X‑ray, 14k by NMR, 14k by E

- fixed number of colums

- structure is modelled via indentation

- a line is called a record and is typed

- typing happens via keyword in the first column

- subkeywords are indented

- no keyword: continuation of the previous line

- application of verb (GET/PUT/POST/DELETE) to a noun and an optional response

- map: applied to all elements of a list, returns modified list

- reduce: aggregate return values from map into one results

- parallel processing, initial data strucutre is conserved, new copy with every entry level, no deadlocks or side effects

- pattern based: cypher

- navigation based: gremlin

- key/value/tuple stores

- wide column stores

- document stores

- graph databases

- SwissProt curated entries -> much smaller, but (presumably) higher quality

- primary: PDB

- secondary: PFAM