├── .gitignore ├── LICENSE.md ├── README.md ├── build_conf.json ├── build_reveal.py ├── install.sh ├── latex ├── slides │ ├── 01_getting_started.tex │ ├── 02_grundlagen.tex │ ├── 03_builtins.tex │ ├── 04_modules_packages_pip.tex │ ├── 05_decorators.tex │ ├── 06_comprehensions.tex │ ├── 07_functions_advanced.tex │ ├── 08_process.tex │ ├── 09_web_client.tex │ ├── 10_regex.tex │ ├── 11_smtplib.tex │ ├── 12_curses.tex │ ├── beamercolorthememetropolis.sty │ ├── beamercolorthemesolarized.sty │ ├── beamerfontthememetropolis.sty │ ├── beamerinnerthememetropolis.sty │ ├── beamerouterthememetropolis.sty │ ├── beamerthememetropolis.sty │ └── resources │ │ ├── 01_getting_started │ │ ├── attributes.py │ │ ├── comments.py │ │ ├── hello_world.py │ │ ├── string_concatenation.py │ │ └── string_format.py │ │ ├── 02_grundlagen │ │ ├── boilerplate.py │ │ ├── classattributes.py │ │ ├── inheritance.py │ │ ├── instanceattributes.py │ │ ├── scope.py │ │ └── scope_fix.py │ │ ├── 03_builtins │ │ ├── cm.py │ │ ├── dict.py │ │ ├── exceptions.py │ │ ├── file.py │ │ ├── iterate.py │ │ ├── list.py │ │ ├── set.py │ │ ├── tuple.py │ │ └── unpacking.py │ │ ├── 04_modules_and_packages │ │ ├── incdec.py │ │ ├── modules.py │ │ └── path.py │ │ ├── 05_pip │ │ └── requirements.txt │ │ ├── 06_comprehensions │ │ ├── dicts.py │ │ └── lists.py │ │ ├── 06_decorators │ │ ├── decorator.py │ │ └── functions.py │ │ ├── 07_funtions_advanced │ │ ├── default.py │ │ ├── mixed_aggr.py │ │ ├── named_aggr.py │ │ ├── nameless_aggr.py │ │ ├── positional_aggregators.py │ │ └── use_func.py │ │ ├── 08_process │ │ ├── context_mgr.py │ │ ├── defs.py │ │ └── popen_call.py │ │ ├── 09_web_client │ │ ├── req_example.py │ │ ├── requests_example.py │ │ └── urllib_calls.py │ │ ├── 10_regex │ │ ├── match.py │ │ └── methods.py │ │ ├── 11_sendmail │ │ ├── defs.py │ │ └── mailer.py │ │ ├── 12_curses │ │ └── functions.py │ │ └── list_example.py └── templates │ ├── course_definitions.tex │ ├── course_information.tex │ ├── fsr_logo.pdf │ ├── fsr_logo.svg │ ├── fsr_logo_cropped.pdf │ └── new_slide.tex ├── md ├── 01_getting_started.md ├── 02_grundlagen.md ├── 03_builtins.md ├── 04_modules_packages_pip.md ├── 05_decorators.md ├── 06_comprehensions.md ├── 07_functions_advanced.md ├── 08_process.md ├── 09_web_client.md ├── 10_regex.md ├── 11_smtplib.md ├── 12_curses.md └── template.html ├── reveal.json └── src ├── css ├── repl.css ├── repl.css.map └── repl.scss ├── ifsr.css ├── ifsr.css.map ├── index.html └── js ├── repl.it.js └── token.js.example /.gitignore: -------------------------------------------------------------------------------- 1 | build/ 2 | .texpadtmp/ 3 | *.pdf 4 | *.pyg 5 | .c9/ 6 | 7 | 8 | token.js 9 | *.log 10 | *.aux 11 | *.vrb 12 | *.out 13 | *.nav 14 | *.pdf 15 | *.toc 16 | *.snm 17 | *.fdb_latexmk 18 | *.fls 19 | *.synctex.gz 20 | .DS_Store 21 | _site/ 22 | .sass-cache/ 23 | html/ 24 | .jekyll-metadata 25 | -------------------------------------------------------------------------------- /LICENSE.md: -------------------------------------------------------------------------------- 1 | This work is licensed under the Creative Commons Attribution 4.0 International License. To view a copy of this license, visit http://creativecommons.org/licenses/by/4.0/. 2 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Python Lessons 2 | 3 | This repository contains the __Python Lesson__ sources for the free student courses, held at the TU Dresden. 4 | 5 | Exercises to go along with the courses can be found [on GitHub pages](http://fsr.github.io/python-lessons/) or on the `gh-pages` branch of this repository as Markdown sources. 6 | 7 | ## Compiling the markdown sources 8 | 9 | The slides in the `md` folder need to be compiled with **reveal.js**. 10 | 11 | Therefore, `pandoc` has to be installed on your computer. You can find these Instructions [here](http://pandoc.org/installing.html). Mac users can simply install it with *homebrew*: 12 | `brew install pandoc` 13 | 14 | Before installing create a `src/js/token.js` from `src/js/token.js.example` and insert your [repl.it API](https://repl.it/site/blog/api-docs) token. 15 | 16 | Run `./install.sh` to initialize the html folder with reveal.js and copy the ifsr.css this only have to be done once 17 | 18 | To build the slides simply run `./build_reveal.py`. The compiled html files are in the `html` folder and easily can be accessed via the `index.html` 19 | 20 | If you add new slides don't forget to add them to `reveal.json`. 21 | 22 | 23 | 24 | An online copy can be found [here](https://python.felixdoering.com). 25 | 26 | 27 | ## Instructions for teachers and contributors 28 | 29 | If you want to contribute to these lessons, you should note that every topic exists as `.tex` file and as `.md` file because the tex files - rendered as PDF - offer a much more convenient way to look up something after a lesson while the rendered `reveal.js` slides are way better for presenting the slides in class. 30 | The black background and the few lines per slide improve readability and help to focus on the subject. Plus they look much better :wink: 31 | 32 | So if you are thinking about making some content-related changes, it would be nice if you apply those changes to both, the `md` and the `tex` slides. 33 | 34 | For contributing to the tasks, have a look at the `gh-pages` branch of this repository. 35 | 36 | ### Teaching 37 | 38 | As stated above, you should rely on the rendered Markdown slides for presenting. The `tex` files are automatically rendered and can be found at: 39 | [http://fsr.github.io/python-lessons/materials.html](http://fsr.github.io/python-lessons/materials.html) 40 | 41 | Almost every task is linked to a lesson. The corresponding PDF is linked automatically at the beginning of every task. 42 | 43 | Solutions for all tasks on this page can be found at [this repository](https://github.com/Feliix42/python-solutions). 44 | 45 | 46 | These lessons are created and maintained by [@h4llow3En](https://github.com/h4llow3En), [@justusadam](https://github.com/justusadam) and [@feliix42](https://github.com/Feliix42). 47 | -------------------------------------------------------------------------------- /build_conf.json: -------------------------------------------------------------------------------- 1 | { 2 | "builds": { 3 | "pdf": { 4 | "source_dir": "latex/slides", 5 | "target_dir": "build/pdf", 6 | "command": "pdflatex", 7 | "files": [ 8 | "01_getting_started.tex", 9 | "02_grundlagen.tex", 10 | "03_builtins.tex", 11 | "04_modules_packages_pip.tex", 12 | "05_decorators.tex", 13 | "06_comprehensions.tex", 14 | "07_functions_advanced.tex", 15 | "08_process.tex", 16 | "09_web_client.tex", 17 | "10_regex.tex", 18 | "11_smtplib.tex", 19 | "12_curses.tex" 20 | ] 21 | }, 22 | "html": { 23 | "source_dir": "latex/slides", 24 | "target_dir": "build/html", 25 | "command": "hevea", 26 | "files": [ 27 | "01_getting_started.tex", 28 | "02_grundlagen.tex" 29 | ] 30 | } 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /build_reveal.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | 3 | import json 4 | import os 5 | import subprocess 6 | from collections import OrderedDict 7 | 8 | reveal_config = OrderedDict() 9 | template = [] 10 | index = '' 11 | 12 | 13 | def main(): 14 | global index 15 | if not os.path.isdir('html'): 16 | print('Please run ./install.sh first') 17 | exit() 18 | load() 19 | for title in reveal_config: 20 | source = reveal_config[title]['source'] 21 | theme = reveal_config[title]['theme'] 22 | destination = 'html/{source}.html'.format(source=source) 23 | subprocess.call(['pandoc', '-t', 'revealjs', '-s', 24 | '--template', 'md/template.html', 25 | 'md/{}.md'.format(source), '--no-highlight', 26 | '--variable', 'theme={}'.format(theme), 27 | '--variable', 'pagetitle={}'.format(title), 28 | '-o', 'html/{}.html'.format(source)]) 29 | index += index_link.format(link=source + '.html', title=title) 30 | generated_index = index_content.format(links=index) 31 | new_index = '' 32 | for line in template: 33 | new_index += line.replace('{content}', generated_index) 34 | with open('html/index.html', 'w') as indexfile: 35 | indexfile.write(new_index) 36 | 37 | 38 | def load(): 39 | global reveal_config, template 40 | try: 41 | with open('reveal.json') as json_data: 42 | configdata = json.load(json_data) 43 | for i in range(1, len(configdata) + 1): 44 | search = str(i) if i > 9 else '0' + str(i) 45 | for title in configdata: 46 | if configdata[title]['source'].startswith(search): 47 | reveal_config[title] = configdata[title] 48 | except FileNotFoundError: 49 | print('No reveal.json found.') 50 | exit() 51 | try: 52 | with open('src/index.html') as template_file: 53 | template = template_file.readlines() 54 | except FileNotFoundError: 55 | print('No src/index.html found.') 56 | exit() 57 | 58 | 59 | index_content = '''

Index

