Formulas

formulas/Block 2.md

@@ -1,70 +1,43 @@
 ## CAP-Theorem
+
 - • **Konsistenz (Consistency):** Alle Knoten zeigen zur gleichen Zeit die gleichen Daten an.
 - **Verfügbarkeit (Availability):** Jeder Anfrage wird garantiert eine Antwort geliefert – auch wenn sie nicht den aktuellsten Stand widerspiegelt.
 - **Partitionstoleranz (Partition Tolerance):** Das System funktioniert weiter, auch wenn Teile des Netzwerks ausfallen oder nicht miteinander kommunizieren können.
-- **CA (Konsistenz + Verfügbarkeit):** 
+- **CA (Konsistenz + Verfügbarkeit):**
-    Funktioniert nur ohne Netzwerkausfall. 
+    Funktioniert nur ohne Netzwerkausfall.
     Beispiel: Einzelner MySQL-Server.
-- **CP (Konsistenz + Partitionstoleranz):** 
+- **CP (Konsistenz + Partitionstoleranz):**
-    Bleibt bei Ausfall konsistent, aber nicht immer erreichbar. 
+    Bleibt bei Ausfall konsistent, aber nicht immer erreichbar.
     Beispiel: HBase, MongoDB (strikte Konsistenz).
-- **AP (Verfügbarkeit + Partitionstoleranz):** 
+- **AP (Verfügbarkeit + Partitionstoleranz):**
-    Immer erreichbar, aber Daten können kurz inkonsistent sein. 
+    Immer erreichbar, aber Daten können kurz inkonsistent sein.
     Beispiel: Cassandra, DynamoDB.
 ```python
-pd.DataFrame(data: dict[str, Any]) -> DataFrame  # Erstellt DataFrame aus dict
+# --- Pandas ----------
-pd.read_csv(filepath_or_buffer: str, index_col: str | None = None, ...) -> DataFrame  # CSV/URL einlesen
+pd.read_csv("path.csv") -> DataFrame          # CSV einlesen
-np.array(obj: Iterable[Any], dtype: type | None = None) -> ndarray  # Array aus Werten
+pd.DataFrame(data) -> DataFrame               # DataFrame aus dict/array
-np.nan: float  # Not a Number (fehlender Wert)
+df.head(), df.tail()                          # Erste/letzte Zeilen
-np.arange(stop: int) -> ndarray  # Array von 0 bis stop-1
+df.info(), df.describe()                      # Überblick & Statistik
-np.random.randn(*shape: int) -> ndarray  # Zufallszahlen (Normalverteilung)
+df.loc[row, col], df.iloc[row_idx, col_idx]   # Label- & Positionszugriff
-np.sin(x: float | ndarray), np.cos(x: float | ndarray) -> float | ndarray  # Sinus/Kosinus
+df.groupby(keys).agg(func)                    # Gruppierung & Aggregation
-pd.date_range(start: str, periods: int, freq: str) -> DatetimeIndex  # Datumsreihe
+pd.merge(left, right, on="col")               # Tabellen verbinden
-pd.cut(x: Series, bins: list[float], labels: list[str] | None = None) -> Categorical  # Werte in Intervalle
+df.pivot_table(values, index, columns, aggfunc="mean")  # Schnelles Pivottable
-pd.get_dummies(df: DataFrame, columns: list[str] | None = None) -> DataFrame  # One-Hot-Encoding
+df.isna().sum(), df.fillna(value)             # Fehlende Werte prüfen/behandeln
-DataFrame.info() -> None  # Übersicht zu DataFrame
+df.sort_values(by="col"), df.sort_index()     # Sortieren
-DataFrame.dtypes -> Series  # Spaltentypen
+# --- NumPy ----------
-DataFrame.head(n: int = 5) -> DataFrame  # Erste n Zeilen
+np.array(data)                                # Array erstellen
-DataFrame.tail(n: int = 5) -> DataFrame  # Letzte n Zeilen
+np.arange(stop), np.linspace(start, stop, num) # Sequenzen
-DataFrame.columns -> Index  # Spaltennamen
+np.zeros(shape), np.ones(shape)               # Nullen/Einsen-Arrays
-DataFrame.shape -> tuple[int, int]  # Form (Zeilen, Spalten)
+np.reshape(a, newshape)                       # Form ändern
-DataFrame.to_numpy() -> ndarray  # Als Numpy-Array
+np.mean(a), np.median(a), np.std(a)           # Statistiken
-DataFrame.set_index(keys: str | list[str]) -> DataFrame  # Setzt Index
+# --- Matplotlib ----------
-DataFrame.sort_index() -> DataFrame  # Sortiert nach Index
+import matplotlib.pyplot as plt
-DataFrame.copy() -> DataFrame  # Kopie erstellen
+plt.figure(figsize=(6,4))                     # Figure erstellen
-DataFrame.describe() -> DataFrame  # Statistik
+plt.plot(x, y, label="Linie")                 # Liniendiagramm
-DataFrame.count() -> Series  # Anzahl Werte pro Spalte
+plt.scatter(x, y, c="r", label="Punkte")      # Streudiagramm
-DataFrame.min()/max()/mean()/std()/var() -> Series | float  # Statistische Werte
+plt.bar(x, height, label="Balken")            # Balkendiagramm
-DataFrame.cumsum() -> DataFrame  # Kumulierte Summe
+plt.hist(data, bins=30, alpha=0.7)            # Histogramm
-DataFrame.drop(labels: str | list[str], axis: int = 0) -> DataFrame  # Entfernt Zeilen/Spalten
+plt.axvline(x, color="k", ls="--")            # Vertikale Linie
-DataFrame.dropna() -> DataFrame  # Entfernt Zeilen mit NaN
+plt.xlabel("x-Achse"); plt.ylabel("y-Achse")  # Achsenbeschriftung
-DataFrame.fillna(value: Any) -> DataFrame  # Füllt NaN
+plt.title("Titel"); plt.legend(); plt.tight_layout(); plt.show()
-DataFrame.interpolate() -> DataFrame  # Interpoliert NaN
-DataFrame.combine_first(other: DataFrame) -> DataFrame  # Füllt NaN aus anderem DF
-DataFrame.sample(n: int | None = None, frac: float | None = None, axis: int = 0) -> DataFrame  # Zufallsstichprobe
-DataFrame.loc[...] / .iloc[...] -> DataFrame | Series | scalar  # Zugriff per Label/Position
-DataFrame.groupby(by: str | list[str] | Callable) -> GroupBy  # Gruppiert nach Kriterium
-DataFrame.melt(id_vars: str | list[str]) -> DataFrame  # Spalten zu Zeilen
-DataFrame.pivot(index: str, columns: str) -> DataFrame  # Breite Tabelle
-DataFrame.pivot_table(values: str, index: str, columns: str, aggfunc: str | Callable) -> DataFrame  # Pivot-Tabelle
-DataFrame.replace(to_replace: Any, value: Any) -> DataFrame  # Werte ersetzen
-DataFrame.plot(...), .plot.line(...), .plot.scatter(...), .boxplot(...) -> Axes  # Plotten
-Series.value_counts() -> Series  # Zählt eindeutige Werte
-Series.count() -> int  # Anzahl Werte
-Series.map(func: Callable) -> Series  # Wendet Funktion an
-Series.str.lower() -> Series  # Kleinbuchstaben
-Series.str.contains(pat: str) -> Series  # Stringsuche
-Series.plot.hist(bins: int) -> Axes  # Histogramm
-GroupBy.agg(func: str | Callable) -> DataFrame  # Aggregation auf Gruppen
-GroupBy.sum()/min()/max()/describe() -> DataFrame  # Statistiken auf Gruppen
-GroupBy.__iter__() -> Iterator  # Über Gruppen iterieren
-plt.axvline(x: float, c: str | None = None) -> None  # Vertikale Linie
-plt.cm.Blues(x: float) -> tuple  # Farbe aus Colormap
-Axes.axhline(y: float, ...) -> None  # Horizontale Linie
-Axes.set_xticks(ticks: list[float]) -> None  # X-Ticks setzen
-Axes.set_ylabel(label: str), Axes.set_xlabel(label: str) -> None  # Achsenbeschriftung
-train_test_split(X: ndarray | DataFrame, y: ndarray | Series, train_size: float = ...) -> tuple  # Split in Train/Test
-LogisticRegression().fit(X: ndarray | DataFrame, y: ndarray | Series) -> LogisticRegression  # Modell trainieren
-LogisticRegression().score(X: ndarray | DataFrame, y: ndarray | Series) -> float  # Modellgüte
-LogisticRegression().predict_proba(X: ndarray | DataFrame) -> ndarray  # Vorhersagewahrscheinlichkeit    Beispiel: Cassandra, DynamoDB.
 ```