Reorganize and explain commands a little bit better

reference-card.tex

@@ -22,12 +22,12 @@
 
 \setlength{\parindent}{0cm}
 \newminted[python]{python}{}
-\newmintinline{python}{breaklines}
+\newmintinline{python}{breaklines,tabsize=2}
 
 \begin{document}
 \begin{multicols*}{3}
 
-\subsection*{Bibliotheken}
+\subsection*{Häufig verwendete Bibliotheken}
 \begin{python}
 import matplotlib.pyplot as plt
 import scipy.stats as st
@@ -42,49 +42,50 @@ \subsection*{Numpy Basics}
 \pythoninline{np.sqrt(2)}: Wurzel von Zahl berechnen \\
 \pythoninline{np.square(2)}: Quadrat von Zahl berechen \\
 \pythoninline{np.abs(-45)}: Absolutwert einer Zahl berechnen \\
-\pythoninline{np.round(2.35, 1)}: Zahl auf x Nachkomastellen runden \\
-\pythoninline{np.corrcoef(x, y)}: Korrelationsmatrix berechnen \\
+\pythoninline{np.round(2.35, x)}: Zahl auf \textit{x} Nachkomastellen runden \\
 \pythoninline{np.log(100)}: Natürlicher Logarithmus berechnen \\
 \pythoninline{np.log10(100)}: Logarithmus mit Basis 10 berechnen
 
 \subsection*{Numpy Arrays}
-\begin{python}
-arr = np.array([2, 1, 4, 5, -8, 10])
-\end{python}
-
-\pythoninline{3*arr}: Jede Array-Komponent mit Zahl multiplizieren \\
+\pythoninline{arr = np.array([2, 1, 4, 5, -8, 10])} \\
+Numpy-Array erzeugen \\
 
 \pythoninline{np.linspace(start=1, stop=2, num=4)} \\
-num Zahlen zwischen start und stop \\
+\textit{num} Zahlen zwischen \textit{start} und \textit{stop} \\
 In diesem Beispiel: [1.0, 1.333, 1.666, 2.0] \\
 
 \pythoninline{np.arange(start=1, stop=4, step=.6)} \\
-Zahlen von start bis stop mit inkrement step\\
+Zahlen von \textit{start} bis \textit{stop} mit inkrement \textit{step} \\
 In diesem Beispiel: [1.0, 1.6, 2.2, 2.8, 3.4] \\
 
 \pythoninline{new_arr = arr.reshape((n, m))} \\
 1-dimensionales Array in 2-dimensionales umwandeln \\
-Neues Array hat n Zeilen mit je m Elementen \\
+Neues Array hat \textit{n} Zeilen mit je \textit{m} Elementen \\
 
-\pythoninline{new_arr = np.random.choice(arr, size=1000)} \\
-Neues Array mit der Grösse size erstellen und zufällig \\
+\pythoninline{arr = np.random.choice(arr, size=1000)} \\
+Neues Array mit der Grösse \textit{size} erstellen und zufällig \\
 mit Werten aus dem übergebenen Array befüllen \\
 
 \pythoninline{arr = np.arange(1, 25)} \\
 \pythoninline{np.random.choice(arr, 24, replace=False)} \\
-Zahlen 1 bis 24 zufällig sortieren \\
+Zahlen zufällig sortieren \\
+In diesem Beispiel die Zahlen 1 bis 24 \\
 
 \pythoninline{np.percentile(arr, q=[2.5, 97.5])} \\
 Werte der Quantile eines Datensatz anzeigen \\
+In diesem Beispiel die 2.5\%- und 97.5\%-Quantile \\
 
-\pythoninline{np.sum(arr > 0)} \\
-Werte grösser als x in einem Array zählen \\
+\pythoninline{np.sum(arr > x)} \\
+Werte grösser als \textit{x} in einem Array zählen \\
 
 \pythoninline{np.tile(arr, x)} \\
-Array x-Mal wiederholen und aneinander hängen \\
+Array \textit{x}-Mal wiederholen und aneinander hängen \\
 
 \pythoninline{np.repeat(["M1","M2","M3"], [x1, x2, x3])} \\
-Jeder Werte des Array mit Index $i$, $x_i$-mal wiederholen
+Jeder Werte des Array mit Index $i$, $x_i$-mal wiederholen \\
+
+\pythoninline{np.corrcoef(arr_x, arr_y)} \\
+Korrelationsmatrix berechnen
 
 \subsection*{Pandas Series}
 \begin{python}
@@ -95,39 +96,40 @@ \subsection*{Pandas Series}
 )
 \end{python}
 