''' 60 | 61 | index_link = '''
  • {title}
    • \n''' 62 | 63 | 64 | if __name__ == '__main__': 65 | main() 66 | -------------------------------------------------------------------------------- /install.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | source_url=https://github.com/hakimel/reveal.js.git 3 | 4 | mkdir html 5 | 6 | git clone $source_url html/reveal.js 7 | cp src/ifsr.css html/reveal.js/css/theme/ifsr.css 8 | cp src/ifsr.css.map html/reveal.js/css/theme/ifsr.css.map 9 | cp -r src/css html/css 10 | cp -r src/js html/js 11 | -------------------------------------------------------------------------------- /latex/slides/02_grundlagen.tex: -------------------------------------------------------------------------------- 1 | % The Slide Definitions 2 | \input{../templates/course_definitions} 3 | 4 | % Author and Course information 5 | \input{../templates/course_information} 6 | 7 | % Presentation title 8 | \title{Grundlagen} 9 | \date{\today} 10 | 11 | 12 | \begin{document} 13 | 14 | \maketitle 15 | 16 | \begin{frame}{Gliederung} 17 | \begin{multicols}{2} 18 | \setbeamertemplate{section in toc}[sections numbered] 19 | \tableofcontents 20 | \end{multicols} 21 | \end{frame} 22 | 23 | 24 | 25 | \section{Scriptcharakter} 26 | \begin{frame}[fragile]{Scriptcharakter} 27 | \begin{itemize} 28 | \item Beim Ausführen oder Importieren wird der Code im obersten Level des Moduls (der .py Datei) ausgeführt 29 | \item Funktionen, Klassen und globale Variablen werden üblicherweise auf dem obersten Level definiert 30 | \item Imports anderer Python Module werden auch hier ausgeführt 31 | \end{itemize} 32 | \end{frame} 33 | 34 | \begin{frame}[fragile]{Scriptcharakter} 35 | \lstinputlisting{resources/02_grundlagen/boilerplate.py} 36 | Soll das entsprechende Modul ausführbar sein und nicht nur als Bibliothek dienen, definiert man üblicherweise eine \alert{main}-Funktion.\\ 37 | Zus\"atzlich f\"ugt man am Ende des Moduls die Boilerplate ein.\\ 38 | \end{frame} 39 | 40 | \begin{frame}{Scriptcharakter} 41 | \begin{itemize} 42 | \item Python Code wird nicht kompiliert, sondern beim importieren in Python Bytecode übersetzt 43 | \item Bytecode wird auf einer VM ausgeführt 44 | \item Kein Memory Management nötig, alles sind Referenzen 45 | \item Syntaxerror wird beim Importieren geworfen 46 | \item Andere Fehler findet man erst, wenn die betreffende Zeile ausgeführt wird. 47 | \end{itemize} 48 | \end{frame} 49 | 50 | 51 | 52 | \section{Programmierparadigmen} 53 | \subsection{Imperatives Programmieren} 54 | \begin{frame}[fragile]{Programmierpradigmen} 55 | \begin{itemize} 56 | \item Python ist vor allem eine imperative und objektorientierte Sprache 57 | \item reine Funktionen und Variablen können auf oberster Ebene definiert werden 58 | \item Variablen, Klassen und Funktionen sind ab der Ebene sichtbar, in der sie eingeführt werden 59 | \end{itemize} 60 | \end{frame} 61 | 62 | \subsection{Das Scoping Problem} 63 | \begin{frame}[fragile]{Das Problem mit dem Scope} 64 | \lstinputlisting{resources/02_grundlagen/scope.py} 65 | \end{frame} 66 | 67 | \begin{frame}{Das Problem mit dem Scope} 68 | \textbf{\alert{Das Problem:}} \\[.25cm] 69 | Variablen sind zwar nach innen sichtbar, werden aber beim Reassignment innerhalb der Funktion neu angelegt und verschwinden so aus dem Scope. 70 | \end{frame} 71 | 72 | \begin{frame}[fragile]{Die Lösung} 73 | \lstinputlisting{resources/02_grundlagen/scope_fix.py} 74 | \end{frame} 75 | 76 | \subsection{Objektorientiertes Programmieren} 77 | \begin{frame}[fragile]{Objektorientiertung} 78 | \begin{itemize} 79 | \item Python ist auch fundamental objektorientiert 80 | \item Alles in Python ist ein Objekt 81 | \item Selbst die Datentypen \texttt{int}, \texttt{bool}, \texttt{str} und \texttt{type} sind Instanzen von \texttt{object} und haben folglich Methoden und Attribute 82 | \item Der Typ jedes Wertes und jeder Variable lässt sich mit \alert{\texttt{type()}} ermitteln 83 | \end{itemize} 84 | \end{frame} 85 | 86 | \section{Klassen und Attribute} 87 | % TODO: Dieser Frame muss noch mal überarbeitet werden! 88 | \begin{frame}[fragile]{Klassen und Attribute} 89 | \begin{itemize} 90 | \item Typen in Python werden ausgedrückt durch Klassen (Keyword \alert{\texttt{class}}) 91 | \item Klassen dienen als Vorlage bzw. Schablone $\rightarrow$ Objekte sind dann Instanzen davon 92 | \item Die Besonderheit: alle Variablen und Werte sind Instanzen von \texttt{object} 93 | \end{itemize} 94 | \texttt{object} und alle Typen selbst sind widerum Objekte, genauer gesagt Instanzen vom Typ \texttt{type} und \texttt{type} widerum ist eine Subklasse von \texttt{object}. 95 | \end{frame} 96 | 97 | \begin{frame}[fragile]{Klassen und Attribute} 98 | \begin{itemize} 99 | \item Klassen und Objekte können selbst auch Variablen tragen (ähnlich wie in Java) 100 | \item Man unterscheidet dabei zwischen Klassenattributen und Instanzattributen 101 | \end{itemize} 102 | 103 | \begin{description} 104 | \item[Klassenattribute] werden für die Klasse definiert und sind für alle Instanzen gleich 105 | \item[Instanzattribute] werden außerhalb der Klassendefnition hinzugefügt (normalerweise im Initialisierer) und sind für jede Instanz unterschiedlich. 106 | \end{description} 107 | \end{frame} 108 | 109 | \begin{frame}[fragile]{Klassen und Attribute} 110 | \begin{itemize} 111 | \item Zugriff auf Attribute über Punktnotation (wie in Ruby/Java) 112 | \item Attribute werden wie Variablen mithilfe von \alert{\texttt{=}} gesetzt 113 | \item Man kann Objekten jederzeit neue Attribute hinzufügen (auch \texttt{type}-Objekten) 114 | \item Ist außerhalb des Initialisierers nicht empfehlenswert 115 | \end{itemize} 116 | \end{frame} 117 | 118 | \subsection{Klassen- und Objektattribute im Detail} 119 | \begin{frame}[fragile]{Klassen- und Objektattribute im Detail} 120 | Klassenattribute sind für jede Instanz eines Objektes gleich. 121 | \lstinputlisting{resources/02_grundlagen/classattributes.py} 122 | \end{frame} 123 | 124 | \begin{frame}{Klassen- und Objektattribute im Detail} 125 | Gewöhnlich definiert man Instanzattribute allerdings im \textbf{Initialisierer}. 126 | \lstinputlisting{resources/02_grundlagen/instanceattributes.py} 127 | \begin{itemize} 128 | \item Instanzattribute sollten immer in \alert{\texttt{\_\_init\_\_}} definiert werden, um sicherzustellen, dass alle Instanzen die gleichen Attribute haben 129 | \end{itemize} 130 | \end{frame} 131 | 132 | \subsection{Super- und Subklassen} 133 | \begin{frame}[fragile]{Super- und Subklassen} 134 | Eine Klasse kann Attribute einer anderen Klasse erben, indem sie mit \alert{\texttt{class subclass(superclass):}} definiert wird. 135 | \begin{itemize} 136 | \item Subklassen enthalten von Anfang an alle Attribute der Superklasse. 137 | \item Es können neue Variablen und Methoden hinzugefügt, und auch alte überschrieben werden. 138 | \item Die Attribute der Superklasse können mit \alert{\texttt{super()}} aufgerufen werden. 139 | \end{itemize} 140 | \end{frame} 141 | 142 | \begin{frame}[fragile]{Super- und Subklassen} 143 | \lstinputlisting{resources/02_grundlagen/inheritance.py} 144 | \end{frame} 145 | 146 | 147 | \section{Methoden} 148 | \begin{frame}[fragile]{Methoden} 149 | \begin{itemize} 150 | \item Methoden sind Funktionen 151 | \item Allgemeiner Typ von Methoden ist daher \alert{\texttt{function}} 152 | \item Methoden liegen im Namespace der zugehörigen Klasse, müssen daher mit \alert{\texttt{ClassName.method\_name()}} angesteuert werden (oder auf dem Objekt aufgerufen werden) 153 | \item Methoden haben ein implizites erstes Argument (typischerweise \texttt{self} genannt, kann aber variieren) 154 | \item Beim Aufruf auf einer Instanz wird das Objekt selbst automatisch übergeben 155 | \end{itemize} 156 | \end{frame} 157 | 158 | 159 | \subsection{Spezielle Methoden} 160 | \begin{frame}[fragile]{Methoden} 161 | Dies sind Methoden die auf den meisten Grundlegenden Datenstrukturen implementiert sind, z.B. \texttt{object}.\\ 162 | Die Folgenden beginnen und enden normalerweise mit zwei Unterstrichen. 163 | 164 | \begin{description} 165 | \item[Initialisierer] Oft auch (fälschlicherweise) Konstruktor genannt.\\ Name: \alert{\texttt{\_\_init\_\_}}\\ 166 | Wird immer aufgerufen wenn eine neue Instanz der Klasse erstellt wird. 167 | \item[Finalisierer] Oft auch (fälschlicherweise) Destructor genannt.\\ 168 | Name: \alert{\texttt{\_\_del\_\_}}\\ 169 | Wird immer aufgerufen wenn das Objekt vom Garbage Collector aufgeräumt wird. (selten verwendet) 170 | \end{description} 171 | \end{frame} 172 | 173 | \begin{frame}[fragile]{Methoden} 174 | \begin{description} 175 | \item[String Konvertierer] Äquivalent zu Java's \texttt{toString} Methode. \\ Name: \alert{\texttt{\_\_str\_\_}} 176 | \item[String Repräsentation] Ähnlich wie \alert{\texttt{\_\_str\_\_}} aber gedacht für eine für Debug verwendbare Repräsentation anstatt für Output wie \alert{\texttt{\_\_str\_\_}}. 177 | \end{description} 178 | \end{frame} 179 | 180 | 181 | 182 | 183 | 184 | \end{document} 185 | -------------------------------------------------------------------------------- /latex/slides/03_builtins.tex: -------------------------------------------------------------------------------- 1 | % The Slide Definitions 2 | \input{../templates/course_definitions} 3 | 4 | % Author and Course information 5 | \input{../templates/course_information} 6 | 7 | % Presentation title 8 | \title{Builtin Datenstrukturen} 9 | \date{\today} 10 | 11 | 12 | \begin{document} 13 | 14 | \maketitle 15 | 16 | \begin{frame}{Gliederung} 17 | \begin{multicols}{2} 18 | \setbeamertemplate{section in toc}[sections numbered] 19 | \tableofcontents 20 | \end{multicols} 21 | \end{frame} 22 | 23 | 24 | % ############################################################################# 25 | % ------------------------------- 1. Exceptions ------------------------------- 26 | % ############################################################################# 27 | \section{Exceptions} 28 | 29 | \begin{frame}{Exception Handling} 30 | \begin{itemize} 31 | \item Alle Exceptions erben von \alert{\texttt{Exception}} 32 | \item Catching mit try/except 33 | \item \alert{\texttt{finally}} um Code auszuführen, der \textit{unbedingt} laufen muss, egal ob eine Exception vorliegt oder nicht 34 | \end{itemize} 35 | \end{frame} 36 | 37 | \begin{frame}{Exception Handling - Beispiel} 38 | \lstinputlisting{resources/03_builtins/exceptions.py} 39 | \end{frame} 40 | 41 | 42 | % ############################################################################# 43 | % -------------------------------- 2. Booleans -------------------------------- 44 | % ############################################################################# 45 | \section{Booleans} 46 | 47 | \begin{frame}{Boolsche Werte} 48 | \begin{itemize} 49 | \item \textit{type} ist \alert{\texttt{bool}} 50 | \item Mögliche Werte: \texttt{True} oder \texttt{False} 51 | \item Operationen sind \textit{und}, \textit{oder}, \textit{nicht} (\texttt{and, or, not}) 52 | \end{itemize} 53 | \end{frame} 54 | 55 | 56 | % ############################################################################# 57 | % --------------------------------- 3. Lists ---------------------------------- 58 | % ############################################################################# 59 | \section{Lists} 60 | 61 | \begin{frame}{list} 62 | \begin{itemize} 63 | \item enthält variable Anzahl von Objekten 64 | \item eine Liste kann beliebig viele verschiedene Datentypen enthalten (z.B. \texttt{bool} und \texttt{list}) 65 | \item Auch Listen können in Listen gespeichert werden! 66 | \item Listenobjekte haben eine feste Reihenfolge (\textit{first in, last out}) 67 | \item optimiert für einseitige Benutzung wie z.B. Queue (\alert{\texttt{append}} und \alert{\texttt{pop}}) 68 | \end{itemize} 69 | \end{frame} 70 | 71 | \begin{frame}{list - Beispiel} 72 | \lstinputlisting{resources/03_builtins/list.py} 73 | \end{frame} 74 | 75 | 76 | % ############################################################################# 77 | % --------------------------------- 4. Tuples --------------------------------- 78 | % ############################################################################# 79 | \section{Tuples} 80 | 81 | \begin{frame}{tuple} 82 | \begin{itemize} 83 | \item Gruppiert Daten 84 | \item kann nicht mehr verändert werden, sobald es erstellt wurde 85 | \item Funktionen mit mehreren Rückgabewerten geben ein Tupel zurück 86 | \end{itemize} 87 | \end{frame} 88 | 89 | \begin{frame}{tuple - Beispiel} 90 | \lstinputlisting{resources/03_builtins/tuple.py} 91 | \end{frame} 92 | 93 | 94 | % ############################################################################# 95 | % --------------------------------- 5. Dicts ---------------------------------- 96 | % ############################################################################# 97 | \section{Dicts} 98 | 99 | \begin{frame}{dict} 100 | \begin{itemize} 101 | \item einfache Hashmap 102 | \item ungeordnet 103 | \item jeder hashbare Typ kann ein Key sein 104 | \item jedem Key ist dann ein Value zugeordnet 105 | \end{itemize} 106 | \end{frame} 107 | 108 | \begin{frame}{dict - Beispiel} 109 | \lstinputlisting[lastline=10]{resources/03_builtins/dict.py} 110 | \end{frame} 111 | 112 | \begin{frame}{dict - Beispiel} 113 | \lstinputlisting[firstline=11]{resources/03_builtins/dict.py} 114 | \end{frame} 115 | 116 | 117 | % ############################################################################# 118 | % ----------------------------- 6. Set/Frozenset ------------------------------ 119 | % ############################################################################# 120 | \section{Set/Frozenset} 121 | 122 | \begin{frame}{set/frozenset} 123 | \begin{itemize} 124 | \item kann nur hashbare Einträge enthalten 125 | \item \texttt{set} selbst ist nicht hashbar 126 | \item \texttt{frozensets} sind hashbar, jedoch nicht mehr veränderbar 127 | \item enthält jedes Element nur einmal 128 | \item schnellere Überprüfung mit \alert{\texttt{in}} (prüft, ob Element enthalten ist) 129 | \item Mögliche Operationen: \alert{\texttt{superset()}}, \alert{\texttt{subset()}}, \alert{\texttt{isdisjoint()}}, \alert{\texttt{difference()}}, \alert{\texttt{<}}, \alert{\texttt{>}}, \alert{\texttt{disjoint()}}, \alert{\texttt{-}} 130 | \item ungeordnet 131 | \item (frozen)sets können frozensets enthalten (da sie einen festen Hashwert haben) 132 | \end{itemize} 133 | \end{frame} 134 | 135 | \begin{frame}{set/frozenset - Beispiel} 136 | \lstinputlisting{resources/03_builtins/set.py} 137 | \end{frame} 138 | 139 | 140 | % ############################################################################# 141 | % ------------------------------- 7. Iterations ------------------------------- 142 | % ############################################################################# 143 | \section{Iterations} 144 | 145 | \begin{frame}{Iteration} 146 | \begin{itemize} 147 | \item nur foreach 148 | \item für Iterationen über Integer gibt es \\ \hspace{0.5cm} \texttt{range([start], stop, step=1)} 149 | \item um Iteratoren zu kombinieren kann man \\ \hspace{0.5cm} \texttt{zip(iterator\_1, iterator\_2, ..., iterator\_n)} verwenden 150 | \item alles mit einer \alert{\texttt{\_\_iter\_\_}} Methode ist iterierbar 151 | % TODO: stateful Iterator erklaeren oder entfernen 152 | \item \texttt{iter(iterable)} konstruiert einen \textit{stateful iterator} 153 | \end{itemize} 154 | \end{frame} 155 | 156 | \begin{frame}{Iteration - Beispiel} 157 | \lstinputlisting[lastline=15]{resources/03_builtins/iterate.py} 158 | \end{frame} 159 | 160 | \begin{frame}{Iteration - Beispiel} 161 | \lstinputlisting[firstline=18]{resources/03_builtins/iterate.py} 162 | \end{frame} 163 | 164 | 165 | % ############################################################################# 166 | % ------------------------------- 8. Unpacking -------------------------------- 167 | % ############################################################################# 168 | \section{Unpacking} 169 | 170 | \begin{frame}{Unpacking} 171 | \begin{itemize} 172 | \item einfaches Auflösen von Listen und Tupeln in einzelne Variablen 173 | \item nützlich in \alert{\texttt{for}}-Schleifen 174 | \end{itemize} 175 | \end{frame} 176 | 177 | \begin{frame}{Unpacking - Beispiel} 178 | \lstinputlisting{resources/03_builtins/unpacking.py} 179 | \end{frame} 180 | 181 | 182 | % ############################################################################# 183 | % ----------------------------- 9. File Handling ------------------------------ 184 | % ############################################################################# 185 | \section{File Handling} 186 | 187 | \begin{frame}{File Handling} 188 | \begin{itemize} 189 | \item Dateien können mit \alert{\texttt{open(filename, mode="r")}} geöffnet werden 190 | \item \textit{File Handler} sind Iteratoren über die Zeilen einer Datei 191 | \item \textbf{Wichtig:} File Handler müssen auch wieder geschlossen werden 192 | \item \texttt{r} steht für Lesezugriff, \texttt{w} für Schreibzugriff 193 | \end{itemize} 194 | \textbf{Beachte:} Wird eine Datei mit Schreibzugriff geöffnet, wird sie geleert! Also wichtige Inhalte vorher auslesen. 195 | \end{frame} 196 | 197 | \begin{frame}{File Handling - Beispiel} 198 | \lstinputlisting{resources/03_builtins/file.py} 199 | \end{frame} 200 | 201 | 202 | % ############################################################################# 203 | % ---------------------------- 10. Context Manager ---------------------------- 204 | % ############################################################################# 205 | \section{Context Manager} 206 | 207 | \begin{frame}{Context Manager} 208 | \begin{itemize} 209 | \item Aufruf mit \alert{\texttt{with}} 210 | \item kann jedes Objekt sein, welches eine \texttt{\_\_enter\_\_} und \texttt{\_\_exit\_\_} Methode hat 211 | \item praktisch beim \textit{File Handling} 212 | \end{itemize} 213 | \end{frame} 214 | 215 | \begin{frame}{Context Manager} 216 | \lstinputlisting{resources/03_builtins/cm.py} 217 | \end{frame} 218 | 219 | 220 | \end{document} 221 | -------------------------------------------------------------------------------- /latex/slides/04_modules_packages_pip.tex: -------------------------------------------------------------------------------- 1 | % The Slide Definitions 2 | \input{../templates/course_definitions} 3 | 4 | % Author and Course information 5 | \input{../templates/course_information} 6 | 7 | % Presentation title 8 | \title{Module, Packete und PIP} 9 | \date{\today} 10 | 11 | 12 | \begin{document} 13 | 14 | \maketitle 15 | 16 | \begin{frame}{Gliederung} 17 | \begin{multicols}{2} 18 | \setbeamertemplate{section in toc}[sections numbered] 19 | \tableofcontents 20 | \end{multicols} 21 | \end{frame} 22 | 23 | % ---------------------------------- Module ---------------------------------- 24 | 25 | \section{Module} 26 | \subsection{Eigene Module} 27 | \begin{frame}[fragile]{Module} 28 | \begin{itemize} 29 | \item Ein Modul ist die python-interne Repr\"asentation einer \texttt{.py} Datei 30 | \item Der Dateiname setzt sich daher aus Modulname + \texttt{.py} zusammen 31 | \item Module beinhalten eine beliebige Anzahl an Definitionen (Klassen, Funktionen, Variablen/Konstanten) 32 | \item Das komplette Modul wird mit \alert{\texttt{import}} hinzugef\"ugt 33 | \item Einzelne Inhalte mit \alert{\texttt{from}} Modul \alert{\texttt{import}} Name 34 | \item Mit Hilfe von \alert{\texttt{as}} kann ein Alias f\"ur den importierten Namen angelegt werden 35 | \end{itemize} 36 | \end{frame} 37 | 38 | \begin{frame}{Ein Beispiel} 39 | Die Datei \textbf{incdec.py} enth\"alt eine Reihe von Funktionen: 40 | \lstinputlisting{resources/04_modules_and_packages/incdec.py} 41 | \end{frame} 42 | 43 | \begin{frame}{Ein Beispiel} 44 | In einem anderen Python-Script kann ich diese Funktionen nutzen: 45 | \lstinputlisting[lastline=15]{resources/04_modules_and_packages/modules.py} 46 | \end{frame} 47 | 48 | \begin{frame}{Ein Beispiel} 49 | In einem anderen Python-Script kann ich diese Funktionen nutzen: 50 | \lstinputlisting[firstline=17]{resources/04_modules_and_packages/modules.py} 51 | \end{frame} 52 | 53 | \subsection{Der Sinn der Boilerplate} 54 | \begin{frame}{Der Sinn der Boilerplate} 55 | \begin{itemize} 56 | \item Verhindert, dass Code beim Importieren eines Scriptes ausgef\"uhrt wird 57 | \item Beim Aufruf des Moduls \"uber \texttt{import} ist der Name des Moduls \alert{nicht \texttt{\_\_main\_\_}}, sondern der Name des Scriptes (im vorherigen Beispiel w\"are das \texttt{incdec}) 58 | \end{itemize} 59 | \end{frame} 60 | 61 | 62 | 63 | \subsection{Suchpfad f\"ur Module} 64 | \begin{frame}{Suchpfad f\"ur Module} 65 | \begin{itemize} 66 | \item Python sucht Module beim Import an allen im \alert{\textbf{PYTHONPATH}} aufgelisteten Ordnern 67 | \item dieser findet sich in Python unter \alert{\texttt{sys.path}}, in der Kommandozeile in der Umgebungsvariable PYTHONPATH 68 | \item \texttt{sys.path} l\"asst sich zur Laufzeit im Interpreter \"andern (z.B. um nachtr\"aglich neue eigene Module hinzuzuf\"ugen) 69 | \end{itemize} 70 | \end{frame} 71 | 72 | \begin{frame}{Suchpfad f\"ur Module} 73 | Standardm\"a\ss{}ig enth\"alt der Suchpfad folgende Module: \\ \ \\ 74 | \begin{itemize} 75 | \item die \textit{Standardbibliothek} der derzeitig verwendeten Python-Version 76 | \item das \textit{aktuelle Verzeichnis}, in dem der Interpreter aufgerufen wurde 77 | \item eine \textit{Verzeichnis mit plattfomspezifischen Modulen}, z.B. 78 | "/usr/local/Cellar/python3/3.5.1/Frameworks/Python.framework/ 79 | Versions/3.5/lib/python3.5/plat-darwin" f\"ur Mac 80 | \item \textit{Benutzerspezifische Module f\"ur die jeweilige Python Version}, z.B. "/usr/local/lib/python3.5/site-packages" f\"ur Python 3.5 81 | \end{itemize} 82 | \end{frame} 83 | 84 | 85 | 86 | \subsection{Suchpfad modifizieren} 87 | \begin{frame}{Suchpfad modifizieren} 88 | Zus\"atzliche Verzeichnisse f\"ur den PYTHONPATH kann man beim Aufruf \"ubergeben:\\ 89 | \hspace*{.5cm}\codeline{\$ PYTHONPATH=/my/directory python3 script.py}\\ \ \\ 90 | Oder im Programm: 91 | \lstinputlisting{resources/04_modules_and_packages/path.py} 92 | \"Anderungen am Pfad sind erst \textbf{nach} der entsprechenden Codezeile verf\"ugbar. 93 | \end{frame} 94 | 95 | 96 | 97 | \subsection{Standardmodule} 98 | \begin{frame}{Standardmodule} 99 | Python liefert viele n\"utzliche Module bereits in der Standardbibliothek mit, z.B.: 100 | \texttt{sys}, \texttt{os}, \texttt{http}, \texttt{re}, \texttt{fuctools}, \texttt{itertools}, \texttt{collections}, \texttt{hashlib}, \texttt{urllib} und viele mehr. \\ \ \\ 101 | Daher bezeichnet man Python oft auch als \textbf{Batteries included}. 102 | \end{frame} 103 | 104 | % --------------------------------- Packages --------------------------------- 105 | 106 | \section{Packages} 107 | \begin{frame}{Packages} 108 | \begin{itemize} 109 | \item Packages sind Ordner, die mindestens ein \alert{\texttt{\_\_init\_\_.py}} Modul enthalten. 110 | \item der Inhalt dieses Moduls ist prinzipiell egal 111 | \item Packages k\"onnen genau wie Module importiert werden 112 | \item Wird das Package selbst importiert, sind alle Definitionen in \texttt{\_\_init\_\_.py} \"uber das importierte Package erreichbar. 113 | \item wird benutzt, um Module in sinnvolle Gruppen zusammenzufassen 114 | \end{itemize} 115 | \end{frame} 116 | 117 | % -------------------- merged from presentation about 'pip' ------------------- 118 | 119 | \section{PIP} 120 | \subsection{Installation von PIP} 121 | \begin{frame}{Installation von PIP} 122 | Nicht jedes Modul ist in der Standardbibliothek vorhanden, muss aber nicht zwingen manuell als Datei hinzugef\"ugt werden. Man kann ganz einfach PIP zur Hilfe nehmen.\\[.5cm] 123 | \textbf{Installation:}\\ 124 | \begin{enumerate} 125 | \item Downloaden der \texttt{get-pip.py} von pypa \href{https://bootstrap.pypa.io/get-pip.py}{(hier)} 126 | \item Installieren via \texttt{python3 get-pip.py}\\[.5cm] 127 | \end{enumerate} 128 | 129 | Hinweis f\"ur Mac-Nutzer:\\ 130 | Bei der Pythoninstallation via \textit{Homebrew} wird pip gleich mit installiert. 131 | \end{frame} 132 | 133 | 134 | 135 | \subsection{Verwendung} 136 | \begin{frame}{Verwendung} 137 | Die Installation von Modulen ist einfach und es gibt mehrere M\"oglichkeiten: 138 | \begin{itemize} 139 | \item die aktuellste Version eines Moduls:\\ 140 | \noindent\hspace*{.5cm} \texttt{pip install Modulname} 141 | \item eine bestimmte Version:\\ 142 | \noindent\hspace*{.5cm} \texttt{pip install Modulname==2.1} 143 | \item alle Versionen ab einem Minimum:\\ 144 | \noindent\hspace*{.5cm} \texttt{pip install Modulname>=2.1} 145 | \item alle Versionen bis zu einem Maximum:\\ 146 | \noindent\hspace*{.5cm} \texttt{pip install Modulname<=2.1} 147 | \end{itemize} 148 | \end{frame} 149 | 150 | 151 | 152 | \subsection{Die requirements.txt} 153 | \begin{frame}{Die requirements.txt} 154 | Wenn jemand Scripte ausf\"uhren m\"ochte, in denen Module verwendet werden, die mit Hilfe von PIP installiert wurden, ist es hilfreich eine \alert{\texttt{requirements.txt}} mitzuliefern.\\ 155 | In dieser sind alle Module aufgelistet, die ben\"otigt werden.\\[.5cm] 156 | \lstinputlisting{resources/05_pip/requirements.txt} 157 | 158 | Via \alert{\texttt{pip install -r requirements.txt}} k\"onnen alle Module von der Liste installiert werden 159 | \end{frame} 160 | 161 | \end{document} 162 | -------------------------------------------------------------------------------- /latex/slides/05_decorators.tex: -------------------------------------------------------------------------------- 1 | % The Slide Definitions 2 | \input{../templates/course_definitions} 3 | 4 | % Author and Course information 5 | \input{../templates/course_information} 6 | \usepackage{comment} 7 | % Presentation title 8 | \title{Decorators} 9 | \date{\today} 10 | 11 | 12 | \begin{document} 13 | 14 | \maketitle 15 | 16 | \begin{frame}{Gliederung} 17 | \setbeamertemplate{section in toc}[sections numbered] 18 | \tableofcontents 19 | \end{frame} 20 | 21 | 22 | \section{Fakten über Funktionen} 23 | \begin{frame}{Fakten über Funktionen} 24 | \begin{itemize} 25 | \item Funktionen können Variablen zugewiesen werden, 26 | \lstinputlisting[lastline=8]{resources/06_decorators/functions.py} 27 | \item Sie können in Funktionen definiert werden, 28 | \lstinputlisting[firstline=11, lastline=19]{resources/06_decorators/functions.py} 29 | \end{itemize} 30 | \end{frame} 31 | \begin{frame}{Fakten über Funktionen} 32 | \begin{itemize} 33 | \item Sie können andere Funktionen zurückgeben, 34 | \lstinputlisting[firstline=22, lastline=29]{resources/06_decorators/functions.py} 35 | \end{itemize} 36 | \end{frame} 37 | \begin{frame}{Fakten über Funktionen} 38 | \begin{itemize} 39 | \item Sie können als Parameter mitgegeben werden 40 | \lstinputlisting[firstline=32]{resources/06_decorators/functions.py} 41 | \end{itemize} 42 | \end{frame} 43 | 44 | \section{Decorator} 45 | \subsection{einfache Decorator} 46 | \begin{frame}{einfache Decorator} 47 | Decorator sind Wrapper über existierende Funktionen. Dabei werden die zuvor genannten Eigenschaften verwendet.\\ 48 | Eine Funktion, die eine weitere als Argument hat, erstellt eine neue Funktion. 49 | \lstinputlisting[lastline=9]{resources/06_decorators/decorator.py} 50 | \end{frame} 51 | \begin{frame}{einfache Decorator} 52 | \lstinputlisting[firstline=11,lastline=18]{resources/06_decorators/decorator.py} 53 | \end{frame} 54 | 55 | \begin{frame}[fragile]{einfache Decorator} 56 | Durch das \alert{\texttt{@} Symbol} lässt sich der Decorator wesentlich einfacher verwenden. 57 | \lstinputlisting[firstline=22, lastline=35]{resources/06_decorators/decorator.py} 58 | Es können auch mehrere Decorator übereinander geschrieben werden. 59 | \end{frame} 60 | 61 | \subsection{Decorator mit Argumenten} 62 | \begin{frame}{Decorator mit Argumenten} 63 | Decorator erwarten Funktionen als Argumente. Aus diesem Grund kann man nicht einfach andere Argumente mitgeben, sondern man muss eine Funktion schreiben, die dann den Decorator erstellt. 64 | \lstinputlisting[firstline= 38]{resources/06_decorators/decorator.py} 65 | \end{frame} 66 | 67 | % nothing to do from here on 68 | \end{document} 69 | -------------------------------------------------------------------------------- /latex/slides/06_comprehensions.tex: -------------------------------------------------------------------------------- 1 | % The Slide Definitions 2 | \input{../templates/course_definitions} 3 | 4 | % Author and Course information 5 | \input{../templates/course_information} 6 | 7 | % Presentation title 8 | \title{Comprehensions} 9 | \date{\today} 10 | 11 | 12 | \begin{document} 13 | 14 | \maketitle 15 | 16 | \begin{frame}{Gliederung} 17 | \setbeamertemplate{section in toc}[sections numbered] 18 | \tableofcontents 19 | \end{frame} 20 | 21 | 22 | \section{Basics} 23 | \begin{frame}{Basics} 24 | Comprehensions sind eine bequeme Art und Weise, um Funktoren (Datenstrukturen, die andere Datenstrukturen beinhalten) mit kleinen Expressions zu erstellen und zu füllen und sind in allen modernen Sprachen vorhanden. 25 | \end{frame} 26 | 27 | 28 | 29 | \section{List Comprehension} 30 | \begin{frame}{List Comprehension} 31 | Grundlegender Syntax: \alert{\texttt{[ EXPRESSION for LAUFVARIABLE in ITERABLE (if FILTER) ]}}\\ 32 | \begin{description} 33 | \item[EXPRESSION] Ist ein beliebiger Ausdruck (man stelle sich ein implizites \texttt{return} vor), etwa ein Wert, eine Variable, eine Gleichung, etc ... \\ 34 | \texttt{EXPRESSION} wird am Ende in der Liste abgelegt. 35 | \item[LAUFVARIABLE] Eine beliebige Variable, die in \textit{EXPRESSION} und \textit{FILTER} zur Verfügung steht 36 | \item[ITERABLE] Ist häufig etwas wie \texttt{range()} oder eine andere Liste. 37 | \item[FILTER] Eine optionale boolean expression, womit Einträge gefiltert werden (falls \texttt{False}). N\"utzlich, wenn z.B. nur gerade Zahlen \"ubernommen werden sollen, usw... 38 | \end{description} 39 | 40 | \end{frame} 41 | 42 | \begin{frame}{List Comprehension - Beispiel} 43 | \lstinputlisting{resources/06_comprehensions/lists.py} 44 | \end{frame} 45 | 46 | 47 | 48 | \section{Dict Comprehension} 49 | \begin{frame}{Dict Comprehension} 50 | Grundlegender Syntax: \alert{\texttt{\{ KEY : VALUE for LAUFVARIABLE in ITERABLE (if FILTER) \}}}\\[.75cm] 51 | Fast der gleiche Syntax, nur dieses Mal mit 2 Expressions: \textit{KEY} und \textit{VALUE}. Ansonsten gelten die gleichen Regeln. 52 | \end{frame} 53 | 54 | \begin{frame}{Dict Comprehension - Beispiel} 55 | \lstinputlisting{resources/06_comprehensions/dicts.py} 56 | \end{frame} 57 | 58 | 59 | 60 | \section{Generators} 61 | \begin{frame}{Generators} 62 | \begin{description} 63 | \item[Generator] Ein Objekt, \"uber das iteriert werden kann. Wenn ein Element daraus verwendet wurde, ist es nicht mehr in dem Generatorobjekt enthalten.\\[.5cm] 64 | \end{description} 65 | 66 | Die grundlegende Syntax ist gleich der einer \textit{List Comprehension}. 67 | Da sich \alert{\texttt{list}} und \alert{\texttt{dict}} auch aus Iterables bauen lassen, gilt prinzipiell:\\[.25cm] 68 | 69 | \alert{\texttt{list(EXPRESSION for VARIABLE in ITERABLE) == [EXPRESSION for VARIABLE in ITERABLE]}}\\[.25cm] 70 | und\\[.25cm] 71 | \alert{\texttt{dict((KEY, VALUE) for VARIABLE in ITERABLE) == \{KEY:VALUE for VARIABLE in ITERABLE\}}}\\[.25cm] 72 | 73 | \textbf{Aber:} Generators verhalten sich anders als Lists oder Dicts! 74 | 75 | \end{frame} 76 | 77 | 78 | %\section{Misc} 79 | %\begin{frame}{Misc} 80 | % Mit \texttt{tuple()} und der generator expression lassen sich theoretisch auch tuple comprehensions bauen, ist aber konzeptionell eher Unsinn. 81 | %\end{frame} 82 | 83 | 84 | % nothing to do from here on 85 | \end{document} 86 | -------------------------------------------------------------------------------- /latex/slides/07_functions_advanced.tex: -------------------------------------------------------------------------------- 1 | % The Slide Definitions 2 | \input{../templates/course_definitions} 3 | 4 | % Author and Course information 5 | \input{../templates/course_information} 6 | 7 | % Presentation title 8 | \title{Funktionen (fortgeschritten)} 9 | \date{\today} 10 | 11 | 12 | \begin{document} 13 | 14 | \maketitle 15 | 16 | \begin{frame}{Gliederung} 17 | \begin{multicols}{2} 18 | \setbeamertemplate{section in toc}[sections numbered] 19 | \tableofcontents 20 | \end{multicols} 21 | \end{frame} 22 | 23 | 24 | \section{Nutzung von Funktionen} 25 | \begin{frame}[fragile]{Funktionen als Werte} 26 | Funktionen k\"onnen wie alle anderen Werte zugewiesen werden\\[.25cm] 27 | \lstinputlisting[lastline=5]{resources/07_funtions_advanced/use_func.py} 28 | 29 | \ \\[.25cm] 30 | Oder als Parameter mitgegeben werden\\[.25cm] 31 | \lstinputlisting[firstline=8, lastline=12]{resources/07_funtions_advanced/use_func.py} 32 | \end{frame} 33 | 34 | \begin{frame}[fragile]{Methoden sind Funktionen} 35 | \lstinputlisting[firstline=15]{resources/07_funtions_advanced/use_func.py} 36 | \end{frame} 37 | 38 | 39 | \subsection{Default Parameter} 40 | \begin{frame}[fragile]{Default Parameter} 41 | \begin{itemize} 42 | \item Funktionen k\"onnen vordefinierte Werte für Parameter haben. 43 | \item Parameter ohne \texttt{default}-Werten werden positionale Argumente genannt 44 | \item Parameter mit \texttt{default}-Werten werden name 45 | \end{itemize} 46 | \lstinputlisting[lastline=5]{resources/07_funtions_advanced/default.py} 47 | \end{frame} 48 | 49 | \begin{frame}{ACHTUNG!} 50 | \center{\alert{\textbf{Niemals \texttt{mutable Values} (änderbare Werte) als \texttt{default}-Parameter verwenden!}}}\\[1cm] 51 | \begin{description} 52 | \item[mutable Values] \ \ \ \texttt{list}, \texttt{dict}, \texttt{set} und eigene Klassen \\ 53 | \ \ \ \ \ (bzw. deren Attribute) 54 | \item[immutable Values] \texttt{string}, \texttt{function}, \texttt{int}, \texttt{type} und \texttt{None} 55 | \end{description} 56 | \end{frame} 57 | 58 | \begin{frame}{ACHTUNG!} 59 | \textbf{Warum?}\\[.25cm] 60 | \lstinputlisting[firstline=8, lastline=10]{resources/07_funtions_advanced/default.py} 61 | Man denkt, die Funktion hat jedes mal eine leere List, jedoch passiert folgendes:\\[.25cm] 62 | \lstinputlisting[firstline=12, lastline=14]{resources/07_funtions_advanced/default.py} 63 | Die Liste wird einmalig zum Start angelegt und fortgeführt. 64 | \end{frame} 65 | 66 | \begin{frame}[fragile]{ACHTUNG!} 67 | So sollte man es machen:\\[.5cm] 68 | \lstinputlisting[firstline=16, lastline=19]{resources/07_funtions_advanced/default.py} 69 | \ \\[.5cm] 70 | Den \texttt{default}-Parameter als \texttt{None} setzten und dann, falls er \texttt{None} ist als z.B. leere Liste setzen. 71 | \end{frame} 72 | 73 | 74 | \subsection{Aufruf mit Namen} 75 | \begin{frame}[fragile]{Aufruf mit Namen} 76 | Funktionsparameter können direkt mit ihrem Namen aufgerufen werden, dann spielt die Aufrufreihenfolge keine Rolle mehr.\\[.25cm] 77 | \lstinputlisting[firstline=22]{resources/07_funtions_advanced/default.py} 78 | \end{frame} 79 | 80 | \begin{frame}{Aufruf mit Namen} 81 | Es gelten folgende Regeln: 82 | \begin{itemize} 83 | \item Alle Parameter können an ihrer Position angesprochen werden 84 | \item Es können auch alle mit ihrem Namen angesprochen werden 85 | \item Wenn eins mit dem Namen angesprochen wurde, m\"ussen die folgenden ebenfalls mit Namen angesprochen werden 86 | \end{itemize} 87 | \end{frame} 88 | 89 | % ------------------------------- Aggregatoren ------------------------------- 90 | \section{Aggregatoren} 91 | \begin{frame}{Aggregatoren} 92 | \textbf{Aggregatoren} (auch Sammler genannt), sind sehr n\"utzlich, wenn man, 93 | zus\"atzlich zu bereits definierten Parametern, in einer Funktion eine unbestimmte 94 | Anzahl an Funktionsargumenten entgegen nehmen will. 95 | \end{frame} 96 | 97 | 98 | \subsection{Positionale Aggregatoren} 99 | \begin{frame}[fragile]{Positionale Aggregatoren} 100 | \begin{itemize} 101 | \item jede Funktion kann einen Aggregator haben 102 | \item dieser muss der \textit{letzte} positionale Parameter sein 103 | \item Positionale Aggregatoren werden durch einen \texttt{*} gekennzeichnet 104 | \item nach einem Aggregator k\"onnen nur noch benamte Parameter definiert werden, 105 | diese m\"ussen auch mit Namen aufgerufen werden \\[.5cm] 106 | \end{itemize} 107 | Der Inhalt des Aggregators wird in einem \textit{Tupel} gespeichert: 108 | \lstinputlisting[firstline=1, lastline=2]{resources/07_funtions_advanced/positional_aggregators.py} 109 | \end{frame} 110 | 111 | \begin{frame}{Positionale Aggregatoren - Beispiel} 112 | \lstinputlisting[firstline=5]{resources/07_funtions_advanced/positional_aggregators.py} 113 | \end{frame} 114 | 115 | \begin{frame}[fragile]{Positionale Aggregatoren} 116 | \begin{itemize} 117 | \item Eine Funktion kann auch nur einen Aggregator als Parameter entgegennehmen (keine anderen Parameter) 118 | \item Ohne Argumente ergibt sich f\"ur \texttt{len(args)} 0 119 | \item Werden keine anderen Parameter erwartet, nennt man den Aggregator meist 120 | \texttt{args} (kurz für \textit{Arguments}) \\[.75cm] 121 | \end{itemize} 122 | In \textbf{Python 3} kann man Aggregatoren auch ohne Namen definieren: 123 | \lstinputlisting{resources/07_funtions_advanced/nameless_aggr.py} 124 | Auf diesen Aggregator kann nicht zugegriffen werden. Er erzwingt lediglich, dass 125 | alle folgenden Parameter mit Namen aufgerufen werden. 126 | \end{frame} 127 | 128 | 129 | \subsection{Benannte Aggregatoren} 130 | \begin{frame}[fragile]{Benannte Aggregatoren} 131 | Analog zu Parametern gibt es auch benannte Aggregatoren. Diese werden mit \texttt{**} 132 | vor dem Parameternamen definiert. Diese Aggregatoren akzeptieren lediglich 133 | benannte Parameter und sind vom Typ \texttt{dict}. 134 | \end{frame} 135 | 136 | \begin{frame}[fragile]{Benannte Aggregatoren - Beispiel} 137 | \lstinputlisting{resources/07_funtions_advanced/named_aggr.py} \ \\[.75cm] 138 | Wenn eine Funktion keine anderen Parameter erwartet, nennt man den Aggregator meist 139 | \texttt{**kwargs} (kurz für \textit{Keyword Arguments}) 140 | \end{frame} 141 | 142 | 143 | \subsection{Benannte und Positionale Aggregatoren} 144 | \begin{frame}{Benannte und Positionale Aggregatoren} 145 | Beide Aggregatoren können gleichzeitig in einer Funktion verwendet werden. 146 | Die Regel dabei ist: Von jeder Sorte nur \textit{ein} Aggregator. \\[.5cm] 147 | Ein Beispiel: 148 | \lstinputlisting[firstline=12, lastline=18]{resources/07_funtions_advanced/mixed_aggr.py} 149 | \textit{Eckige Klammern stehen für optionale Parameter/Namen.} 150 | \end{frame} 151 | 152 | \begin{frame}{Generelle Funktionsstruktur} 153 | Wenn beide Aggregatoren zum Einsatz kommen sollen, ergibt sich folgende Funktionsstruktur: \\[.25cm] 154 | \lstinputlisting[firstline=1, lastline=9]{resources/07_funtions_advanced/mixed_aggr.py} 155 | 156 | \end{frame} 157 | 158 | % nothing to do from here on 159 | \end{document} 160 | -------------------------------------------------------------------------------- /latex/slides/08_process.tex: -------------------------------------------------------------------------------- 1 | % The Slide Definitions 2 | \input{../templates/course_definitions} 3 | 4 | % Author and Course information 5 | \input{../templates/course_information} 6 | 7 | % Presentation title 8 | \title{Subprozesse in Python} 9 | \date{\today} 10 | 11 | 12 | \begin{document} 13 | 14 | \maketitle 15 | 16 | \begin{frame}{Gliederung} 17 | \begin{multicols}{2} 18 | \setbeamertemplate{section in toc}[sections numbered] 19 | \tableofcontents 20 | \end{multicols} 21 | \end{frame} 22 | 23 | 24 | \section{Grundlagen} 25 | \begin{frame}[fragile]{Das Modul subprocess} 26 | Das Modul \alert{subprocess} erlaubt die Ausf\"uhrung externer Befehle und 27 | Skripte von einem Python Skript aus. Man kann sich die Funktionsweise \"ahnlich 28 | der eines Terminals vorstellen. 29 | \end{frame} 30 | 31 | 32 | \subsection{Eigenschaften} 33 | \begin{frame}[fragile]{Eigenschaften} 34 | \begin{itemize} 35 | \item Subprozesse laufen \alert{asynchron} 36 | \item Sie laufen direkt auf dem System, nicht in einer Shell 37 | (wenn nicht anders festgelegt) 38 | \item Verf\"ugbare Programme h\"angen vom System ab, auf dem sie ausgef\"uhrt werden 39 | \item Der Aufruf ist allgemeing\"ultig, die Bibliothek verwandelt den 40 | Aufruf unter Windows in einen kompatiblen \texttt{CreateProcess()} String 41 | \end{itemize} 42 | \end{frame} 43 | 44 | 45 | \section{Konstanten} 46 | \subsection{File Descriptoren} 47 | \begin{frame}{File Descriptoren} 48 | \begin{description} 49 | \item[DEVNULL] Der systeminterne 'M\"ulleimer' 50 | \item[PIPE] Die Verbindung zwischen zwei Prozessen 51 | \item[STDOUT] Die Standardausgabe oder der laufende Prozess 52 | \end{description} 53 | \end{frame} 54 | 55 | \subsection{Exceptions} 56 | \begin{frame}[fragile]{Exceptions} 57 | \begin{description} 58 | \item[\texttt{SubprocessError}] Der Standardfehler dieses Moduls 59 | \item[\texttt{TimeoutError}] Ein Timeout ist aufgetreten 60 | \item[\texttt{CalledProcessError}] Der Subprozess endete auf eine unerwartete Art 61 | \end{description} 62 | \end{frame} 63 | 64 | 65 | \section{Popen Klasse} 66 | \begin{frame}[fragile]{Die Popen Klasse} 67 | Die \texttt{Popen} Klasse bildet die Basis des Moduls \texttt{subprocess}. \\ 68 | Die Funktionssignatur sieht wie folgt aus: 69 | \lstinputlisting{resources/08_process/popen_call.py} 70 | \end{frame} 71 | 72 | \subsection{Wichtige Argumente} 73 | \begin{frame}[fragile]{Einige wichtige Argumente} 74 | \begin{description} 75 | \item[\texttt{args}] Die aufzurufenden Argumente. Sollten vom Typ 76 | \alert{tuple} oder \alert{list} sein. Im Prinzip splittet man den 77 | Konsolenbefehl an den Leerzeichen: \\ 78 | \texttt{ls -A *.md} entspricht \texttt{['ls', '-A', '*.md']} 79 | \item[\texttt{shell}] F\"uhrt den Befehl in einer Shell aus. 80 | Sollte \texttt{False} sein (Standard), sonst ist der Aufruf unsicher. 81 | \item[\texttt{stdout}] zusammen mit \texttt{stdin} und \texttt{stderr} die Input- und 82 | Output-Verbindungen des Subprozesses \\ 83 | (hier sind \texttt{DEVNULL}, \texttt{PIPE} und \texttt{STDOUT} n\"utzlich) 84 | \item[\texttt{env}] Umgebungsvariablen des Kindprozesses. Standard ist ein 85 | Subset von \texttt{os.environ} (dem Python Prozess Environment) 86 | \item[\texttt{cwd}] Das Arbeitsverzeichnis des Subprozesses 87 | \end{description} 88 | \end{frame} 89 | 90 | 91 | \section{Popen Objekte} 92 | \begin{frame}{Popen Objekte} 93 | Wenn Popen instanziiert wird, wird der darin enthaltene Prozess gestartet und 94 | das zur\"uckgegebene \texttt{Popen} Objekt enth\"alt Informationen \"uber den 95 | laufenden Prozess. 96 | \end{frame} 97 | 98 | \subsection{Informationen sammeln} 99 | \begin{frame}[fragile]{Informationen sammeln} 100 | \begin{itemize} 101 | \item \texttt{process.args} \\ 102 | Gibt die Argumente zur\"uck, mit denen der Prozess aufgerufen wurde. 103 | \item \texttt{obj.stdout}, \texttt{obj.stdin}, \texttt{obj.stderr} \\ 104 | Input- und Output-Verbindungen, die beim Start gesetzt wurden 105 | \item \texttt{process.pid} \\ 106 | Vom System zugewiesene \textit{Prozess ID}. 107 | \item \texttt{process.poll()} \\ 108 | Pr\"uft, ob der Prozess beendet wurde. Gibt den \textit{R\"uckgabewert} 109 | des Prozesses zur\"uck oder \texttt{None}, wenn der Prozess noch l\"auft. 110 | \item \texttt{process.returncode} \\ 111 | Der R\"uckgabewert von \texttt{process.poll()} (der R\"uckgabewert des Prozesses) 112 | \end{itemize} 113 | \end{frame} 114 | 115 | \subsection{Interaktion mit dem Prozess} 116 | \begin{frame}[fragile]{Interaktion mit dem Prozess} 117 | \begin{itemize} 118 | \item \texttt{process.wait(timeout=None)} \\ 119 | Wartet \textit{timeout} Sekunden auf die Terminierung des Prozesses 120 | (wartet unendlich lang, wenn timeout \textit{None} ist). \\ 121 | Wirft nach Ablauf von \textit{timeout} eine \texttt{TimeoutExpired} Exception. 122 | \item \texttt{process.send\_signal(signal)} \\ 123 | Sendet das Signal \textit{signal} an den Prozess (z.B. \texttt{SIGTERM}). 124 | \item \texttt{process.communicate(input=None, timeout=None)} \\ 125 | Schreibt die Daten aus \textit{input} in den Standardinput (\texttt{stdin}) 126 | des Prozesses (wenn stdin PIPE ist), wartet auf die Terminierung 127 | des Prozesses und liest die Daten, die der Prozess in \texttt{stdout} 128 | geschrieben hat (wenn stdout PIPE ist). \textit{timeout} funktioniert wie oben. 129 | \end{itemize} 130 | \end{frame} 131 | 132 | \begin{frame}[fragile]{Interaktion mit dem Prozess} 133 | \begin{itemize} 134 | \item \texttt{process.terminate()} \\ 135 | Sendet ein Terminationssignal an den Prozess (\texttt{SIGTERM}). 136 | \item \texttt{process.kill()} \\ 137 | Erzwingt die Beendigung des Prozesses (\texttt{SIGKILL}). 138 | \end{itemize} 139 | \end{frame} 140 | 141 | \subsection{Nutzung des Kontextmanagers} 142 | \begin{frame}{Popen im Kontextmanager} 143 | Popen kann mit dem Kontextmanager verwendet werden (siehe \textit{File Handling}). \\ 144 | Der Code daf\"ur w\"urde wie folgt aussehen: 145 | \lstinputlisting{resources/08_process/context_mgr.py} 146 | \end{frame} 147 | 148 | \section{N\"utzliche Funktionen} 149 | \begin{frame}[fragile]{N\"utzliche Funktionen} 150 | \texttt{subprocess} enth\"alt einige Kurzfassungen f\"ur h\"aufig genutzte Arbeitsabl\"aufe. 151 | Intern rufen diese allerdings auch nur \texttt{Popen} auf. 152 | \end{frame} 153 | 154 | \begin{frame}[fragile]{run} 155 | Die wohl n\"utzlichste Funktion ist \texttt{subprocess.run()}: 156 | \lstinputlisting[lastline=2]{resources/08_process/defs.py} 157 | \begin{itemize} 158 | \item eingef\"uhrt in Python 3.5 159 | \item ruft durch \texttt{args} definierten Prozess auf 160 | \item wartet auf Beendigung des Prozesses (wenn \textit{timeout} \texttt{None} ist) 161 | \item gibt ein \texttt{CompletedProcess} Objekt zur\"uck 162 | \item \textbf{Beachte:} Einsatz eines unbenannten Aggregators 163 | \end{itemize} 164 | \end{frame} 165 | 166 | \begin{frame}[fragile]{CompletedProcess Objekt} 167 | Ist der Rückgabewert von \texttt{run()}, der zur\"uckgegeben wird, wenn der Prozess beendet wurde. 168 | Enth\"alt folgende Eigenschaften: \\[.25cm] 169 | \begin{description} 170 | \item[\texttt{args}] Argumente, mit denen der Prozess aufgerufen wurde. 171 | \item[\texttt{returncode}] R\"uckgabewert des Prozesses 172 | \item[\texttt{stdout}] Ausgabe des Prozesses 173 | \item[\texttt{stderr}] stderr Output des Prozesses \\[.5cm] 174 | \end{description} 175 | Au{\ss}erdem gibt es die Funktion \texttt{check\_returncode()}, die einen \texttt{CalledProcessError} 176 | beim Aufruf wirft, wenn der R\"uckgabewert nicht 0 ist. 177 | \end{frame} 178 | 179 | \begin{frame}[fragile]{call} 180 | \lstinputlisting[firstline=5, lastline=6]{resources/08_process/defs.py} 181 | \begin{itemize} 182 | \item Ruft einen Prozess auf, wartet auf Terminierung 183 | \item gibt Returncode des Prozesses zur\"uck \\[.5cm] 184 | \end{itemize} 185 | Diese Funktion macht das selbe, wie \\ 186 | \hspace*{1.5cm}\texttt{run(...).returncode}, \\ 187 | nur dass \textit{check} und \textit{input} nicht unterst\"utzt werden. 188 | \end{frame} 189 | 190 | \begin{frame}[fragile]{check\_call} 191 | Argumente entsprechen den Argumenten von \texttt{call()}. 192 | \begin{itemize} 193 | \item Ruft Prozess auf, wartet auf Terminierung 194 | \item gibt nichts zur\"uck, wenn Ausf\"uhrung erfolgreich (Returncode == 0) 195 | \item wenn Aufruf nicht erfolgreich, wird \texttt{CalledProcessError} geworfen \\[.5cm] 196 | \end{itemize} 197 | Diese Funktion macht das selbe, wie \\ 198 | \hspace*{1.5cm}\texttt{run(..., check=True)}, \\ 199 | nur dass \textit{input} nicht unterst\"utzt wird. 200 | \end{frame} 201 | 202 | \begin{frame}[fragile]{check\_output} 203 | \lstinputlisting[firstline=9]{resources/08_process/defs.py} 204 | \begin{itemize} 205 | \item f\"uhrt Kommando aus und gibt den Prozessoutput zur\"uck 206 | \item wirft ebenfalls \texttt{CalledProcessError}, wenn der Returncode nicht 0 ist \\[.5cm] 207 | \end{itemize} 208 | Diese Funktion macht das selbe, wie \\ 209 | \hspace*{1.5cm}\texttt{run(..., check=True, stdout=PIPE).stdout} 210 | \end{frame} 211 | 212 | % nothing to do from here on 213 | \end{document} 214 | -------------------------------------------------------------------------------- /latex/slides/09_web_client.tex: -------------------------------------------------------------------------------- 1 | % The Slide Definitions 2 | \input{../templates/course_definitions} 3 | 4 | % Author and Course information 5 | \input{../templates/course_information} 6 | 7 | % Presentation title 8 | % TODO Change the topic of the lesson 9 | \title{Python als Webclient} 10 | \date{\today} 11 | 12 | 13 | \begin{document} 14 | 15 | \maketitle 16 | 17 | \begin{frame}{Gliederung} 18 | \setbeamertemplate{section in toc}[sections numbered] 19 | \tableofcontents 20 | \end{frame} 21 | 22 | 23 | \begin{frame}[fragile]{Das Package urllib} 24 | Das Package \texttt{urllib} ist eine nützliche Sammlung mehrerer Module 25 | zur Arbeit mit URLs. 26 | \end{frame} 27 | 28 | 29 | \section{urllib.request} 30 | \begin{frame}[fragile]{urllib.request} 31 | Das Modul \alert{\texttt{urllib.request}} enthält Funktionen und Klassen, welche 32 | beim Öffnen von URLs (vor allem über HTTP) helfen. \\[.5cm] 33 | Unterstützt werden: 34 | \begin{itemize} 35 | \item verschiedene Authentifizierungsarten 36 | \item Weiterleitungen 37 | \item Cookies 38 | \item und mehr... 39 | \end{itemize} 40 | \end{frame} 41 | 42 | \subsection{Öffnen einer URL} 43 | \begin{frame}[fragile]{Öffnen einer URL} 44 | Das Öffnen einer URL wird über die Funktion \alert{\texttt{urlopen()}} realisiert: 45 | \lstinputlisting[lastline=5]{resources/09_web_client/urllib_calls.py} 46 | \end{frame} 47 | 48 | \begin{frame}[fragile]{Öffnen einer URL} 49 | \begin{description} 50 | \item[\textbf{url}] ein String für simple URLs oder ein \texttt{Request} Objekt für komplexere Anfragen 51 | \item[\textbf{data}] Daten, die an den Server gesendet werden sollen. \\ 52 | vom Typ \texttt{bytes} oder ein Iterable von \texttt{bytes} Objekten \\[.75cm] 53 | \end{description} 54 | \textbf{Rückgabewerte} 55 | \begin{description} 56 | \item bei URLs mit http-Requests \\ 57 | \hspace*{1cm}\texttt{httplib.client.HTTPResponse} Objekt 58 | \item bei ftp, file und data \\ 59 | \hspace*{1cm}\texttt{urllib.addinfourl} Objekt 60 | \end{description} 61 | \end{frame} 62 | 63 | \subsection{Request Klasse} 64 | \begin{frame}{Request Klasse} 65 | Um komplexere Anfragen stellen zu können, kann man Request Objekte verwenden: 66 | \lstinputlisting[firstline=8, lastline=10]{resources/09_web_client/urllib_calls.py} 67 | \end{frame} 68 | 69 | \begin{frame}{Request Klasse} 70 | \begin{description} 71 | \item[\textbf{url}] muss String mit gültiger URl sein 72 | \item[\textbf{data}] wie bei \textit{urlopen} 73 | \item[\textbf{headers}] \texttt{dict} mit \texttt{\{Header-Name : Header-Value, ...\}} oder \\ 74 | \texttt{list} von Tupeln mit \texttt{[(Header-Name, Header-Value), ...]} 75 | \item[\textbf{method}] String, der Art des HTTP Request angibt (\texttt{HEAD}, \texttt{GET}, \texttt{POST}, ...) 76 | \end{description} 77 | \end{frame} 78 | 79 | \begin{frame}{Beispiel} 80 | \lstinputlisting{resources/09_web_client/req_example.py} \ \\[.5cm] 81 | Die Request Klasse kann man Verwenden zum: 82 | \begin{itemize} 83 | \item Kontrollieren der gesendeten Header \textit{(z.B. Content-Type oder User-Agent)} 84 | \item Kontrollieren der Method \texttt{POST}, \texttt{PUT} oder \texttt{HEAD} 85 | % TODO 86 | \end{itemize} 87 | \end{frame} 88 | 89 | \subsection{HTTPResponse Klasse} 90 | \begin{frame}[fragile]{HTTPResponse Klasse} 91 | Objekte dieser Klasse werden nicht direkt vom User erstellt. 92 | \lstinputlisting[firstline=13]{resources/09_web_client/urllib_calls.py} \ \\[.5cm] 93 | Klasse enthält Funktionen und Variablen wie: 94 | \begin{itemize} 95 | \item \texttt{read()} - gibt zurückgelieferten Inhalt zurück 96 | \item \texttt{getheader()} oder \texttt{getheaders()} liefert einen/alle Header zurück 97 | \item \texttt{status} gibt den HTTP Statuscode zurück 98 | \item \texttt{version} gibt die HTTP Version zurück 99 | \end{itemize} 100 | \end{frame} 101 | 102 | 103 | \section{Andere Module} 104 | \begin{frame}[fragile]{Andere Module} 105 | Das Package \alert{\texttt{urllib}} enthält au{\ss}erdem folgende Module: 106 | \begin{itemize} 107 | \item \texttt{urllib.error} \ \\ 108 | Enthält Exceptions, die von \texttt{urllib.request} geworfen werden. 109 | \item \texttt{urllib.parse} \ \\ 110 | Zum Parsen von URLs. 111 | \item \texttt{urllib.robotparse} \ \\ 112 | Zum Parsen der \textit{robots.txt} von Webseiten. 113 | \end{itemize} 114 | \end{frame} 115 | 116 | 117 | \section{Das Requests-Modul} 118 | \subsection{Installation} 119 | \begin{frame}{Das Requests Modul} 120 | Das Requests Modul ist eine gute und für Menschen verständliche Alternative 121 | zu \texttt{urllib.requests}, das HTTP Requests vereinfacht. \\[.75cm] 122 | 123 | Das Requests Package lässt sich ganz einfach über \textbf{pip} installieren: \\ 124 | \texttt{pip install requests} 125 | \end{frame} 126 | 127 | \begin{frame}{Beispiel} 128 | \lstinputlisting{resources/09_web_client/requests_example.py} \ \\[.5cm] 129 | Ruft die API-Seite von \textbf{GitHub} auf und authentifiziert sich mit Nutzername und Passwort. 130 | \end{frame} 131 | 132 | % nothing to do from here on 133 | \end{document} 134 | -------------------------------------------------------------------------------- /latex/slides/11_smtplib.tex: -------------------------------------------------------------------------------- 1 | % The Slide Definitions 2 | \input{../templates/course_definitions} 3 | 4 | % Author and Course information 5 | \input{../templates/course_information} 6 | 7 | % Presentation title 8 | % TODO Change the topic of the lesson 9 | \title{Mails in Python senden} 10 | \date{\today} 11 | 12 | 13 | \begin{document} 14 | 15 | \maketitle 16 | 17 | \begin{frame}{Gliederung} 18 | \setbeamertemplate{section in toc}[sections numbered] 19 | \tableofcontents 20 | \end{frame} 21 | 22 | \begin{frame} 23 | Die folgenden Folien enthalten eine praktische Anleitung zum Senden von Mails in Python. 24 | \end{frame} 25 | 26 | 27 | \section{Grundlagen: Mails senden} 28 | \subsection{Das Modul \texttt{smtplib}} 29 | \begin{frame}[fragile]{Das Modul \texttt{smtplib}} 30 | Das Modul \texttt{\alert{smtplib}} definiert eine SMTP\textbf{*}-Client Session, die genutzt werden kann, um von jedem beliebigen, internetf\"ahigen Ger\"at E-Mails zu verschicken. \\[1cm] 31 | 32 | \textbf{*}\textit{SMTP} steht für \textbf{S}imple \textbf{M}ail \textbf{T}ransfer 33 | \textbf{P}rotocol und ist das Standard-Protokoll zum E-Mail Versand. 34 | \end{frame} 35 | 36 | \begin{frame}[fragile]{Verbindung zum Server} 37 | Die smtplib kann sich zu einem SMTP-Server verbinden\\[.5cm] 38 | \lstinputlisting[firstline=3, lastline=3]{resources/11_sendmail/defs.py} 39 | 40 | \ \\[.25cm] 41 | Der Server kann zum einen als einheitlicher \texttt{String} (inkl. Port) oder einzeln als \texttt{host} und \texttt{port} angeben werden. 42 | \end{frame} 43 | 44 | \begin{frame}[fragile]{Login auf dem Server} 45 | Heutzutage arbeiten die meisten SMTP-Server mit \texttt{TLS}, um eine sichere Verbindung zu gewährleisten. Diese muss mithilfe der Methode \texttt{\alert{starttls()}} hergestellt werden.\\[.25cm] 46 | Der eigentliche Login erfolgt im Anschluss durch:\\[.25cm] 47 | \lstinputlisting[firstline=5, lastline=5]{resources/11_sendmail/defs.py} 48 | \ \\[.25cm] 49 | Der Parameter \texttt{initial\_response\_ok} kann in unserem Fall vernachlässigt werden. 50 | \end{frame} 51 | 52 | \begin{frame}[fragile]{Senden der Mail} 53 | Das tatsächliche Versenden der Mail funktioniert dann mit folgender Methode:\\[.25cm] 54 | \lstinputlisting[firstline=7]{resources/11_sendmail/defs.py} 55 | \ \\[.25cm] 56 | Jedoch l\"asst sich das ganze auch mit einem \texttt{MIME}-Objekt vereinfachen, auf das später noch eingegangen wird. \\ 57 | Dieses wird mit \texttt{\alert{send\_message()}} versendet. 58 | \end{frame} 59 | 60 | \begin{frame}{Schließen der Verbindung} 61 | Zum Schluss darf nicht vergessen werden, die Verbindung zum SMTP-Server wieder zu schließen.\\ 62 | Dies geschieht mit der Methode \texttt{\alert{quit()}} oder man stellt die Verbindung mithilfe eines \textit{Filehandlers} her. 63 | \end{frame} 64 | 65 | \begin{frame}[fragile]{Die vollst\"andige Serverkommunikation} 66 | \lstinputlisting[linerange={3-3,19-34}]{resources/11_sendmail/mailer.py} 67 | %\ \\[1cm] 68 | Auf \texttt{buildmessage()} wird im folgenden Teil eingegangen. 69 | \end{frame} 70 | 71 | \section{Komplexere Mails senden} 72 | \subsection{Das Modul \texttt{email}} 73 | \begin{frame}[fragile]{Das Modul \texttt{email}} 74 | Um mehr Möglichkeiten zur Gestaltung der E-Mail zu haben, lohnt sich die Verwendung des Moduls \texttt{email}.\\[.5cm] 75 | Mit \texttt{\alert{email.mime}} lassen sich Emails individuell bauen und zusammensetzen. Außerdem kann man mehrteilige Mails und Mails mit Anhängen (z.B. Bildern) erstellen. 76 | \end{frame} 77 | 78 | \begin{frame}[fragile]{Die Klasse \texttt{MIMEText}} 79 | Die Klasse \texttt{email.mime.text.MIMEText()} erstellt ein MIME Objekt, welches hautps\"achlich aus Text besteht und einfach dem SMTP-Objekt \"ubergeben werden kann: \\ \ \\ 80 | \lstinputlisting[lastline=1]{resources/11_sendmail/defs.py} \ \\ 81 | 82 | \begin{description} 83 | \item[\_text] Ein String, der den Inhalt der Nachricht enth\"alt. 84 | \item[\_subtype] Der Untertyp des Objekts, per default \texttt{plain} 85 | \item[charset] Der Zeichensatz, der zur Kodierung der Zeichen verwendet werden soll. Standardm\"a\ss{}ig \texttt{us-ascii} oder \texttt{utf8}, abh\"angig von dem eingegebenen Text. 86 | \end{description} 87 | \end{frame} 88 | 89 | \begin{frame}[fragile]{Die Meta-Felder} 90 | Wenn das \texttt{MIMEText} Objekt instanziiert ist, muss dieses mit weiteren Informationen erg\"anzt werden: 91 | \lstinputlisting[firstline=10,lastline=15]{resources/11_sendmail/mailer.py} 92 | \begin{description} 93 | \item[From] Daten des Absenders (nur Mail oder Name und Mail) 94 | \item[To] Daten des Empfängers (nur Mail oder Name und Mail) 95 | \item[Subject] Betreff der Mail 96 | \end{description} 97 | Die Message l\"asst sich au\ss{}erdem noch um einen \texttt{Cc} oder einen \texttt{Bcc} erweitern. 98 | \end{frame} 99 | 100 | \begin{frame}{Das fertige Mail-Skript} 101 | \lstinputlisting[firstline=4,lastline=17]{resources/11_sendmail/mailer.py} 102 | \end{frame} 103 | 104 | % nothing to do from here on 105 | \end{document} 106 | -------------------------------------------------------------------------------- /latex/slides/12_curses.tex: -------------------------------------------------------------------------------- 1 | % The Slide Definitions 2 | \input{../templates/course_definitions} 3 | 4 | % Author and Course information 5 | \input{../templates/course_information} 6 | 7 | % Presentation title 8 | \title{\texttt{ncurses} in Python} 9 | \date{\today} 10 | 11 | 12 | \begin{document} 13 | 14 | \maketitle 15 | 16 | \begin{frame}{Gliederung} 17 | \setbeamertemplate{section in toc}[sections numbered] 18 | \tableofcontents 19 | \end{frame} 20 | 21 | 22 | 23 | \section{Das Modul \texttt{curses}} 24 | 25 | \begin{frame}{Das Modul \texttt{curses}} 26 | \texttt{\alert{curses}} bietet ein Interface für die \glqq{}curses\grqq{}-Bibliothek, den de-facto Standard für fortgeschrittenes Terminal Handling. 27 | \end{frame} 28 | 29 | \begin{frame}{Das Modul \texttt{curses}} 30 | \begin{itemize} 31 | \item curses ist vor allem in Unix-Umgebungen weit verbreitet 32 | \item dieses Modul wurde auf die API von \emph{ncurses}, einer Open-Source Library für curses, zugeschnitten und funktioniert nur unter Linux und BSD Varianten von Unix 33 | \end{itemize} 34 | \end{frame} 35 | 36 | \begin{frame}{Mitgelieferte Submodule} 37 | \begin{description} 38 | \item [\texttt{curses.ascii}] zur Arbeit mit ASCII-kodierten Zeichen 39 | \item [\texttt{curses.panel}] Support für Panels, also mehrere Fenster übereinander (Fenster mit Ebenen) 40 | \item [\texttt{curses.textpad}] Widget zum editieren von Text mit \emph{emacs}-artigen Key-Bindings 41 | \end{description} 42 | \end{frame} 43 | 44 | 45 | \section{Erstellen eines simplen Fensters} 46 | 47 | \subsection{Grundlegende Funktionen} 48 | 49 | \begin{frame}{Grundlegende Funktionen} 50 | Zum Erstellen eines \texttt{curses}-Fensters benutzt man den Befehl 51 | 52 | \lstinputlisting[lastline=1]{resources/12_curses/functions.py} 53 | 54 | \begin{itemize} 55 | \item instanziiert die Bibliothek, gibt ein \texttt{WindowObject} zurück, welches den gesamten Screen repräsentiert 56 | \item Fehler beim Terminal öffnen können zum Beenden des Interpreters führen! 57 | \end{itemize} 58 | \end{frame} 59 | 60 | \begin{frame}{Grundlegende Funktionen} 61 | \lstinputlisting[firstline=3, lastline=3]{resources/12_curses/functions.py} 62 | 63 | \begin{itemize} 64 | \item deinitialisiert Bibliothek 65 | \item führt Terminal in normalen Zustand zurück 66 | \end{itemize} 67 | \end{frame} 68 | 69 | \begin{frame} 70 | \texttt{curses} liefert einen eigenen Wrapper zum Starten und Beenden: 71 | 72 | \lstinputlisting[firstline=5, lastline=5]{resources/12_curses/functions.py} 73 | 74 | \begin{itemize} 75 | \item setzt nützliche Standards, initialisiert curses und ruft \emph{func} auf 76 | \item Wrapper fängt Exceptions, stellt Terminal wieder her und wirft Exception erneut 77 | \item \emph{func} muss \alert{\texttt{stdscr}} als erstes Argument akzeptieren (für das \texttt{WindowObject}) 78 | \end{itemize} 79 | \end{frame} 80 | 81 | 82 | \subsection{Darstellen von Symbolen} 83 | 84 | \begin{frame}{Darstellen von Symbolen} 85 | Zur Darstellung einzelner Symbole verwendet man \texttt{addch}: 86 | 87 | \lstinputlisting[firstline=7, lastline=8]{resources/12_curses/functions.py} 88 | 89 | \begin{description} 90 | \item [\texttt{ch}] zu schreibendes ASCII-Zeichen (im ASCII-Format!) \\ Zum konvertieren ggf. auf \texttt{ord()} zurück greifen. 91 | \item [\texttt{y, x}] Koordinaten, an die das Zeichen geschrieben wird. Beachte invertierte Reihenfolge! 92 | \item [\texttt{attr}] zu setzende Attribute 93 | \end{description} 94 | \end{frame} 95 | 96 | \begin{frame}{Darstellen von Symbolen} 97 | Zum Darstellen eines Strings existiert die Funktion \texttt{addstr()}: 98 | 99 | \lstinputlisting[firstline=10, lastline=11]{resources/12_curses/functions.py} 100 | 101 | \begin{itemize} 102 | \item fügt ab \texttt{(y, x)} den gegebenen String ein 103 | \item überschreibt alle vorher vorhandenen Zeichen 104 | \end{itemize} 105 | \end{frame} 106 | 107 | 108 | \begin{frame}{Zeichen entfernen} 109 | \lstinputlisting[firstline=13, lastline=15]{resources/12_curses/functions.py} 110 | 111 | \begin{itemize} 112 | \item Funktionen zum löschen einzelner Zeichen, einer ganzen Zeile oder dem gesamten Fenster 113 | \end{itemize} 114 | \end{frame} 115 | 116 | 117 | \subsection{Allgemeine Hinweise} 118 | 119 | \begin{frame}{Allgemeine Hinweise} 120 | \begin{itemize} 121 | \item Werden bei Funktionen \texttt{x} und \texttt{y} weg gelassen und sind optional, wird die Funktion an der aktuellen Cursorstelle ausgeführt. 122 | \item Beachte die invertierte Zählweise! 123 | \begin{itemize} 124 | \item Punkt (0, 0) liegt oben links in der Ecke vom Terminal 125 | \item x zählt von da nach rechts aufwärts 126 | \item y zählt von da nach unten aufwärts 127 | \end{itemize} 128 | \end{itemize} 129 | \end{frame} 130 | 131 | \section{Arbeiten mit \texttt{curses.textpad}} 132 | \begin{frame}{\texttt{rectangle}} 133 | \lstinputlisting[firstline=17, lastline=17]{resources/12_curses/functions.py} 134 | \begin{itemize} 135 | \item erzeugt im WindowObject \texttt{win} ein Rechteck 136 | \item Anfangspunkt ist (\texttt{ulx}, \texttt{uly}) (ul $\hat=$ upper left corner) 137 | \item Endpunkt ist (\texttt{lrx}, \texttt{lry}) (lr $\hat=$ lower right corner) 138 | \end{itemize} 139 | \end{frame} 140 | 141 | \begin{frame}{\texttt{Textbox}} 142 | \lstinputlisting[firstline=19, lastline=23]{resources/12_curses/functions.py} 143 | \begin{itemize} 144 | \item Eine \texttt{Textbox} wird mit einem WindowObject erstellt und hat diese drei Funktionen 145 | \item \texttt{edit()} \glqq{}Editormodus\grqq{} wobei \texttt{validator} eine Funktion ist 146 | \item \texttt{do\_command()} f\"uhrt einen Befehl aus \href{http://bit.ly/29sJ8QJ}{(Link hier)} 147 | \item \texttt{gather()} gibt den Inhalt der Textbox zur\"uck 148 | \end{itemize} 149 | \end{frame} 150 | 151 | 152 | \end{document} 153 | -------------------------------------------------------------------------------- /latex/slides/beamercolorthememetropolis.sty: -------------------------------------------------------------------------------- 1 | %% 2 | %% This is file `beamercolorthememetropolis.sty', 3 | %% generated with the docstrip utility. 4 | %% 5 | %% The original source files were: 6 | %% 7 | %% beamercolorthememetropolis.dtx (with options: `package') 8 | %% --------------------------------------------------------------------------- 9 | %% Copyright 2015 Matthias Vogelgesang and the LaTeX community. A full list of 10 | %% contributors can be found at 11 | %% 12 | %% https://github.com/matze/mtheme/graphs/contributors 13 | %% 14 | %% and the original template was based on the HSRM theme by Benjamin Weiss. 15 | %% 16 | %% This work is licensed under a Creative Commons Attribution-ShareAlike 4.0 17 | %% International License (https://creativecommons.org/licenses/by-sa/4.0/). 18 | %% --------------------------------------------------------------------------- 19 | \NeedsTeXFormat{LaTeX2e} 20 | \ProvidesPackage{beamercolorthememetropolis}[2016/02/21 Metropolis color theme] 21 | \RequirePackage{pgfopts} 22 | \pgfkeys{ 23 | /metropolis/color/block/.cd, 24 | .is choice, 25 | transparent/.code=\metropolis@block@transparent, 26 | fill/.code=\metropolis@block@fill, 27 | } 28 | \pgfkeys{ 29 | /metropolis/color/background/.cd, 30 | .is choice, 31 | dark/.code=\metropolis@colors@dark, 32 | light/.code=\metropolis@colors@light, 33 | } 34 | \newcommand{\metropolis@color@setdefaults}{ 35 | \pgfkeys{/metropolis/color/.cd, 36 | background=light, 37 | block=transparent, 38 | } 39 | } 40 | \definecolor{mDarkBrown}{HTML}{604c38} 41 | \definecolor{mDarkTeal}{HTML}{23373b} 42 | \definecolor{mLightBrown}{HTML}{EB811B} 43 | \definecolor{mLightGreen}{HTML}{14B03D} 44 | \newcommand{\metropolis@colors@dark}{ 45 | \setbeamercolor{normal text}{% 46 | fg=black!2, 47 | bg=mDarkTeal 48 | } 49 | } 50 | \newcommand{\metropolis@colors@light}{ 51 | \setbeamercolor{normal text}{% 52 | fg=mDarkTeal, 53 | bg=black!2 54 | } 55 | } 56 | \setbeamercolor{alerted text}{% 57 | fg=mLightBrown 58 | } 59 | \setbeamercolor{example text}{% 60 | fg=mLightGreen 61 | } 62 | \setbeamercolor{titlelike}{use=normal text, parent=normal text} 63 | \setbeamercolor{author}{use=normal text, parent=normal text} 64 | \setbeamercolor{date}{use=normal text, parent=normal text} 65 | \setbeamercolor{institute}{use=normal text, parent=normal text} 66 | \setbeamercolor{structure}{use=normal text, fg=normal text.fg} 67 | \setbeamercolor{palette primary}{% 68 | use=normal text, 69 | fg=normal text.bg, 70 | bg=normal text.fg 71 | } 72 | \setbeamercolor{frametitle}{% 73 | use=palette primary, 74 | parent=palette primary 75 | } 76 | \setbeamercolor{progress bar}{% 77 | use=alerted text, 78 | fg=alerted text.fg, 79 | bg=alerted text.fg!50!black!30 80 | } 81 | \setbeamercolor{title separator}{ 82 | use=progress bar, 83 | parent=progress bar 84 | } 85 | \setbeamercolor{progress bar in head/foot}{% 86 | use=progress bar, 87 | parent=progress bar 88 | } 89 | \setbeamercolor{progress bar in section page}{ 90 | use=progress bar, 91 | parent=progress bar 92 | } 93 | \newcommand{\metropolis@block@transparent}{ 94 | \setbeamercolor{block title}{% 95 | use=normal text, 96 | fg=normal text.fg, 97 | bg= 98 | } 99 | \setbeamercolor{block body}{ 100 | bg= 101 | } 102 | } 103 | \newcommand{\metropolis@block@fill}{ 104 | \setbeamercolor{block title}{% 105 | use=normal text, 106 | fg=normal text.fg, 107 | bg=normal text.bg!80!fg 108 | } 109 | \setbeamercolor{block body}{ 110 | use={block title, normal text}, 111 | bg=block title.bg!50!normal text.bg 112 | } 113 | } 114 | \setbeamercolor{block title alerted}{% 115 | use={block title, alerted text}, 116 | bg=block title.bg, 117 | fg=alerted text.fg 118 | } 119 | \setbeamercolor{block title example}{% 120 | use={block title, example text}, 121 | bg=block title.bg, 122 | fg=example text.fg 123 | } 124 | \setbeamercolor{block body alerted}{use=block body, parent=block body} 125 | \setbeamercolor{block body example}{use=block body, parent=block body} 126 | \setbeamercolor{footnote}{fg=normal text.fg!90} 127 | \setbeamercolor{footnote mark}{fg=.} 128 | \metropolis@color@setdefaults 129 | \ProcessPgfPackageOptions{/metropolis/color} 130 | \mode 131 | \endinput 132 | %% 133 | %% End of file `beamercolorthememetropolis.sty'. 134 | -------------------------------------------------------------------------------- /latex/slides/beamercolorthemesolarized.sty: -------------------------------------------------------------------------------- 1 | % Beamer Color Theme using the Solarized Palette, 2 | % http://ethanschoonover.com/solarized. 3 | % 4 | % Copyright 2012 Jeffrey B. Arnold 5 | % 6 | % This program is free software: you can redistribute it and/or modify 7 | % it under the terms of the GNU General Public License as published by 8 | % the Free Software Foundation, either version 3 of the License, or 9 | % (at your option) any later version. 10 | % 11 | % This program is distributed in the hope that it will be useful, 12 | % but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | % MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | % GNU General Public License for more details. 15 | % 16 | % You should have received a copy of the GNU General Public License 17 | % along with this program. If not, see . 18 | 19 | \ProvidesPackage{beamercolorthemesolarized}[2013/10/11 1.0.1 Solarized color theme for beamer] 20 | \RequirePackage{etoolbox} 21 | \RequirePackage{kvoptions} 22 | 23 | %% This is ugly. First time using options and conditionals in LaTeX 24 | \SetupKeyvalOptions{ 25 | family=solarized, 26 | prefix=solarized@, 27 | } 28 | \DeclareBoolOption[false]{dark} 29 | \DeclareComplementaryOption{light}{dark} 30 | \DeclareStringOption[yellow]{accent}[yellow] 31 | \ProcessKeyvalOptions* 32 | 33 | % Solarized palette 34 | \definecolor{solarizedBase03}{HTML}{002B36} 35 | \definecolor{solarizedBase02}{HTML}{073642} 36 | \definecolor{solarizedBase01}{HTML}{586e75} 37 | \definecolor{solarizedBase00}{HTML}{657b83} 38 | \definecolor{solarizedBase0}{HTML}{839496} 39 | \definecolor{solarizedBase1}{HTML}{93a1a1} 40 | \definecolor{solarizedBase2}{HTML}{EEE8D5} 41 | \definecolor{solarizedBase3}{HTML}{FDF6E3} 42 | \definecolor{solarizedYellow}{HTML}{B58900} 43 | \definecolor{solarizedOrange}{HTML}{CB4B16} 44 | \definecolor{solarizedRed}{HTML}{DC322F} 45 | \definecolor{solarizedMagenta}{HTML}{D33682} 46 | \definecolor{solarizedViolet}{HTML}{6C71C4} 47 | \definecolor{solarizedBlue}{HTML}{268BD2} 48 | \definecolor{solarizedCyan}{HTML}{2AA198} 49 | \definecolor{solarizedGreen}{HTML}{859900} 50 | 51 | % Set Accent color 52 | % Ugly. Should be done with a switch 53 | \ifdefstring{\solarized@accent}{yellow}{ 54 | \colorlet{solarizedAccent}{solarizedYellow} 55 | }{} 56 | \ifdefstring{\solarized@accent}{orange}{ 57 | \colorlet{solarizedAccent}{solarizedOrange} 58 | }{} 59 | \ifdefstring{\solarized@accent}{red}{ 60 | \colorlet{solarizedAccent}{solarizedRed} 61 | }{} 62 | \ifdefstring{\solarized@accent}{magenta}{ 63 | \colorlet{solarizedAccent}{solarizedMagenta} 64 | }{} 65 | \ifdefstring{\solarized@accent}{violet}{ 66 | \colorlet{solarizedAccent}{solarizedViolet} 67 | }{} 68 | \ifdefstring{\solarized@accent}{blue}{ 69 | \colorlet{solarizedAccent}{solarizedBlue} 70 | }{} 71 | \ifdefstring{\solarized@accent}{cyan}{ 72 | \colorlet{solarizedAccent}{solarizedCyan} 73 | }{} 74 | \ifdefstring{\solarized@accent}{green}{ 75 | \colorlet{solarizedAccent}{solarizedGreen} 76 | }{} 77 | 78 | %% Set base colors for dark or light versions 79 | %% Dark 80 | % Switch between light and dark themes using the method in the CSS 81 | % stylesheet http://ethanschoonover.com/solarized 82 | \ifboolexpe{ bool {solarized@dark}}{ 83 | \colorlet{solarizedRebase03}{solarizedBase03} 84 | \colorlet{solarizedRebase02}{solarizedBase02} 85 | \colorlet{solarizedRebase01}{solarizedBase01} 86 | \colorlet{solarizedRebase00}{solarizedBase00} 87 | \colorlet{solarizedRebase0}{solarizedBase0} 88 | \colorlet{solarizedRebase1}{solarizedBase1} 89 | \colorlet{solarizedRebase2}{solarizedBase2} 90 | \colorlet{solarizedRebase3}{solarizedBase3} 91 | }{ 92 | %% Light 93 | \colorlet{solarizedRebase03}{solarizedBase3} 94 | \colorlet{solarizedRebase02}{solarizedBase2} 95 | \colorlet{solarizedRebase01}{solarizedBase1} 96 | \colorlet{solarizedRebase00}{solarizedBase0} 97 | \colorlet{solarizedRebase0}{solarizedBase00} 98 | \colorlet{solarizedRebase1}{solarizedBase01} 99 | \colorlet{solarizedRebase2}{solarizedBase02} 100 | \colorlet{solarizedRebase3}{solarizedBase03} 101 | } 102 | 103 | \mode 104 | 105 | \setbeamercolor{normal text}{fg=solarizedRebase0, bg=solarizedRebase03} 106 | \setbeamercolor{alerted text}{fg=solarizedAccent} 107 | % based css pre element 108 | \setbeamercolor{example text}{fg=solarizedRebase1, bg=solarizedRebase02} 109 | 110 | % Header and footer from CSS 111 | \setbeamercolor{footline}{bg=solarizedRebase02,fg=solarizedRebase01} 112 | \setbeamercolor{headline}{bg=solarizedRebase01,fg=solarizedRebase1} 113 | 114 | % Titles 115 | \setbeamercolor*{titlelike}{fg=solarizedAccent} 116 | \setbeamercolor*{frametitle}{fg=solarizedAccent} 117 | \setbeamercolor*{title}{fg=solarizedAccent} 118 | 119 | % Structure elements use css style for header 120 | \setbeamercolor*{structure}{bg=solarizedRebase01, fg=solarizedRebase1} 121 | 122 | % Do not mess with subtle colors in palette. I don't like it. 123 | \setbeamercolor*{palette primary}{bg=solarizedRebase01, fg=solarizedRebase1} 124 | \setbeamercolor*{palette secondary}{bg=solarizedRebase01, fg=solarizedRebase1} 125 | \setbeamercolor*{palette tertiary}{bg=solarizedRebase01, fg=solarizedRebase1} 126 | \setbeamercolor*{palette quaternary}{bg=solarizedRebase01, fg=solarizedRebase1} 127 | 128 | % Make Blocks slightly lighter/darker 129 | \setbeamercolor{block title}{fg=solarizedAccent, bg=solarizedRebase02} 130 | %\setbeamercolor{block title alerted}{} 131 | %\setbeamercolor{block title example}{} 132 | 133 | \setbeamercolor{block body}{parent=normal text, bg=solarizedRebase02} 134 | % \setbeamercolor{block body alerted}{} 135 | % \setbeamercolor{block body example}{} 136 | 137 | % same as footline 138 | % Set Sidebar and footline to use the css style for footer 139 | \setbeamercolor*{sidebar}{parent=headline} 140 | \setbeamercolor*{palette sidebar primary}{fg=solarizedRebase01, fg=solarizedRebase1} 141 | \setbeamercolor*{palette sidebar secondary}{fg=solarizedRebase01, fg=solarizedRebase1} 142 | \setbeamercolor*{palette sidebar tertiary}{fg=solarizedRebase01, fg=solarizedRebase1} 143 | \setbeamercolor*{palette sidebar quaternary}{fg=solarizedRebase01, fg=solarizedRebase1} 144 | 145 | % border-color for headings 146 | \setbeamercolor{separation line}{fg=solarizedRebase0} 147 | \setbeamercolor{fine separation line}{fg=solarizedRebase0} 148 | 149 | \setbeamercolor*{section in sidebar shaded}{parent=palette sidebar primary} 150 | % a.hover.navlink in CSS 151 | \setbeamercolor*{section in sidebar}{parent=palette sidebar primary, fg=solarizedRebase02} 152 | \setbeamercolor*{subsection in sidebar}{parent=section in sidebar} 153 | \setbeamercolor*{subsection in sidebar shaded}{parent=section in sidebar shaded} 154 | 155 | \mode 156 | 157 | -------------------------------------------------------------------------------- /latex/slides/beamerinnerthememetropolis.sty: -------------------------------------------------------------------------------- 1 | %% 2 | %% This is file `beamerinnerthememetropolis.sty', 3 | %% generated with the docstrip utility. 4 | %% 5 | %% The original source files were: 6 | %% 7 | %% beamerinnerthememetropolis.dtx (with options: `package') 8 | %% --------------------------------------------------------------------------- 9 | %% Copyright 2015 Matthias Vogelgesang and the LaTeX community. A full list of 10 | %% contributors can be found at 11 | %% 12 | %% https://github.com/matze/mtheme/graphs/contributors 13 | %% 14 | %% and the original template was based on the HSRM theme by Benjamin Weiss. 15 | %% 16 | %% This work is licensed under a Creative Commons Attribution-ShareAlike 4.0 17 | %% International License (https://creativecommons.org/licenses/by-sa/4.0/). 18 | %% --------------------------------------------------------------------------- 19 | \NeedsTeXFormat{LaTeX2e} 20 | \ProvidesPackage{beamerinnerthememetropolis}[2016/02/21 Metropolis inner theme] 21 | \RequirePackage{etoolbox} 22 | \RequirePackage{calc} 23 | \RequirePackage{pgfopts} 24 | \RequirePackage{tikz} 25 | \pgfkeys{ 26 | /metropolis/inner/sectionpage/.cd, 27 | .is choice, 28 | none/.code=\metropolis@sectionpage@none, 29 | simple/.code=\metropolis@sectionpage@simple, 30 | progressbar/.code=\metropolis@sectionpage@progressbar, 31 | } 32 | \newcommand{\metropolis@inner@setdefaults}{ 33 | \pgfkeys{/metropolis/inner/.cd, 34 | sectionpage=progressbar, 35 | } 36 | } 37 | \setbeamertemplate{title page}{ 38 | \begin{minipage}[b][\paperheight]{\textwidth} 39 | \ifx\inserttitlegraphic\@empty\else\usebeamertemplate*{title graphic}\fi 40 | \vfill% 41 | \ifx\inserttitle\@empty\else\usebeamertemplate*{title}\fi 42 | \ifx\insertsubtitle\@empty\else\usebeamertemplate*{subtitle}\fi 43 | \usebeamertemplate*{title separator} 44 | \ifx\beamer@shortauthor\@empty\else\usebeamertemplate*{author}\fi 45 | \ifx\insertdate\@empty\else\usebeamertemplate*{date}\fi 46 | \ifx\insertinstitute\@empty\else\usebeamertemplate*{institute}\fi 47 | \vfill 48 | \vspace*{1mm} 49 | \end{minipage} 50 | } 51 | \def\maketitle{% 52 | \ifbeamer@inframe 53 | \titlepage 54 | \else 55 | \frame[plain,noframenumbering]{\titlepage} 56 | \fi 57 | } 58 | \def\titlepage{% 59 | \usebeamertemplate{title page} 60 | } 61 | \setbeamertemplate{title graphic}{ 62 | \vbox to 0pt { 63 | \vspace*{2em} 64 | \inserttitlegraphic% 65 | }% 66 | \nointerlineskip% 67 | } 68 | \setbeamertemplate{title}{ 69 | \raggedright% 70 | \linespread{1.0}% 71 | \inserttitle% 72 | \par% 73 | \vspace*{0.5em} 74 | } 75 | \setbeamertemplate{subtitle}{ 76 | \insertsubtitle% 77 | \par% 78 | \vspace*{0.5em} 79 | } 80 | \setbeamertemplate{title separator}{ 81 | \begin{tikzpicture} 82 | \draw[fg, fill=fg] (0,0) rectangle (\textwidth, 0.4pt); 83 | \end{tikzpicture}% 84 | \par% 85 | } 86 | \setbeamertemplate{author}{ 87 | \vspace*{2em} 88 | \insertauthor% 89 | \par% 90 | \vspace*{0.25em} 91 | } 92 | \setbeamertemplate{date}{ 93 | \insertdate% 94 | \par% 95 | } 96 | \setbeamertemplate{institute}{ 97 | \vspace*{3mm} 98 | \insertinstitute% 99 | \par% 100 | } 101 | \newcommand{\metropolis@sectionpage@none}{ 102 | \AtBeginSection{ 103 | % intenionally empty 104 | } 105 | } 106 | \defbeamertemplate{section page}{simple}{ 107 | \centering 108 | \usebeamercolor[fg]{section title} 109 | \usebeamerfont{section title} 110 | \insertsectionhead\\ 111 | } 112 | \newcommand{\metropolis@sectionpage@simple}{ 113 | \setbeamertemplate{section page}[simple] 114 | \AtBeginSection{ 115 | \ifbeamer@inframe 116 | \sectionpage 117 | \else 118 | \frame[plain,c,noframenumbering]{\sectionpage} 119 | \fi 120 | } 121 | } 122 | \defbeamertemplate{section page}{progressbar}{ 123 | \centering 124 | \begin{minipage}{22em} 125 | \raggedright 126 | \usebeamercolor[fg]{section title} 127 | \usebeamerfont{section title} 128 | \insertsectionhead\\[-1ex] 129 | \usebeamertemplate*{progress bar in section page} 130 | \end{minipage} 131 | \par 132 | \vspace{\baselineskip} 133 | } 134 | \newcommand{\metropolis@sectionpage@progressbar}{ 135 | \setbeamertemplate{section page}[progressbar] 136 | \AtBeginSection{ 137 | \ifbeamer@inframe 138 | \sectionpage 139 | \else 140 | \frame[plain,c,noframenumbering]{\sectionpage} 141 | \fi 142 | } 143 | } 144 | \newlength{\metropolis@progressonsectionpage} 145 | \setbeamertemplate{progress bar in section page}{ 146 | \setlength{\metropolis@progressonsectionpage}{% 147 | \textwidth * \ratio{\insertframenumber pt}{\inserttotalframenumber pt}% 148 | }% 149 | \begin{tikzpicture} 150 | \draw[bg, fill=bg] (0,0) rectangle (\textwidth, 0.4pt); 151 | \draw[fg, fill=fg] (0,0) rectangle (\metropolis@progressonsectionpage, 0.4pt); 152 | \end{tikzpicture}% 153 | } 154 | \def\inserttotalframenumber{100} 155 | \newlength{\metropolis@blocksep} 156 | \newlength{\metropolis@blockadjust} 157 | \setlength{\metropolis@blocksep}{0.75ex} 158 | \setlength{\metropolis@blockadjust}{0.25ex} 159 | \providecommand{\metropolis@strut}{% 160 | \vphantom{ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz()}% 161 | } 162 | \newcommand{\metropolis@block}[1]{ 163 | \par\vskip\medskipamount% 164 | \setlength{\parskip}{0pt} 165 | \ifbeamercolorempty[bg]{block title}{% 166 | \begin{beamercolorbox}[rightskip=0pt plus 4em]{block title#1}% 167 | }% 168 | {% 169 | \begin{beamercolorbox}[ 170 | sep=\dimexpr\metropolis@blocksep-\metropolis@blockadjust\relax, 171 | leftskip=\metropolis@blockadjust, 172 | rightskip=\dimexpr\metropolis@blockadjust plus 4em\relax 173 | ]{block title#1}% 174 | }% 175 | \usebeamerfont*{block title#1}% 176 | \metropolis@strut% 177 | \insertblocktitle% 178 | \metropolis@strut% 179 | \end{beamercolorbox}% 180 | \nointerlineskip% 181 | \ifbeamercolorempty[bg]{block body}{ 182 | \begin{beamercolorbox}[vmode]{block body#1}% 183 | }{% 184 | \begin{beamercolorbox}[sep=\metropolis@blocksep, vmode]{block body#1}% 185 | \vspace{-\metropolis@parskip} 186 | }% 187 | \usebeamerfont{block body#1}% 188 | \setlength{\parskip}{\metropolis@parskip}% 189 | } 190 | \setbeamertemplate{block begin}{\metropolis@block{}} 191 | \setbeamertemplate{block alerted begin}{\metropolis@block{ alerted}} 192 | \setbeamertemplate{block example begin}{\metropolis@block{ example}} 193 | \setbeamertemplate{block end}{\end{beamercolorbox}\vspace*{0.2ex}} 194 | \setbeamertemplate{block alerted end}{\end{beamercolorbox}\vspace*{0.2ex}} 195 | \setbeamertemplate{block example end}{\end{beamercolorbox}\vspace*{0.2ex}} 196 | \setbeamertemplate{itemize items}{\textbullet} 197 | \setbeamertemplate{caption label separator}{: } 198 | \setbeamertemplate{caption}[numbered] 199 | \setbeamertemplate{footnote}{% 200 | \parindent 0em\noindent% 201 | \raggedright 202 | \usebeamercolor{footnote}\hbox to 0.8em{\hfil\insertfootnotemark}\insertfootnotetext\par% 203 | } 204 | \newlength{\metropolis@parskip} 205 | \setlength{\metropolis@parskip}{0.5em} 206 | \setlength{\parskip}{\metropolis@parskip} 207 | \linespread{1.15} 208 | \define@key{beamerframe}{c}[true]{% centered 209 | \beamer@frametopskip=0pt plus 1fill\relax% 210 | \beamer@framebottomskip=0pt plus 1fill\relax% 211 | \beamer@frametopskipautobreak=0pt plus .4\paperheight\relax% 212 | \beamer@framebottomskipautobreak=0pt plus .6\paperheight\relax% 213 | \def\beamer@initfirstlineunskip{}% 214 | } 215 | \metropolis@inner@setdefaults 216 | \ProcessPgfPackageOptions{/metropolis/inner} 217 | \endinput 218 | %% 219 | %% End of file `beamerinnerthememetropolis.sty'. 220 | -------------------------------------------------------------------------------- /latex/slides/beamerouterthememetropolis.sty: -------------------------------------------------------------------------------- 1 | %% 2 | %% This is file `beamerouterthememetropolis.sty', 3 | %% generated with the docstrip utility. 4 | %% 5 | %% The original source files were: 6 | %% 7 | %% beamerouterthememetropolis.dtx (with options: `package') 8 | %% --------------------------------------------------------------------------- 9 | %% Copyright 2015 Matthias Vogelgesang and the LaTeX community. A full list of 10 | %% contributors can be found at 11 | %% 12 | %% https://github.com/matze/mtheme/graphs/contributors 13 | %% 14 | %% and the original template was based on the HSRM theme by Benjamin Weiss. 15 | %% 16 | %% This work is licensed under a Creative Commons Attribution-ShareAlike 4.0 17 | %% International License (https://creativecommons.org/licenses/by-sa/4.0/). 18 | %% --------------------------------------------------------------------------- 19 | \NeedsTeXFormat{LaTeX2e} 20 | \ProvidesPackage{beamerouterthememetropolis}[2016/02/21 Metropolis outer theme] 21 | \RequirePackage{etoolbox} 22 | \RequirePackage{calc} 23 | \RequirePackage{pgfopts} 24 | \pgfkeys{ 25 | /metropolis/outer/numbering/.cd, 26 | .is choice, 27 | none/.code=\setbeamertemplate{frame numbering}[none], 28 | counter/.code=\setbeamertemplate{frame numbering}[counter], 29 | fraction/.code=\setbeamertemplate{frame numbering}[fraction], 30 | } 31 | \pgfkeys{ 32 | /metropolis/outer/progressbar/.cd, 33 | .is choice, 34 | none/.code={% 35 | \setbeamertemplate{headline}[plain] 36 | \setbeamertemplate{frametitle}[plain] 37 | \setbeamertemplate{footline}[plain] 38 | }, 39 | head/.code={\pgfkeys{/metropolis/outer/progressbar=none} 40 | \addtobeamertemplate{headline}{}{% 41 | \usebeamertemplate*{progress bar in head/foot} 42 | } 43 | }, 44 | frametitle/.code={\pgfkeys{/metropolis/outer/progressbar=none} 45 | \addtobeamertemplate{frametitle}{}{% 46 | \usebeamertemplate*{progress bar in head/foot} 47 | } 48 | }, 49 | foot/.code={\pgfkeys{/metropolis/outer/progressbar=none} 50 | \addtobeamertemplate{footline}{}{% 51 | \usebeamertemplate*{progress bar in head/foot}% 52 | } 53 | }, 54 | } 55 | \newcommand{\metropolis@outer@setdefaults}{ 56 | \pgfkeys{/metropolis/outer/.cd, 57 | numbering=counter, 58 | progressbar=none, 59 | } 60 | } 61 | \setbeamertemplate{navigation symbols}{} 62 | \defbeamertemplate{frame footer}{none}{} 63 | \defbeamertemplate{frame footer}{custom}[1]{ #1 } 64 | \defbeamertemplate{frame numbering}{none}{} 65 | \defbeamertemplate{frame numbering}{counter}{\insertframenumber} 66 | \defbeamertemplate{frame numbering}{fraction}{ 67 | \insertframenumber/\inserttotalframenumber 68 | } 69 | \defbeamertemplate{headline}{plain}{} 70 | \defbeamertemplate{footline}{plain}{% 71 | \begin{beamercolorbox}[wd=\textwidth, sep=3ex]{footline}% 72 | \usebeamerfont{page number in head/foot}% 73 | \usebeamertemplate*{frame footer} 74 | \hfill% 75 | \usebeamertemplate*{frame numbering} 76 | \end{beamercolorbox}% 77 | } 78 | \newlength{\metropolis@frametitle@padding} 79 | \setlength{\metropolis@frametitle@padding}{1.5ex} 80 | \newcommand{\metropolis@frametitlestrut@start}{ 81 | \rule{0pt}{\metropolis@frametitle@padding +% 82 | \totalheightof{% 83 | \ifcsdef{metropolis@frametitleformat}{\metropolis@frametitleformat X}{X}% 84 | }% 85 | }% 86 | } 87 | \newcommand{\metropolis@frametitlestrut@end}{ 88 | \rule[-\metropolis@frametitle@padding]{0pt}{\metropolis@frametitle@padding} 89 | } 90 | \defbeamertemplate{frametitle}{plain}{% 91 | \nointerlineskip% 92 | \begin{beamercolorbox}[% 93 | wd=\paperwidth,% 94 | sep=0pt,% 95 | leftskip=\metropolis@frametitle@padding,% 96 | rightskip=\metropolis@frametitle@padding,% 97 | ]{frametitle}% 98 | \metropolis@frametitlestrut@start\insertframetitle\metropolis@frametitlestrut@end% 99 | \end{beamercolorbox}% 100 | } 101 | \newlength{\metropolis@progressinheadfoot} 102 | \setbeamertemplate{progress bar in head/foot}{ 103 | \nointerlineskip 104 | \setlength{\metropolis@progressinheadfoot}{% 105 | \paperwidth * \ratio{\insertframenumber pt}{\inserttotalframenumber pt}% 106 | }% 107 | \begin{beamercolorbox}[wd=\paperwidth]{progress bar in head/foot} 108 | \begin{tikzpicture} 109 | \draw[bg, fill=bg] (0,0) rectangle (\paperwidth, 0.4pt); 110 | \draw[fg, fill=fg] (0,0) rectangle (\metropolis@progressinheadfoot, 0.4pt); 111 | \end{tikzpicture}% 112 | \end{beamercolorbox} 113 | } 114 | \AtBeginDocument{% 115 | \apptocmd{\appendix}{% 116 | \pgfkeys{% 117 | /metropolis/outer/.cd, 118 | numbering=none, 119 | progressbar=none} 120 | }{}{} 121 | } 122 | \metropolis@outer@setdefaults 123 | \ProcessPgfPackageOptions{/metropolis/outer} 124 | \endinput 125 | %% 126 | %% End of file `beamerouterthememetropolis.sty'. 127 | -------------------------------------------------------------------------------- /latex/slides/beamerthememetropolis.sty: -------------------------------------------------------------------------------- 1 | %% 2 | %% This is file `beamerthememetropolis.sty', 3 | %% generated with the docstrip utility. 4 | %% 5 | %% The original source files were: 6 | %% 7 | %% beamerthememetropolis.dtx (with options: `package') 8 | %% --------------------------------------------------------------------------- 9 | %% Copyright 2015 Matthias Vogelgesang and the LaTeX community. A full list of 10 | %% contributors can be found at 11 | %% 12 | %% https://github.com/matze/mtheme/graphs/contributors 13 | %% 14 | %% and the original template was based on the HSRM theme by Benjamin Weiss. 15 | %% 16 | %% This work is licensed under a Creative Commons Attribution-ShareAlike 4.0 17 | %% International License (https://creativecommons.org/licenses/by-sa/4.0/). 18 | %% --------------------------------------------------------------------------- 19 | \NeedsTeXFormat{LaTeX2e} 20 | \ProvidesPackage{beamerthememetropolis} 21 | [2016/02/21 v1.1 Metropolis Beamer theme] 22 | \RequirePackage{etoolbox} 23 | \RequirePackage{pgfopts} 24 | \pgfkeys{/metropolis/.cd, 25 | .search also={ 26 | /metropolis/inner, 27 | /metropolis/outer, 28 | /metropolis/color, 29 | /metropolis/font, 30 | } 31 | } 32 | \pgfkeys{ 33 | /metropolis/titleformat plain/.cd, 34 | .is choice, 35 | regular/.code={% 36 | \let\metropolis@plaintitleformat\@empty% 37 | \setbeamerfont{plain title}{shape=\normalfont}% 38 | }, 39 | smallcaps/.code={% 40 | \let\metropolis@plaintitleformat\@empty% 41 | \setbeamerfont{plain title}{shape=\scshape}% 42 | }, 43 | allsmallcaps/.code={% 44 | \let\metropolis@plaintitleformat\MakeLowercase% 45 | \setbeamerfont{plain title}{shape=\scshape}% 46 | \PackageWarning{beamerthememetropolis}{% 47 | Be aware that titleformat plain=allsmallcaps can lead to problems% 48 | } 49 | }, 50 | allcaps/.code={% 51 | \let\metropolis@plaintitleformat\MakeUppercase% 52 | \setbeamerfont{plain title}{shape=\normalfont}% 53 | \PackageWarning{beamerthememetropolis}{% 54 | Be aware that titleformat plain=allcaps can lead to problems% 55 | } 56 | }, 57 | } 58 | \pgfkeys{ 59 | /metropolis/titleformat/.code=\pgfkeysalso{ 60 | font/titleformat title=#1, 61 | font/titleformat subtitle=#1, 62 | font/titleformat section=#1, 63 | font/titleformat frame=#1, 64 | titleformat plain=#1, 65 | } 66 | } 67 | \pgfkeys{/metropolis/.cd, 68 | usetitleprogressbar/.code=\pgfkeysalso{outer/progressbar=frametitle}, 69 | noslidenumbers/.code=\pgfkeysalso{outer/numbering=none}, 70 | usetotalslideindicator/.code=\pgfkeysalso{outer/numbering=fraction}, 71 | nosectionslide/.code=\pgfkeysalso{inner/sectionpage=none}, 72 | darkcolors/.code=\pgfkeysalso{color/background=dark}, 73 | blockbg/.code=\pgfkeysalso{color/block=fill, inner/block=fill}, 74 | } 75 | \newcommand{\metropolis@setdefaults}{ 76 | \pgfkeys{/metropolis/.cd, 77 | titleformat plain=regular, 78 | } 79 | } 80 | \useinnertheme{metropolis} 81 | \useoutertheme{metropolis} 82 | \usecolortheme{metropolis} 83 | \usefonttheme{metropolis} 84 | \AtEndPreamble{% 85 | \@ifpackageloaded{pgfplots}{% 86 | \RequirePackage{pgfplotsthemetol} 87 | }{} 88 | } 89 | \newcommand{\metroset}[1]{\pgfkeys{/metropolis/.cd,#1}} 90 | \def\metropolis@plaintitleformat#1{#1} 91 | \newcommand{\plain}[2][]{% 92 | \begingroup 93 | \ifbeamercolorempty[bg]{palette primary}{ 94 | \setbeamercolor{background canvas}{ 95 | use=palette primary, 96 | bg=-palette primary.fg 97 | } 98 | }{ 99 | \setbeamercolor{background canvas}{ 100 | use=palette primary, 101 | bg=palette primary.bg 102 | } 103 | } 104 | \begin{frame}[c,noframenumbering]{#1} 105 | \begin{center} 106 | \usebeamercolor[fg]{palette primary} 107 | \usebeamerfont{plain title} 108 | \metropolis@plaintitleformat{#2} 109 | \end{center} 110 | \end{frame} 111 | \endgroup 112 | } 113 | \newcommand{\mreducelistspacing}{\vspace{-\topsep}} 114 | \metropolis@setdefaults 115 | \ProcessPgfOptions{/metropolis} 116 | \endinput 117 | %% 118 | %% End of file `beamerthememetropolis.sty'. 119 | -------------------------------------------------------------------------------- /latex/slides/resources/01_getting_started/attributes.py: -------------------------------------------------------------------------------- 1 | class A: 2 | """ 3 | This is the class definition 4 | 5 | this is where mehtods and class attributes are defined 6 | """ 7 | 8 | class_attribute_2 = 'I am a class attribute' 9 | 10 | def __init__(self, argument_1): 11 | """ 12 | This is the class initializer 13 | 14 | this is where typically instance attributes are defined 15 | """ 16 | 17 | self.instance_attribute_1 = 'I am an instance attribute' 18 | self.instance_attribute_2 = argument_1 19 | 20 | 21 | a = A('argument') # instantiating a new instace of 'A' 22 | b = A(6) 23 | 24 | # attrbute access 25 | a.instance_attribute_2 # ==> 'argument' 26 | b.instance_attribute_2 # ==> 6 27 | 28 | a.class_attribute_2 # ==> 'I am a class attribute' 29 | b.class_attribute_2 # ==> 'I am a class attribute' 30 | 31 | a.instance_attribute_1 == b.instance_attribute_1 # ==> True 32 | 33 | # setting the attribute 34 | a.instance_attribute_1 = 5 35 | 36 | a.instance_attribute_1 == b.instance_attribute_1 # ==> False -------------------------------------------------------------------------------- /latex/slides/resources/01_getting_started/comments.py: -------------------------------------------------------------------------------- 1 | # in python nur einzeilige Kommentare 2 | 3 | def my_function(params): 4 | """ 5 | Oder docstrings wie dieser, 6 | aber nur zu beginn einer Funktions- 7 | oder Klassendefinition 8 | """ 9 | pass 10 | -------------------------------------------------------------------------------- /latex/slides/resources/01_getting_started/hello_world.py: -------------------------------------------------------------------------------- 1 | def my_function(): 2 | print('Hallo Welt!') 3 | 4 | if __name__ == '__main__': 5 | my_function() 6 | -------------------------------------------------------------------------------- /latex/slides/resources/01_getting_started/string_concatenation.py: -------------------------------------------------------------------------------- 1 | 'Hallo' + '_' + 'Welt' # => 'Hallo_Welt' 2 | 3 | '_'.join(['Hallo', 'Welt']) # => 'Hallo_Welt' 4 | -------------------------------------------------------------------------------- /latex/slides/resources/01_getting_started/string_format.py: -------------------------------------------------------------------------------- 1 | # mit `str.format()` 2 | 3 | 'my string {} {}'.format(4, 'vier') 4 | # in Reihenfolge der argumente 5 | 6 | 'my string {number} {name}'.format(name='vier', number=4)` 7 | # via Name, Reihenfolge egal 8 | 9 | 'my string {number} {}'.format('vier', number=4) 10 | # oder beides kombiniert 11 | 12 | # und mit dem %-Operator 13 | 14 | 'string %d %s' % (4, 'vier') 15 | # in Reihenfolge 16 | 17 | 'string %(number)d %(name)s' % {number:4, name:'vier'} 18 | # via Name 19 | -------------------------------------------------------------------------------- /latex/slides/resources/02_grundlagen/boilerplate.py: -------------------------------------------------------------------------------- 1 | def main(): 2 | pass 3 | 4 | if __name__ == '__main__': 5 | main() 6 | -------------------------------------------------------------------------------- /latex/slides/resources/02_grundlagen/classattributes.py: -------------------------------------------------------------------------------- 1 | class TestClass: 2 | # jeder Instanz wird bei Erstellung bereits dieses Attribut zugewiesen 3 | num = 12 4 | 5 | def main(): 6 | a = TestClass() 7 | b = TestClass() 8 | # beide Variablen haben fuer 'num' von der Erstellung an den gleichen Wert 9 | 10 | # das Aendern der Variable ueberschreibt das Klassenattribut mit einem Instanzattribut 11 | a.num = -3 12 | print(b.num) # -> liefert immer noch 12 13 | -------------------------------------------------------------------------------- /latex/slides/resources/02_grundlagen/inheritance.py: -------------------------------------------------------------------------------- 1 | class Human(): 2 | def __init__(self, fistname, lastname, dob): 3 | self.firstname = firstname 4 | self.lastname = lastname 5 | self.dob = dob 6 | 7 | 8 | class Child(Human): 9 | # Ein Child ist einfach nur ein Human mit den 10 | # zusaetzlichen Attributen father und mother 11 | def __init__(self, fistname, lastname, dob, father, mother): 12 | super.__init__(fistname, lastname, dob) 13 | self.father = father 14 | self.mother = mother 15 | -------------------------------------------------------------------------------- /latex/slides/resources/02_grundlagen/instanceattributes.py: -------------------------------------------------------------------------------- 1 | class Human: 2 | def __init__(self, firstname, lastname): 3 | # die beiden Parameterwerte werden in Instanzattributen gespeichert. 4 | self.firstname = firstname 5 | self.lastame = lastname 6 | 7 | def main(): 8 | # instanziiert zwei Objekte vom Typ 'Human' 9 | matthias = Human("Matthias", "Stuhlbein") 10 | john = Human("John", "Doe") 11 | -------------------------------------------------------------------------------- /latex/slides/resources/02_grundlagen/scope.py: -------------------------------------------------------------------------------- 1 | var = 12 2 | 3 | def foo(): 4 | # erwarteter Effekt: var wird auf 9 gesetzt 5 | var = 9 6 | 7 | def main(): 8 | print(var) # -> gibt 12 zurueck 9 | foo() 10 | print(var) # -> Erwartung: gibt 9 aus. 11 | # Realitaet: gibt 12 aus. 12 | 13 | if __name__ == '__main__': 14 | main() 15 | -------------------------------------------------------------------------------- /latex/slides/resources/02_grundlagen/scope_fix.py: -------------------------------------------------------------------------------- 1 | var = 12 2 | 3 | def foo(): 4 | global var 5 | # global sagt dem Interpreter, dass er hier auf die oberhalb definierte Variable zurueckgreifen soll 6 | var = 9 7 | 8 | def main(): 9 | print(var) # -> gibt 12 zurueck 10 | foo() 11 | print(var) # -> gibt jetzt 9 aus 12 | 13 | if __name__ == '__main__': 14 | main() 15 | -------------------------------------------------------------------------------- /latex/slides/resources/03_builtins/cm.py: -------------------------------------------------------------------------------- 1 | class MyManager: 2 | def __enter__(self): 3 | # tue dinge 4 | pass 5 | 6 | def __exit__(self): 7 | # schliesse handler etc ... 8 | pass 9 | 10 | def do_things(self): 11 | # ... 12 | pass 13 | 14 | with MyManager() as m: 15 | m.do_things() 16 | -------------------------------------------------------------------------------- /latex/slides/resources/03_builtins/dict.py: -------------------------------------------------------------------------------- 1 | d = { 'm': 4, 3: 'val2', object: 'auch typen koennen keys sein' } 2 | 3 | d[3] # ==> "val2" 4 | d['q'] # ==> KeyError: 'q' 5 | d.get('q') # ==> None 6 | d.get('q', 5) # ==> 5 7 | 8 | d[0] = 7 9 | d # ==> {3: 'val2', 'm': 4, 'q': 5, : 'auch typen koennen keys sein'} 10 | 11 | d.setdefault('m') # ==> 4 12 | d.setdefault('q', 5) # ==> 5 13 | d # ==> { 'm': 4, 3: 'val2', object: 'auch typen koennen keys sein', 0:7, 'q': 5 } 14 | len(d) # ==> 5 15 | d.keys() # ==> dict_keys([3, 0, 'm', 'q', ]) 16 | d.values() # ==> dict_values(['val2', 7, 4, 5, 'auch typen koennen keys sein']) 17 | d.items() # ==> dict_items([(3, 'val2'), (0, 7), ('m', 4), ('q', 5), (, 'auch typen koennen keys sein')]) 18 | 19 | 'm' in d # ==> True 20 | object in d # ==> True 21 | tuple in d # ==> False 22 | -------------------------------------------------------------------------------- /latex/slides/resources/03_builtins/exceptions.py: -------------------------------------------------------------------------------- 1 | class MyException(Exception): 2 | def __init__(self, message): 3 | self.message = message 4 | 5 | def __repr__(self): 6 | return '{} mit nachricht {}'.format(self.__class__, self.message) 7 | 8 | try: 9 | # code 10 | raise KeyError('message') 11 | # mit nur einer exception 12 | # except MyException as error: 13 | except (KeyError, MyException) as error: 14 | print(error) 15 | pass 16 | finally: 17 | # was unbedingt zu tun ist 18 | -------------------------------------------------------------------------------- /latex/slides/resources/03_builtins/file.py: -------------------------------------------------------------------------------- 1 | with open(myfile, mode='r') as f: 2 | for line in f: 3 | # code 4 | 5 | 6 | with open(myfile, mode='w+') as f: 7 | for line in document: 8 | f.write(line) 9 | # oder 10 | print(line, file=f) 11 | 12 | f = open(myfile) 13 | 14 | # code 15 | 16 | f.close() 17 | -------------------------------------------------------------------------------- /latex/slides/resources/03_builtins/iterate.py: -------------------------------------------------------------------------------- 1 | for i in [1,2,3]: 2 | if i > 9: 3 | break 4 | # code 5 | else: 6 | pass 7 | # wenn kein break vorkommt 8 | 9 | for i in (1,2,3): 10 | # code 11 | pass 12 | 13 | for i in {1:'value1', 2:'value2'}: 14 | # iteration ueber die keys 15 | pass 16 | 17 | 18 | for i in {1:'value1', 2:'value2'}.items(): 19 | # i ist tuple von (key, value) 20 | pass 21 | 22 | for value1, value2 in [ 23 | (1, 'werner'), 24 | (3, 'geh mal in den keller'), 25 | (42, 'ich glaub die russen komm\'') 26 | ]: 27 | # iteration mit tuple unpacking 28 | # code 29 | 30 | # oder auch 31 | 32 | for value1, value2 in zip([1,3,42], ['werner', 'geh mal in den keller', 'ich glaub die russen komm\'', 'dieser string wird in der iteration nicht auftauchen', 'dieser auch nicht']) 33 | 34 | for key, value in {1:'value1', 2:'value2'}.items(): 35 | # iteration ueber keys und values mit tuple unpacking 36 | pass 37 | -------------------------------------------------------------------------------- /latex/slides/resources/03_builtins/list.py: -------------------------------------------------------------------------------- 1 | l = [1, 9, 'string', object] 2 | 3 | isinstance(l[0], int) # ==> True 4 | l[1] == 9 # ==> True 5 | len(l) # ==> 4 6 | 7 | 9 in l # ==> True 8 | 9 | l.pop() # ==> object 10 | len(l) # ==> 3 11 | l.append([]) # ==> None 12 | 13 | l # ==> [1, 9, 'string', []] 14 | len(l) # ==> 4 15 | -------------------------------------------------------------------------------- /latex/slides/resources/03_builtins/set.py: -------------------------------------------------------------------------------- 1 | s1 = {1, 2, 'string', object, ('ein', 'tuple')} 2 | 3 | 2 in s1 # ==> True 4 | 'ein' in s1 # ==> False 5 | ('ein', 'tuple') in s1 # ==> True 6 | set(('ein', 'tuple')) # ==> {'ein', 'tuple'} 7 | 8 | s2 = {'anderes', 'set'} 9 | s1 > s2 # ==> False 10 | s1.isdisjoint(s2) # ==> True 11 | 12 | s1.add('anderes') 13 | s1 | s2 # ==> {1, 2, 'string', object, ('ein', 'tuple'), 'set'} 14 | s1 & s2 # ==> {'anderes'} 15 | s2 - s1 # ==> {'set'} 16 | 17 | s2 = frozenset(s2) 18 | s1.add(s2) 19 | s2.add(5) # ==> AttributeError: 'frozenset' object has no attribute 'add' 20 | -------------------------------------------------------------------------------- /latex/slides/resources/03_builtins/tuple.py: -------------------------------------------------------------------------------- 1 | # Tupel mit 3 Elementen 2 | t = (1, 3, 'ein string') 3 | isinstance(t, tuple) # ==> True 4 | 5 | t[0] == 1 # ==> True 6 | t[1] == 3 # ==> True 7 | t[2] == 'ein string' # ==> True 8 | t[4] == 'ein string' # ==> IndexError: tuple index out of range 9 | t[2] = 'ein anderer string' # ==> TypeError: 'tuple' object does not support item assignment 10 | 11 | # oder auch ohne klammern 12 | t = 1, 3, 'ein string' 13 | # macht es (manchmal) besser lesbar, z.b. bei 14 | return 1, 2, 5 15 | -------------------------------------------------------------------------------- /latex/slides/resources/03_builtins/unpacking.py: -------------------------------------------------------------------------------- 1 | # unpacking (geht auch mit listen) 2 | t = 1, 3, 'ein string' # tuple ohne klammern gebaut 3 | 4 | x, y, z = t 5 | x is t[0] # ==> True 6 | y is t[1] # ==> True 7 | 8 | # oder 9 | x, *y = t 10 | x # ==> 1 11 | y # ==> [3, 'ein string'] 12 | 13 | a, b, c = 1, 2, 4 14 | 15 | d, e, f, *g = [3, 0, 8, 7, 46, 42] 16 | f # ==> 8 17 | g # ==> [7, 46, 42] 18 | -------------------------------------------------------------------------------- /latex/slides/resources/04_modules_and_packages/incdec.py: -------------------------------------------------------------------------------- 1 | def increment(a): 2 | return a+1 3 | 4 | 5 | def decrement(a): 6 | return a-1 7 | -------------------------------------------------------------------------------- /latex/slides/resources/04_modules_and_packages/modules.py: -------------------------------------------------------------------------------- 1 | # Importieren des kompletten Moduls incdec 2 | import incdec 3 | 4 | # Die Funktionen koennen wie folgt aufgerufen werden: 5 | incdec.increment(3) 6 | # => 4 7 | incdec.decrement(3) 8 | # => 2 9 | 10 | # Importieren einzelner Funktionen 11 | from incdec import increment 12 | 13 | # Diese kann jetzt sofort aufgerufen werden 14 | increment(3) 15 | # => 4 16 | 17 | # Alias fuer Module verwenden 18 | import incdec as plusoneminusone 19 | 20 | plusoneminusone.inrement(3) 21 | # => 4 22 | -------------------------------------------------------------------------------- /latex/slides/resources/04_modules_and_packages/path.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | sys.path.append('my/directory') 4 | -------------------------------------------------------------------------------- /latex/slides/resources/05_pip/requirements.txt: -------------------------------------------------------------------------------- 1 | pathlib>=1.0 2 | pyyaml>=3.08 3 | markdown 4 | 5 | -------------------------------------------------------------------------------- /latex/slides/resources/06_comprehensions/dicts.py: -------------------------------------------------------------------------------- 1 | liste = ["Fritz", "Alex", "Nadine", "Peter", "Anna"] 2 | 3 | names = {key: len(key) for key in liste} 4 | # => {'Peter': 5, 'Fritz': 5, 'Alex': 4, 'Anna': 4, 'Nadine': 6} 5 | -------------------------------------------------------------------------------- /latex/slides/resources/06_comprehensions/lists.py: -------------------------------------------------------------------------------- 1 | varList = [var*8 for var in range(10)] 2 | # => [0, 8, 16, 24, 32, 40, 48, 56, 64, 72] 3 | 4 | 5 | # Mit Filter (hier: Fuer i ist gerade) 6 | evenVarList = [var*8 for var in range(10) if var % 2 == 0] 7 | # => [0, 16, 32, 48, 64] 8 | -------------------------------------------------------------------------------- /latex/slides/resources/06_decorators/decorator.py: -------------------------------------------------------------------------------- 1 | def get_date(date): 2 | return ", today it's {}.".format(date) 3 | 4 | 5 | # unser decorator 6 | def tell_the_world(func): 7 | def complete_sentence(date): 8 | return "Hello World{}".format(func(date)) 9 | return complete_sentence 10 | 11 | # normaler Aufruf: 12 | print(tell_the_world(get_date)("25th June 2015")) 13 | 14 | # als decorator 15 | get_date = tell_the_world(get_date) 16 | 17 | print(get_date("25th June 2015")) 18 | # => Hello World, today it's 25th June 2015. 19 | 20 | 21 | 22 | # Nutzung des @ Syntaxes 23 | def tell_the_world(func): 24 | def complete_sentence(date): 25 | return "Hello World, {}".format(func(date)) 26 | return complete_sentence 27 | 28 | 29 | @tell_the_world 30 | def get_date(date): 31 | return "today it's {}.".format(date) 32 | 33 | print(get_date("25th June 2015")) 34 | # => Hello World, today it's 25th June 2015. 35 | 36 | 37 | # Decorator mit Argumenten 38 | def tell_the_date_to(name): 39 | def name_decorator(func): 40 | def complete_sentence(date): 41 | return "Hello {name}, {date}".format(name=name, date=func(date)) 42 | return complete_sentence 43 | return name_decorator 44 | 45 | 46 | @tell_the_date_to("John Doe") 47 | def get_date(date): 48 | return "today it's {}.".format(date) 49 | 50 | print(get_date("25th June 2015")) 51 | # => Hello John Doe, today it's 25th June 2015. 52 | -------------------------------------------------------------------------------- /latex/slides/resources/06_decorators/functions.py: -------------------------------------------------------------------------------- 1 | # Funktionen Variablen zuweisen 2 | def return_hello(): 3 | return "Hello" 4 | 5 | say_hello = return_hello 6 | 7 | print(say_hello()) 8 | # => Hello 9 | 10 | 11 | # Funktionen in Funktionen definieren 12 | def greet(name): 13 | def return_hello(): 14 | return "Hello " 15 | greeting = return_hello() + name 16 | return greeting 17 | 18 | print(greet("World")) 19 | # => Hello World 20 | 21 | 22 | # Rueckgabe von Funktionen 23 | def greet(): 24 | def say_hello(): 25 | return "Hello" 26 | return say_hello 27 | 28 | print(greet()) 29 | # Hello 30 | 31 | 32 | # Uebergabe von Funktionen 33 | def say_date(date): 34 | return "Today it's {date}".format(date=date) 35 | 36 | def which_date(function): 37 | date = "25th June 2015" 38 | return function(date) 39 | 40 | print(which_date(say_date)) 41 | # => Today it's 25th June 2015 42 | -------------------------------------------------------------------------------- /latex/slides/resources/07_funtions_advanced/default.py: -------------------------------------------------------------------------------- 1 | def greet(name, greeting='Hello'): 2 | return '{} {}'.format(greeting, name) 3 | 4 | greet('Herbert') # ==> 'Hallo Herbert' 5 | greet('Herbert', 'Gruess Gott') # ==> 'Gruess Gott Herbert' 6 | 7 | 8 | def func(param1, param2=[]): 9 | print(param2) 10 | param2.append(param1) 11 | 12 | func(1) # ==> [] 13 | func(2) # ==> [1] 14 | func('j') # ==> [1,2] 15 | 16 | 17 | def func(param1, param2=None): 18 | param2 = [] if param2 is None else param2 19 | pass 20 | 21 | 22 | def land(house, tree, pond): 23 | return 'You own land with a {} a {} and a {}'.format(house, tree, pond) 24 | 25 | land('green house', 'maple', 'fish pond') 26 | 27 | # oder mit Aufruf durch Namen: 28 | land(house='green house', pond='fish pond', tree='maple') 29 | 30 | # or vermischt 31 | land('green house', pond='fish pond', tree='maple') 32 | 33 | # folgendes funktioniert NICHT! 34 | land('maple', house='green house', tree='maple' 35 | -------------------------------------------------------------------------------- /latex/slides/resources/07_funtions_advanced/mixed_aggr.py: -------------------------------------------------------------------------------- 1 | def function( 2 | param1, 3 | param2, 4 | *args, 5 | kwparam1=0, 6 | kwparam2=None, 7 | **kwargs 8 | ): 9 | pass 10 | 11 | 12 | def name( 13 | [params, ...] 14 | [, *[aggregator]] 15 | [, kwparams=kwvalue, ...] 16 | [**kwaggreg] 17 | ): 18 | pass 19 | -------------------------------------------------------------------------------- /latex/slides/resources/07_funtions_advanced/named_aggr.py: -------------------------------------------------------------------------------- 1 | def function(param1, **aggr): 2 | pass 3 | 4 | 5 | function(1) # korrekt, aggr = {} 6 | function(1, some=9) # korrekt, agar = {'some': 9} 7 | function(some=6) # inkorrekt, param1 braucht einen Wert 8 | function(some=0, param1=8, param2=4) 9 | # korrekt, agar = {'some': 0, 'param2': 4} 10 | -------------------------------------------------------------------------------- /latex/slides/resources/07_funtions_advanced/nameless_aggr.py: -------------------------------------------------------------------------------- 1 | def function(param1, param2, *, param3=6): 2 | pass 3 | -------------------------------------------------------------------------------- /latex/slides/resources/07_funtions_advanced/positional_aggregators.py: -------------------------------------------------------------------------------- 1 | def f(*args): 2 | print(type(args)) # ==> tuple 3 | 4 | 5 | def function(param1, *aggr, param2=0): 6 | pass 7 | 8 | 9 | function(1, 2, 3, 4) # korrekt, aggr = (2,3,4) 10 | function(1, 2, 4, 5, 6, 78, 9, 90, 0) 11 | # auch korrekt, aggr = (2,4,5,6,78,9,90,0) 12 | function() # inkorrekt, param1 braucht mindestens ein Argument 13 | function(1, param2=7) # korrekt, aggr = () 14 | function(param2=8) # inkorrekt, param1 braucht einen Wert 15 | function(param2=0, param1=6) # korrekt 16 | -------------------------------------------------------------------------------- /latex/slides/resources/07_funtions_advanced/use_func.py: -------------------------------------------------------------------------------- 1 | def function(params): 2 | return 4 3 | 4 | my_var = function 5 | my_var(2) # ==> 4 6 | 7 | 8 | def callif(boolean, callback): 9 | if boolean: 10 | callback() 11 | 12 | callif(True, lambda: print("hello world")) 13 | 14 | 15 | class MyClass(object): 16 | def function(self, param): 17 | return 4 18 | 19 | my_var = MyClass.function 20 | my_var(MyClass(), 2) # ==> 4 21 | -------------------------------------------------------------------------------- /latex/slides/resources/08_process/context_mgr.py: -------------------------------------------------------------------------------- 1 | with subprocess.Popen(['ls']) as process: 2 | pass 3 | -------------------------------------------------------------------------------- /latex/slides/resources/08_process/defs.py: -------------------------------------------------------------------------------- 1 | run(args, *, stdin=None, input=None, 2 | stdout=None, stderr=None, shell=False, timeout=None, check=False) 3 | 4 | 5 | call(args, *, stdin=None, stdout=None, 6 | stderr=None, shell=False, timeout=None) 7 | 8 | 9 | check_output(args, *, stdin=None, stdout=None, 10 | stderr=None, shell=False, timeout=None) 11 | -------------------------------------------------------------------------------- /latex/slides/resources/08_process/popen_call.py: -------------------------------------------------------------------------------- 1 | import subprocess 2 | 3 | Popen(args, bufsize=-1, executable=None, stdin=None, stdout=None, 4 | stderr=None, preexec_fn=None, close_fds=True, shell=False, 5 | cwd=None, env=None, universal_newlines=False, startupinfo=None, 6 | creationflags=0, restore_signals=True, start_new_session=False, 7 | pass_fds=()) 8 | -------------------------------------------------------------------------------- /latex/slides/resources/09_web_client/req_example.py: -------------------------------------------------------------------------------- 1 | import urllib.request 2 | 3 | r = urllib.request.Request( 4 | 'http://python.org', 5 | headers={'content-type': 'application/json'}, 6 | method='PUT' 7 | ) 8 | -------------------------------------------------------------------------------- /latex/slides/resources/09_web_client/requests_example.py: -------------------------------------------------------------------------------- 1 | r = requests.get('https://api.github.com/user', auth=('user', 'pass')) 2 | 3 | r.status_code # -> 200 4 | r.headers['content-type'] 5 | # -> 'application/json; charset=utf8' 6 | r.encoding # -> 'utf-8' 7 | r.text # -> u'{"type":"User"...' 8 | r.json() 9 | # -> {u'private_gists': 419, u'total_private_repos': 77, ...} 10 | -------------------------------------------------------------------------------- /latex/slides/resources/09_web_client/urllib_calls.py: -------------------------------------------------------------------------------- 1 | import urllib.request 2 | 3 | urllib.request.urlopen(url, data=None, [timeout, ] *, 4 | cafile=None, capath=None, 5 | cadefault=False, context=None) 6 | 7 | 8 | urllib.request.Request(url, data=None, headers={}, 9 | origin_req_host=None, 10 | unverifiable=False, method=None) 11 | 12 | 13 | http.client.HTTPResponse(sock, debuglevel=0, 14 | method=None, url=None) 15 | -------------------------------------------------------------------------------- /latex/slides/resources/10_regex/match.py: -------------------------------------------------------------------------------- 1 | start([group]) 2 | 3 | end([group]) 4 | 5 | span([group]) 6 | 7 | -------------------------------------------------------------------------------- /latex/slides/resources/10_regex/methods.py: -------------------------------------------------------------------------------- 1 | compile(pattern, flags=0) 2 | 3 | search(pattern, string, flags=0) 4 | 5 | match(pattern, string, flags=0) 6 | 7 | fullmatch(pattern, string, flags=0) 8 | 9 | findall(pattern, string, flags=0) 10 | 11 | finditer(pattern, string, flags=0) 12 | -------------------------------------------------------------------------------- /latex/slides/resources/11_sendmail/defs.py: -------------------------------------------------------------------------------- 1 | email.mime.text.MIMEText(_text, _subtype='plain', _charset=None) 2 | 3 | smtplib.SMTP(host='', port=0, local_hostname=None, [timeout, ]source_address=None) 4 | 5 | SMTP.login(user, password, *, initial_response_ok=True) 6 | 7 | SMTP.sendmail(from_addr, to_addrs, msg, mail_options=[], rcpt_options=[]) 8 | -------------------------------------------------------------------------------- /latex/slides/resources/11_sendmail/mailer.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | 3 | import smtplib 4 | from email.mime.text import MIMEText 5 | 6 | 7 | def buildmessage(): 8 | message = MIMEText('Text der E-Mail.') 9 | 10 | # set the sender of your mail 11 | message['From'] = 'Sender name ' 12 | # set the receiver of your mail 13 | message['To'] = 'Receiver name ' 14 | 15 | message['Subject'] = 'Betreff der E-Mail' 16 | 17 | return message 18 | 19 | 20 | def main(): 21 | message = buildmessage() 22 | server = 'Servername' 23 | port = 587 # This is the default Port of an smtp server 24 | 25 | try: 26 | with smtplib.SMTP(host=server, port=port) as smtpObj: 27 | smtpObj.starttls() 28 | smtpObj.login('user', 'pass') 29 | smtpObj.send_message(message) 30 | except SMTPException: 31 | print("Error: unable to send email.") 32 | 33 | if __name__ == '__main__': 34 | main() 35 | -------------------------------------------------------------------------------- /latex/slides/resources/12_curses/functions.py: -------------------------------------------------------------------------------- 1 | curses.initscr() 2 | 3 | curses.endwin() 4 | 5 | curses.wrapper(func, ...) 6 | 7 | window.addch(ch[, attr]) 8 | window.addch(y, x, ch[, attr]) 9 | 10 | window.addstr(str[, attr]) 11 | window.addstr(y, x, str[, attr]) 12 | 13 | window.delch([y, x]) 14 | window.deleteln() 15 | window.erase() 16 | 17 | curses.textpad.rectangle(win, uly, ulx, lry, lrx) 18 | 19 | curses.textpad.Textbox(win) 20 | 21 | Textbox().edit([validator]) 22 | Textbox().do_command(ch) 23 | Textbox().gather() 24 | -------------------------------------------------------------------------------- /latex/slides/resources/list_example.py: -------------------------------------------------------------------------------- 1 | list_1 = [1, 2, 3] # lists can be created using square brakets 2 | 3 | type(list_1) == list # ==> True 4 | 5 | list_2 = [ # lists can contain different types 6 | 1, # an integer 7 | 'a string', # a string 8 | int # a type 9 | ] 10 | 11 | list_3 = list(list_2) # lists can be created from other iterables using the list() constructor 12 | 13 | list_1[1] == 2 # indexing with square brackets 14 | list_1[0] = 4 # settings using quare brackets 15 | 16 | list_1.append('new string') # append to the end 17 | list_1 == [4, 1, 3, 'new string'] # ==> True 18 | # pop from the end 19 | # removes and returns the element 20 | list_1.pop() # ==> 'new string' 21 | 22 | list_1 == [4, 1, 3] # ==> True 23 | 24 | # new in python 3.4 25 | list_1.clear() 26 | list_1 == [] # ==> True 27 | -------------------------------------------------------------------------------- /latex/templates/course_definitions.tex: -------------------------------------------------------------------------------- 1 | %document 2 | \documentclass[10pt]{beamer} 3 | %theme 4 | \usetheme{metropolis} 5 | % packages 6 | \usepackage{color} 7 | \usepackage{listings} 8 | \usepackage[ngerman]{babel} 9 | \usepackage[utf8]{inputenc} 10 | \usepackage{multicol} 11 | 12 | 13 | % color definitions 14 | \definecolor{mygreen}{rgb}{0,0.6,0} 15 | \definecolor{mygray}{rgb}{0.5,0.5,0.5} 16 | \definecolor{mymauve}{rgb}{0.58,0,0.82} 17 | 18 | \lstset{ 19 | backgroundcolor=\color{white}, 20 | % choose the background color; 21 | % you must add \usepackage{color} or \usepackage{xcolor} 22 | basicstyle=\footnotesize\ttfamily, 23 | % the size of the fonts that are used for the code 24 | breakatwhitespace=false, 25 | % sets if automatic breaks should only happen at whitespace 26 | breaklines=true, % sets automatic line breaking 27 | captionpos=b, % sets the caption-position to bottom 28 | commentstyle=\color{mygreen}, % comment style 29 | % deletekeywords={...}, 30 | % if you want to delete keywords from the given language 31 | extendedchars=true, 32 | % lets you use non-ASCII characters; 33 | % for 8-bits encodings only, does not work with UTF-8 34 | frame=single, % adds a frame around the code 35 | keepspaces=true, 36 | % keeps spaces in text, 37 | % useful for keeping indentation of code 38 | % (possibly needs columns=flexible) 39 | keywordstyle=\color{blue}, % keyword style 40 | % morekeywords={*,...}, 41 | % if you want to add more keywords to the set 42 | numbers=left, 43 | % where to put the line-numbers; possible values are (none, left, right) 44 | numbersep=5pt, 45 | % how far the line-numbers are from the code 46 | numberstyle=\tiny\color{mygray}, 47 | % the style that is used for the line-numbers 48 | rulecolor=\color{black}, 49 | % if not set, the frame-color may be changed on line-breaks 50 | % within not-black text (e.g. comments (green here)) 51 | stepnumber=1, 52 | % the step between two line-numbers. 53 | % If it's 1, each line will be numbered 54 | stringstyle=\color{mymauve}, % string literal style 55 | tabsize=4, % sets default tabsize to 4 spaces 56 | % show the filename of files included with \lstinputlisting; 57 | % also try caption instead of title 58 | language = Python, 59 | showspaces = false, 60 | showtabs = false, 61 | showstringspaces = false, 62 | escapechar = , 63 | } 64 | 65 | \def\ContinueLineNumber{\lstset{firstnumber=last}} 66 | \def\StartLineAt#1{\lstset{firstnumber=#1}} 67 | \let\numberLineAt\StartLineAt 68 | 69 | 70 | 71 | \newcommand{\codeline}[1]{ 72 | \alert{\texttt{#1}} 73 | } 74 | -------------------------------------------------------------------------------- /latex/templates/course_information.tex: -------------------------------------------------------------------------------- 1 | % This Document contains the information about this course. 2 | 3 | % Authors of the slides 4 | \author{Felix Döring, Felix Wittwer} 5 | 6 | % Name of the Course 7 | \institute{Python-Kurs} 8 | 9 | % Fancy Logo 10 | \titlegraphic{\hfill\includegraphics[height=1.25cm]{../templates/fsr_logo_cropped}} 11 | 12 | 13 | 14 | % Custom Bindings 15 | % \newcommand{\codeline}[1]{ 16 | % \alert{\texttt{#1}} 17 | %} 18 | -------------------------------------------------------------------------------- /latex/templates/fsr_logo.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/fsr/python-lessons/3a5e58a374658fdbcbdccf38e1e1660a31f0e2e4/latex/templates/fsr_logo.pdf -------------------------------------------------------------------------------- /latex/templates/fsr_logo.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 6 | 7 | 9 | 11 | 16 | 19 | 20 | 21 | 23 | 28 | 31 | 33 | 37 | 40 | 42 | 47 | 49 | 52 | 56 | 58 | 63 | 66 | 67 | 69 | 71 | 75 | 77 | 81 | 86 | 89 | 91 | 93 | 94 | 96 | 97 | 98 | 99 | 100 | 101 | 102 | 103 | 104 | 105 | 106 | 107 | 108 | 109 | 110 | 111 | 112 | 113 | 114 | 115 | 116 | 117 | 118 | 119 | 120 | 121 | 122 | 123 | 124 | 125 | 126 | 127 | -------------------------------------------------------------------------------- /latex/templates/fsr_logo_cropped.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/fsr/python-lessons/3a5e58a374658fdbcbdccf38e1e1660a31f0e2e4/latex/templates/fsr_logo_cropped.pdf -------------------------------------------------------------------------------- /latex/templates/new_slide.tex: -------------------------------------------------------------------------------- 1 | % The Slide Definitions 2 | \input{../templates/course_definitions} 3 | 4 | % Author and Course information 5 | \input{../templates/course_information} 6 | 7 | % Presentation title 8 | % TODO Change the topic of the lesson 9 | \title{Cool Topic} 10 | \date{\today} 11 | 12 | 13 | \begin{document} 14 | 15 | \maketitle 16 | 17 | \begin{frame}{Gliederung} 18 | \setbeamertemplate{section in toc}[sections numbered] 19 | \tableofcontents 20 | \end{frame} 21 | 22 | % TODO: Add your content right below here. 23 | 24 | 25 | 26 | \end{document} 27 | -------------------------------------------------------------------------------- /md/01_getting_started.md: -------------------------------------------------------------------------------- 1 | # Über diesen Kurs 2 | 3 | --- 4 | 5 | - 12 Kurseinheiten 6 | - setzt grundlegende Programmierkenntnisse voraus 7 | - Ressourcen 8 | - [auditorium](http://auditorium.inf.tu-dresden.de) 9 | - Google (python/python3 meine frage hier) landet oft in der 10 | python 2.7 Doku (Versionsswitcher im Menü) 11 | - [offizielle Dokumentation](docs.python.org) 12 | - unsere [Github-Organisation](https://github.com/fsr) 13 | - Hinweis: SCM’s sind hilfreich ([git](https://git-scm.com), 14 | [mercurial](http://mercurial.selenic.com/)) 15 | 16 | 17 |
    18 | Es ist für 11 Kurseinheiten offiziell Material vorhanden. 19 | Alle weiteres Stunden sollten sich auf Wünsche der Studenten beziehen. 20 |
    21 | 22 | 23 | # Der Python Interpreter 24 | 25 | --- 26 | 27 | - Die zwei verbreitet verwendeten Python Versionen sind 2.7 und 3.5, 28 | wir werden 3.5 nutzen, weil es cooler ist und bessere Features hat 29 | - Python kann [hier](https://www.python.org/downloads/) heruntergeladen und installiert werden oder mit dem 30 | Paketmanager eurer Wahl. (Das Paket sollte `python3` und 31 | `python3-dev` sein, außer unter Arch) 32 | 33 | --- 34 | 35 | - Python funktioniert am besten unter UNIX (ist aber okay 36 | unter Windows) 37 | - Den Interpreter startet man mit `python3` im Terminal oder mit 38 | `Python.exe` 39 | - Der Interpreter stellt die volle Funktionalität von Python bereit, 40 | einschließlich dem Erstellen von Klassen und Funktionen 41 | 42 | 43 | # Python Scripte 44 | 45 | ## Editor 46 | 47 | empfohlen (benutzen wir im Kurs) 48 | 49 | - [atom](https://atom.io) (weil Github) 50 | - [Sublime Text 3](http://www.sublimetext.com/3) (“Winrar-free”) 51 | - [cloud9](https://c9.i) (online, free für open source Projekte) 52 | 53 | ## IDEs 54 | 55 | hilfreich bei größeren Projekten, hier nicht genutzt 56 | 57 | - [PyCharm](https://jetbrains.com/pycharm) (free + professional für Studenten) 58 | 59 | ## Struktur 60 | 61 | - Python Scripte sind Textdateien, die auf `.py` enden 62 | - Python Packages sind Ordner mit einer `__init__.py` Datei (behandeln wir später) 63 | 64 | 65 | # Grundlagen der Sprache 66 | 67 | --- 68 | 69 | Python ist eine schwach typisierte Scriptsprache (weakly typed scripting language). Es gibt 70 | Typen (anders als in JavaScript), aber Variablen haben keine festen 71 | Typen. 72 | 73 | --- 74 | 75 | ## Kommentare: 76 | ```python 77 | # in python nur einzeilige Kommentare 78 | 79 | def my_function(params): 80 | """ 81 | Oder docstrings wie dieser, 82 | aber nur zu beginn einer Funktions- 83 | oder Klassendefinition 84 | """ 85 | pass 86 | ``` 87 | 88 | --- 89 | 90 | ## builtin Datentypen: 91 | 92 | | Name | Funktion | 93 | | :------------- | :------------- | 94 | | `object` |Basistyp, alles erbt von `object`| 95 | | `int` |Ganzzahl “beliebiger” Größe| 96 | | `float` |Kommazahl “beliebiger” Größe| 97 | | `bool` | Wahrheitswert (`True`, `False`)| 98 | | `None` | Typ des `None`-Objektes| 99 | | `type` | Grundtyp aller Typen (z.B. `int` ist eine Instanz von `int`)| 100 | 101 | --- 102 | 103 | | Name | Funktion | 104 | | :------------- | :------------- | 105 | | `list` | standard Liste| 106 | | `tuple` | unveränderbares n-Tupel| 107 | | `set` |(mathematische) Menge von Objekten| 108 | | `frozenset`| unveränderbare (mathematische) Menge von Objekten| 109 | | `dict` |Hash-Map| 110 | 111 | # Das erste Programm 112 | 113 | --- 114 | 115 | Ein simples “Hallo 116 | Welt”-Programm: 117 | ```python 118 | def my_function(): 119 | print('Hallo Welt!') 120 | 121 | if __name__ == '__main__': 122 | my_function() 123 | ``` 124 | 125 | --- 126 | 127 | ## Wichtige Eigenschaften: 128 | 129 | - Keine Semikolons 130 | - Keine geschweiften Klammern für Codeblöcke 131 | - Einrückungen zeigen Codeblöcke an 132 | - Funktionsaufrufe immer mit runden Klammern 133 | 134 | --- 135 | 136 | - Funktionen definieren mit 137 | ```python 138 | def ([parameter_liste, ...]): 139 | ``` 140 | - Variablen mit der Struktur `__name__` sind spezielle Werte (gewöhnlich aus `builtin` oder Methoden von Standardtypen) 141 | 142 | # Operatoren 143 | 144 | --- 145 | 146 | ## mathematisch 147 | 148 | `+`, `-`, `*`, `/` 149 | 150 | ## vergleichend 151 | 152 | `<`, `>`, `<=`, `>=`, `==` (Wert gleich), `is` (gleiches Objekt/gleiche Referenz) 153 | 154 | --- 155 | 156 | ## logisch 157 | 158 | `and`, `or`, `not` 159 | `(a && b) || (!c)` aus C oder Java entspricht in Python 160 | `(a and b) or not c` 161 | 162 | ## bitweise 163 | 164 | `&`, `|`, `<<`, `>>`, `^` (xor), `~` (invertieren) 165 | 166 | ## Accessoren 167 | 168 | `.` (für Methoden und Attribute), `[]` (für Datenstrukturen mit Index) 169 | 170 | # Namenskonvention 171 | 172 | --- 173 | 174 | 175 | ## Klassen 176 | 177 | *PascalCase*, alles direkt zusammen, groß beginnend und jedes neue Wort groß 178 | 179 | ## Variablen, Funktionen, Methoden 180 | 181 | *snake\_case*, alles klein und Wörter mit Unterstrich getrennt 182 | **Merke:** Da `-` ein Operator ist, ist es in Namen von Variablen, 183 | Funktionen etc. **nicht** zulässig (damit Python eine Kontextfreie Sprache ist) 184 | 185 | --- 186 | 187 | ## protected Variablen, Funktionen, Methoden 188 | 189 | beginnen mit einem Unterstrich `_` oder mit zweien `__` für private 190 | 191 | --- 192 | 193 | **Merke** 194 | Python hat kein Zugriffsmanagement. Die Regel mit dem Unterstrich 195 | ist nur eine Konvention um zu verhindern, dass andere Teile des 196 | Codes nutzen, der eine hohe Wahrscheinlichkeit hat in Zukunft 197 | verändert zu werden. 198 | 199 | # Strings 200 | 201 | --- 202 | 203 | ## Grundlagen 204 | 205 | 206 | - Der Typ eines Strings ist `str`. 207 | 208 | - Strings sind in Python immutable (nicht veränderbar). Jede String 209 | Operation erzeugt einen neuen String. 210 | 211 | - Ein String kann erzeugt werden mit einer Zeichenkette in 212 | Anführungszeichen, `''` oder `""` (beide sind äquivalent). 213 | 214 | - rohe Strings mir dem Präfix `r`, `r"mystring"` oder `r'mystring'` 215 | 216 | - Strings in Python3 sind UTF-8 encoded. 217 | 218 | --- 219 | 220 | ### Verknüpfen 221 | 222 | - Strings können durch Konkatenation verknüpft werden 223 | ```python 224 | ’Hallo’ + ’_’ + ’Welt’ # => ’Hallo_Welt’ 225 | ``` 226 | - Listen, Tupel etc. von Strings können via `str.join` verknüpft 227 | werden 228 | ```python 229 | ’_’.join([’Hallo’, ’Welt’]) # => ’Hallo_Welt’ 230 | ``` 231 | Dabei ist der String, auf welchem die Methode aufgerufen wird, 232 | der Separator. 233 | 234 | --- 235 | 236 | ## Formatierung 237 | 238 | Wir wollen den String `'my string 4 vier'` erzeugen. 239 | ```python 240 | # mit str.format() 241 | 242 | 'my string {} {}'.format(4, 'vier') 243 | # in Reihenfolge der argumente 244 | 245 | 'my string {number} {name}'.format(name='vier', number=4)‘ 246 | # via Name, Reihenfolge egal 247 | 248 | 'my string {number} {}'.format('vier', number=4) 249 | # oder beides kombiniert 250 | ``` 251 | --- 252 | 253 | Wir wollen den String `'my string 4 vier'` erzeugen. 254 | ```python 255 | # und mit dem %−Operator 256 | 257 | 'string%d%s'%(4, 'vier') 258 | # in Reihenfolge 259 | 260 | 'string %(number)d%(name)s' % {number:4, name:'vier'} 261 | # via Name 262 | ``` 263 | -------------------------------------------------------------------------------- /md/02_grundlagen.md: -------------------------------------------------------------------------------- 1 | # Scriptcharakter 2 | 3 | --- 4 | 5 | 6 | - Beim Ausführen oder Importieren wird der Code im obersten Level des 7 | Moduls (der .py Datei) ausgeführt 8 | - Funktionen, Klassen und globale Variablen werden üblicherweise 9 | auf dem obersten Level definiert 10 | - Imports anderer Python Module werden auch hier ausgeführt 11 | 12 | --- 13 | 14 | Soll das entsprechende Modul ausführbar sein und nicht 15 | nur als Bibliothek dienen, definiert man üblicherweise eine _main_-Funktion. 16 | Zusätzlich fügt man am Ende des Moduls die _Boilerplate_ ein. 17 | 18 | --- 19 | 20 | ```python 21 | def main(): 22 | pass 23 | 24 | if __name__ == '__main__': 25 | main() 26 | 27 | ``` 28 | 29 | --- 30 | 31 | - Python Code wird nicht kompiliert, sondern beim importieren in 32 | Python Bytecode übersetzt 33 | - Bytecode wird auf einer VM ausgeführt 34 | - Kein Memory Management nötig, alles sind Referenzen 35 | - Syntaxerror wird beim Importieren geworfen 36 | - Andere Fehler findet man erst, wenn die betreffende Zeile 37 | ausgeführt wird. 38 | 39 | # Programmierparadigmen 40 | 41 | ## Imperatives Programmieren 42 | 43 | - Python ist vor allem eine imperative und objektorientierte Sprache 44 | - reine Funktionen und Variablen können auf oberster Ebene definiert 45 | werden 46 | - Variablen, Klassen und Funktionen sind ab der Ebene sichtbar, in der 47 | sie eingeführt werden 48 | 49 | ## Das Scoping Problem 50 | 51 | Variablen sind zwar nach innen sichtbar, werden aber beim Reassignment 52 | innerhalb der Funktion neu angelegt und verschwinden so aus dem Scope. 53 | 54 | --- 55 | 56 | ```python 57 | var = 12 58 | 59 | def foo(): 60 | # erwarteter Effekt: var wird auf 9 gesetzt 61 | var = 9 62 | 63 | def main(): 64 | print(var) # -> gibt 12 zurueck 65 | foo() 66 | print(var) # -> Erwartung: gibt 9 aus. 67 | # Realitaet: gibt 12 aus. 68 | 69 | if __name__ == '__main__': 70 | main() 71 | ``` 72 | 73 | --- 74 | 75 | **Die Lösung:** 76 | ```python 77 | var = 12 78 | 79 | def foo(): 80 | global var 81 | # global sagt dem Interpreter, dass er hier auf die 82 | # oberhalb definierte Variable zurueckgreifen soll 83 | var = 9 84 | 85 | def main(): 86 | print(var) # -> gibt 12 zurueck 87 | foo() 88 | print(var) # -> gibt jetzt 9 aus 89 | 90 | if __name__ == '__main__': 91 | main() 92 | ``` 93 | 94 | ## Objektorientiertes Programmieren 95 | 96 | - Python ist auch fundamental objektorientiert 97 | - Alles in Python ist ein Objekt 98 | - Selbst die Datentypen `int`, `bool`, `str` und `type` sind Instanzen 99 | von `object` und haben folglich Methoden und Attribute 100 | - Der Typ jedes Wertes und jeder Variablen lässt sich mit `type()` 101 | ermitteln 102 | 103 | 104 | # Klassen und Attribute 105 | 106 | --- 107 | 108 | - Typen in Python werden ausgedrückt durch Klassen (Keyword `class`) 109 | - Klassen dienen als Vorlage bzw. Schablone -> Objekte sind dann 110 | Instanzen davon 111 | - Die Besonderheit: alle Variablen und Werte sind Instanzen von 112 | `object` 113 | 114 | --- 115 | 116 | `object` und alle Typen selbst sind widerum Objekte, genauer gesagt 117 | Instanzen vom Typ `type` und `type` widerum ist eine Subklasse von 118 | `object`. 119 | 120 | --- 121 | 122 | - Klassen und Objekte können selbst auch Variablen tragen (ähnlich wie 123 | in Java) 124 | - Man unterscheidet dabei zwischen Klassenattributen und 125 | Instanzattributen 126 | 127 | --- 128 | 129 | **Klassenattribute** 130 | werden für die Klasse definiert und sind für alle Instanzen gleich 131 | 132 | **Instanzattribute** 133 | werden außerhalb der Klassendefnition hinzugefügt (normalerweise 134 | im Initialisierer) und sind für jede Instanz unterschiedlich. 135 | 136 | --- 137 | 138 | - Zugriff auf Attribute über Punktnotation (wie in Ruby/Java) 139 | - Attribute werden wie Variablen mithilfe von `=` gesetzt 140 | - Man kann Objekten jederzeit neue Attribute hinzufügen (auch 141 | `type`-Objekten) 142 | - Ist außerhalb des Initialisierers nicht empfehlenswert 143 | 144 | 145 | ## Klassen- und Objektattribute im Detail 146 | 147 | --- 148 | 149 | Klassenattribute sind für jede Instanz eines Objektes gleich. 150 | ```python 151 | class TestClass: 152 | # jeder Instanz wird bei Erstellung bereits 153 | # dieses Attribut zugewiesen 154 | num = 12 155 | 156 | def main(): 157 | a = TestClass() 158 | b = TestClass() 159 | # beide Variablen haben fuer 'num' von der 160 | # Erstellung an den gleichen Wert 161 | 162 | # das Aendern der Variable ueberschreibt das 163 | # Klassenattribut mit einem Instanzattribut 164 | a.num = -3 165 | print(b.num) # -> liefert immer noch 12 166 | ``` 167 | 168 | --- 169 | 170 | Gewöhnlich definiert man Instanzattribute allerdings im 171 | *Initialisierer*. 172 | ```python 173 | class Human: 174 | def __init__(self, firstname, lastname): 175 | # die beiden Parameterwerte werden in Instanz- 176 | # attributen gespeichert. 177 | self.firstname = firstname 178 | self.lastame = lastname 179 | 180 | def main(): 181 | # instanziiert zwei Objekte vom Typ 'Human' 182 | matthias = Human("Matthias", "Stuhlbein") 183 | john = Human("John", "Doe") 184 | ``` 185 | Instanzattribute sollten immer in \_\_init\_\_ definiert werden, um 186 | sicherzustellen, dass alle Instanzen die gleichen Attribute haben 187 | 188 | 189 | ## Super- und Subklassen 190 | 191 | Eine Klasse kann Attribute einer anderen Klasse erben, indem sie mit 192 | ```python 193 | class subclass(superclass): 194 | ``` 195 | definiert wird. 196 | 197 | --- 198 | 199 | - Subklassen enthalten von Anfang an alle Attribute der Superklasse. 200 | - Es können neue Variablen und Methoden hinzugefügt, und auch alte überschrieben werden. 201 | - Die Attribute der Superklasse können mit `super()` aufgerufen werden. 202 | 203 | --- 204 | 205 | ```python 206 | class Human(): 207 | def __init__(self, fistname, lastname, dob): 208 | self.firstname = firstname 209 | self.lastname = lastname 210 | self.dob = dob 211 | 212 | 213 | class Child(Human): 214 | # Ein Child ist einfach nur ein Human mit den 215 | # zusaetzlichen Attributen father und mother 216 | def __init__(self, fistname, lastname, dob, father, mother): 217 | super.__init__(fistname, lastname, dob) 218 | self.father = father 219 | self.mother = mother 220 | ``` 221 | 222 | # Methoden 223 | 224 | --- 225 | 226 | 227 | - Methoden sind Funktionen 228 | - Allgemeiner Typ von Methoden ist daher `function` 229 | - Methoden liegen im Namespace der zugehörigen Klasse, müssen daher 230 | mit `ClassName.method_name()` angesteuert werden (oder auf dem 231 | Objekt aufgerufen werden) 232 | 233 | --- 234 | 235 | - Methoden haben ein implizites erstes Argument (typischerweise “self” 236 | genannt, kann aber variieren) 237 | - Beim Aufruf auf einer Instanz wird das Objekt selbst automatisch 238 | übergeben 239 | 240 | ## Spezielle Methoden 241 | 242 | Dies sind Methoden die auf den meisten 243 | Grundlegenden Datenstrukturen implementiert sind, z.B. `object`.\ 244 | Die Folgenden beginnen und enden normalerweise mit zwei Unterstrichen. 245 | 246 | --- 247 | 248 | **Initialisierer** 249 | Oft auch (fälschlicherweise) Konstruktor genannt. 250 | Name: `__init__` 251 | Wird immer aufgerufen wenn eine neue Instanz der Klasse erstellt wird. 252 | 253 | --- 254 | 255 | **Finalisierer** 256 | Oft auch (fälschlicherweise) Destructor genannt. 257 | Name: `__del__` 258 | Wird immer aufgerufen wenn das Objekt vom Garbage Collector aufgeräumt wird. 259 | (selten verwendet) 260 | 261 | --- 262 | 263 | **String Konvertierer** 264 | Äquivalent zu Java’s `toString` Methode. Name: `__str__` 265 | 266 | **String Repräsentation** 267 | Ähnlich wie `__str__` aber gedacht für eine für Debug verwendbare Repräsentation anstatt für Output wie `__str__`. 268 | -------------------------------------------------------------------------------- /md/03_builtins.md: -------------------------------------------------------------------------------- 1 | # Exception Handling 2 | 3 | --- 4 | 5 | - Alle Exceptions erben von `Exception` 6 | - Catching mit try/except 7 | - `finally` um Code auszuführen, der *unbedingt* laufen muss, egal ob 8 | eine Exception vorliegt oder nicht 9 | 10 | --- 11 | 12 | ```python 13 | class MyException(Exception): 14 | def __init__(self, message): 15 | self.message = message 16 | 17 | def __repr__(self): 18 | return '{} mit nachricht {}'.format(self.__class__, 19 | self.message) 20 | ``` 21 | 22 | --- 23 | 24 | ```python 25 | try: 26 | # code 27 | raise KeyError('message') 28 | # mit nur einer exception 29 | # except MyException as error: 30 | except (KeyError, MyException) as error: 31 | print(error) 32 | pass 33 | finally: 34 | # was unbedingt zu tun ist 35 | 36 | ``` 37 | 38 | # Boolsche Werte 39 | 40 | --- 41 | 42 | - *type* ist `bool` 43 | - Mögliche Werte: `True` oder `False` 44 | - Operationen sind *und*, *oder*, *nicht* (`and, or, not`) 45 | 46 | 47 | # list 48 | 49 | --- 50 | 51 | - enthält variable Anzahl von Objekten 52 | - eine Liste kann beliebig viele verschiedene Datentypen 53 | enthalten (z.B. `bool` und `list`) 54 | - Auch Listen können in Listen gespeichert werden! 55 | - Listenobjekte haben eine feste Reihenfolge (*first in, last out*) 56 | - optimiert für einseitige Benutzung wie z.B. Queue (`append` und 57 | `pop`) 58 | 59 | --- 60 | 61 | ```python 62 | l = [1, 9, 'string', object] 63 | 64 | isinstance(l[0], int) # ==> True 65 | l[1] == 9 # ==> True 66 | len(l) # ==> 4 67 | 68 | 9 in l # ==> True 69 | 70 | l.pop() # ==> object 71 | len(l) # ==> 3 72 | l.append([]) # ==> None 73 | 74 | l # ==> [1, 9, 'string', []] 75 | len(l) # ==> 4 76 | ``` 77 | 78 | # tuple 79 | 80 | --- 81 | 82 | - Gruppiert Daten 83 | - kann nicht mehr verändert werden, sobald es erstellt wurde 84 | - Funktionen mit mehreren Rückgabewerten geben ein Tupel zurück 85 | 86 | --- 87 | 88 | ```python 89 | # Tupel mit 3 Elementen 90 | t = (1, 3, 'ein string') 91 | isinstance(t, tuple) # ==> True 92 | 93 | t[0] == 1 # ==> True 94 | t[1] == 3 # ==> True 95 | t[2] == 'ein string' # ==> True 96 | t[4] == 'ein string' # ==> IndexError: tuple index out of range 97 | t[2] = 'ein anderer string' # ==> TypeError: 'tuple' object 98 | # does not support item assignment 99 | 100 | # oder auch ohne klammern 101 | t = 1, 3, 'ein string' 102 | # macht es (manchmal) besser lesbar, z.b. bei 103 | return 1, 2, 5 104 | ``` 105 | 106 | # dict 107 | 108 | --- 109 | 110 | - einfache HashMap 111 | - ungeordnet 112 | - jeder hashbare Typ kann ein Key sein 113 | - jedem Key ist dann ein Value zugeordnet 114 | 115 | --- 116 | 117 | ```python 118 | d = { 'm': 4, 3: 'val2', object: 'auch typen koennen keys sein' } 119 | 120 | d[3] # ==> "val2" 121 | d['q'] # ==> KeyError: 'q' 122 | d.get('q') # ==> None 123 | d.get('q', 5) # ==> 5 124 | 125 | d[0] = 7 126 | d # ==> {3: 'val2', 'm': 4, 'q': 5, 127 | # : 'auch typen koennen schluessel sein'} 128 | ``` 129 | 130 | --- 131 | 132 | ```python 133 | d.setdefault('m') # ==> 4 134 | d.setdefault('q', 5) # ==> 5 135 | d # ==> { 'm': 4, 3: 'val2', 136 | # object: 'auch typen koennen keys sein', 137 | # 0:7, 'q': 5 } 138 | len(d) # ==> 5 139 | d.keys() # ==> dict_keys([3, 0, 'm', 'q', ]) 140 | d.values() # ==> dict_values(['val2', 7, 4, 5, 141 | # 'auch typen koennen keys sein']) 142 | d.items() # ==> dict_items([(3, 'val2'), (0, 7), ('m', 4), 143 | # ('q', 5), (, 144 | # 'auch typen koennen ...')]) 145 | 146 | 'm' in d # ==> True 147 | object in d # ==> True 148 | tuple in d # ==> False 149 | ``` 150 | 151 | # set/frozenset 152 | 153 | --- 154 | 155 | - kann nur hashbare Einträge enthalten 156 | - `set` selbst ist nicht hashbar 157 | - `frozensets` sind hashbar, jedoch nicht mehr veränderbar 158 | - enthält jedes Element nur einmal 159 | 160 | --- 161 | 162 | - schnellere Überprüfung mit `in` (prüft, ob Element enthalten ist) 163 | - Mögliche Operationen: `superset()`, `subset()`, `isdisjoint()`, 164 | `difference()`, `<`, `>`, `disjoint()`, `-` 165 | - ungeordnet 166 | - (frozen)sets können frozensets enthalten 167 | 168 | --- 169 | 170 | ```python 171 | s1 = {1, 2, 'string', object, ('ein', 'tuple')} 172 | 173 | 2 in s1 # ==> True 174 | 'ein' in s1 # ==> False 175 | ('ein', 'tuple') in s1 # ==> True 176 | set(('ein', 'tuple')) # ==> {'ein', 'tuple'} 177 | 178 | s2 = {'anderes', 'set'} 179 | s1 > s2 # ==> False 180 | s1.isdisjoint(s2) # ==> True 181 | 182 | s1.add('anderes') 183 | s1 | s2 # ==> {1, 2, 'string', object, ('ein', 'tuple'), 'set'} 184 | s1 & s2 # ==> {'anderes'} 185 | s2 - s1 # ==> {'set'} 186 | ``` 187 | 188 | --- 189 | 190 | ```python 191 | s2 = frozenset(s2) 192 | s1.add(s2) 193 | s2.add(5) # ==> AttributeError: 'frozenset' object has no attribute 'add' 194 | ``` 195 | 196 | # Iteraton 197 | 198 | --- 199 | 200 | - nur foreach 201 | - für Iterationen über Integer gibt es `range([start], stop, step=1)` 202 | - um Iteratoren zu kombinieren kann man 203 | `zip(iterator_1, iterator_2, ..., iterator_n)` verwenden 204 | - alles mit einer `__iter__` Methode ist iterierbar 205 | - `iter(iterable)` konstruiert einen *stateful iterator* 206 | 207 | --- 208 | 209 | ```python 210 | for i in [1,2,3]: 211 | if i > 9: 212 | break 213 | # code 214 | else: 215 | pass 216 | # wenn kein break vorkommt 217 | 218 | for i in (1,2,3): 219 | # code 220 | pass 221 | 222 | for i in {1:'value1', 2:'value2'}: 223 | # iteration ueber die keys 224 | pass 225 | ``` 226 | 227 | --- 228 | 229 | ```python 230 | for i in {1:'value1', 2:'value2'}.items(): 231 | # i ist tuple von (key, value) 232 | pass 233 | 234 | for value1, value2 in [ 235 | (1, 'werner'), 236 | (3, 'geh mal in den keller'), 237 | (42, 'ich glaub die russen komm\'') 238 | ]: 239 | # iteration mit tuple unpacking 240 | # code 241 | ``` 242 | 243 | --- 244 | 245 | ```python 246 | # oder auch 247 | 248 | for value1, value2 in zip([1,3,42], ['werner', 249 | 'geh mal in den keller', 250 | 'ich glaub die russen komm\'', 251 | 'dieser string wird in \ 252 | der iteration nicht auftauchen', 'dieser auch nicht']) 253 | 254 | for key, value in {1:'value1', 2:'value2'}.items(): 255 | # iteration ueber keys und values mit tuple unpacking 256 | pass 257 | ``` 258 | 259 | # unpacking 260 | 261 | --- 262 | 263 | - einfaches Auflösen von Listen und Tupeln in einzelne Variablen 264 | - nützlich in `for`-Schleifen 265 | 266 | --- 267 | 268 | ```python 269 | # unpacking (geht auch mit listen) 270 | t = 1, 3, 'ein string' # tuple ohne klammern gebaut 271 | 272 | x, y, z = t 273 | x is t[0] # ==> True 274 | y is t[1] # ==> True 275 | 276 | x, *y = t 277 | x # ==> 1 278 | y # ==> [3, 'ein string'] 279 | 280 | a, b, c = 1, 2, 4 281 | 282 | d, e, f, *g = [3, 0, 8, 7, 46, 42] 283 | f # ==> 8 284 | g # ==> [7, 46, 42] 285 | ``` 286 | 287 | # Context Manager 288 | 289 | --- 290 | 291 | - Aufruf mit `with` 292 | - kann jedes Objekt sein, welches eine `__enter__` und `__exit__` 293 | Methode hat 294 | - praktisch beim *File Handling* 295 | 296 | --- 297 | 298 | ```python 299 | class MyManager: 300 | def __enter__(self): 301 | # tue dinge 302 | pass 303 | 304 | def __exit__(self): 305 | # schliesse handler etc ... 306 | pass 307 | 308 | def do_things(self): 309 | # ... 310 | pass 311 | 312 | with MyManager() as m: 313 | m.do_things() 314 | ``` 315 | 316 | #File Handling 317 | 318 | --- 319 | 320 | - Dateien können mit `open(filename, mode=r)` geöffnet werden 321 | - *File Handler* sind Iteratoren über die Zeilen einer Datei 322 | - **Wichtig:** File Handler müssen auch wieder geschlossen werden 323 | - `r` steht für Lesezugriff, `w` für Schreibzugriff 324 | 325 | **Beachte:** Wird eine Datei mit Schreibzugriff geöffnet, wird 326 | sie geleert! Also wichtige Inhalte vorher auslesen. 327 | 328 | --- 329 | 330 | ```python 331 | with open(myfile, mode='r') as f: 332 | for line in f: 333 | # code 334 | 335 | with open(myfile, mode='w+') as f: 336 | 337 | for line in document: 338 | f.write(line) 339 | # oder 340 | print(line, file=f) 341 | 342 | f = open(myfile) 343 | # code 344 | f.close() 345 | ``` 346 | -------------------------------------------------------------------------------- /md/04_modules_packages_pip.md: -------------------------------------------------------------------------------- 1 | # Module 2 | 3 | ## (Eigene) Module 4 | 5 | 6 | - Ein Modul ist die python-interne Repräsentation einer `.py` Datei 7 | - Der Dateiname setzt sich daher aus Modulname + `.py` zusammen 8 | 9 | --- 10 | 11 | - Module beinhalten eine beliebige Anzahl an Definitionen (Klassen, 12 | Funktionen, Variablen/Konstanten) 13 | - Das komplette Modul wird mit `import` hinzugefügt 14 | - Einzelne Inhalte mit `from` Modul `import` Name 15 | - Mit Hilfe von `as` kann ein Alias für den importierten Namen 16 | angelegt werden 17 | 18 | --- 19 | 20 | ### Ein Beispiel 21 | 22 | Die Datei **incdec.py** enthält eine Reihe von 23 | Funktionen: 24 | 25 | ```python 26 | def increment(a): 27 | return a+1 28 | 29 | def decrement(a): 30 | return a-1 31 | ``` 32 | 33 | --- 34 | 35 | In einem anderen Python-Script kann ich diese 36 | Funktionen nutzen: 37 | 38 | ```python 39 | # Importieren des kompletten Moduls incdec 40 | import incdec 41 | 42 | # Die Funktionen koennen wie folgt aufgerufen werden: 43 | incdec.increment(3) # => 4 44 | incdec.decrement(3) # => 2 45 | 46 | # Importieren einzelner Funktionen 47 | from incdec import increment 48 | 49 | # Diese kann jetzt sofort aufgerufen werden 50 | increment(3) # => 4 51 | ``` 52 | 53 | --- 54 | 55 | ```python 56 | # Alias fuer Module verwenden 57 | import incdec as plusoneminusone 58 | 59 | plusoneminusone.inrement(3) # => 4 60 | ``` 61 | 62 | --- 63 | 64 | ### Der Sinn der Boilerplate 65 | 66 | - Verhindert, dass Code beim Importieren eines Scriptes ausgeführt 67 | wird 68 | - Beim Aufruf des Moduls über `import` ist der Name des Moduls nicht 69 | `__main__`, sondern der Name des Scriptes (im vorherigen Beispiel 70 | wäre das `incdec`) 71 | 72 | ## Suchpfad für Module 73 | 74 | --- 75 | 76 | - Python sucht Module beim Import an allen im **PYTHONPATH** 77 | aufgelisteten Ordnern 78 | - dieser findet sich in Python unter `sys.path`, in der Kommandozeile 79 | in der Umgebungsvariable PYTHONPATH 80 | - `sys.path` lässt sich zur Laufzeit im Interpreter ändern (z.B. um 81 | nachträglich neue eigene Module hinzuzufügen) 82 | 83 | --- 84 | 85 | Standardmäßig enthält der Suchpfad 86 | folgende Module: 87 | 88 | - die *Standardbibliothek* der derzeitig verwendeten Python-Version 89 | - das *aktuelle Verzeichnis*, in dem der Interpreter aufgerufen wurde 90 | - eine *Verzeichnis mit plattfomspezifischen Modulen*, z.B. 91 | “/usr/local/Cellar/python3/3.5.1/Frameworks/Python.framework/ 92 | Versions/3.5/lib/python3.5/plat-darwin” für Mac 93 | - *Benutzerspezifische Module für die jeweilige Python Version*, z.B. 94 | “/usr/local/lib/python3.5/site-packages” für Python 3.5 95 | 96 | ## Suchpfad modifizieren 97 | 98 | --- 99 | 100 | Zusätzliche Verzeichnisse für den 101 | PYTHONPATH kann man beim Aufruf übergeben: 102 | 103 | `$ PYTHONPATH=/my/directory python3 script.py` 104 | 105 | --- 106 | 107 | Oder im Programm: 108 | 109 | ```python 110 | import sys 111 | 112 | sys.path.append('my/directory') 113 | ``` 114 | 115 | Änderungen am Pfad sind erst **nach** der 116 | entsprechenden Codezeile verfügbar. 117 | 118 | ## Standardmodule 119 | 120 | --- 121 | 122 | Python liefert viele nützliche Module 123 | bereits in der Standardbibliothek mit, z.B.: `sys`, `os`, `http`, `re`, 124 | `functools`, `itertools`, `collections`, `hashlib`, `urllib` und viele 125 | mehr. 126 | 127 | Daher bezeichnet man Python oft auch als **Batteries included**. 128 | 129 | # Packages 130 | 131 | --- 132 | 133 | - Packages sind Ordner, die mindestens ein `__init__.py` 134 | Modul enthalten. 135 | - der Inhalt dieses Moduls ist prinzipiell egal 136 | - Packages können genau wie Module importiert werden 137 | 138 | --- 139 | 140 | - Wird das Package selbst importiert, sind alle Definitionen in 141 | `__init__.py` über das importierte Package erreichbar. 142 | - wird benutzt, um Module in sinnvolle Gruppen zusammenzufassen 143 | 144 | # PIP 145 | 146 | 147 | 148 | ## Installation von PIP 149 | 150 | --- 151 | 152 | Nicht jedes Modul ist in der Standardbibliothek vorhanden, 153 | muss aber nicht zwingen manuell als Datei hinzugefügt werden. 154 | Man kann ganz einfach PIP zur Hilfe nehmen. 155 | 156 | --- 157 | 158 | **Installation:** 159 | 160 | 1. Downloaden der `get-pip.py` von pypa 161 | 2. Installieren via `python3 get-pip.py` 162 | 163 | 164 | *Hinweis für Mac-Nutzer:* 165 | Bei der Pythoninstallation via *Homebrew* wird pip gleich mit 166 | installiert. 167 | 168 | ## Verwendung 169 | 170 | --- 171 | 172 | Die Installation von Modulen ist einfach und es 173 | gibt mehrere Möglichkeiten: 174 | 175 | - die aktuellste Version eines Moduls: 176 | `pip install Modulname` 177 | - eine bestimmte Version: 178 | `pip install Modulname==2.1` 179 | - alle Versionen ab einem Minimum: 180 | `pip install Modulname>=2.1` 181 | - alle Versionen bis zu einem Maximum: 182 | `pip install Modulname<=2.1` 183 | 184 | ## Die requirements.txt 185 | 186 | --- 187 | 188 | Wenn jemand Scripte ausführen möchte, in denen Module verwendet werden, 189 | die mit Hilfe von PIP installiert wurden, ist es hilfreich eine 190 | `requirements.txt` mitzuliefern. In dieser sind alle Module aufgelistet, 191 | die benötigt werden. 192 | Via `pip install -r requirements.txt` können alle 193 | Module von der Liste installiert werden. 194 | -------------------------------------------------------------------------------- /md/05_decorators.md: -------------------------------------------------------------------------------- 1 | # Fakten über Funktionen 2 | 3 | --- 4 | 5 | 6 | - Funktionen können Variablen zugewiesen werden, 7 | 8 | ```python 9 | # Funktionen Variablen zuweisen 10 | def return_hello(): 11 | return "Hello" 12 | 13 | say_hello = return_hello 14 | 15 | print(say_hello()) 16 | # => Hello 17 | ``` 18 | 19 | --- 20 | 21 | - Sie können in Funktionen definiert werden, 22 | 23 | ```python 24 | # Funktionen in Funktionen definieren 25 | def greet(name): 26 | def return_hello(): 27 | return "Hello " 28 | greeting = return_hello() + name 29 | return greeting 30 | 31 | print(greet("World")) 32 | # => Hello World 33 | ``` 34 | 35 | --- 36 | 37 | - Sie können andere Funktionen zurückgeben, 38 | 39 | ```python 40 | # Rueckgabe von Funktionen 41 | def greet(): 42 | def say_hello(): 43 | return "Hello" 44 | return say_hello 45 | 46 | print(greet()) 47 | # Hello 48 | ``` 49 | 50 | --- 51 | 52 | - Sie können als Parameter mitgegeben werden 53 | 54 | ```python 55 | # Uebergabe von Funktionen 56 | def say_date(date): 57 | return "Today it's {date}".format(date=date) 58 | 59 | def which_date(function): 60 | date = "25th June 2015" 61 | return function(date) 62 | 63 | print(which_date(say_date)) 64 | # => Today it's 25th June 2015 65 | ``` 66 | 67 | # Decorator 68 | 69 | ## einfache Decorator 70 | 71 | 72 | Decorator sind Wrapper über existierende Funktionen. 73 | Dabei werden die zuvor genannten Eigenschaften verwendet. 74 | Eine Funktion, die eine weitere als Argument hat, erstellt eine neue 75 | Funktion. 76 | 77 | --- 78 | 79 | ```python 80 | def get_date(date): 81 | return ", today it's {}.".format(date) 82 | 83 | 84 | # unser decorator 85 | def tell_the_world(func): 86 | def complete_sentence(date): 87 | return "Hello World{}".format(func(date)) 88 | return complete_sentence 89 | ``` 90 | 91 | --- 92 | 93 | ```python 94 | # normaler Aufruf: 95 | print(tell_the_world(get_date)("25th June 2015")) 96 | 97 | # als decorator 98 | get_date = tell_the_world(get_date) 99 | 100 | print(get_date("25th June 2015")) 101 | # => Hello World, today it's 25th June 2015. 102 | ``` 103 | 104 | --- 105 | 106 | Durch das `@` Symbol lässt sich der Decorator wesentlich einfacher verwenden. 107 | Es können auch mehrere Decorator übereinander geschrieben werden. 108 | 109 | --- 110 | 111 | ```python 112 | # Nutzung des @ Syntaxes 113 | def tell_the_world(func): 114 | def complete_sentence(date): 115 | return "Hello World, {}".format(func(date)) 116 | return complete_sentence 117 | 118 | 119 | @tell_the_world 120 | def get_date(date): 121 | return "today it's {}.".format(date) 122 | 123 | print(get_date("25th June 2015")) 124 | # => Hello World, today it's 25th June 2015. 125 | ``` 126 | 127 | ## Decorator mit Argumenten 128 | 129 | 130 | Decorator erwarten Funktionen als 131 | Argumente. Aus diesem Grund kann man nicht einfach andere Argumente 132 | mitgeben, sondern man muss eine Funktion schreiben, die dann den 133 | Decorator erstellt. 134 | 135 | --- 136 | 137 | ```python 138 | # Decorator mit Argumenten 139 | def tell_the_date_to(name): 140 | def name_decorator(func): 141 | def complete_sentence(date): 142 | return "Hello {name}, {date}".format(name=name, 143 | date=func(date)) 144 | return complete_sentence 145 | return name_decorator 146 | 147 | 148 | @tell_the_date_to("John Doe") 149 | def get_date(date): 150 | return "today it's {}.".format(date) 151 | 152 | print(get_date("25th June 2015")) 153 | # => Hello John Doe, today it's 25th June 2015. 154 | ``` 155 | -------------------------------------------------------------------------------- /md/06_comprehensions.md: -------------------------------------------------------------------------------- 1 | # Basics 2 | 3 | --- 4 | 5 | Comprehensions sind eine bequeme Art und Weise, um 6 | _Funktoren_ (Datenstrukturen, die andere Datenstrukturen beinhalten) mit 7 | kleinen Expressions zu erstellen und zu füllen und sind in allen 8 | modernen Sprachen vorhanden. 9 | 10 | 11 | # List Comprehensions 12 | 13 | --- 14 | 15 | 16 | Grundlegender Syntax: 17 | 18 | ```python 19 | [EXPRESSION for LAUFVARIABLE in ITERABLE (if FILTER)] 20 | ``` 21 | 22 | 23 | ### EXPRESSION 24 | 25 | ein beliebiger Ausdruck (man stelle sich ein implizites 26 | `return` vor), etwa ein Wert, eine Variable, eine Gleichung, etc ... 27 | 28 | `EXPRESSION` wird am Ende in der Liste abgelegt. 29 | 30 | --- 31 | 32 | ### LAUFVARIABLE 33 | 34 | Eine beliebige Variable, die in *EXPRESSION* und *FILTER* zur 35 | Verfügung steht 36 | 37 | --- 38 | 39 | ### ITERABLE 40 | 41 | Ist häufig etwas wie `range()` oder eine andere Liste. 42 | 43 | --- 44 | 45 | ### FILTER 46 | 47 | Eine optionale boolean expression, womit Einträge gefiltert werden 48 | (falls Expression `false`) Nützlich, wenn z.B. nur gerade Zahlen übernommen werden 49 | sollen, usw... 50 | 51 | --- 52 | 53 | ### Beispiel 54 | 55 | ```python 56 | varList = [var * 8 for var in range(10)] 57 | # => [0, 8, 16, 24, 32, 40, 48, 56, 64, 72] 58 | 59 | 60 | # mit Filter (hier: für i ist gerade) 61 | evenVarList = [var * 8 for var in range(10) if var % 2 == 0] 62 | # => [0, 16, 32, 48, 64] 63 | ``` 64 | 65 | 66 | # Dict Comprehension 67 | 68 | --- 69 | 70 | Grundlegender Syntax: 71 | 72 | ```python 73 | {KEY: VALUE for LAUFVARIABLE in ITERABLE (if FILTER)} 74 | ``` 75 | 76 | --- 77 | 78 | Fast der gleiche Syntax, nur diesmal mit 2 Expressions: __KEY__ und 79 | __VALUE__. Ansonsten gelten die gleichen Regeln. 80 | 81 | 82 | ## Beispiel 83 | 84 | ```python 85 | liste = ["Fritz", "Alex", "Nadine", "Peter", "Anna"] 86 | 87 | names = {key: len(key) for key in liste} 88 | # => {'Peter': 5, 'Fritz': 5, 'Alex': 4, 'Anna': 4, 'Nadine': 6} 89 | ``` 90 | 91 | 92 | # Generators 93 | 94 | ## Generator 95 | 96 | Ein Objekt, über das iteriert werden kann. Wenn ein Element daraus 97 | verwendet wurde, ist es nicht mehr in dem Generatorobjekt 98 | enthalten. 99 | 100 | --- 101 | 102 | Die grundlegende Syntax ist gleich der einer *List Comprehension*. Da 103 | sich `list` und `dict` auch aus Iterables bauen lassen, gilt prinzipiell: 104 | 105 | ```python 106 | list(EXPR for VAR in ITERABLE) == [EXPR for VAR in ITERABLE] 107 | ``` 108 | und 109 | ```python 110 | dict((KEY, VAL) for VAR in ITERABLE) == {KEY: VAL for VAR in ITERABLE} 111 | ``` 112 | 113 | --- 114 | 115 | **Aber:** Generators verhalten sich anders als Lists oder Dicts! 116 | -------------------------------------------------------------------------------- /md/07_functions_advanced.md: -------------------------------------------------------------------------------- 1 | # Nutzung von Funktionen 2 | 3 | 4 | ## Funktionen als Werte 5 | 6 | --- 7 | 8 | Funktionen können wie alle 9 | anderen Werte zugewiesen werden 10 | 11 | ```python 12 | def function(params): 13 | return 4 14 | 15 | my_var = function 16 | my_var(2) # ==> 4 17 | ``` 18 | 19 | --- 20 | 21 | Oder als Parameter mitgegeben werden 22 | 23 | ```python 24 | def callif(boolean, callback): 25 | if boolean: 26 | callback() 27 | 28 | callif(True, lambda: print("hello world")) 29 | ``` 30 | 31 | --- 32 | 33 | ## Methoden sind Funktionen 34 | 35 | ```python 36 | class MyClass(object): 37 | def function(self, param): 38 | return 4 39 | 40 | my_var = MyClass.function 41 | my_var(MyClass(), 2) # ==> 4 42 | ``` 43 | 44 | 45 | ## Default Parameter 46 | 47 | --- 48 | 49 | 50 | - Funktionen können vordefinierte Werte für Parameter haben. 51 | 52 | - Parameter ohne `default`-Werten werden positionale Argumente genannt 53 | 54 | - Parameter mit `default`-Werten werden benannte Argumente genannt 55 | 56 | --- 57 | 58 | ```python 59 | def greet(name, greeting='Hello'): 60 | return '{} {}'.format(greeting, name) 61 | 62 | greet('Herbert') 63 | # ==> 'Hallo Herbert' 64 | 65 | greet('Herbert', 'Gruess Gott') 66 | # ==> 'Gruess Gott Herbert' 67 | ``` 68 | 69 | --- 70 | 71 | ## ACHTUNG! 72 | 73 | --- 74 | 75 | __Niemals `mutable Values` (änderbare Werte) als `default`-Parameter verwenden!__ 76 | 77 | --- 78 | 79 | __mutable Values:__ 80 | 81 | `list`, `dict`, `set` und eigene Klassen (bzw. deren Attribute) 82 | 83 | __immutable Values:__ 84 | 85 | `string`, `function`, `int`, `type` und `None` 86 | 87 | --- 88 | 89 | __Warum?__ 90 | 91 | ```python 92 | def func(param1, param2=[]): 93 | print(param2) 94 | param2.append(param1) 95 | ``` 96 | 97 | --- 98 | 99 | Man denkt, die Funktion hat jedes mal eine leere 100 | List, jedoch passiert folgendes: 101 | 102 | ```python 103 | func(1) # ==> [] 104 | func(2) # ==> [1] 105 | func('j') # ==> [1,2] 106 | ``` 107 | 108 | Die Liste wird einmalig zum Start angelegt und fortgeführt. 109 | 110 | --- 111 | 112 | So sollte man es machen: 113 | 114 | ```python 115 | def func(param1, param2=None): 116 | param2 = [] if param2 is None else param2 117 | pass 118 | ``` 119 | 120 | Den `default`-Parameter als `None` setzten und dann, falls er `None` ist 121 | als z.B. leere Liste setzen. 122 | 123 | --- 124 | 125 | ## Aufruf mit Namen 126 | 127 | --- 128 | 129 | Funktionsparameter können 130 | direkt mit ihrem Namen aufgerufen werden, dann spielt die 131 | Aufrufreihenfolge keine Rolle mehr. 132 | 133 | --- 134 | 135 | ```python 136 | def land(house, tree, pond): 137 | return 'You own land with a {} \ 138 | a {} and a {}'.format(house, tree, pond) 139 | 140 | land('green house', 'maple', 'fish pond') 141 | 142 | # oder mit Aufruf durch Namen: 143 | land(house='green house', pond='fish pond', tree='maple') 144 | 145 | # oder vermischt 146 | land('green house', pond='fish pond', tree='maple') 147 | 148 | # folgendes funktioniert NICHT! 149 | land('maple', house='green house', tree='maple') 150 | ``` 151 | 152 | --- 153 | 154 | __Es gelten folgende Regeln:__ 155 | 156 | - Alle Parameter können an ihrer Position angesprochen werden 157 | - Es können auch alle mit ihrem Namen angesprochen werden 158 | - Wenn eins mit dem Namen angesprochen wurde, müssen die folgenden 159 | ebenfalls mit Namen angesprochen werden 160 | 161 | 162 | # Aggregatoren 163 | 164 | --- 165 | 166 | **Aggregatoren** (auch Sammler genannt), sind 167 | sehr nützlich, wenn man, zusätzlich zu bereits definierten Parametern, 168 | in einer Funktion eine unbestimmte Anzahl an Funktionsargumenten 169 | entgegen nehmen will. 170 | 171 | ## Positionale Aggregatoren 172 | 173 | --- 174 | 175 | - jede Funktion kann einen Aggregator haben 176 | - dieser muss der *letzte* positionale Parameter sein 177 | - Positionale Aggregatoren werden durch einen `*` gekennzeichnet 178 | - nach einem Aggregator können nur noch benamte Parameter definiert 179 | werden, diese müssen auch mit Namen aufgerufen werden\ 180 | 181 | --- 182 | 183 | Der Inhalt des Aggregators wird in einem *Tupel* gespeichert: 184 | 185 | ```python 186 | def f(*args): 187 | print(type(args)) # ==> tuple 188 | ``` 189 | 190 | --- 191 | 192 | ### Beispiel 193 | 194 | ```python 195 | def function(param1, *aggr, param2=0): 196 | pass 197 | 198 | function(1, 2, 3, 4) # korrekt, aggr = (2,3,4) 199 | function(1, 2, 4, 5, 6, 78, 9, 90, 0) 200 | # auch korrekt, aggr = (2,4,5,6,78,9,90,0) 201 | function() # inkorrekt, param1 braucht mindestens ein Argument 202 | function(1, param2=7) # korrekt, aggr = () 203 | function(param2=8) # inkorrekt, param1 braucht einen Wert 204 | function(param2=0, param1=6) # korrekt 205 | ``` 206 | 207 | --- 208 | 209 | - Eine Funktion kann auch nur einen Aggregator als Parameter 210 | entgegennehmen (keine anderen Parameter) 211 | - Ohne Argumente ergibt sich `len(args)` zu 0 212 | - Werden keine anderen Parameter erwartet, nennt man den Aggregator 213 | meist `args` (kurz für *Arguments*)\ 214 | 215 | --- 216 | 217 | In **Python 3** kann man Aggregatoren auch ohne Namen definieren: 218 | ```python 219 | def function(param1, param2, *, param3=6): 220 | pass 221 | ``` 222 | Auf diesen Aggregator kann nicht zugegriffen werden. Er erzwingt lediglich, 223 | dass alle folgenden Parameter mit Namen aufgerufen werden. 224 | 225 | ## Benannte Aggregatoren 226 | 227 | --- 228 | 229 | Analog zu Parametern gibt es auch benannte Aggregatoren. Diese werden mit `**` vor dem 230 | Parameternamen definiert. Diese Aggregatoren akzeptieren lediglich 231 | benannte Parameter und sind vom Typ `dict`. 232 | 233 | --- 234 | 235 | ### Beispiel 236 | 237 | ```python 238 | def function(param1, **aggr): 239 | pass 240 | 241 | 242 | function(1) # korrekt, aggr = {} 243 | function(1, some=9) # korrekt, agar = {'some': 9} 244 | function(some=6) # inkorrekt, param1 braucht einen Wert 245 | function(some=0, param1=8, param2=4) 246 | # korrekt, agar = {'some': 0, 'param2': 4} 247 | ``` 248 | 249 | Wenn eine Funktion keine anderen Parameter erwartet, nennt man den 250 | Aggregator meist `**kwargs` (kurz für *Keyword Arguments*) 251 | 252 | 253 | ## Benannte und Positionale Aggregatoren 254 | 255 | --- 256 | 257 | Beide Aggregatoren können gleichzeitig in einer Funktion verwendet werden. 258 | Die Regel dabei ist: Von jeder Sorte nur *ein* Aggregator. 259 | 260 | --- 261 | 262 | ### Beispiel 263 | 264 | ```python 265 | def function( 266 | param1, 267 | param2, 268 | *args, 269 | kwparam1=0, 270 | kwparam2=None, 271 | **kwargs 272 | ): 273 | pass 274 | ``` 275 | 276 | --- 277 | 278 | ### Generelle Funktionsstruktur 279 | 280 | Wenn beide Aggregatoren zum Einsatz kommen sollen, ergibt sich folgende Funktionsstruktur: 281 | 282 | 283 | ```python 284 | def name( 285 | [params, ...] 286 | [, *[aggregator]] 287 | [, kwparams=kwvalue, ...] 288 | [**kwaggreg] 289 | ): 290 | pass 291 | ``` 292 | *Eckige Klammern stehen für optionale Parameter/Namen.* 293 | -------------------------------------------------------------------------------- /md/08_process.md: -------------------------------------------------------------------------------- 1 | # Grundlagen 2 | 3 | --- 4 | 5 | Das Modul `subprocess` erlaubt die Ausführung externer Befehle und Skripte von 6 | einem Python Skript aus. 7 | 8 | Man kann sich die Funktionsweise ähnlich der eines Terminals vorstellen. 9 | 10 | --- 11 | 12 | ## Eigenschaften 13 | 14 | - Subprozesse laufen asynchron 15 | 16 | - Sie laufen direkt auf dem System, nicht in einer Shell (wenn nicht 17 | anders festgelegt) 18 | 19 | - Verfügbare Programme hängen vom System ab, auf dem sie ausgeführt 20 | werden 21 | 22 | - Der Aufruf ist allgemeingültig, die Bibliothek verwandelt den Aufruf 23 | unter Windows in einen kompatiblen `CreateProcess()` String 24 | 25 | # Konstanten 26 | 27 | --- 28 | 29 | ### File Descriptoren 30 | 31 | `DEVNULL` 32 | 33 | Der systeminterne ’Mülleimer’ 34 | 35 | `PIPE` 36 | 37 | Die Verbindung zwischen zwei Prozessen 38 | 39 | `STDOUT` 40 | 41 | Die Standardausgabe oder der laufende Prozess 42 | 43 | --- 44 | 45 | ### Exceptions 46 | 47 | `SubprocessError` 48 | 49 | Der Standardfehler dieses Moduls 50 | 51 | `TimeoutError` 52 | 53 | Ein Timeout ist aufgetreten 54 | 55 | `CalledProcessError` 56 | 57 | Der Subprozess endete auf eine unerwartete Art 58 | 59 | # Popen Klasse 60 | 61 | --- 62 | 63 | Die `Popen` Klasse bildet die Basis des Moduls `subprocess`. 64 | 65 | Die Funktionssignatur sieht wie folgt aus: 66 | 67 | ```python 68 | from subprocess import Popen 69 | 70 | Popen(args, bufsize=-1, executable=None, stdin=None, 71 | stdout=None, stderr=None, preexec_fn=None, 72 | close_fds=True, shell=False, cwd=None, env=None, 73 | universal_newlines=False, startupinfo=None, 74 | creationflags=0, restore_signals=True, 75 | start_new_session=False, pass_fds=()) 76 | ``` 77 | 78 | --- 79 | 80 | ## Wichtige Argumente 81 | 82 | `args` 83 | 84 | Die aufzurufenden Argumente. Sollten vom Typ `tuple` oder `list` sein. 85 | Im Prinzip splittet man den Konsolenbefehl an den Leerzeichen: 86 | 87 | `ls -A *.md` entspricht `[’ls’, ’-A’, ’*.md’]` 88 | 89 | --- 90 | 91 | `shell` 92 | 93 | Führt den Befehl in einer Shell aus. Sollte `False` sein (Standard), 94 | sonst ist der Aufruf unsicher. 95 | 96 | --- 97 | 98 | `stdout` 99 | 100 | zusammen mit `stdin` und `stderr` die Input- und Output-Verbindungen 101 | des Subprozesses 102 | 103 | (hier sind `DEVNULL`, `PIPE` und `STDOUT` nützlich) 104 | 105 | --- 106 | 107 | `env` 108 | 109 | Umgebungsvariablen des Kindprozesses. Standard ist ein Subset von 110 | `os.environ` (dem Python Prozess Environment) 111 | 112 | `cwd` 113 | 114 | Das Arbeitsverzeichnis des Subprozesses 115 | 116 | # Popen Objekte 117 | 118 | --- 119 | 120 | Wenn Popen instanziiert wird, wird der darin enthaltene Prozess gestartet und 121 | das zurückgegebene `Popen` Objekt enthält Informationen über den laufenden Prozess. 122 | 123 | --- 124 | 125 | ## Informationen sammeln 126 | 127 | --- 128 | 129 | `process.args` 130 | 131 | Gibt die Argumente zurück, mit denen der Prozess aufgerufen wurde. 132 | 133 | `obj.stdout`, `obj.stdin`, `obj.stderr` 134 | 135 | Input- und Output-Verbindungen, die beim Start gesetzt wurden 136 | 137 | `process.pid` 138 | 139 | Vom System zugewiesene *Prozess ID*. 140 | 141 | 142 | --- 143 | 144 | `process.poll()` 145 | Prüft, ob der Prozess beendet wurde. Gibt den *Rückgabewert* des Prozesses zurück oder `None`, wenn der Prozess noch läuft. 146 | 147 | `process.returncode` 148 | 149 | Der Rückgabewert von `process.poll()` (der Rückgabewert des Prozesses) 150 | 151 | --- 152 | 153 | ## Interaktion mit dem Prozess 154 | 155 | `process.wait(timeout=None)` 156 | 157 | Wartet *timeout* Sekunden auf die Terminierung des Prozesses (wartet 158 | unendlich lang, wenn timeout *None* ist). 159 | Wirft nach Ablauf von *timeout* eine `TimeoutExpired` Exception. 160 | 161 | --- 162 | 163 | `process.send_signal(signal)` 164 | 165 | Sendet das Signal *signal* an den Prozess (z.B. `SIGTERM`). 166 | 167 | --- 168 | 169 | `process.communicate(input=None, timeout=None)` 170 | 171 | Schreibt die Daten aus *input* in den Standardinput (`stdin`) des Prozesses (wenn stdin PIPE ist), wartet auf die Terminierung des Prozesses und liest Daten, die der Prozess in `stdout` geschrieben hat (wenn stdout PIPE ist). 172 | 173 | --- 174 | 175 | `process.terminate()` 176 | 177 | Sendet ein Terminationssignal an den Prozess (`SIGTERM`). 178 | 179 | `process.kill()` 180 | 181 | Erzwingt die Beendigung des Prozesses (`SIGKILL`). 182 | 183 | --- 184 | 185 | ## Nutzung des Kontextmanagers 186 | 187 | Popen kann mit dem Kontextmanager verwendet werden (siehe *File Handling*). 188 | Der Code dafür würde wie folgt aussehen: 189 | ```python 190 | with subprocess.Popen(['ls']) as process: 191 | pass 192 | ``` 193 | 194 | # Nützliche Funktionen 195 | 196 | --- 197 | 198 | `subprocess` enthält einige Kurzfassungen für häufig genutzte Arbeitsabläufe. 199 | Intern rufen diese allerdings auch nur `Popen` auf. 200 | 201 | --- 202 | 203 | Die wohl nützlichste Funktion ist `subprocess.run()`: 204 | 205 | ```python 206 | subprocess.run(args, *, stdin=None, input=None, 207 | stdout=None, stderr=None, shell=False, 208 | timeout=None, check=False) 209 | ``` 210 | 211 | --- 212 | 213 | - eingeführt in Python 3.5 214 | 215 | - ruft durch `args` definierten Prozess auf 216 | 217 | - wartet auf Beendigung des Prozesses (wenn *timeout* `None` ist) 218 | 219 | - gibt ein `CompletedProcess` Objekt zurück 220 | 221 | - **Beachte:** Einsatz eines unbenannten Aggregators 222 | 223 | --- 224 | 225 | ### CompletedProcess Objekt 226 | 227 | ist der Rückgabewert von `run()`, der zurückgegeben wird, wenn der Prozess 228 | beendet wurde. Enthält folgende Eigenschaften: 229 | 230 | `args` 231 | 232 | Argumente, mit denen der Prozess aufgerufen wurde. 233 | 234 | --- 235 | 236 | `returncode` 237 | 238 | Rückgabewert des Prozesses 239 | 240 | `stdout` 241 | 242 | Ausgabe des Prozesses 243 | 244 | `stderr` 245 | 246 | stderr Output des Prozesses 247 | 248 | --- 249 | 250 | Außerdem gibt es die Funktion `check_returncode()`, die einen 251 | `CalledProcessError` beim Aufruf wirft, wenn der Rückgabewert nicht 0 ist. 252 | 253 | --- 254 | 255 | ### subprocess.call() 256 | 257 | - Ruft einen Prozess auf, wartet auf Terminierung 258 | 259 | - gibt Returncode des Prozesses zurück 260 | 261 | Diese Funktion macht das selbe, wie 262 | `run(...).returncode`, 263 | nur dass *check* und *input* nicht unterstützt werden. 264 | 265 | --- 266 | 267 | ### subprocess.check_call() 268 | 269 | Argumente entsprechen den Argumenten von `call()`. 270 | 271 | - Ruft Prozess auf, wartet auf Terminierung 272 | 273 | - gibt nichts zurück, wenn Ausführung erfolgreich (Returncode == 0) 274 | 275 | - wenn Aufruf nicht erfolgreich, wird `CalledProcessError` geworfen 276 | 277 | --- 278 | 279 | Diese Funktion macht das selbe, wie 280 | `run(..., check=True)`, 281 | nur dass *input* nicht unterstützt wird. 282 | 283 | --- 284 | 285 | ### subprocess.check_output() 286 | 287 | - führt Kommando aus und gibt den Prozessoutput zurück 288 | 289 | - wirft ebenfalls `CalledProcessError`, wenn der Returncode nicht 0 290 | ist 291 | 292 | Diese Funktion macht das selbe, wie 293 | `run(..., check=True, stdout=PIPE).stdout` 294 | -------------------------------------------------------------------------------- /md/09_web_client.md: -------------------------------------------------------------------------------- 1 | # Das Package urllib 2 | 3 | --- 4 | 5 | Das Package `urllib` ist eine nützliche Sammlung mehrerer Module zur Arbeit mit URLs. 6 | 7 | ## urllib.request 8 | 9 | Das Modul `urllib.request` enthält Funktionen und Klassen, welche beim Öffnen 10 | von URLs (vor allem über HTTP) helfen. 11 | 12 | --- 13 | 14 | Unterstützt werden: 15 | 16 | - verschiedene Authentifizierungsarten 17 | - Weiterleitungen 18 | - Cookies 19 | - und mehr... 20 | 21 | --- 22 | 23 | ### Öffnen einer URL 24 | 25 | Das Öffnen einer URL wird über die Funktion `urlopen()` realisiert: 26 | 27 | ```python 28 | import urllib.request 29 | 30 | urllib.request.urlopen(url, data=None, [timeout, ] *, 31 | cafile=None, capath=None, cadefault=False, 32 | context=None) 33 | ``` 34 | 35 | --- 36 | 37 | **url** 38 | 39 | ein String für simple URLs oder ein `Request` Objekt für komplexere 40 | Anfragen 41 | 42 | **data** 43 | 44 | Daten, die an den Server gesendet werden sollen. 45 | Vom Typ `bytes` oder ein Iterable von `bytes` Objekten. 46 | 47 | --- 48 | 49 | **Rückgabewerte** 50 | 51 | Bei URLs mit http-Requests: 52 | `httplib.client.HTTPResponse` Objekt 53 | 54 | bei ftp, file und data: 55 | `urllib.addinfourl` Objekt 56 | 57 | 58 | 59 | ## Request Klasse 60 | 61 | --- 62 | 63 | Um komplexere Anfragen stellen zu können, kann man Request Objekte verwenden: 64 | 65 | ```python 66 | urllib.request.Request(url, data=None, headers={}, 67 | origin_req_host=None, unverifiable=False, 68 | method=None) 69 | ``` 70 | 71 | --- 72 | 73 | **url** 74 | 75 | muss String mit gültiger URl sein 76 | 77 | **data** 78 | 79 | wie bei *urlopen* 80 | 81 | --- 82 | 83 | **headers** 84 | 85 | `dict` mit `{Header-Name : Header-Value, ...}` oder 86 | `list` von Tupeln mit `[(Header-Name, Header-Value), ...]` 87 | 88 | **method** 89 | 90 | String, der Art des HTTP Request angibt (`HEAD`, `GET`, `POST`, ...) 91 | 92 | --- 93 | 94 | ### Beispiel 95 | 96 | ```python 97 | import urllib 98 | 99 | r = urllib.request.Request( 100 | 'http://python.org', 101 | headers={'content-type': 'application/json'}, 102 | method='PUT' 103 | ) 104 | ``` 105 | 106 | --- 107 | 108 | Die Request Klasse kann man Verwenden zum: 109 | 110 | - Kontrollieren der gesendeten Header *(z.B. Content-Type 111 | oder User-Agent)* 112 | - Kontrollieren der Method `POST`, `PUT` oder `HEAD` 113 | 114 | 115 | 116 | ## HTTPResponse Klasse 117 | 118 | --- 119 | 120 | ```python 121 | http.client.HTTPResponse(sock, debuglevel=0, 122 | method=None, url=None) 123 | ``` 124 | 125 | --- 126 | 127 | Objekte dieser Klasse werden nicht direkt vom User erstellt.   128 | Klasse enthält Funktionen und Variablen wie: 129 | 130 | - `read()` - gibt zurückgelieferten Inhalt zurück 131 | - `getheader()` oder `getheaders()` liefert einen/alle Header zurück 132 | - `status` gibt den HTTP Statuscode zurück 133 | - `version` gibt die HTTP Version zurück 134 | 135 | 136 | # Andere Module 137 | 138 | --- 139 | 140 | Das Package `urllib` enthält außerdem folgende Module: 141 | 142 | --- 143 | 144 | `urllib.error` 145 | Enthält Exceptions, die von `urllib.request` geworfen werden. 146 | 147 | --- 148 | 149 | `urllib.parse` 150 | Zum Parsen von URLs. 151 | 152 | --- 153 | 154 | `urllib.robotparse` 155 | Zum Parsen der *robots.txt* von Webseiten. 156 | 157 | 158 | # Das Requests-Modul 159 | 160 | ## Installation 161 | 162 | Das Requests Modul ist eine gute und für Menschen verständliche Alternative zu 163 | `urllib.requests`, das HTTP Requests vereinfacht. 164 | 165 | --- 166 | 167 | Das Requests Package lässt sich ganz einfach über **pip** installieren: 168 | `pip install requests` 169 | 170 | --- 171 | 172 | ### Beispiel 173 | 174 | ```python 175 | r = requests.get('https://api.github.com/user', 176 | auth=('user', 'pass')) 177 | 178 | r.status_code # -> 200 179 | r.headers['content-type'] 180 | # -> 'application/json; charset=utf8' 181 | r.encoding # -> 'utf-8' 182 | r.text # -> u'{"type":"User"...' 183 | r.json() 184 | # -> {u'private_gists': 419, u'total_private_repos': 77, ...} 185 | ``` 186 | --- 187 | 188 | Ruft die API-Seite von **GitHub** auf und authentifiziert sich mit 189 | Nutzername und Passwort. 190 | -------------------------------------------------------------------------------- /md/10_regex.md: -------------------------------------------------------------------------------- 1 | # Grundlage 2 | 3 | --- 4 | 5 | Das `re` Modul der Python Standard Library ist die Python Implementierung von _regulären Ausdrücken_. 6 | 7 | Reguläre Ausdrücke werden verwendet um die Struktur von Text/Sprachen zu beschreiben. 8 | 9 | --- 10 | 11 | Ein erstellter regulärer Ausdruck kann verwendet werden um: 12 | 13 | - die Struktur eines Textes zu überprüfen 14 | - bestimmte Teile eines Textes zu extrahieren 15 | 16 | --- 17 | 18 | Die Anwendung eines regulären Ausdruckes nennt man Matching. 19 | 20 | Matcht der reguläre Ausdruck einem String, bedeutet dies, dass der String die Struktur hat, die der reguläre Ausdruck beschreibt. 21 | 22 | --- 23 | 24 | Reguläre Ausdrücke werden oft auch 'regex' genannt (kurz für __regular expression__). 25 | 26 | # Matching Regeln 27 | 28 | --- 29 | 30 | Jeder Buchstabe und jede Zahl matcht immer **einmal** sich selbst. 31 | 32 | d.h. 33 | 34 | Der String `'a'` matcht der regex `'a'`. 35 | Der String `'abc'` matcht der regex `'abc'`, nicht aber regex `'a'`. 36 | `'4'` matcht `'4'`, nicht aber `'5'`, `'a'` oder `'41'` usw. 37 | 38 | 39 | ## Sonderzeichen 40 | 41 | `.` (Punkt) matcht **einem** beliebingen Schriftzeichen, außer `\n` (newline) 42 | 43 | Für die regex `'.'` gilt: 44 | 45 | - `'a'` matcht 46 | - `'b'` matcht 47 | - `'4'` matcht 48 | - `'ab'` matcht nicht, denn `'.'` ist nur ein Zeichen und `'ab'` sind zwei. 49 | 50 | --- 51 | 52 | `[]` matcht jedem der in den Klammern stehenden Zeichen, jedoch nur **einmal** (wie bei `.`). 53 | 54 | Für die regex `'[abg]'` gilt also: 55 | 56 | - `'a'` matcht 57 | - `'b'` matcht 58 | - `'g'` matcht 59 | - `'ab'` matcht nicht (zwei zeichen matchen nicht einem). 60 | 61 | --- 62 | 63 | `()` erstellt eine Gruppe. Alles was in den Klammern steht, muss genau so vor kommen. 64 | 65 | Für die regex `'(abc)'` gilt: 66 | 67 | - `'a'` matcht nicht 68 | - `'ab'` matcht nicht 69 | - `'abc'` matcht 70 | 71 | --- 72 | 73 | `\` escaped ein Sonderzeichen. 74 | 75 | Alle hier aufgeführten Sonderzeichen können nicht in einem Pattern vorkommen, als das, was sie eigentlich bedeuten, dafür müssen sie extra markiert werden. 76 | 77 | - `'\\'` als Pattern matcht auf den String `'\'` 78 | - `'\.'` als Pattern matcht auf den String `'.'` 79 | 80 | --- 81 | 82 | `^` matcht ab dem Anfang eines Strings oder ab jedem `\n` 83 | 84 | Für die regex `'^a'` ergibt sich also: 85 | 86 | - `'a'` matcht 87 | - `'ba'` matcht nicht, da der falsche Character am Anfang steht. 88 | - `'aba'` matcht 89 | 90 | --- 91 | 92 | `$` matcht dem Ende eines Strings (oder dem Zeilenende) 93 | 94 | Für die regex `'a$'` folgt daraus: 95 | 96 | - `'a'` matcht 97 | - `'ba'` matcht 98 | - `'bab'` matcht nicht, da der falsche Character am Ende steht 99 | - `'aba'` matcht 100 | 101 | --- 102 | 103 | `|` ist ein __ODER__. Entweder die regex davor oder danach muss matchen. 104 | 105 | Für die regex `'a|b'` gilt: 106 | 107 | - `'a'` matcht 108 | - `'b'` matcht 109 | - `'ab'` matcht nicht, da `'a|b'` mit [ab] gleichzusetzen ist 110 | 111 | 112 | ## Zusammengesetzte Regex 113 | 114 | --- 115 | 116 | Regular Expressions setzen sich aus kleineren Regular Expressions zusammen. 117 | So kann man z.B. auch festlegen, wie häufig ein Zeichen auftreten soll. 118 | 119 | --- 120 | 121 | `*` - Die _vorangestellte_ Regex muss 0 - n Mal vorkommen. 122 | 123 | Für die regex `'a*'` gilt: 124 | 125 | - `''` matcht 126 | - `'a'` matcht 127 | - `'aa'` matcht 128 | - `'aaaab'` matcht nicht, da ein anderes Zeichen als 'a' vorkommt 129 | 130 | --- 131 | 132 | `+` - Die _vorangestellte_ Regex muss 1 - n Mal vorkommen. 133 | 134 | Für die regex `'a+'` gilt: 135 | 136 | - `''` matcht nicht, da es kein mal vorkommt 137 | - `'a'` matcht 138 | - `'aa'` matcht 139 | - `'ab'` matcht nicht, da ein anderes Zeichen als 'a' vorkommt 140 | 141 | --- 142 | 143 | `?` - Die _vorangestellte_ regex muss 0 - 1 Mal vorkommen. 144 | 145 | Für die regex `'a?'` gilt: 146 | 147 | - `''` matcht 148 | - `'a'` matcht 149 | - `'aa'` matcht nicht, da das Zeichen öfter, als nur ein mal vorkommt 150 | 151 | --- 152 | 153 | `{m}` - Die _vorangestellte_ regex muss genau m Mal vorkommen. 154 | 155 | Für die regex `'y{3}'` gilt: 156 | 157 | - `'yyy'` matcht 158 | - `'y'` matcht nicht, da es zu wenige Zeichen sind 159 | - `'yyyy'` matcht nicht, da es mehr Zeichen sind 160 | 161 | --- 162 | 163 | `{m,n}` - Die _vorangestellte_ regex muss m - n Mal vorkommen. 164 | 165 | Für die regex `'y{2,5}'` gilt: 166 | 167 | - `'yyy'` matcht 168 | - `'y'` matcht nicht, da es zu wenige Zeichen sind 169 | - `'yyyy'` matcht 170 | - `'yyyyyy'` matcht nicht, da es zu viele Zeichen sind 171 | 172 | 173 | ## Spezielle Sequenzen 174 | 175 | --- 176 | 177 | Desweiteren gibt es noch spezielle Sequenzen, wie z. B. 178 | 179 | - `\d` für Unicode Ziffern, äquivalent für `[0-9]` 180 | - `\D` ist das Gegenteil, alles was keine Unicode Ziffern sind 181 | 182 | --- 183 | 184 | - `\s` für alle Whitespace Zeichen, das entspricht `'[ \t\n\r\f\v]'` 185 | - `\S` entspricht wieder dem Gegenteil 186 | 187 | --- 188 | 189 | - `\w` für alle Unicode Zeichen `'[a-zA-Z0-9_]'` 190 | - `\W` für alle Nicht-Unicode Zeichen 191 | - `[^...]` entspricht allem, was nicht in den Klammern steht 192 | 193 | # Methoden 194 | 195 | --- 196 | 197 | ```python 198 | compile(pattern, flags=0) 199 | ``` 200 | Wandelt einen String in ein regular expression Objekt um. 201 | 202 | --- 203 | 204 | ```python 205 | search(pattern, string, flags=0) 206 | ``` 207 | Sucht in `string` nach dem Pattern `pattern`. 208 | 209 | --- 210 | 211 | ```python 212 | match(pattern, string, flags=0) 213 | ``` 214 | Sucht am Begin des Strings nach dem Pattern. 215 | 216 | --- 217 | 218 | ```python 219 | fullmatch(pattern, string, flags=0) 220 | ``` 221 | Der komplette String und das Pattern müssen übereinstimmen. 222 | 223 | --- 224 | 225 | ```pyhton 226 | findall(pattern, string, flags=0) 227 | ``` 228 | Gibt eine Liste von Strings mit allen passenden Übereinstimmungen zurück. 229 | 230 | --- 231 | 232 | ```python 233 | finditer(pattern, string, flags=0) 234 | ``` 235 | Gibt einen Iterator, welcher `match` Objekte beinhaltet zurück 236 | 237 | Die restlichen Funktionen können in den [Docs](https://docs.python.org/3/library/re.html) gefunden werden. 238 | 239 | # regular expression Objekt 240 | 241 | --- 242 | 243 | Ein solches Objekt hat im Großen und Ganzen die selben Methoden, jedoch ohne zusätzliches Pattern, da das Objekt an sich bereits ein Pattern enthält. 244 | 245 | # Match Objekt 246 | 247 | --- 248 | 249 | 250 | ```python 251 | start([group]) 252 | ``` 253 | Gibt die Startposition des Patterns im String zurück. 254 | 255 | ```python 256 | end([group]) 257 | ``` 258 | Gibt die Endposition des Patterns im String zurück. 259 | 260 | --- 261 | 262 | ```python 263 | span([group]) 264 | ``` 265 | Gibt ein Tuple zurück `(m.start([group]), m.end([group]))` 266 | -------------------------------------------------------------------------------- /md/11_smtplib.md: -------------------------------------------------------------------------------- 1 | # Grundlagen: Mails senden 2 | 3 | 4 | ## Das Modul `smtplib` 5 | 6 | 7 | Das Modul `smtplib` definiert eine SMTP**\***-Client Session, die genutzt werden kann, um 8 | von jedem beliebigen, internetfähigen Gerät E-Mails zu verschicken. 9 | 10 | **\****SMTP* steht für Simple Mail Transfer Protocol und ist das Standard-Protokoll zum E-Mail Versand. 11 | 12 | --- 13 | 14 | ### Verbindung zum Server 15 | 16 | 17 | Die smtplib kann sich zu 18 | einem SMTP-Server verbinden 19 | 20 | ```python 21 | smtplib.SMTP(host=’ ’, port=0, local_hostname=None, 22 | [timeout,] source_address=None) 23 | ``` 24 | 25 | Der Server kann zum einen als einheitlicher `String` (inkl. Port) oder 26 | einzeln als `host` und `port` angeben werden. 27 | 28 | --- 29 | 30 | ### Login auf dem Server 31 | 32 | 33 | Heutzutage Zeit arbeiten die meisten SMTP-Server mit `TLS`, um eine sichere Verbindung zu gewährleisten. Diese muss mithilfe von der Methode `starttls()` hergestellt werden. 34 | Der eigentliche Login erfolgt im Anschluss durch: 35 | 36 | ```python 37 | SMTP.login(user, password, ∗, initial_response_ok=True) 38 | ``` 39 | 40 | Der Parameter `initial_response_ok` kann in unserem Fall vernachlässigt 41 | werden. 42 | 43 | --- 44 | 45 | ### Senden der Mail 46 | 47 | 48 | Das tatsächliche Versenden der Mail funktioniert dann mit folgender Methode: 49 | 50 | ```python 51 | SMTP.sendmail(from_addr, to_addrs, msg, mail_options=[], 52 | rcpt_options=[]) 53 | ``` 54 | 55 | Jedoch lässt sich das ganze auch mit einem `MIME`-Objekt vereinfachen, auf das später noch eingegangen wird. 56 | Dieses wird mit `send_message()` versendet. 57 | 58 | --- 59 | 60 | ### Schließen der Verbindung 61 | 62 | Zum Schluss darf nicht vergessen werden, die Verbindung zum SMTP-Server wieder zu schließen. 63 | Dies geschieht mit der Methode `quit()` oder man stellt die Verbindung 64 | mithilfe eines `Filehandlers` her. 65 | 66 | 67 | #Komplexere Mails senden 68 | 69 | 70 | ## Das Modul `email` 71 | 72 | 73 | Um mehr Möglichkeiten zur Gestaltung der E-Mail zu haben, lohnt sich die Verwendung des Moduls 74 | `email`. 75 | Mit `email.mime` lassen sich Emails individuell bauen und 76 | zusammensetzen. Außerdem kann man mehrteilige Mails und Mails mit 77 | Anhängen (z.B. Bildern) erstellen. 78 | 79 | --- 80 | 81 | ### Die Klasse `MIMEText` 82 | 83 | Die Klasse `email.mime.text.MIMEText()` erstellt ein MIME Objekt, welches 84 | hautpsächlich aus Text besteht und einfach dem SMTP-Objekt übergeben 85 | werden kann: 86 | ```python 87 | email.mime.text.MIMEText(_text, _subtype='plain', _charset=None) 88 | ``` 89 | 90 | --- 91 | 92 | \_text: Ein String, der den Inhalt der Nachricht enthält. 93 | 94 | \_subtype: Der Untertyp des Objekts, per default `plain` 95 | 96 | charset: Der Zeichensatz, der zur Kodierung der Zeichen verwendet 97 | werden soll. Standardmäßig `us-ascii` oder `utf8`, abhängig von dem 98 | eingegebenen Text. 99 | 100 | --- 101 | 102 | ### Die Meta-Felder 103 | 104 | 105 | Wenn das `MIMEText` Objekt instanziiert ist, muss dieses mit weiteren Informationen ergänzt werden: 106 | 107 | ```python 108 | # set the sender of your mail 109 | message['From'] = 'Sender name ' 110 | # set the receiver of your mail 111 | message['To'] = 'Receiver name ' 112 | 113 | message['Subject'] = 'Betreff der E-Mail' 114 | ``` 115 | 116 | Die Message lässt sich außerdem noch um einen `Cc` oder einen `Bcc` 117 | erweitern. 118 | -------------------------------------------------------------------------------- /md/12_curses.md: -------------------------------------------------------------------------------- 1 | # Das Modul `curses` 2 | 3 | --- 4 | 5 | `curses` bietet ein Interface für die "curses"-Bibliothek, den de-facto Standard für fortgeschrittenes Terminal 6 | Handling. 7 | 8 | --- 9 | 10 | - curses ist vor allem in Unix-Umgebungen weit verbreitet 11 | 12 | - dieses Modul wurde auf die API von *ncurses*, einer Open-Source 13 | Library für curses, zugeschnitten und funktioniert nur unter Linux 14 | und BSD Varianten von Unix 15 | 16 | 17 | ## Mitgelieferte Submodule 18 | 19 | `curses.ascii`: zur Arbeit mit ASCII-kodierten Zeichen 20 | 21 | `curses.panel`: Support für Panels, also mehrere Fenster übereinander (Fenster mit Ebenen) 22 | 23 | `curses.textpad`: Widget zum editieren von Text mit *emacs*-artigen Key-Bindings 24 | 25 | 26 | 27 | # Erstellen eines simplen Fensters 28 | 29 | ## Grundlegende Funktionen 30 | 31 | --- 32 | 33 | Zum Erstellen eines `curses`-Fensters benutzt man den Befehl 34 | 35 | ```python 36 | curses.initscr() 37 | ``` 38 | 39 | - instanziiert die Bibliothek, gibt ein `WindowObject` zurück, welches 40 | den gesamten Screen repräsentiert 41 | 42 | - Fehler beim Terminal öffnen können zum Beenden des Interpreters 43 | führen! 44 | 45 | --- 46 | 47 | ```python 48 | curses.endwin() 49 | ``` 50 | 51 | - deinitialisiert Bibliothek 52 | 53 | - führt Terminal in normalen Zustand zurück 54 | 55 | --- 56 | 57 | `curses` liefert einen eigenen Wrapper zum Starten und Beenden: 58 | 59 | ```python 60 | curses.wrapper(func, ...) 61 | ``` 62 | 63 | - setzt nützliche Standards, initialisiert curses und ruft *func* auf 64 | 65 | - Wrapper fängt Exceptions, stellt Terminal wieder her und wirft 66 | Exception erneut 67 | 68 | - *func* muss `stdscr` als erstes Argument akzeptieren (für das `WindowObject`) 69 | 70 | 71 | ## Darstellen von Symbolen 72 | 73 | --- 74 | 75 | Zur Darstellung einzelner Symbole verwendet man `addch`: 76 | 77 | ```python 78 | window.addch(ch[, attr]) 79 | window.addch(y, x, ch[, attr]) 80 | ``` 81 | 82 | `ch`: zu schreibendes ASCII-Zeichen (im ASCII-Format!)\ 83 | Zum konvertieren ggf. auf `ord()` zurück greifen. 84 | 85 | `y, x`: Koordinaten, an die das Zeichen geschrieben wird. Beachte 86 | invertierte Reihenfolge! 87 | 88 | `attr`: zu setzende Attribute 89 | 90 | --- 91 | 92 | Zum Darstellen eines Strings 93 | existiert die Funktion `addstr()`: 94 | 95 | ```python 96 | window.addstr(str[, attr]) 97 | window.addstr(y, x, str[, attr]) 98 | ``` 99 | 100 | - fügt ab `(y, x)` den gegebenen String ein 101 | 102 | - überschreibt alle vorher vorhandenen Zeichen 103 | 104 | --- 105 | 106 | **Zeichen entfernen** 107 | 108 | ```python 109 | window.delch([y, x]) 110 | window.deleteln() 111 | window.erase() 112 | ``` 113 | 114 | - Funktionen zum löschen einzelner Zeichen, einer ganzen Zeile oder 115 | dem gesamten Fenster 116 | 117 | ## Allgemeine Hinweise 118 | 119 | --- 120 | 121 | - Werden bei Funktionen `x` und `y` weg gelassen und sind optional, 122 | wird die Funktion an der aktuellen Cursorstelle ausgeführt. 123 | 124 | - Beachte die invertierte Zählweise! 125 | 126 | - Punkt (0, 0) liegt oben links in der Ecke vom Terminal 127 | 128 | - x zählt von da nach rechts aufwärts 129 | 130 | - y zählt von da nach unten aufwärts 131 | 132 | 133 | # `curses.textpad` 134 | 135 | ## `Rectangle` 136 | 137 | ```python 138 | curses.textpad.rectangle(win, uly, ulx, lry, lrx) 139 | ``` 140 | 141 | - erzeugt im WindowObject `win` ein Rechteck 142 | 143 | - Anfangspunkt ist (`ulx`, `uly`) (ul ≙ upper left corner) 144 | 145 | - Endpunkt ist (`lrx`, `lry`) (lr ≙ lower right corner) 146 | 147 | ##`Textbox` 148 | 149 | ```python 150 | curses.textpad.Textbox(win) 151 | ``` 152 | Eine `Textbox` wird mit einem WindowObject erstellt und hat diese drei Funktionen 153 | 154 | --- 155 | 156 | ```python 157 | Textbox().edit([validator]) 158 | Textbox().do_command(ch) 159 | Textbox().gather() 160 | ``` 161 | - `edit()` Editormodus wobei `validator` eine Funktion ist 162 | 163 | - `do_command()` führt einen Befehl aus 164 | [(Link hier)](http://bit.ly/29sJ8QJ) 165 | 166 | - `gather()` gibt den Inhalt der Textbox zurück 167 | -------------------------------------------------------------------------------- /md/template.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | $for(author-meta)$ 7 | 8 | $endfor$ 9 | $if(date-meta)$ 10 | 11 | $endif$ 12 | $if(title-prefix)$$title-prefix$ - $endif$$pagetitle$ 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | $if(highlighting-css)$ 23 | 26 | $endif$ 27 | $if(css)$ 28 | $for(css)$ 29 | 30 | $endfor$ 31 | $else$ 32 | 33 | $endif$ 34 | 35 | 36 | 45 | 48 | $if(math)$ 49 | $math$ 50 | $endif$ 51 | $for(header-includes)$ 52 | $header-includes$ 53 | $endfor$ 54 | 55 | 56 | $for(include-before)$ 57 | $include-before$ 58 | $endfor$ 59 |
    60 |
    61 | 62 | $if(title)$ 63 |
    64 |

    $title$

    65 | $if(subtitle)$ 66 |

    $subtitle$

    67 | $endif$ 68 | $for(author)$ 69 |

    $author$

    70 | $endfor$ 71 |

    $date$

    72 |
    73 | $endif$ 74 | $if(toc)$ 75 |
    76 | $toc$ 77 |
    78 | $endif$ 79 | 80 | $body$ 81 |
    82 | zurück zum Index 83 |
    84 |
    85 |
    86 | 87 | 88 | 89 | 90 | 91 | 121 | $for(include-after)$ 122 | $include-after$ 123 | $endfor$ 124 | 125 | 126 | -------------------------------------------------------------------------------- /reveal.json: -------------------------------------------------------------------------------- 1 | { 2 | "Getting started": { 3 | "theme": "ifsr", 4 | "source": "01_getting_started" 5 | }, 6 | "Grundlagen von Python": { 7 | "theme": "ifsr", 8 | "source": "02_grundlagen" 9 | }, 10 | "Builtin Datenstrukturen": { 11 | "theme": "ifsr", 12 | "source": "03_builtins" 13 | }, 14 | "Module, Pakete und PIP": { 15 | "theme": "ifsr", 16 | "source": "04_modules_packages_pip" 17 | }, 18 | "Decorators": { 19 | "theme": "ifsr", 20 | "source": "05_decorators" 21 | }, 22 | "Comprehensions": { 23 | "theme": "ifsr", 24 | "source": "06_comprehensions" 25 | }, 26 | "Funktionen (fortgeschritten)": { 27 | "theme": "ifsr", 28 | "source": "07_functions_advanced" 29 | }, 30 | "Subprozesse in Python": { 31 | "theme": "ifsr", 32 | "source": "08_process" 33 | }, 34 | "Web Client": { 35 | "theme": "ifsr", 36 | "source": "09_web_client" 37 | }, 38 | "re - Regular Expressions": { 39 | "theme": "ifsr", 40 | "source": "10_regex" 41 | }, 42 | "Mails in Python senden": { 43 | "theme": "ifsr", 44 | "source": "11_smtplib" 45 | }, 46 | "ncurses in Python": { 47 | "theme": "ifsr", 48 | "source": "12_curses" 49 | } 50 | } 51 | -------------------------------------------------------------------------------- /src/css/repl.css: -------------------------------------------------------------------------------- 1 | /* line 1, /Users/h4llow3En/projects/custom-repl.it-embedding/repl.scss */ 2 | .exec { 3 | background: #dcdcdc; 4 | width: 100%; 5 | color: black; } 6 | /* line 5, /Users/h4llow3En/projects/custom-repl.it-embedding/repl.scss */ 7 | .exec pre { 8 | box-shadow: none; } 9 | /* line 8, /Users/h4llow3En/projects/custom-repl.it-embedding/repl.scss */ 10 | .exec .repl { 11 | width: 100%; 12 | background: #dcdcdc; } 13 | /* line 12, /Users/h4llow3En/projects/custom-repl.it-embedding/repl.scss */ 14 | .exec .repl-top { 15 | background: darkgray; 16 | padding: 5px 5px 5px 5px; } 17 | /* line 16, /Users/h4llow3En/projects/custom-repl.it-embedding/repl.scss */ 18 | .exec .repl-code { 19 | width: 100%; 20 | background-color: white; } 21 | /* line 20, /Users/h4llow3En/projects/custom-repl.it-embedding/repl.scss */ 22 | .exec .repl-result { 23 | padding-left: 20px; 24 | padding-bottom: 5px; } 25 | /* line 24, /Users/h4llow3En/projects/custom-repl.it-embedding/repl.scss */ 26 | .exec .input { 27 | text-align: left; 28 | color: black; 29 | margin-top: 0px; 30 | padding-top: 10px; 31 | padding-left: 20px; 32 | padding-bottom: 10px; } 33 | /* line 32, /Users/h4llow3En/projects/custom-repl.it-embedding/repl.scss */ 34 | .exec .run-button { 35 | width: 100px; 36 | height: 30px; 37 | font-size: 16px; 38 | border-style: none; 39 | color: black; 40 | text-align: center; 41 | background: #b1e11c; } 42 | /* line 40, /Users/h4llow3En/projects/custom-repl.it-embedding/repl.scss */ 43 | .exec .run-button:hover { 44 | background: #e0f3a3; 45 | color: #4d4d4d; } 46 | 47 | /*# sourceMappingURL=repl.css.map */ -------------------------------------------------------------------------------- /src/css/repl.css.map: -------------------------------------------------------------------------------- 1 | { 2 | "version": 3, 3 | "file": "repl.css", 4 | "sources": [ 5 | "repl.scss" 6 | ], 7 | "sourcesContent": [], 8 | "mappings": ";AAAA,KAAK,CAAC;EACF,UAAU,EAAE,OAAQ;EACpB,KAAK,EAAE,IAAK;EACZ,KAAK,EAAE,KAAM,GAHV;;EAIH,KAAK,CAAC,GAAG,CAAL;IACA,UAAU,EAAE,IAAK,GADhB;;EAGL,KAAK,CAAC,KAAK,CAAL;IACF,KAAK,EAAE,IAAK;IACZ,UAAU,EAAE,OAAQ,GAFjB;;EAIP,KAAK,CAAC,SAAS,CAAL;IACN,UAAU,EAAE,QAAM;IAClB,OAAO,EAAE,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,GAFjB;;EAIX,KAAK,CAAC,UAAU,CAAL;IACP,KAAK,EAAE,IAAK;IACZ,gBAAgB,EAAE,KAAM,GAFhB;;EAIZ,KAAK,CAAC,YAAY,CAAL;IACT,YAAY,EAAE,IAAK;IACnB,cAAc,EAAE,GAAI,GAFV;;EAId,KAAK,CAAC,MAAM,CAAL;IACH,UAAU,EAAE,IAAK;IACjB,KAAK,EAAE,KAAM;IACb,UAAU,EAAE,GAAI;IAChB,WAAW,EAAE,IAAK;IAClB,YAAY,EAAE,IAAK;IACnB,cAAc,EAAE,IAAK,GANjB;;EAQR,KAAK,CAAC,WAAW,CAAL;IACR,KAAK,EAAE,KAAM;IACb,MAAM,EAAE,IAAK;IACb,SAAS,EAAE,IAAK;IAChB,YAAY,EAAE,IAAK;IACnB,KAAK,EAAE,KAAM;IACb,UAAU,EAAE,MAAO;IACnB,UAAU,EAAE,OAAQ,GAPX;;IAQR,KAAK,CAAC,WAAW,AAAA,MAAM,CAAhB;MACJ,UAAU,EAAE,OAAO;MACnB,KAAK,EAAE,OAAO,GAFT", 9 | "names": [] 10 | } -------------------------------------------------------------------------------- /src/css/repl.scss: -------------------------------------------------------------------------------- 1 | .exec { 2 | background: #dcdcdc; 3 | width: 100%; 4 | color: black; 5 | pre { 6 | box-shadow: none; 7 | } 8 | .repl { 9 | width: 100%; 10 | background: #dcdcdc; 11 | } 12 | .repl-top { 13 | background: darken(#dcdcdc, 20%); 14 | padding: 5px 5px 5px 5px; 15 | } 16 | .repl-code { 17 | width: 100%; 18 | background-color: white; 19 | } 20 | .repl-result { 21 | padding-left: 20px; 22 | padding-bottom: 5px; 23 | } 24 | .input { 25 | text-align: left; 26 | color: black; 27 | margin-top: 0px; 28 | padding-top: 10px; 29 | padding-left: 20px; 30 | padding-bottom: 10px; 31 | } 32 | .run-button { 33 | width: 100px; 34 | height: 30px; 35 | font-size: 16px; 36 | border-style: none; 37 | color: black; 38 | text-align: center; 39 | background: #b1e11c; 40 | &:hover { 41 | background: lighten(#b1e11c, 30%); 42 | color: lighten(black, 30%); 43 | } 44 | } 45 | } -------------------------------------------------------------------------------- /src/ifsr.css.map: -------------------------------------------------------------------------------- 1 | { 2 | "version": 3, 3 | "file": "ifsr.css", 4 | "sources": [ 5 | "ifsr.scss", 6 | "../template/mixins.scss", 7 | "../template/settings.scss", 8 | "../template/theme.scss" 9 | ], 10 | "sourcesContent": [], 11 | "mappings": "AAAA;;;;GAIG;AAUH,OAAO,CAAC,kDAAI;AACZ,OAAO,CAAC,kFAAI;AGbZ;;+CAE+C;;AAE/C,IAAI,CAAC;EDmCJ,UAAU,EFtBO,IAAI;EGXrB,gBAAgB,EHWC,IAAI,GGbhB;;;AAKN,OAAO,CAAC;EACP,WAAW,EHSD,WAAW,EAAE,UAAU;EGRjC,SAAS,EHgBK,IAAI;EGflB,WAAW,EAAE,MAAO;EACpB,KAAK,EDNM,IAAI,GCEP;;;AAOT,WAAW,CAAC;EACX,KAAK,EDiBW,IAAI;EChBpB,UAAU,EHQgB,OAAO;EGPjC,WAAW,EAAE,IAAK,GAHN;;;AAOW,OAAO,CAAC,OAAO,GAAG,OAAO;AACjD,OAAO,CAAC,OAAO,GAAG,OAAO,GAAG,OAAO,CADH;EAC/B,WAAW,EAAE,GAAI;EACjB,WAAW,EAAE,OAAQ,GAFW;;AAKjC;;+CAE+C;;AAOvC,OAAO,CAAC,EAAE;AAClB,OAAO,CAAC,EAAE;AACV,OAAO,CAAC,EAAE;AACV,OAAO,CAAC,EAAE;AACV,OAAO,CAAC,EAAE;AACV,OAAO,CAAC,EAAE,CALC;EACV,MAAM,EDzBS,CAAC,CAAC,CAAC,CAHL,IAAI,CAGe,CAAC;EC0BjC,KAAK,EDxBS,IAAI;EC0BlB,WAAW,EHnBE,OAAO,EAAE,MAAM,EAAE,UAAU;EGoBxC,WAAW,EDtBQ,MAAM;ECuBzB,WAAW,ED3BQ,GAAG;EC4BtB,cAAc,EHpBS,OAAM;EGsB7B,cAAc,EHrBQ,IAAI;EGsB1B,WAAW,EHxBQ,IAAI;EG0BvB,SAAS,EAAE,UAAW,GAZX;;;AAeJ,OAAO,CAAC,EAAE,CAAP;EAAC,SAAS,ED7BN,MAAM,GC6BT;;;AACJ,OAAO,CAAC,EAAE,CAAP;EAAC,SAAS,ED7BN,MAAM,GC6BT;;;AACJ,OAAO,CAAC,EAAE,CAAP;EAAC,SAAS,ED7BN,MAAM,GC6BT;;;AACJ,OAAO,CAAC,EAAE,CAAP;EAAC,SAAS,ED7BN,GAAM,GC6BT;;;AAEJ,OAAO,CAAC,EAAE,CAAP;EACV,WAAW,EDvCQ,IAAI,GCsCZ;;AAKZ;;+CAE+C;;AAEvC,OAAO,CAAC,CAAC,CAAP;EACT,MAAM,EDzDO,IAAI,CCyDI,CAAC;EACtB,WAAW,EAAE,GAAI,GAFP;;AAKX,oEAAoE;;AAG5D,OAAO,CAAC,GAAG;AACnB,OAAO,CAAC,KAAK;AACb,OAAO,CAAC,MAAM,CAFC;EACd,SAAS,EAAE,GAAI;EACf,UAAU,EAAE,GAAI,GAFD;;;AAKR,OAAO,CAAC,MAAM;AACtB,OAAO,CAAC,CAAC,CADC;EACT,WAAW,EAAE,IAAK,GADR;;;AAIH,OAAO,CAAC,EAAE,CAAP;EACV,UAAU,EAAE,MAAO,GADR;;;AAMJ,OAAO,CAAC,EAAE;AAClB,OAAO,CAAC,EAAE;AACV,OAAO,CAAC,EAAE,CAFC;EACV,OAAO,EAAE,YAAa;EAEtB,UAAU,EAAE,IAAK;EACjB,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,GAJN;;;AAOJ,OAAO,CAAC,EAAE,CAAP;EACV,eAAe,EAAE,OAAQ,GADd;;;AAIJ,OAAO,CAAC,EAAE,CAAP;EACV,eAAe,EAAE,IAAK,GADX;;;AAID,OAAO,CAAC,EAAE,CAAC,EAAE,CAAV;EACb,eAAe,EAAE,MAAO,GADV;;;AAID,OAAO,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAb;EAChB,eAAe,EAAE,MAAO,GADP;;;AAOP,OAAO,CAAC,EAAE,CAAC,EAAE;AACxB,OAAO,CAAC,EAAE,CAAC,EAAE;AACb,OAAO,CAAC,EAAE,CAAC,EAAE;AACb,OAAO,CAAC,EAAE,CAAC,EAAE,CAHC;EACb,OAAO,EAAE,KAAM;EACf,WAAW,EAAE,IAAK,GAFJ;;;AAKP,OAAO,CAAC,EAAE,CAAP;EACV,WAAW,EAAE,IAAK,GADP;;;AAIJ,OAAO,CAAC,EAAE,CAAP;EACV,WAAW,EAAE,IAAK,GADP;;;AAKJ,OAAO,CAAC,CAAC;AACjB,OAAO,CAAC,UAAU,CADC;EAClB,MAAM,EAAE,IAAK,GADM;;;AAIZ,OAAO,CAAC,UAAU,CAAP;EAClB,OAAO,EAAE,KAAM;EACf,QAAQ,EAAE,QAAS;EACnB,KAAK,EAAE,GAAI;EACX,MAAM,ED/HO,IAAI,CC+HI,IAAI;EACzB,OAAO,EAAE,GAAI;EAEb,UAAU,EAAE,MAAO;EACnB,UAAU,EAAE,yBAAI;EAChB,UAAU,EAAE,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,kBAAI,GATT;;;AAYC,OAAO,CAAC,UAAU,CAAC,CAAC,AAAA,YAAY;AACrD,OAAO,CAAC,UAAU,CAAC,CAAC,AAAA,WAAW,CADE;EAC/B,OAAO,EAAE,YAAa,GADU;;;AAI1B,OAAO,CAAC,CAAC,CAAP;EACT,UAAU,EAAE,MAAO,GADT;;;AAIH,OAAO,CAAC,GAAG,CAAP;EACX,OAAO,EAAE,KAAM;EACf,QAAQ,EAAE,QAAS;EACnB,KAAK,EAAE,GAAI;EACX,MAAM,EDnJO,IAAI,CCmJI,IAAI;EAEzB,UAAU,EAAE,IAAK;EACjB,SAAS,EAAE,MAAO;EAClB,WAAW,EAAE,SAAU;EACvB,WAAW,EAAE,KAAM;EAEnB,SAAS,EAAE,UAAW;EAEtB,UAAU,EAAE,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,kBAAI,GAbhB;;;AAeL,OAAO,CAAC,IAAI,CAAP;EACZ,WAAW,EAAE,SAAU,GADV;;;AAIF,OAAO,CAAC,GAAG,CAAC,IAAI,CAAX;EAChB,OAAO,EAAE,KAAM;EACf,OAAO,EAAE,GAAI;EACb,QAAQ,EAAE,IAAK;EACf,UAAU,EAAE,KAAM;EAClB,SAAS,EAAE,MAAO,GALD;;;AAQV,OAAO,CAAC,KAAK,CAAP;EACb,MAAM,EAAE,IAAK;EACb,eAAe,EAAE,QAAS;EAC1B,cAAc,EAAE,CAAE,GAHJ;;;AAMD,OAAO,CAAC,KAAK,CAAC,EAAE,CAAb;EAChB,WAAW,EAAE,IAAK,GADD;;;AAKJ,OAAO,CAAC,KAAK,CAAC,EAAE;AAC9B,OAAO,CAAC,KAAK,CAAC,EAAE,CADC;EAChB,UAAU,EAAE,IAAK;EACjB,OAAO,EAAE,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK;EAChC,aAAa,EAAE,SAAU,GAHR;;;AAOa,OAAO,CAAC,KAAK,CAAC,EAAE,CAAA,AAAA,KAAC,CAAM,QAAQ,AAAd;AAChD,OAAO,CAAC,KAAK,CAAC,EAAE,CAAA,AAAA,KAAC,CAAM,QAAQ,AAAd,EADgB;EAChC,UAAU,EAAE,MAAO,GADc;;;AAKJ,OAAO,CAAC,KAAK,CAAC,EAAE,CAAA,AAAA,KAAC,CAAM,OAAO,AAAb;AAC/C,OAAO,CAAC,KAAK,CAAC,EAAE,CAAA,AAAA,KAAC,CAAM,OAAO,AAAb,EADe;EAC/B,UAAU,EAAE,KAAM,GADc;;;AAKC,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,AAAA,WAAW,CAAC,EAAE;AACtE,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,AAAA,WAAW,CAAC,EAAE,CADC;EACpC,aAAa,EAAE,IAAK,GADiB;;;AAI9B,OAAO,CAAC,GAAG,CAAP;EACX,cAAc,EAAE,KAAM,GADV;;;AAGL,OAAO,CAAC,GAAG,CAAP;EACX,cAAc,EAAE,GAAI,GADR;;;AAIL,OAAO,CAAC,KAAK,CAAP;EACb,OAAO,EAAE,YAAa;EACtB,SAAS,EAAE,KAAM;EACjB,WAAW,EAAE,KAAM;EACnB,cAAc,EAAE,GAAI,GAJN;;;AAOD,OAAO,CAAC,KAAK,CAAC,CAAC,CAAb;EACf,cAAc,EAAE,GAAI,GADJ;;AAKjB;;+CAE+C;;AAEvC,OAAO,CAAC,CAAC,CAAP;EACT,KAAK,EHxNM,OAAO;EGyNlB,eAAe,EAAE,IAAK;EAEtB,kBAAkB,EAAE,KAAK,CAAC,KAAI,CAAC,IAAI;EAChC,eAAe,EAAE,KAAK,CAAC,KAAI,CAAC,IAAI;EAC3B,UAAU,EAAE,KAAK,CAAC,KAAI,CAAC,IAAI,GANzB;;;AAQD,OAAO,CAAC,CAAC,AAAA,MAAM,CAAR;EACf,KAAK,EH/NU,OAAO;EGiOtB,WAAW,EAAE,IAAK;EAClB,MAAM,EAAE,IAAK,GAJG;;;AAOA,OAAO,CAAC,KAAK,CAAC,IAAI,AAAA,MAAM,CAAjB;EACxB,KAAK,EAAE,IAAK;EACZ,UAAU,EAAE,OAAM,GAFO;;AAM1B;;+CAE+C;;AAE/B,OAAO,CAAC,OAAO,CAAC,GAAG,CAAf;EACnB,MAAM,EAAE,IAAI,CAAC,GAAG;EAChB,UAAU,EAAE,yBAAI;EAChB,MAAM,EAAE,GAAG,CAAC,KAAK,CDhQN,IAAI;ECkQf,UAAU,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,mBAAI,GALL;;;AAQD,OAAO,CAAC,OAAO,CAAC,GAAG,AAAA,MAAM,CAAlB;EACzB,MAAM,EAAE,CAAE;EACV,UAAU,EAAE,IAAK,GAFS;;;AAKjB,OAAO,CAAC,CAAC,CAAC,GAAG,CAAT;EACb,kBAAkB,EAAE,GAAG,CAAC,KAAI,CAAC,MAAM;EAChC,eAAe,EAAE,GAAG,CAAC,KAAI,CAAC,MAAM;EAC3B,UAAU,EAAE,GAAG,CAAC,KAAI,CAAC,MAAM,GAHrB;;;AAMC,OAAO,CAAC,CAAC,AAAA,MAAM,CAAC,GAAG,CAAf;EACnB,UAAU,EAAE,wBAAI;EAChB,YAAY,EHrQF,OAAO;EGuQjB,UAAU,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,mBAAI,GAJL;;AAQtB;;+CAE+C;;AAGf,OAAO,CAAC,SAAS,CAAC,cAAc;AAChE,OAAO,CAAC,SAAS,CAAC,cAAc,AAAA,QAAQ,CADC;EACxC,kBAAkB,EHjRP,OAAO,GGgRuB;;;AAKT,OAAO,CAAC,SAAS,CAAC,eAAe;AAClE,OAAO,CAAC,SAAS,CAAC,eAAe,AAAA,QAAQ,CADC;EACzC,iBAAiB,EHtRN,OAAO,GGqRwB;;;AAKb,OAAO,CAAC,SAAS,CAAC,YAAY;AAC5D,OAAO,CAAC,SAAS,CAAC,YAAY,AAAA,QAAQ,CADC;EACtC,mBAAmB,EH3RR,OAAO,GG0RqB;;;AAKR,OAAO,CAAC,SAAS,CAAC,cAAc;AAChE,OAAO,CAAC,SAAS,CAAC,cAAc,AAAA,QAAQ,CADC;EACxC,gBAAgB,EHhSL,OAAO,GG+RuB;;;AAIF,OAAO,CAAC,SAAS,CAAC,cAAc,AAAA,QAAQ,AAAA,MAAM,CAAvC;EAC9C,kBAAkB,EHnSF,OAAO,GGkSwB;;;AAIP,OAAO,CAAC,SAAS,CAAC,eAAe,AAAA,QAAQ,AAAA,MAAM,CAAxC;EAC/C,iBAAiB,EHvSD,OAAO,GGsSyB;;;AAIX,OAAO,CAAC,SAAS,CAAC,YAAY,AAAA,QAAQ,AAAA,MAAM,CAArC;EAC5C,mBAAmB,EH3SH,OAAO,GG0SsB;;;AAIN,OAAO,CAAC,SAAS,CAAC,cAAc,AAAA,QAAQ,AAAA,MAAM,CAAvC;EAC9C,gBAAgB,EH/SA,OAAO,GG8SwB;;AAKhD;;+CAE+C;;AAEvC,OAAO,CAAC,SAAS,CAAP;EACjB,UAAU,EAAE,kBAAI,GADE;;;AAGA,OAAO,CAAC,SAAS,CAAC,IAAI,CAAjB;EACtB,UAAU,EH5TA,OAAO;EG8TjB,kBAAkB,EAAE,KAAK,CAAC,KAAK,CAAC,qCAAY;EACzC,eAAe,EAAE,KAAK,CAAC,KAAK,CAAC,qCAAY;EACpC,UAAU,EAAE,KAAK,CAAC,KAAK,CAAC,qCAAY,GALrB", 12 | "names": [] 13 | } -------------------------------------------------------------------------------- /src/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | Index 8 | 9 | 10 | 11 | 12 | 13 | 18 | 19 | 28 | 29 | 30 | 31 |
    32 |
    33 | {content} 34 |
    35 |
    36 | 37 | 38 | 39 | 40 | 58 | 59 | 60 | 61 | -------------------------------------------------------------------------------- /src/js/repl.it.js: -------------------------------------------------------------------------------- 1 | function codereplace(snippet) { 2 | var frontmatter = '
    \ 3 |
    \ 4 | \ 5 |
    \ 6 |
    \ 7 |
    \ 8 |
    \ 9 | 
    \
10 | ';
11 | 
12 |     var postmatter = '
    \ 13 |
    \ 14 |
    \ 15 |

    Output:

    \ 16 | 
    \
17 | 
    \
18 | 
    ';
19 | 
20 |     var code = frontmatter + snippet + postmatter;
21 |     return code;
22 | }
23 | 
24 | function init() {
25 |     var elements = document.getElementsByClassName('exec');
26 |     for (var i=0; i < elements.length; i++) {
27 |         var snippet = elements[i].innerHTML;
28 |         elements[i].innerHTML = codereplace(snippet);
29 |     }
30 | }
31 | 
32 | window.onload = function () {
33 |     init();
34 | 
35 | 
36 |     repl = new ReplitClient('api.repl.it', '80', 'python3', TOKEN);
37 | 
38 | 
39 |     repl.connect().then(
40 |         function () {
41 |             document.querySelector('.run-button').innerHTML = 'RUN';
42 |             document.querySelector('.run-button').disabled = false;
43 |             start();
44 |         },
45 |         function () {
46 |             document.querySelector('.run-button').innerHTML = 'failed';
47 |             document.querySelector('.run-button').disabled = true;
48 | 
49 |         }
50 |     );
51 | 
52 |     function start() {
53 |     document.querySelector('.run-button').onclick = function () {
54 |         document.querySelector('.run-button').disabled = true;
55 |         document.querySelector('.run-button').innerHTML = 'running';
56 |         repl.evaluate(
57 |             document.querySelector('.input').innerHTML, {
58 |                 stdout: function (str) {
59 |                     document.querySelector('.out').innerHTML += str;
60 |                 }
61 |             }
62 |         ).then(
63 |             function (err) {
64 |                 console.log(err);
65 |             }
66 |         );
67 |         document.querySelector('.run-button').innerHTML = 'RUN';
68 |         document.querySelector('.run-button').disabled = false;
69 |     };
70 | }
71 | }
72 | 


--------------------------------------------------------------------------------
/src/js/token.js.example:
--------------------------------------------------------------------------------
1 | TOKEN = //Insert repl.it token here
2 | 


--------------------------------------------------------------------------------