-\pythoninline{series.sum()}: Die Summe der Elemente von series \\
-\pythoninline{series.mean()}: Der Durchschnitt der Elemente von series \\
-\pythoninline{series.median()}: Der Median der Elemente von series \\
-\pythoninline{series.var()}: Die Varianz der Elemente von series \\
-\pythoninline{series.std()}: Standardabweichung von series \\
-\pythoninline{series.count()}: Anzahl Elemente der series \\
-\pythoninline{series.round(0)}: Werte auf x Nachkomastellen runden \\
-\pythoninline{series.index}: Zeilenbeschrift der Elemente von series \\
-\pythoninline{series.size}: Die Anzahl der Elemente von series \\
+\pythoninline{series.sum()}: Die Summe der Elemente von \textit{series} \\
+\pythoninline{series.mean()}: Der Durchschnitt der Elemente von \textit{series} \\
+\pythoninline{series.median()}: Der Median der Elemente von \textit{series} \\
+\pythoninline{series.var()}: Die Varianz der Elemente von \textit{series} \\
+\pythoninline{series.std()}: Standardabweichung von \textit{series} \\
+\pythoninline{series.count()}: Anzahl Elemente der \textit{series} \\
+\pythoninline{series.round(x)}: Werte auf \textit{x} Nachkomastellen runden \\
+\pythoninline{series.index}: Zeilenbeschrift der Elemente von \textit{series} \\
+\pythoninline{series.size}: Die Anzahl der Elemente von \textit{series} \\
 \pythoninline{series[1]}: Zugriff auf ein Elemente via Index \\
 \pythoninline{series["mi"]}: Zugriff via Zeilenbeschrift \\
 
-\pythoninline{series.hist(bins=[0,1,10,11,12])} \\
+\pythoninline{series.hist(bins=[0, 1, 10, 11, 12])} \\
 Histogramm mit angegebenen Klassengrenzen plotten 
 
 \subsection*{Quantile und Quartilsdifferenz}
 \pythoninline{series.quantile(q=0.25, interpolation="midpoint")}
-Quantile (z.B. 25\%, 75\%, \dots) von series \\
+Quantile (z.B. 25\%, 75\%, \dots) von \textit{series} berechnen \\
 
-\pythoninline{q75, q25 = series.quantile(q = [.75, .25], 
-	interpolation="midpoint")} \\
+\pythoninline{q75, q25 = series.quantile(q = [.75, .25], }\\
+\pythoninline{	interpolation="midpoint")} \\
 \pythoninline{iqr = q75 - q25} \\
 Quartilsdifferenz von series berechnen
 
 \subsection*{Werte einlesen}
 \pythoninline{np.loadtxt(r"./data.txt")} \\
 Daten für ein Array aus einem Textfile laden \\
 
-\pythoninline{frame = pd.read_csv(r"./data.csv", sep=",", 
-	index_col=0)} \\
+\pythoninline{frame = pd.read_csv(r"./data.csv", } \\
+\pythoninline{	sep=",", index_col=0)} \\
 Werte für eine Frame aus einem CSV auslesen \\
 
-\pythoninline{pd.read_table(r"./gamma.txt", delim_whitespace=True)} \\
+\pythoninline{pd.read_table(r"./gamma.txt", } \\
+\pythoninline{	delim_whitespace=True)} \\
 leerzeichengetrennte Daten einlesen mit Pandas
 
 \subsection*{Pandas DataFrame}
@@ -146,10 +148,10 @@ \subsection*{Pandas DataFrame}
 \pythoninline{frame.describe()}: Kennzahlen jeder Spalte anzeigen \\
 \pythoninline{frame.mean(axis=0)}: Durchschnitt pro Spalte berechnen \\ 
 \pythoninline{frame.mean(axis=1)}: Durchschnitt pro Zeile berechnen \\
-\pythoninline{frame.head(5)}: Erste n Zeilen des Frames anzeigen \\
-\pythoninline{frame.tail(5)}: Letzte n Zeilen des Frames anzeigen \\
-\pythoninline{frame.drop('mar', 0)}: Zeile mit dem Index xy löschen \\
-\pythoninline{frame.drop('Luzern', 1)}: Spalte xy löschen \\
+\pythoninline{frame.head(n)}: Erste \textit{n} Zeilen des Frames anzeigen \\
+\pythoninline{frame.tail(n)}: Letzte \textit{n} Zeilen des Frames anzeigen \\
+\pythoninline{frame.drop(x, 0)}: Zeile mit dem Index \textit{x} löschen \\
+\pythoninline{frame.drop(x, 1)}: Spalte \textit{x} löschen \\
 \pythoninline{frame.corr()}: Korrelationsmatrix berechnen \\
 
 \pythoninline{frame.loc["mar":"mai","Luzern"]} \\
@@ -162,10 +164,10 @@ \subsection*{DataFrame filtern}
 \pythoninline{frame.sort_values(by='Luzern', ascending=False)} \\
 Daten im Frame nach einer Spalte sortieren \\
 
-\pythoninline{frame.nsmallest(1, 'Luzern')} \\
-\pythoninline{frame.nlargest(1, 'Luzern')} \\
+\pythoninline{frame.nsmallest(n, 'Luzern')} \\
+\pythoninline{frame.nlargest(n, 'Luzern')} \\
 Daten im Frame nach einer Spalte sortieren und dann \\ 
-n Zeilen mit grösstem oder kleinstem Werte zurückgeben \\
+\textit{n} Zeilen mit grösstem oder kleinstem Werte zurückgeben \\
 
 \pythoninline{mean = frame.mean()['Luzern']} \\
 \pythoninline{frame.loc[frame['Luzern'] < mean, :]} \\
@@ -184,7 +186,7 @@ \subsection*{Matplotlib PyPlot}
 
 \subsection*{Plots erstellen}
 \pythoninline{series.plot(kind="hist", edgecolor="black")} \\
-Histogramm erstellen und Blaken mit Farbe umrahmen \\
+Histogramm erstellen und Balken mit Farbe umrahmen \\
 
 \pythoninline{series.plot(kind="hist", normed=True, ...)}
 Normiertes Histogramm erstellen \\
@@ -197,24 +199,23 @@ \subsection*{Plots erstellen}
 Empirische kumulative Verteilungsfunktion plotten \\
 
 \pythoninline{series.plot(kind='box', title='Methode A')} \\
-Boxplot von series erstellen und Titel des Plots festlegen \\
+Boxplot von \textit{series} erstellen und Titel des Plots festlegen \\
 
 \pythoninline{frame.plot(kind='scatter', x='wine', y='mor')} \\
 Streudiagramm mit zwei ausgewählten Achsen erstellen \\
-Parameter x und y müssen auf Indizes des frame verweisen \\
+Parameter \textit{x} und \textit{y} müssen auf Indizes des \textit{frame} verweisen \\
 
 \pythoninline{b, a = np.polyfit(x_series, y_series, deg=1)} \\
 \pythoninline{x = np.linspace(x_series.min(), x_series.max())} \\
 \pythoninline{plt.plot(x, a + b * x, c='orange')} \\
 Plotten einer Regressionsgerade, bei welcher die Daten \\
 einem Polynom ersten Grades angeglichen wurden \\
 
-\pythoninline{arr = np.array([24.4, 27.6, 27.8, 27.9, ...])} \\
 \pythoninline{st.probplot(arr, plot=plt)} \\
 QQ-Plot anhand einer Normalverteilung \\
 
 \pythoninline{plt.hist(series.T, bins=20, density=True)} \\
-Plotten eines Histograms mit der Fläche 1 unter den Balken
+Plotten eines Histograms mit der Fläche 1
 
 \subsection*{Verteilungen}
 \pythoninline{cdf}: $P(X \leq x)$ \\
@@ -226,7 +227,7 @@ \subsection*{Verteilungen}
 $P(X \leq 1)$ falls $X \sim Unif(0, 7)$ \\
 
 \pythoninline{st.uniform.pdf(x=1, loc=0, scale=7)} \\
-Dichte an der Stelle x = 3 falls $X \sim Unif(0, 7)$ \\
+Dichte an der Stelle \textit{x} = 3 falls $X \sim Unif(0, 7)$ \\
 
 \pythoninline{st.uniform.rvs(size=3, loc=0, scale=7)} \\
 uniform verteilte Zufallszahlen, $X_i \sim Unif(0, 7)$ \\
@@ -235,7 +236,7 @@ \subsection*{Verteilungen}
 $P(X \leq 4)$ falls $X \sim Exp(3)$ \\
 
 \pythoninline{st.expon.pdf(x=1, loc=0, scale=1/3)} \\
-Dichte an der Stelle x = 1 falls $X \sim Exp(3)$ \\
+Dichte an der Stelle \textit{x} = 1 falls $X \sim Exp(3)$ \\
 
 \pythoninline{st.norm.cdf(x=130, loc=100, scale=15)} \\
 $P(X \leq 130)$ falls $X \sim \mathcal{N}(100, 15^2)$ \\
@@ -253,17 +254,17 @@ \subsection*{Verteilungen}
 \pythoninline{	scale=10/np.sqrt(150))} \\
 $P[\overline{X}_{150} \leq 168]$ falls $u = 164$, $\hat{o} = 10$ und $T \sim t_{149}$ \\
 
-\pythoninline{st.t.ppf(0.05, df=149)} \\
-Quantile einer T-Verteilung mit n Freiheitsgrade \\
+\pythoninline{st.t.ppf(0.05, df=v)} \\
+Quantile einer T-Verteilung mit \textit{v} Freiheitsgrade \\
 
 \pythoninline{st.norm.rvs(size=n)}\\
-generiert n normalverteilte Zahlen \\
+generiert \textit{n} normalverteilte Zahlen \\
 
 \pythoninline{st.t.rvs(size=n, df=v)} \\
-generiert n t-verteilte Zahlen mit v Freiheitsgrade \\
+generiert \textit{n} t-verteilte Zahlen mit \textit{v} Freiheitsgrade \\
 
 \pythoninline{st.chi2.rvs(size=n, df=v)} \\
-generiert n chi-verteilte Zahlen mit v Freiheitsgrade
+generiert \textit{n} chi-verteilte Zahlen mit \textit{v} Freiheitsgrade
 
 \subsection*{Integral berechnen}
 \pythoninline{from scipy.integrate import quad} \\
@@ -282,7 +283,7 @@ \subsection*{Vertrauensintervall}
 
 \subsection*{Statistische Tests}
 \pythoninline{st.binom_test(x=3, n=5, p=0.5)} \\
-Vorzeichentest \\
+Vorzeichentest mit \textit{x} Erfolge bei \textit{n} Versuchen \\
 
 \pythoninline{st.wilcoxon(arr, correction=True)} \\
 Wilcoxon-Test \\
@@ -305,15 +306,13 @@ \subsection*{Varianzanalyse}
 \pythoninline{from statsmodels.stats.anova import anova_lm} \\
 \pythoninline{from statsmodels.formula.api import ols} \\
 \pythoninline{from patsy.contrasts import Sum} \\
-Benötigte Bibliotheksfunktionen \\
+Benötigte Bibliotheksfunktionen für Varianzanalysen \\
 
-\pythoninline{sns.stripplot(x="Treatment", y="steak_id", 
-	data=frame)} \\
-Varianz-Analyse mit Stripcharts \\
+\pythoninline{sns.stripplot(x="...", y="...", data=frame)} \\
+Varianz-Analyse mit Stripcharts zwischen \textit{x} und \textit{y} \\
 
-\pythoninline{sns.boxplot(x="Treatment", y="steak_id", 
-	data=frame)} \\
-Varianz-Analyse mit Boxplots \\
+\pythoninline{sns.boxplot(x="...", y="...", data=frame)} \\
+Varianz-Analyse mit Boxplots zwischen \textit{x} und \textit{y} \\
 
 \pythoninline{sns.distplot(Fstat, kde=False, norm_hist=True, 
 	hist_kws=dict(edgecolor="black", 
@@ -330,21 +329,21 @@ \subsection*{Varianzanalyse}
 
 \pythoninline{interaction_plot(x=frame["Batch"], }\\
 \pythoninline{	trace=frame["Methode"], response=frame["Y"])} \\
-Interaktionsplot zwischen einer Zielgrösse und den Faktoren \\
-- entlang der y -Achse die Zielgrösse (response) \\
-- entlang der x -Achse der durch x festgelegte Faktor \\
+Interaktionsplot erstellen \\
+- entlang der y-Achse die Zielgrösse (response) \\
+- entlang der x-Achse der durch x festgelegte Faktor \\
 - für jede Stufe in trace wird dann eine Linie gezogen \\
 
 \pythoninline{fit = ols("steak_id~Treatment", data=frame).fit()} \\
 \pythoninline{anova_lm(fit)} \\
 Anova Tabelle berechnen \\
 
-\pythoninline{fit = ols("Y ~ C(Methode, Sum) + C(Batch, Sum)", 
-	data=frame).fit()} \\
+\pythoninline{formula = "Y ~ C(Methode, Sum) + C(Batch, Sum)"} \\
+\pythoninline{fit = ols(formula, data=frame).fit()} \\
 Zweiweg-Varianzanalyse mit Blöcken \\
 
-\pythoninline{fit = ols("Y ~ C(Konz,Sum) * C(Temp,Sum)", 
-	data=frame).fit()} \\
+\pythoninline{formula = "Y ~ C(Konz,Sum) * C(Temp,Sum)"} \\
+\pythoninline{fit = ols(formula, data=frame).fit()} \\
 Faktorielle Experimente mit zwei Faktoren
 
 \end{multicols*}