Seabaer-Software/MyPythonBook
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
MyPythonBook/PythonBook.html
Uwe Schimanski 17376c5a80 First Version
2024-10-14 17:16:34 +02:00

4460 lines
259 KiB
HTML
Executable File
Raw Permalink Blame History

<!DOCTYPE html>
<html>
<head>
<title>PythonBook.md</title>
<meta http-equiv="Content-type" content="text/html;charset=UTF-8">
<style>
/* https://github.com/microsoft/vscode/blob/master/extensions/markdown-language-features/media/markdown.css */
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
body {
font-family: var(--vscode-markdown-font-family, -apple-system, BlinkMacSystemFont, "Segoe WPC", "Segoe UI", "Ubuntu", "Droid Sans", sans-serif);
font-size: var(--vscode-markdown-font-size, 14px);
padding: 0 26px;
line-height: var(--vscode-markdown-line-height, 22px);
word-wrap: break-word;
}
#code-csp-warning {
position: fixed;
top: 0;
right: 0;
color: white;
margin: 16px;
text-align: center;
font-size: 12px;
font-family: sans-serif;
background-color:#444444;
cursor: pointer;
padding: 6px;
box-shadow: 1px 1px 1px rgba(0,0,0,.25);
}
#code-csp-warning:hover {
text-decoration: none;
background-color:#007acc;
box-shadow: 2px 2px 2px rgba(0,0,0,.25);
}
body.scrollBeyondLastLine {
margin-bottom: calc(100vh - 22px);
}
body.showEditorSelection .code-line {
position: relative;
}
body.showEditorSelection .code-active-line:before,
body.showEditorSelection .code-line:hover:before {
content: "";
display: block;
position: absolute;
top: 0;
left: -12px;
height: 100%;
}
body.showEditorSelection li.code-active-line:before,
body.showEditorSelection li.code-line:hover:before {
left: -30px;
}
.vscode-light.showEditorSelection .code-active-line:before {
border-left: 3px solid rgba(0, 0, 0, 0.15);
}
.vscode-light.showEditorSelection .code-line:hover:before {
border-left: 3px solid rgba(0, 0, 0, 0.40);
}
.vscode-light.showEditorSelection .code-line .code-line:hover:before {
border-left: none;
}
.vscode-dark.showEditorSelection .code-active-line:before {
border-left: 3px solid rgba(255, 255, 255, 0.4);
}
.vscode-dark.showEditorSelection .code-line:hover:before {
border-left: 3px solid rgba(255, 255, 255, 0.60);
}
.vscode-dark.showEditorSelection .code-line .code-line:hover:before {
border-left: none;
}
.vscode-high-contrast.showEditorSelection .code-active-line:before {
border-left: 3px solid rgba(255, 160, 0, 0.7);
}
.vscode-high-contrast.showEditorSelection .code-line:hover:before {
border-left: 3px solid rgba(255, 160, 0, 1);
}
.vscode-high-contrast.showEditorSelection .code-line .code-line:hover:before {
border-left: none;
}
img {
max-width: 100%;
max-height: 100%;
}
a {
text-decoration: none;
}
a:hover {
text-decoration: underline;
}
a:focus,
input:focus,
select:focus,
textarea:focus {
outline: 1px solid -webkit-focus-ring-color;
outline-offset: -1px;
}
hr {
border: 0;
height: 2px;
border-bottom: 2px solid;
}
h1 {
padding-bottom: 0.3em;
line-height: 1.2;
border-bottom-width: 1px;
border-bottom-style: solid;
}
h1, h2, h3 {
font-weight: normal;
}
table {
border-collapse: collapse;
}
table > thead > tr > th {
text-align: left;
border-bottom: 1px solid;
}
table > thead > tr > th,
table > thead > tr > td,
table > tbody > tr > th,
table > tbody > tr > td {
padding: 5px 10px;
}
table > tbody > tr + tr > td {
border-top: 1px solid;
}
blockquote {
margin: 0 7px 0 5px;
padding: 0 16px 0 10px;
border-left-width: 5px;
border-left-style: solid;
}
code {
font-family: Menlo, Monaco, Consolas, "Droid Sans Mono", "Courier New", monospace, "Droid Sans Fallback";
font-size: 1em;
line-height: 1.357em;
}
body.wordWrap pre {
white-space: pre-wrap;
}
pre:not(.hljs),
pre.hljs code > div {
padding: 16px;
border-radius: 3px;
overflow: auto;
}
pre code {
color: var(--vscode-editor-foreground);
tab-size: 4;
}
/** Theming */
.vscode-light pre {
background-color: rgba(220, 220, 220, 0.4);
}
.vscode-dark pre {
background-color: rgba(10, 10, 10, 0.4);
}
.vscode-high-contrast pre {
background-color: rgb(0, 0, 0);
}
.vscode-high-contrast h1 {
border-color: rgb(0, 0, 0);
}
.vscode-light table > thead > tr > th {
border-color: rgba(0, 0, 0, 0.69);
}
.vscode-dark table > thead > tr > th {
border-color: rgba(255, 255, 255, 0.69);
}
.vscode-light h1,
.vscode-light hr,
.vscode-light table > tbody > tr + tr > td {
border-color: rgba(0, 0, 0, 0.18);
}
.vscode-dark h1,
.vscode-dark hr,
.vscode-dark table > tbody > tr + tr > td {
border-color: rgba(255, 255, 255, 0.18);
}
</style>
<style>
/* Tomorrow Theme */
/* http://jmblog.github.com/color-themes-for-google-code-highlightjs */
/* Original theme - https://github.com/chriskempson/tomorrow-theme */
/* Tomorrow Comment */
.hljs-comment,
.hljs-quote {
color: #8e908c;
}
/* Tomorrow Red */
.hljs-variable,
.hljs-template-variable,
.hljs-tag,
.hljs-name,
.hljs-selector-id,
.hljs-selector-class,
.hljs-regexp,
.hljs-deletion {
color: #c82829;
}
/* Tomorrow Orange */
.hljs-number,
.hljs-built_in,
.hljs-builtin-name,
.hljs-literal,
.hljs-type,
.hljs-params,
.hljs-meta,
.hljs-link {
color: #f5871f;
}
/* Tomorrow Yellow */
.hljs-attribute {
color: #eab700;
}
/* Tomorrow Green */
.hljs-string,
.hljs-symbol,
.hljs-bullet,
.hljs-addition {
color: #718c00;
}
/* Tomorrow Blue */
.hljs-title,
.hljs-section {
color: #4271ae;
}
/* Tomorrow Purple */
.hljs-keyword,
.hljs-selector-tag {
color: #8959a8;
}
.hljs {
display: block;
overflow-x: auto;
color: #4d4d4c;
padding: 0.5em;
}
.hljs-emphasis {
font-style: italic;
}
.hljs-strong {
font-weight: bold;
}
</style>
<style>
/*
* Markdown PDF CSS
*/
body {
font-family: -apple-system, BlinkMacSystemFont, "Segoe WPC", "Segoe UI", "Ubuntu", "Droid Sans", sans-serif, "Meiryo";
padding: 0 12px;
}
pre {
background-color: #f8f8f8;
border: 1px solid #cccccc;
border-radius: 3px;
overflow-x: auto;
white-space: pre-wrap;
overflow-wrap: break-word;
}
pre:not(.hljs) {
padding: 23px;
line-height: 19px;
}
blockquote {
background: rgba(127, 127, 127, 0.1);
border-color: rgba(0, 122, 204, 0.5);
}
.emoji {
height: 1.4em;
}
code {
font-size: 14px;
line-height: 19px;
}
/* for inline code */
:not(pre):not(.hljs) > code {
color: #C9AE75; /* Change the old color so it seems less like an error */
font-size: inherit;
}
/* Page Break : use <div class="page"/> to insert page break
-------------------------------------------------------- */
.page {
page-break-after: always;
}
</style>
<script src="https://unpkg.com/mermaid/dist/mermaid.min.js"></script>
</head>
<body>
<script>
mermaid.initialize({
startOnLoad: true,
theme: document.body.classList.contains('vscode-dark') || document.body.classList.contains('vscode-high-contrast')
? 'dark'
: 'default'
});
</script>
<h1 id="div-align%22center%22pythondiv"><strong><div align="center">Python</div></strong></h1>
<div align="center">Alles Schlange oder was?</div>
<br>
<p>
<div align="center">Author: Uwe Schimanski</div>
<div align="center"> Mail: uwe@schimanski-nrw.de</div>
<div align="center">13.07.2024</div>
</p>
<hr>
<div style='page-break-after: always'></div>
<h2 id="table-of-contents">Table of Contents</h2>
<ul>
<li><a href="#python"><strong>Python</strong></a>
<ul>
<li><a href="#table-of-contents">Table of Contents</a></li>
<li><a href="#1-projekt-umgebung">1. Projekt Umgebung</a></li>
<li><a href="#2-basics">2. Basics</a>
<ul>
<li><a href="#21-output-text">2.1 Output Text</a></li>
<li><a href="#22-listen-array">2.2 Listen (Array)</a>
<ul>
<li><a href="#221-allgemein">2.2.1 Allgemein</a></li>
<li><a href="#222-list-slicing">2.2.2 List Slicing</a></li>
<li><a href="#223-list-comprehension">2.2.3 List Comprehension</a></li>
<li><a href="#224-tupel--dictionaries">2.2.4 Tupel &amp; Dictionaries</a></li>
<li><a href="#225-listen-verschachteln">2.2.5 Listen verschachteln</a></li>
</ul>
</li>
<li><a href="#23-daten-umwandeln">2.3 Daten umwandeln</a></li>
<li><a href="#24-join">2.4 Join</a></li>
<li><a href="#25-kommentare">2.5 Kommentare</a></li>
<li><a href="#26-kontrollstrukturen">2.6 Kontrollstrukturen</a>
<ul>
<li><a href="#261-vergleichsoperatoren">2.6.1 Vergleichsoperatoren</a></li>
<li><a href="#262-if">2.6.2 If</a></li>
<li><a href="#263-in-operator">2.6.3 In-Operator</a></li>
<li><a href="#264-not-operator">2.6.4 Not-Operator</a></li>
<li><a href="#265-elif">2.6.5 Elif</a></li>
<li><a href="#266-while---schleife">2.6.6 While - Schleife</a></li>
<li><a href="#267-for---schleife">2.6.7 For - Schleife</a></li>
<li><a href="#268-break--continue">2.6.8 Break &amp; Continue</a></li>
<li><a href="#269-zufallszahlen-random">2.6.9 Zufallszahlen (Random)</a></li>
</ul>
</li>
<li><a href="#27-rechnen">2.7 Rechnen</a></li>
<li><a href="#28-datum">2.8 Datum</a></li>
<li><a href="#29-string-und-string-manipulation">2.9 String und String Manipulation</a></li>
<li><a href="#210-projekt-pfad">2.10 Projekt Pfad</a></li>
</ul>
</li>
<li><a href="#3-funktionen">3. Funktionen</a>
<ul>
<li><a href="#31-funktion-erstellen">3.1 Funktion erstellen</a></li>
<li><a href="#32-objekte">3.2 Objekte</a></li>
<li><a href="#33-beispiele">3.3 Beispiele</a></li>
</ul>
</li>
<li><a href="#4-dateien">4. Dateien</a>
<ul>
<li><a href="#41-%C3%B6ffnen">4.1 Öffnen</a></li>
<li><a href="#42-schreiben">4.2 Schreiben</a></li>
<li><a href="#43-with">4.3 With</a></li>
<li><a href="#44-csv-datei-%C3%B6ffnen">4.4 CSV-Datei öffnen</a></li>
<li><a href="#45-ini-datei-einlesen">4.5 Ini-Datei einlesen</a></li>
<li><a href="#46-yaml-datei">4.6 Yaml-Datei</a>
<ul>
<li><a href="#461-einlesen">4.6.1 Einlesen</a></li>
<li><a href="#461-schreiben">4.6.1 Schreiben</a></li>
</ul>
</li>
</ul>
</li>
<li><a href="#5-graphiken">5. Graphiken</a></li>
<li><a href="#6-objektorientierung">6. Objektorientierung</a>
<ul>
<li><a href="#61-klasse">6.1 Klasse</a></li>
<li><a href="#62-constructor-eigenschaften-ab%C3%A4ndern">6.2 Constructor, Eigenschaften abändern</a></li>
<li><a href="#63-sichtbarkeit-von-methoden--variablen">6.3 Sichtbarkeit von Methoden &amp; Variablen</a></li>
<li><a href="#64-vererbung">6.4 Vererbung</a></li>
<li><a href="#65-typ-feststellen">6.5 Typ feststellen</a></li>
<li><a href="#66-alles-ist-ein-objekt">6.6 Alles ist ein Objekt</a></li>
<li><a href="#67-benennung-von-klassen-und-variablen">6.7 Benennung von Klassen und Variablen</a></li>
<li><a href="#68-statische-variablen">6.8 Statische Variablen</a></li>
<li><a href="#69-beispiele">6.9 Beispiele</a></li>
</ul>
</li>
<li><a href="#7-module">7. Module</a>
<ul>
<li><a href="#71-module-laden">7.1 Module laden</a></li>
<li><a href="#72-module-in-einem-ordner-erstellen">7.2 Module in einem Ordner erstellen</a></li>
<li><a href="#73-csv-modul">7.3 CSV Modul</a></li>
<li><a href="#74-web-crawler">7.4 Web Crawler</a>
<ul>
<li><a href="#741-allgemeine-beispiele">7.4.1 Allgemeine Beispiele</a></li>
<li><a href="#742-css-selectors">7.4.2 CSS-Selectors</a></li>
<li><a href="#743-elemente-finden">7.4.3 Elemente finden</a></li>
<li><a href="#744-encoding">7.4.4 Encoding</a></li>
<li><a href="#745-generatoren">7.4.5 Generatoren</a></li>
<li><a href="#746-crawler-in-python-programm-umwandeln">7.4.6 Crawler in Python-Programm umwandeln</a></li>
</ul>
</li>
</ul>
</li>
<li><a href="#8-exceptions">8. Exceptions</a></li>
<li><a href="#9-datenstrukturen">9. Datenstrukturen</a>
<ul>
<li><a href="#91-set">9.1 Set</a></li>
<li><a href="#92-queue">9.2 Queue</a></li>
<li><a href="#93-priorityqueue">9.3 PriorityQueue</a></li>
</ul>
</li>
<li><a href="#10-diverses--expertenwissen">10. Diverses / Expertenwissen</a>
<ul>
<li><a href="#101-variable-funktionsparameter">10.1 Variable Funktionsparameter</a></li>
<li><a href="#102-daten-sortieren">10.2 Daten sortieren</a></li>
<li><a href="#103-datumsangaben">10.3 Datumsangaben</a></li>
<li><a href="#104-lambda">10.4 Lambda</a></li>
<li><a href="#105-regul%C3%A4re-ausdr%C3%BCcke">10.5 Reguläre Ausdrücke</a></li>
<li><a href="#106-zeitdifferenzen">10.6 Zeitdifferenzen</a></li>
<li><a href="#107-strings-formatieren">10.7 Strings formatieren</a></li>
<li><a href="#108-defaultdict">10.8 DefaultDict</a></li>
<li><a href="#109-tabellen">10.9 Tabellen</a></li>
</ul>
</li>
<li><a href="#11-diverses">11. Diverses</a>
<ul>
<li><a href="#111-eingaben-einlesen">11.1 Eingaben einlesen</a></li>
<li><a href="#112-parameter-%C3%BCbergeben">11.2 Parameter übergeben</a>
<ul>
<li><a href="#1121-sysargs">11.2.1 sys.args</a></li>
<li><a href="#1122-argsparse">11.2.2 argsparse</a></li>
</ul>
</li>
<li><a href="#113-mit-pfadangaben-arbeiten">11.3 Mit Pfadangaben arbeiten</a></li>
<li><a href="#114-umlaute-und-kodierungen">11.4 Umlaute und Kodierungen</a></li>
</ul>
</li>
<li><a href="#12-jupyter-notebook">12. Jupyter Notebook</a>
<ul>
<li><a href="#121-widgets">12.1 Widgets</a></li>
<li><a href="#122-interaktion-mit-widgets">12.2 Interaktion mit Widgets</a></li>
</ul>
</li>
<li><a href="#13-flask">13. Flask</a>
<ul>
<li><a href="#131-web-seite">13.1 Web-Seite</a></li>
</ul>
</li>
<li><a href="#14-decoratoren">14. Decoratoren</a></li>
<li><a href="#15-datascince-stack">15. Datascince-Stack</a>
<ul>
<li><a href="#151-numpy">15.1 Numpy</a></li>
<li><a href="#152-pandas">15.2 Pandas</a></li>
<li><a href="#153-matplotlib">15.3 Matplotlib</a>
<ul>
<li><a href="#1531-diagramme-konfigurieren">15.3.1 Diagramme konfigurieren</a></li>
<li><a href="#1532-diagrammtypen">15.3.2 Diagrammtypen</a></li>
</ul>
</li>
</ul>
</li>
<li><a href="#16-bildverarbeitung-mit-opencv">16. Bildverarbeitung mit OpenCV</a>
<ul>
<li><a href="#161-installation">16.1 Installation</a></li>
<li><a href="#162-bild-in-opencv-laden">16.2 Bild in OpenCV laden</a></li>
<li><a href="#163-helligkeit-ver%C3%A4ndern">16.3 Helligkeit verändern</a></li>
<li><a href="#164-rechteck-einzeichnen">16.4 Rechteck einzeichnen</a></li>
<li><a href="#155-gesichtserkennung">15.5 Gesichtserkennung</a></li>
</ul>
</li>
<li><a href="#17-oberfl%C3%A4chen-mit-qt">17. Oberflächen mit QT</a>
<ul>
<li><a href="#171-installation">17.1 Installation</a></li>
<li><a href="#172-projekt-anlegen">17.2 Projekt anlegen</a></li>
<li><a href="#173-oberfl%C3%A4che-%C3%BCbersetzen">17.3 Oberfläche übersetzen</a></li>
</ul>
</li>
<li><a href="#18-exe-datei-estellen">18. EXE-Datei estellen</a>
<ul>
<li><a href="#181-pfadangaben">18.1 Pfadangaben</a></li>
<li><a href="#182-exe-datei-erstellen">18.2 EXE-Datei erstellen</a></li>
</ul>
</li>
<li><a href="#19-http-server-und-http-proxy">19. HTTP-Server und HTTP-Proxy</a></li>
</ul>
</li>
</ul>
<div style='page-break-after: always'></div>
<h2 id="1-projekt-umgebung">1. Projekt Umgebung</h2>
<p>Damit man in den verschiedenen Projekten unterschiedliche Versionen von Packages installieren kann, so erstellt man ein Virtual Environment (venv)</p>
<pre class="hljs"><code><div>$&gt;<span class="hljs-comment"># Anlegen der Umgebung</span>
$&gt;mkdir demo1
$&gt;<span class="hljs-comment"># Ohne die Optionale angabe von --prompt wird der Verzeichnis Name ausgegeben.</span>
$&gt;python3 -m venv demo1/ [--prompt=<span class="hljs-string">"First-Demo"</span>]
$&gt;<span class="hljs-comment"># Aktivieren der Umgebung</span>
$&gt;<span class="hljs-built_in">cd</span> demo1
$&gt;<span class="hljs-built_in">source</span> bin/activate
(First-Demo) $&gt;
$&gt;<span class="hljs-comment"># Verlassen der Umgebung</span>
$&gt;deactivate
$&gt;<span class="hljs-comment"># Installieren Package mit einer bestimmten Version</span>
$&gt;<span class="hljs-built_in">source</span> bin/activate
(First-Demo1) $&gt;python -m pip install django==2.2.26
$&gt;<span class="hljs-comment"># Installierte Packages auflisten</span>
$&gt;<span class="hljs-built_in">source</span> bin/activate
(First-Demo1) $&gt;python -m pip list
Package Version
---------- -------
django 2.2.26
pip 24.0
setuptools 65.5.0
</div></code></pre>
<div style='page-break-after: always'></div>
<h2 id="2-basics">2. Basics</h2>
<p>In der Python Datei, sollte angegeben werden, wie die Datei Kodiert ist. In dem Beispiel wird utf-8 verwendet.</p>
<pre class="hljs"><code><div><span class="hljs-comment">#!/usr/bin/env python3</span>
<span class="hljs-comment">#-*- coding: utf-8 -*-</span>
</div></code></pre>
<h3 id="21-output-text">2.1 Output Text</h3>
<p>Eine Ausgabe auf der Standard Ausgabe wird mit der Funktion <strong>print()</strong> gemacht. Mit einem <strong>\n</strong> wird ein Zeilenumbruch eingefügt.</p>
<pre class="hljs"><code><div>print(<span class="hljs-string">"Hier könnte ihre Werbung stehen\n"</span>)
<span class="hljs-comment"># Variable Ausgeben</span>
VERSION = <span class="hljs-string">"24.06.08"</span>
print(<span class="hljs-string">"Programm Version: %s"</span> % (VERSION))
<span class="hljs-comment"># Ausgabe mehrzeiliger Text</span>
vtext = <span class="hljs-string">"""\
{pname} {ver}
Copyright (C) 2024 Seab@er Software
Lizenz GPLv3 +: GNU GPL Version 3 oder hoeher &lt;http://gnu.org/licenses/gpl.html&gt;
Dies ist eine freie Software : Sie koennen sie aendern und weitergeben .
Es gibt keinerlei Garantien , soweit wie es das Gesetz erlaubt.
Geschrieben von Uwe Schimanski
Mail: uws@seabaer-ag.de
Web: https://www.seabaer-ag.de"""</span>.format(pname=os.path.split(__file__)[<span class="hljs-number">1</span>], ver=pversion)
print(vtext)
</div></code></pre>
<p>Auch eine Farbige Ausgabe ist möglich. Hierzu kann das Paket <strong>colorama</strong> geladen werden.</p>
<pre class="hljs"><code><div><span class="hljs-keyword">import</span> colorama
<span class="hljs-comment"># from colorama imort Fore, Back, Style</span>
print(colorama.Fore.RED + <span class="hljs-string">"Error: Hier ist ein Fehler passiert."</span> + colorama.Fore.RESET)
print(Fore.Red + <span class="hljs-string">"Error: Hier ist ein Fehler passiert."</span> + Fore.Reset)
</div></code></pre>
<p>Folgende Werte können mit dem Paket gesetzt werden:</p>
<ul>
<li>Fore: BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE, RESET</li>
<li>Back: BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE, RESET</li>
<li>Style: DIM, NORMAL, BRIGHT, RESET_ALL</li>
</ul>
<h3 id="22-listen-array">2.2 Listen (Array)</h3>
<h4 id="221-allgemein">2.2.1 Allgemein</h4>
<p>In einer Liste können mehrere Werte in einer Variable gespeichert werden. Der erste Wert hat dann immer die Zählnummer 0. Eine Liste wird mit [] eingegrenzt und zwischen den Werten steht ein Komma.</p>
<pre class="hljs"><code><div>name = [<span class="hljs-string">"Max"</span>, <span class="hljs-string">"Susi"</span>, <span class="hljs-string">"Harry"</span>, <span class="hljs-string">"Paul"</span>, <span class="hljs-string">"Walter"</span>]
print(name)
<span class="hljs-string">'Max'</span>, <span class="hljs-string">'Susi'</span>, <span class="hljs-string">'Harry'</span>, <span class="hljs-string">'Paul'</span>, <span class="hljs-string">'Walter'</span>
print(name[<span class="hljs-number">0</span>])
Max
<span class="hljs-comment"># Anzahl der Einträge in der Liste</span>
print(len(name))
<span class="hljs-number">5</span>
<span class="hljs-comment"># Wert ändern</span>
name[<span class="hljs-number">1</span>] = <span class="hljs-string">"Andrea"</span>
</div></code></pre>
<p>Um einen Wert in einer Liste zu löschen, so gibt es hierzu die Funktion <strong>pop</strong>. Die Funktion <strong>pop</strong> hat als Rückgabewert den Namen des gelöschten Wertes. Wird kein Nummer angegeben, so wird immer der letzte Eintrag in der Liste entfernt.</p>
<pre class="hljs"><code><div>name = [<span class="hljs-string">"Max"</span>, <span class="hljs-string">"Susi"</span>, <span class="hljs-string">"Harry"</span>, <span class="hljs-string">"Paul"</span>, <span class="hljs-string">"Walter"</span>]
name.pop()
print(name)
<span class="hljs-string">'Max'</span>, <span class="hljs-string">'Susi'</span>, <span class="hljs-string">'Harry'</span>, <span class="hljs-string">'Paul'</span>
name = [<span class="hljs-string">"Max"</span>, <span class="hljs-string">"Susi"</span>, <span class="hljs-string">"Harry"</span>, <span class="hljs-string">"Paul"</span>, <span class="hljs-string">"Walter"</span>]
p = name.pop()
print(p)
Walter
print(name.pop())
Paul
name = [<span class="hljs-string">"Max"</span>, <span class="hljs-string">"Susi"</span>, <span class="hljs-string">"Harry"</span>, <span class="hljs-string">"Paul"</span>, <span class="hljs-string">"Walter"</span>]
print(name.pop(<span class="hljs-number">2</span>))
Harry
</div></code></pre>
<div style='page-break-after: always'></div>
<p>Weitere Beispiele für Listen.</p>
<pre class="hljs"><code><div><span class="hljs-comment"># Wert hinzufügen</span>
a = [<span class="hljs-string">"Max"</span>, <span class="hljs-string">"Susi"</span>, <span class="hljs-string">"Harry"</span>, <span class="hljs-string">"Paul"</span>, <span class="hljs-string">"Walter"</span>] + [<span class="hljs-string">"Raul"</span>]
<span class="hljs-comment"># Wert löschen</span>
<span class="hljs-keyword">del</span> a[<span class="hljs-number">3</span>]
<span class="hljs-comment"># oder auch</span>
a.remove(<span class="hljs-string">"Susi"</span>)
</div></code></pre>
<h4 id="222-list-slicing">2.2.2 List Slicing</h4>
<pre class="hljs"><code><div>a = [<span class="hljs-string">"Max"</span>, <span class="hljs-string">"Susi"</span>, <span class="hljs-string">"Harry"</span>, <span class="hljs-string">"Paul"</span>, <span class="hljs-string">"Walter"</span>]
print(a[<span class="hljs-number">-1</span>])
print(a[<span class="hljs-number">-2</span>])
Walter
Paul
<span class="hljs-comment"># Ausgabe Liste 2 bis 3</span>
print(a[<span class="hljs-number">2</span>:<span class="hljs-number">4</span>])
[<span class="hljs-string">'Harry'</span>, <span class="hljs-string">'Paul'</span>]
print(a[<span class="hljs-number">1</span>:<span class="hljs-number">-1</span>])
[<span class="hljs-string">'Susi'</span>, <span class="hljs-string">'Harry'</span>, <span class="hljs-string">'Paul'</span>]
<span class="hljs-comment"># Ausgabe Liste Anfang bis vorletzte</span>
print(a[<span class="hljs-number">0</span>:<span class="hljs-number">-1</span>])
print(a[:<span class="hljs-number">-1</span>])
[<span class="hljs-string">'Max'</span>, <span class="hljs-string">'Susi'</span>, <span class="hljs-string">'Harry'</span>, <span class="hljs-string">'Paul'</span>]
[<span class="hljs-string">'Max'</span>, <span class="hljs-string">'Susi'</span>, <span class="hljs-string">'Harry'</span>, <span class="hljs-string">'Paul'</span>]
<span class="hljs-comment"># Ausgabe Liste 1 bis Ende</span>
print(a[<span class="hljs-number">1</span>:])
[<span class="hljs-string">'Susi'</span>, <span class="hljs-string">'Harry'</span>, <span class="hljs-string">'Paul'</span>, <span class="hljs-string">'Walter'</span>]
<span class="hljs-comment"># List Slicing funktioniert auch mit strings</span>
print(<span class="hljs-string">"Hallo Welt"</span>[<span class="hljs-number">0</span>:<span class="hljs-number">5</span>])
Hallo
print(<span class="hljs-string">"Hallo Welt"</span>[<span class="hljs-number">-4</span>:])
Welt
</div></code></pre>
<div style='page-break-after: always'></div>
<h4 id="223-list-comprehension">2.2.3 List Comprehension</h4>
<p>Hiermit kann man vorhandene Listen in eine neue Liste umwandeln.</p>
<pre class="hljs"><code><div><span class="hljs-comment"># Example 1</span>
xs = [<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>, <span class="hljs-number">8</span>]
ys = [x * x <span class="hljs-keyword">for</span> x <span class="hljs-keyword">in</span> xs]
print(xy)
<span class="hljs-comment"># Output</span>
[<span class="hljs-number">1</span>, <span class="hljs-number">4</span>, <span class="hljs-number">9</span>, <span class="hljs-number">16</span>, <span class="hljs-number">25</span>, <span class="hljs-number">36</span>, <span class="hljs-number">49</span>, <span class="hljs-number">64</span>]
<span class="hljs-comment"># Example 2</span>
students = [<span class="hljs-string">"Max"</span>, <span class="hljs-string">"Monika"</span>, <span class="hljs-string">"Franziska"</span>]
lengths = [len(student) <span class="hljs-keyword">for</span> student <span class="hljs-keyword">in</span> students]
print(lengths)
<span class="hljs-comment"># Output</span>
[<span class="hljs-number">3</span>, <span class="hljs-number">6</span>, <span class="hljs-number">9</span>]
<span class="hljs-comment"># Example 3</span>
%matplotlib inline
importmatplotlib.pyplot <span class="hljs-keyword">as</span> plt
xs = [x / <span class="hljs-number">10</span> <span class="hljs-keyword">for</span> x <span class="hljs-keyword">in</span> range(<span class="hljs-number">0</span>, <span class="hljs-number">100</span>)]
ys = [x * x <span class="hljs-keyword">for</span> x <span class="hljs-keyword">in</span> xs]
plt.plot(xs, ys)
plt.show()
</div></code></pre>
<div style='page-break-after: always'></div>
<h4 id="224-tupel--dictionaries">2.2.4 Tupel &amp; Dictionaries</h4>
<p>Mit <strong>Tupel</strong> kann man 2 Werte zusammen gruppieren. <strong>Tupel</strong> Werte kann man nicht bearbeiten oder einen Wert löschen.</p>
<ul>
<li><strong>Liste:</strong> Veränderliche Datenstruktur</li>
<li><strong>Tupel:</strong> Unveränderliche Datenstruktur</li>
</ul>
<pre class="hljs"><code><div>t = (<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>)
print(t[<span class="hljs-number">0</span>])
<span class="hljs-comment"># Tupel entpacken</span>
student = (<span class="hljs-string">"Max Müller"</span>, <span class="hljs-number">22</span>, <span class="hljs-string">"Informatik"</span>)
<span class="hljs-comment"># Variablen Anzahl = Einträge in Tupel</span>
name, age, subject = student
print(name)
print(age)
print(subject)
<span class="hljs-comment"># Mit einem Tupel kann man mehrere Werte zurück geben.</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">get_student</span><span class="hljs-params">()</span>:</span>
<span class="hljs-keyword">return</span> (<span class="hljs-string">"Max Müller"</span>, <span class="hljs-number">22</span>, <span class="hljs-string">"Informatik"</span>)
name, age, subject = get_student()
<span class="hljs-comment"># Eine Liste mit Tupel Einträge</span>
students = [
(<span class="hljs-string">"Max Müller"</span>, <span class="hljs-number">22</span>),
(<span class="hljs-string">"Andrea Hirsch"</span>, <span class="hljs-number">33</span>)
]
<span class="hljs-keyword">for</span> student <span class="hljs-keyword">in</span> students:
name, age = student
print(name)
print(age)
<span class="hljs-comment"># Kürzer</span>
<span class="hljs-keyword">for</span> name, age <span class="hljs-keyword">in</span> students:
print(name)
print(age)
</div></code></pre>
<div style='page-break-after: always'></div>
<p>Mit <strong>Dictionary</strong> kann man eine Zuordnung speichern. Ein <strong>Dictionary</strong> wird mit gescheiften Klammern definiert und die Zuordnung erfolgt mit einem Doppelpunkt.</p>
<pre class="hljs"><code><div>d = {<span class="hljs-string">"Berlin"</span>: <span class="hljs-string">"BER"</span>, <span class="hljs-string">"Helsinki"</span>: <span class="hljs-string">"HEL"</span>, <span class="hljs-string">"Saigon"</span>: <span class="hljs-string">"SGN"</span>}
<span class="hljs-comment"># Gibt es den Wert nicht, so wird eine Error Meldung ausgegeben.</span>
print(d[<span class="hljs-string">"Berlin"</span>])
BER
<span class="hljs-comment"># Bei der get Funktion wird ein None zurück gegeben,</span>
<span class="hljs-comment"># wenn der Wert nicht im Dictionary ist.</span>
print(d.get(<span class="hljs-string">"Berlin"</span>))
BER
<span class="hljs-comment"># Man kann einen Standardwert ausgeben, wenn der Eintrag</span>
<span class="hljs-comment"># nicht im Dictionary vorhanden ist.</span>
print(d.get(<span class="hljs-string">"Düsseldorf"</span>, <span class="hljs-string">"DUS"</span>))
DUS
<span class="hljs-comment"># Wert hinzufügen</span>
d[<span class="hljs-string">"Budapest"</span>] = <span class="hljs-string">"BUD"</span>
<span class="hljs-comment"># Wert entfernen</span>
<span class="hljs-keyword">del</span> d[<span class="hljs-string">"Budapest"</span>]
<span class="hljs-comment"># Abfrage</span>
<span class="hljs-keyword">if</span> <span class="hljs-string">"Saigon"</span> <span class="hljs-keyword">in</span> d:
print(<span class="hljs-string">"Saigon ist im Dictionary enthalten"</span>)
<span class="hljs-comment"># Schleifen</span>
d = {<span class="hljs-string">"München"</span>: <span class="hljs-string">"MUC"</span>, <span class="hljs-string">"Budapest"</span>: <span class="hljs-string">"BUD"</span>, <span class="hljs-string">"Helsinki"</span>: <span class="hljs-string">"HEL"</span>}
<span class="hljs-keyword">for</span> key <span class="hljs-keyword">in</span> d:
value = d[key]
print(key)
print(value)
<span class="hljs-comment"># Kürzer</span>
<span class="hljs-comment"># items erzeugt eine Liste (Tupel) aus dem Dictionary</span>
print(d.items())
<span class="hljs-keyword">for</span> key, value <span class="hljs-keyword">in</span> d.items():
<span class="hljs-keyword">print</span> key + <span class="hljs-string">": "</span> + value
</div></code></pre>
<div style='page-break-after: always'></div>
<p>In dem nächsten Beispiel werden die gleichen Einträge aus einer Liste in ein Dictionary geschrieben.</p>
<pre class="hljs"><code><div>liste = [<span class="hljs-string">"Paul"</span>, <span class="hljs-string">"Walter"</span>, <span class="hljs-string">"Paul"</span>, <span class="hljs-string">"Paul"</span>, <span class="hljs-string">"Andrea"</span>]
d = {}
<span class="hljs-keyword">for</span> element <span class="hljs-keyword">in</span> liste:
<span class="hljs-keyword">if</span> element <span class="hljs-keyword">in</span> d:
d[element] = d[element] + <span class="hljs-number">1</span>
<span class="hljs-keyword">else</span>:
d[element] = <span class="hljs-number">1</span>
print(d)
<span class="hljs-comment"># Max. Wert</span>
max_occ = <span class="hljs-number">0</span>
<span class="hljs-keyword">for</span> key, value <span class="hljs-keyword">in</span> d.items():
<span class="hljs-keyword">if</span> max_occ &lt; value:
max_occ = value
name = key
print(name + <span class="hljs-string">": "</span> + str(max_occ))
</div></code></pre>
<p>Eine CSV-Datei einlesen und die Anzahl der Vornamen ermitteln.</p>
<pre class="hljs"><code><div><span class="hljs-keyword">with</span> open(<span class="hljs-string">"./Documents/Kursmaterialien/Kursmaterialien/data/names.csv"</span>, <span class="hljs-string">"r"</span>) <span class="hljs-keyword">as</span> file:
names = {}
<span class="hljs-keyword">for</span> line <span class="hljs-keyword">in</span> file:
splitted = line.strip().split(<span class="hljs-string">","</span>)
<span class="hljs-keyword">if</span> splitted[<span class="hljs-number">0</span>] == <span class="hljs-string">"Id"</span>:
<span class="hljs-keyword">continue</span>
name = splitted[<span class="hljs-number">1</span>]
count = int(splitted[<span class="hljs-number">5</span>])
<span class="hljs-keyword">if</span> name <span class="hljs-keyword">in</span> names:
names[name] = names[name] + count
<span class="hljs-keyword">else</span>:
names[name] = count
max_occ = <span class="hljs-number">0</span>
name = <span class="hljs-string">""</span>
<span class="hljs-keyword">for</span> key, value <span class="hljs-keyword">in</span> names.items():
<span class="hljs-keyword">if</span> max_occ &lt; value:
max_occ = value
name = key
print(name + <span class="hljs-string">": "</span> + str(max_occ))
James: <span class="hljs-number">4957166</span>
</div></code></pre>
<div style='page-break-after: always'></div>
<h4 id="225-listen-verschachteln">2.2.5 Listen verschachteln</h4>
<pre class="hljs"><code><div>liste = [
[<span class="hljs-string">"Berlin"</span>, <span class="hljs-string">"Gelsenkirchen"</span>, <span class="hljs-string">"Goch"</span>],
[<span class="hljs-string">"Paris"</span>, <span class="hljs-string">"Marseille"</span>, <span class="hljs-string">"Bourdaux"</span>]
]
liste[<span class="hljs-number">0</span>][<span class="hljs-number">1</span>]
Gelsenkirchen
<span class="hljs-comment"># Listen in Dictionary</span>
students = {
<span class="hljs-string">"Informatik"</span>: [<span class="hljs-string">"Uwe"</span>, <span class="hljs-string">"Elisabeth"</span>],
<span class="hljs-string">"BWL"</span>: [<span class="hljs-string">"Franz"</span>, <span class="hljs-string">"Heidi"</span>]
}
print(students[<span class="hljs-string">"Informatik"</span>])
[<span class="hljs-string">'Uwe'</span>, <span class="hljs-string">'Elisabeth'</span>]
</div></code></pre>
<div style='page-break-after: always'></div>
<h3 id="23-daten-umwandeln">2.3 Daten umwandeln</h3>
<pre class="hljs"><code><div><span class="hljs-comment"># String -&gt; Ganze Zahl</span>
a = <span class="hljs-string">"5"</span>
b = <span class="hljs-string">"6"</span>
print(int(a) + int(b))
<span class="hljs-number">11</span>
<span class="hljs-comment"># String -&gt; Kommazahl</span>
a = <span class="hljs-string">"5.5"</span>
b = <span class="hljs-string">"6.6"</span>
print(float(a) + float(b))
<span class="hljs-number">12.1</span>
<span class="hljs-comment"># Zahl -&gt; String</span>
age = <span class="hljs-number">45</span>
print(<span class="hljs-string">"Ich bin "</span> + str(age) + <span class="hljs-string">" Jahre alt."</span>)
Ich bin <span class="hljs-number">45</span> Jahre alt.
<span class="hljs-comment"># Liste -&gt; String</span>
name = [<span class="hljs-string">"Max"</span>, <span class="hljs-string">"Susi"</span>, <span class="hljs-string">"Harry"</span>, <span class="hljs-string">"Paul"</span>, <span class="hljs-string">"Walter"</span>]
print(<span class="hljs-string">"; "</span>.join(name))
Max; Susi; Harry; Paul; Walter
name_as_string = <span class="hljs-string">", "</span>.join(name)
print(<span class="hljs-string">"Unsere Mitarbeiter des Monats: "</span> + name_as_string)
Unsere Mitarbeiter des Monats: Max, Susi, Harry, Paul, Walter
<span class="hljs-comment"># String -&gt; Liste</span>
i = <span class="hljs-string">"Max, Susi, Harry, Paul, Walter"</span>
print(i.split(<span class="hljs-string">", "</span>))
[<span class="hljs-string">'Max'</span>, <span class="hljs-string">'Susi'</span>, <span class="hljs-string">'Harry'</span>, <span class="hljs-string">'Paul'</span>, <span class="hljs-string">'Walter'</span>]
s = <span class="hljs-string">"Ich bin ein Satz mit vielen Wörtern"</span>
print(len(s.split(<span class="hljs-string">" "</span>)))
<span class="hljs-number">7</span>
<span class="hljs-comment"># String Groß- und Kleinschreibung</span>
<span class="hljs-comment"># Kann auch in einer if Abfrage verwendet werden.</span>
<span class="hljs-comment"># if a.lower() == "paul":</span>
a = <span class="hljs-string">"PaUl"</span>
print(a.lower())
paul
print(a.upper())
PAUL
</div></code></pre>
<div style='page-break-after: always'></div>
<h3 id="24-join">2.4 Join</h3>
<p>Mit <strong>join</strong> kann man Werte zusammen setzten.</p>
<pre class="hljs"><code><div>a = [<span class="hljs-string">"Max.Mustermann"</span>, <span class="hljs-string">"internetmail.com"</span>]
print(<span class="hljs-string">"@"</span>.join(a))
Max.Mustermann@internetmail.com
</div></code></pre>
<h3 id="25-kommentare">2.5 Kommentare</h3>
<p>Einzeilige Kommentare werden mit einer Raute (#) eingeleitet. Alles was rechts davon steht wird ignoriert. Der Kommentar kann nicht nur am Anfang eines Code Blocks stehen, sondern auch am Ende einer Zeile.</p>
<p>Wird am Anfang ein Text Block mit drei Hochkommatas (&quot;) gemacht, so wird dieser bei dem Aufruf der Help Funktion angezeigt.</p>
<pre class="hljs"><code><div><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Wauzi</span><span class="hljs-params">()</span>:</span>
<span class="hljs-string">""" Klasse für das Erstellen von Hunden
Ein Hilfetext ist ideal bei mehreren Programmierern in
einem Projekt oder bei schlechten Gedächnis
"""</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, first_name, last_name, birthday)</span>:</span>
<span class="hljs-string">""" Hier wird das Object initialisiert """</span>
self.first_name = first_name
self.last_name = last_name
self.birthday = birthday
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">read</span><span class="hljs-params">(self)</span>:</span>
<span class="hljs-string">""" Auslesen von Werten vom Object. """</span>
<span class="hljs-comment"># Auch ein Kommentar</span>
<span class="hljs-keyword">pass</span>
print(help(Wauzi))
Help on <span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Wauzi</span> <span class="hljs-title">in</span> <span class="hljs-title">module</span> <span class="hljs-title">__main__</span>:</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Wauzi</span><span class="hljs-params">(builtins.object)</span>
| <span class="hljs-title">Wauzi</span><span class="hljs-params">(first_name, last_name, birthday)</span>
|
| <span class="hljs-title">Klasse</span> <span class="hljs-title">f</span>ü<span class="hljs-title">r</span> <span class="hljs-title">das</span> <span class="hljs-title">Erstellen</span> <span class="hljs-title">von</span> <span class="hljs-title">Hunden</span>
| <span class="hljs-title">Ein</span> <span class="hljs-title">Hilfetext</span> <span class="hljs-title">ist</span> <span class="hljs-title">ideal</span> <span class="hljs-title">bei</span> <span class="hljs-title">mehreren</span> <span class="hljs-title">Programmierern</span> <span class="hljs-title">in</span>
| <span class="hljs-title">einem</span> <span class="hljs-title">Projekt</span> <span class="hljs-title">oder</span> <span class="hljs-title">bei</span> <span class="hljs-title">schlechten</span> <span class="hljs-title">Ged</span>ä<span class="hljs-title">chnis</span>
|
| <span class="hljs-title">Methods</span> <span class="hljs-title">defined</span> <span class="hljs-title">here</span>:</span>
|
| __init__(self, first_name, last_name, birthday)
| Hier wird das Object initialisiert
|
| read(self)
| Auslesen von Werten vom Object.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary <span class="hljs-keyword">for</span> instance variables (<span class="hljs-keyword">if</span> defined)
|
| __weakref__
| list of weak references to the object (<span class="hljs-keyword">if</span> defined)
<span class="hljs-literal">None</span>
</div></code></pre>
<div style='page-break-after: always'></div>
<h3 id="26-kontrollstrukturen">2.6 Kontrollstrukturen</h3>
<h4 id="261-vergleichsoperatoren">2.6.1 Vergleichsoperatoren</h4>
<table>
<thead>
<tr>
<th>Operator</th>
<th>Beschreibung</th>
</tr>
</thead>
<tbody>
<tr>
<td>&lt;</td>
<td>kleiner als</td>
</tr>
<tr>
<td>&gt;</td>
<td>größer als</td>
</tr>
<tr>
<td>&gt;=</td>
<td>kleiner gleich</td>
</tr>
<tr>
<td>&gt;=</td>
<td>größer gleich</td>
</tr>
<tr>
<td>==</td>
<td>ist gleich</td>
</tr>
<tr>
<td>!=</td>
<td>nicht gleich</td>
</tr>
</tbody>
</table>
<h4 id="262-if">2.6.2 If</h4>
<p>Nach der Bedingung wird ein Doppelpunkt gesetzt und der Codeblock wird eingerückt. Alles was eingerückt ist, gehört auch zu dem Codeblock.</p>
<pre class="hljs"><code><div>n = <span class="hljs-number">12</span>
<span class="hljs-keyword">if</span> n &lt; <span class="hljs-number">42</span>:
print(<span class="hljs-string">"Die Zahl n ist kleiner als 42"</span>)
m = <span class="hljs-number">10</span>
<span class="hljs-keyword">if</span> m &lt; <span class="hljs-number">5</span>:
print(<span class="hljs-string">"m ist kleiner als 5"</span>)
<span class="hljs-keyword">else</span>:
print(<span class="hljs-string">"Der Wert m ist größe als 5"</span>)
<span class="hljs-comment"># Gibt ein True zurück</span>
result = <span class="hljs-number">5</span> &lt; <span class="hljs-number">6</span>
<span class="hljs-keyword">if</span> result:
print(<span class="hljs-string">"5 ist kleiner als 6"</span>)
w = <span class="hljs-string">"Max"</span>
print(w == <span class="hljs-string">"Max"</span>)
<span class="hljs-literal">True</span>
age = <span class="hljs-number">35</span>
<span class="hljs-keyword">if</span> age &gt;= <span class="hljs-number">30</span> <span class="hljs-keyword">and</span> age &lt;= <span class="hljs-number">39</span>:
print(<span class="hljs-string">"Diese Person ist in den 30-ern"</span>)
age = <span class="hljs-number">45</span>
<span class="hljs-keyword">if</span> age &lt;= <span class="hljs-number">30</span> <span class="hljs-keyword">or</span> age &gt;= <span class="hljs-number">40</span>:
print(<span class="hljs-string">"Diese Person ist nicht in den 30-ern"</span>)
above_30 = age &gt;= <span class="hljs-number">30</span>
print(above_30)
<span class="hljs-literal">True</span>
<span class="hljs-keyword">if</span> <span class="hljs-literal">True</span>:
print(<span class="hljs-string">"if-Abfrage wurde ausgeführt"</span>)
country = <span class="hljs-string">"US"</span>
age = <span class="hljs-number">20</span>
<span class="hljs-keyword">if</span> (country == <span class="hljs-string">"US"</span> <span class="hljs-keyword">and</span> age &gt;= <span class="hljs-number">21</span>) <span class="hljs-keyword">or</span> (country != <span class="hljs-string">"US"</span> <span class="hljs-keyword">and</span> age &gt;=<span class="hljs-number">18</span>):
print(<span class="hljs-string">"Diese Person darf Bier trinken."</span>)
</div></code></pre>
<h4 id="263-in-operator">2.6.3 In-Operator</h4>
<pre class="hljs"><code><div>students = [<span class="hljs-string">"Hans"</span>, <span class="hljs-string">"Paul"</span>, <span class="hljs-string">"Maria"</span>, <span class="hljs-string">"Erika"</span>]
print(<span class="hljs-string">"Maria"</span> <span class="hljs-keyword">in</span> students)
<span class="hljs-keyword">if</span> <span class="hljs-string">"Paul"</span> <span class="hljs-keyword">in</span> students:
print(<span class="hljs-string">"Ja, Paul studiert hier!"</span>)
a = <span class="hljs-string">"Ja, Paul studuert hier!"</span>
<span class="hljs-keyword">if</span> <span class="hljs-string">"?"</span> <span class="hljs-keyword">in</span> a:
print(<span class="hljs-string">"Ja"</span>)
<span class="hljs-keyword">else</span>:
print(<span class="hljs-string">"Nein"</span>)
</div></code></pre>
<h4 id="264-not-operator">2.6.4 Not-Operator</h4>
<p>Bevorzugt ist &quot;not in&quot;.</p>
<pre class="hljs"><code><div>b = [<span class="hljs-string">"Max"</span>, <span class="hljs-string">"Moritz"</span>]
<span class="hljs-keyword">if</span> <span class="hljs-string">"Nadine"</span> <span class="hljs-keyword">not</span> <span class="hljs-keyword">in</span> b:
print(<span class="hljs-string">"Nadine ist nicht in der Liste enthalten."</span>)
<span class="hljs-keyword">if</span> <span class="hljs-keyword">not</span> <span class="hljs-string">"Nadine in b:
print("</span>Nadine ist nicht <span class="hljs-keyword">in</span> der Liste enthalten.<span class="hljs-string">")
</span></div></code></pre>
<h4 id="265-elif">2.6.5 Elif</h4>
<pre class="hljs"><code><div>currency = <span class="hljs-string">"€"</span>
<span class="hljs-keyword">if</span> currency == <span class="hljs-string">"$"</span>:
print(<span class="hljs-string">"US-Dollar"</span>)
<span class="hljs-keyword">elif</span> currency == <span class="hljs-string">"€$"</span>:
print(<span class="hljs-string">"Euro"</span>)
<span class="hljs-keyword">elif</span> currency == <span class="hljs-string">"Y"</span>:
print(<span class="hljs-string">"Japanischer Yen"</span>)
<span class="hljs-keyword">else</span>:
print(<span class="hljs-string">"Sonstiges"</span>)
</div></code></pre>
<div style='page-break-after: always'></div>
<h4 id="266-while---schleife">2.6.6 While - Schleife</h4>
<pre class="hljs"><code><div>c = <span class="hljs-number">0</span>
<span class="hljs-keyword">while</span> c &lt; <span class="hljs-number">10</span>:
print(<span class="hljs-string">"Zahl: "</span> + str(c))
c = c + <span class="hljs-number">1</span>
</div></code></pre>
<h4 id="267-for---schleife">2.6.7 For - Schleife</h4>
<pre class="hljs"><code><div><span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> range(<span class="hljs-number">0</span>, <span class="hljs-number">10</span>):
print(i)
liste = [<span class="hljs-number">4</span>,<span class="hljs-number">6</span>,<span class="hljs-number">12</span>]
<span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> liste:
print(i)
</div></code></pre>
<h4 id="268-break--continue">2.6.8 Break &amp; Continue</h4>
<pre class="hljs"><code><div><span class="hljs-comment"># Schleife wird fortgesetzt</span>
<span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> range(<span class="hljs-number">1</span>, <span class="hljs-number">10</span>):
<span class="hljs-keyword">if</span> i == <span class="hljs-number">3</span>:
<span class="hljs-keyword">continue</span>
print(i)
<span class="hljs-comment"># Schleife wird abgebrochen</span>
<span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> range(<span class="hljs-number">1</span>, <span class="hljs-number">10</span>):
<span class="hljs-keyword">if</span> i == <span class="hljs-number">3</span>:
<span class="hljs-keyword">break</span>
print(i)
liste = [<span class="hljs-number">4</span>, <span class="hljs-number">6</span>, <span class="hljs-number">8</span>, <span class="hljs-number">3</span>, <span class="hljs-number">1</span>, <span class="hljs-number">6</span>, <span class="hljs-number">9</span>]
s = <span class="hljs-number">0</span>
<span class="hljs-keyword">for</span> e <span class="hljs-keyword">in</span> liste:
s = s + e
<span class="hljs-keyword">if</span> s &gt; <span class="hljs-number">10</span>:
<span class="hljs-keyword">break</span>
print(s)
</div></code></pre>
<div style='page-break-after: always'></div>
<h4 id="269-zufallszahlen-random">2.6.9 Zufallszahlen (Random)</h4>
<pre class="hljs"><code><div><span class="hljs-keyword">import</span> random
print(random.randint(<span class="hljs-number">0</span>, <span class="hljs-number">100</span>))
part1 = [<span class="hljs-string">"Walter,"</span>, <span class="hljs-string">"Hillary,"</span>, <span class="hljs-string">"Obama"</span>, <span class="hljs-string">"Fake News,"</span>, <span class="hljs-string">"Mexico,"</span>, <span class="hljs-string">"Arnold Schwarzenegger"</span>, <span class="hljs-string">"The Democrats"</span>]
part2 = [<span class="hljs-string">"no talent,"</span>, <span class="hljs-string">"on the way down,"</span>, <span class="hljs-string">"really poor numbers,"</span>, <span class="hljs-string">"nasty one,"</span>, <span class="hljs-string">"looking like a fool,"</span>, <span class="hljs-string">"bad hombre,"</span>]
part3 = [<span class="hljs-string">"got destroyed by my ratings."</span>, <span class="hljs-string">"rigged the election."</span>, <span class="hljs-string">"had a much smaller crowd."</span>, <span class="hljs-string">"will pay for the wall."</span>]
part4 = [<span class="hljs-string">"So sad"</span>, <span class="hljs-string">"Apologize"</span>, <span class="hljs-string">"So true"</span>, <span class="hljs-string">"Media won't report"</span>, <span class="hljs-string">"Big trouble"</span>, <span class="hljs-string">"fantastic job"</span>, <span class="hljs-string">"Stay tuned"</span>]
<span class="hljs-comment"># Wir können auch Listen von Listen erstellen.</span>
best_words = [part2, part2, part3, part4]
sentence = []
<span class="hljs-keyword">for</span> part <span class="hljs-keyword">in</span> best_words:
r = random.randint(<span class="hljs-number">0</span>, len(part) <span class="hljs-number">-1</span>)
sentence.append(part[r])
print(<span class="hljs-string">" "</span>.join(sentence) + <span class="hljs-string">"!"</span>)
<span class="hljs-comment"># Alternative</span>
print(part1[random.randint(<span class="hljs-number">0</span>,len(part1) - <span class="hljs-number">1</span>)] + part2[random.randint(<span class="hljs-number">0</span>, len(part2) - <span class="hljs-number">1</span>)] + part3[random.randint(<span class="hljs-number">0</span>, len(part3) - <span class="hljs-number">1</span>)] + part4[random.randint(<span class="hljs-number">0</span>, len(part4) - <span class="hljs-number">1</span>)])
</div></code></pre>
<div style='page-break-after: always'></div>
<h3 id="27-rechnen">2.7 Rechnen</h3>
<pre class="hljs"><code><div>a = <span class="hljs-number">3</span>
print(a * a * <span class="hljs-number">6</span>)
<span class="hljs-comment"># oder mit ** = hoch</span>
print(a ** <span class="hljs-number">2</span> * <span class="hljs-number">6</span>)
print(a ** <span class="hljs-number">3</span>)
<span class="hljs-comment"># Mit pi rechnen</span>
<span class="hljs-keyword">import</span> math
print(a * math.pi ** <span class="hljs-number">2</span>)
</div></code></pre>
<h3 id="28-datum">2.8 Datum</h3>
<pre class="hljs"><code><div><span class="hljs-keyword">import</span> datetime
<span class="hljs-comment"># year, month or day</span>
lastyear = datetime.date.today().year <span class="hljs-number">-1</span>
print(datetime.date.today())
print(datetime.datetime.now().year)
print(datetime.datetime.today().year)
</div></code></pre>
<p>Die Datumsausgabe kann man auch Formatiert festlegen.</p>
<pre class="hljs"><code><div><span class="hljs-keyword">import</span> time
<span class="hljs-keyword">from</span> time <span class="hljs-keyword">import</span> strftime
logDate = strftime(<span class="hljs-string">"%Y_%m_%d_%H_%M_%S"</span>)
</div></code></pre>
<p>Format string:</p>
<ul>
<li>%a - Abgekürzter Name des Wochentags</li>
<li>%A - Vollständiger Name des Wochentags</li>
<li>%b - Abgekürzter Name des Monats</li>
<li>%B - Vollständiger Name des Montats</li>
<li>%c - Datum und Uhrzeit im Format des lokalen Systems</li>
<li>%d - Nummer des Tages im aktuellen Monat [1..31]</li>
<li>%H - Stunde im 24-Stunden Format</li>
<li>%I - Stunde im 12-Stunden Format</li>
<li>%j - Nummer des Tages im Jahr</li>
<li>%m - Nummer des Monats</li>
<li>%M - Minute</li>
<li>%p - Die lokalisierte Form für AM / PM</li>
<li>%S - Sekunde</li>
<li>%U - Nummer der aktuellen Woche im Jahr [00..53] Der Sonntag ist der erste Tag im Jahr. Vor dem ersten Sonntag im Jahr wird als Woche 0 genommen</li>
<li>%w - Nummer des aktuellen Tages der Woche. Der Sonntag ist die 0</li>
<li>%W - Wie %U, nur der Montag ist der erste Tag der Woche.</li>
<li>%x - Datum im Format des lokalen Systems</li>
<li>%X - Zeit im Format des lokalen Systems</li>
<li>%y - Jahreszahl zweistellig</li>
<li>%Y - Jahreszahl vierstellig</li>
<li>%Z - Name der lokalen Zeitzone oder leer, wenn keine lokale Zeitzone definiert worden ist.</li>
<li>%% - Erzeugt ein Prozentzeichen</li>
</ul>
<div style='page-break-after: always'></div>
<h3 id="29-string-und-string-manipulation">2.9 String und String Manipulation</h3>
<p>Eine <strong>String</strong> Variable kann man mit oder ohne den <strong>str()</strong> definieren.</p>
<pre class="hljs"><code><div><span class="hljs-comment"># single quote</span>
text1 = <span class="hljs-string">'Hallo Harry Hirsch'</span>
<span class="hljs-comment"># double quote</span>
text2 = <span class="hljs-string">"Ein neuer Tag beginnt."</span>
<span class="hljs-comment"># triple quotes erlaubt mehrere Zeilen</span>
text3 = <span class="hljs-string">"""
Hier
könnte
ihre
Werbung
stehen.
"""</span>
<span class="hljs-comment"># mit str()</span>
text4 = str(<span class="hljs-string">'Und zum Schluss'</span>)
<span class="hljs-comment"># Anzeige des Objekt Types</span>
print(type(text1))
print(type(text4))
&lt;<span class="hljs-class"><span class="hljs-keyword">class</span> '<span class="hljs-title">str</span>'&gt;
&lt;<span class="hljs-title">class</span> '<span class="hljs-title">str</span>'&gt;
</span></div></code></pre>
<p>Es gibt folgende Operatoren für die String Manipulation:</p>
<ul>
<li>Arithmetic (+, -, *, /)</li>
<li>Relational (&lt;, &gt;, &lt;=, &gt;=, =, ==)</li>
<li>Logical (&amp; oder AND, | oder OR)</li>
</ul>
<pre class="hljs"><code><div>string1 = <span class="hljs-string">'Hello'</span>
string2 = <span class="hljs-string">' World'</span>
print(string1 + string2)
Hello World
string3 = <span class="hljs-string">"Wiederholen...' * 5
print(string3)
Wiederholen...Wiederholen...Wiederholen...Wiederholen...Wiederholen...
string4 = 'Wiederholen ' + 'loop...' * 3
print(string4)
Wiederholen loop...loop...loop...
a = 'Hallo'
a += ' Welt'
print(s)
Hallo Welt
</span></div></code></pre>
<div style='page-break-after: always'></div>
<p>Die Anzahl der Characters in dem String kann man mit <strong>len()</strong> aich ausgeben lassen.</p>
<pre class="hljs"><code><div>print(len(<span class="hljs-string">"Das ist ein normaler Text.))
26
</span></div></code></pre>
<p>Mit <strong>find</strong> kann man innerhalb der Wertes suchen. Gibt es den Eintrag in dem Text nicht, so gibt es al Rückgabewert ein <strong>-1</strong>. Es wird der erste gefunde Übereinstimmung ausgegeben. Ebenso ist es Möglich, einen Start- und Endpunkt für die Suche anzugeben.</p>
<pre class="hljs"><code><div>b = <span class="hljs-string">"Programmieren in Python macht Spass."</span>
print(b.find(<span class="hljs-string">"acht"</span>))
print(b.find(<span class="hljs-string">"lacht"</span>))
<span class="hljs-number">25</span>
<span class="hljs-number">-1</span>
text = <span class="hljs-string">"I haven't been this choked up since I got a hunk of moussaka caught in my throat! - Hades."</span>
text2 = <span class="hljs-string">'I"
print(text.find(text2))
print(text.find(text2, 10))
print(text.find(text2, 40))
0
36
-1
</span></div></code></pre>
<p>Mit <strong>count</strong> kann man innerhalb des Textes Zählen, wie oft der zu suchende Wert enthalten ist.</p>
<pre class="hljs"><code><div>c = <span class="hljs-string">"Hänsel und Gretel gingen in den Wald."</span>
<span class="hljs-comment"># Syntax count: search, start_index, end_index</span>
c_count = c.count(<span class="hljs-string">'e'</span>)
print(<span class="hljs-string">"Anzahl von 'e' ist: "</span>, c_count)
<span class="hljs-number">5</span>
n_count = c.count(<span class="hljs-string">'e'</span>, <span class="hljs-number">5</span>, <span class="hljs-number">15</span>)
print(<span class="hljs-string">"Anzahl von 'e' ist: "</span>, n_count)
<span class="hljs-number">1</span>
</div></code></pre>
<div style='page-break-after: always'></div>
<p>Einen Bereich aus einer Variable kann man folgendermaßen machen.</p>
<pre class="hljs"><code><div>text = <span class="hljs-string">"Hello, World!"</span>
<span class="hljs-comment"># Syntax: start:end:step</span>
print(text[<span class="hljs-number">6</span>:<span class="hljs-number">12</span>])
World
print(text[<span class="hljs-number">6</span>:<span class="hljs-number">12</span>:<span class="hljs-number">2</span>])
Wrd
</div></code></pre>
<p>Mit den Methoden <strong>startswith()</strong> und <strong>endswith()</strong> kann man überprüfen, ob der Wert am Anfang oder Ende der Variable vorkommt.</p>
<pre class="hljs"><code><div>text = <span class="hljs-string">'hello World'</span>
print(text.startswith(<span class="hljs-string">"H"</span>))
<span class="hljs-literal">False</span>
print(text.endswith(<span class="hljs-string">"d"</span>))
<span class="hljs-literal">True</span>
</div></code></pre>
<p>Mit <strong>strip, rstrip</strong> und <strong>lstrip</strong> kann man Leerzeichen aus dem String entfernen. Strip entfernt links und rechts die Leerzeichen aus dem String. Rstrip entfernt die Leerzeichen rechts und lstrip links vom String.</p>
<pre class="hljs"><code><div>text = <span class="hljs-string">" ein kleiner Text. "</span>
text.strip()
<span class="hljs-string">'ein kleiner Text.'</span>
<span class="hljs-comment"># Entfernt alle Leerzeichen, einen Punkt und das t aus dem Text</span>
<span class="hljs-comment"># Funktionier auch mit rstrip und lstrip</span>
text.strip(<span class="hljs-string">" .t"</span>)
<span class="hljs-string">'ein kleiner Tex
text.rstrip()
'</span> ein kleiner Text.<span class="hljs-string">'
text.lstrip()
'</span>ein kleiner Text. <span class="hljs-string">'
</span></div></code></pre>
<p>Einen String in Groß und Kleinschreibung umwandeln.</p>
<pre class="hljs"><code><div>text = <span class="hljs-string">"Hier könnte ihre Werbung stehen."</span>
print(text.upper()) <span class="hljs-comment"># Uppercase all characters</span>
print(text.lower()) <span class="hljs-comment"># Lowercase all characters</span>
print(text.title()) <span class="hljs-comment"># Title-case</span>
print(text.capitalize()) <span class="hljs-comment"># Capitalizes the first chartacter</span>
print(text.swapcase()) <span class="hljs-comment"># Swaps whatever case for each characterHIER KÖNNTE IHRE WERBUNG STEHEN.</span>
hier könnte ihre werbung stehen.
Hier Könnte Ihre Werbung Stehen.
Hier könnte ihre werbung stehen.
hIER KÖNNTE IHRE wERBUNG STEHEN.
</div></code></pre>
<div style='page-break-after: always'></div>
<p>Einen String splitten oder Partitionieren mir <strong>split()</strong> und <strong>partition()</strong>.</p>
<pre class="hljs"><code><div>text = <span class="hljs-string">"To be or not to be, that is the question"</span>
print(text.partition(<span class="hljs-string">'to be'</span>))
(<span class="hljs-string">'To be or not '</span>, <span class="hljs-string">'to be'</span>, <span class="hljs-string">', that is the question'</span>)
print(text.split())
[<span class="hljs-string">'To'</span>, <span class="hljs-string">'be'</span>, <span class="hljs-string">'or'</span>, <span class="hljs-string">'not'</span>, <span class="hljs-string">'to'</span>, <span class="hljs-string">'be,'</span>, <span class="hljs-string">'that'</span>, <span class="hljs-string">'is'</span>, <span class="hljs-string">'the'</span>, <span class="hljs-string">'question'</span>]
print(text.split(<span class="hljs-string">','</span>))
[<span class="hljs-string">'To be or not to be'</span>, <span class="hljs-string">' that is the question'</span>]
</div></code></pre>
<p>Mehrere Strings zusammenfügen.</p>
<pre class="hljs"><code><div>text = [<span class="hljs-string">'Eins'</span>, <span class="hljs-string">'Zwei'</span>, <span class="hljs-string">'Drei'</span>, <span class="hljs-string">'Vier'</span>, <span class="hljs-string">'Fünf'</span>]
print(<span class="hljs-string">', '</span>.join(text))
Eins, Zwei, Drei, Vier, Fünf
</div></code></pre>
<p>Ersetzen von Substrings.</p>
<pre class="hljs"><code><div>text = <span class="hljs-string">"Because of what you have done, the heavens are now part of man's world"</span>
print(text.replace(<span class="hljs-string">"man's"</span>, <span class="hljs-string">"human's"</span>))
Because of what you have done, the heavens are now part of human<span class="hljs-string">'s world
</span></div></code></pre>
<h3 id="210-projekt-pfad">2.10 Projekt Pfad</h3>
<p>Um den Projekt Pfad zu ermitteln, kann dieses mit <strong>pathlib</strong> gemacht werden.</p>
<pre class="hljs"><code><div><span class="hljs-keyword">import</span> pathlib
<span class="hljs-keyword">import</span> os
<span class="hljs-keyword">import</span> sys
ProjPath = pathlib.Path(__file__).parent.resolve()
<span class="hljs-comment"># Pfad und Dateinamen zusammenfügen</span>
<span class="hljs-comment"># Füe den Pfad muss als Abschluss ein / angegeben werden.</span>
FileName = (ProjPath / <span class="hljs-string">'data.csv'</span>).resolve()
</div></code></pre>
<div style='page-break-after: always'></div>
<h2 id="3-funktionen">3. Funktionen</h2>
<h3 id="31-funktion-erstellen">3.1 Funktion erstellen</h3>
<p>Eine Funktion wird mit <strong>def</strong> definiert. Nach dem def kommt dann der Name der Funktion und in den Klammern kann dann die übergebenen Werte stehen.</p>
<pre class="hljs"><code><div><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">my_function</span><span class="hljs-params">()</span>:</span>
print(<span class="hljs-string">"Welcome to Python"</span>)
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">my_function2</span><span class="hljs-params">(text)</span>:</span>
print(text)
my_function2(<span class="hljs-string">"Hello World."</span>)
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">multi_print</span><span class="hljs-params">(name, count)</span>:</span>
<span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> range(<span class="hljs-number">0</span>, count):
print(name)
multi_print(<span class="hljs-string">"Hallo"</span>, <span class="hljs-number">4</span>)
<span class="hljs-comment"># innerhalb einer Funktion kann auch eine Funktion aufgerufen werden</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">weitere_funktion</span><span class="hljs-params">()</span>:</span>
multi_print(<span class="hljs-string">"Moin Moin"</span>, <span class="hljs-number">2</span>)
multi_print(<span class="hljs-string">"zusammen"</span>, <span class="hljs-number">2</span>)
<span class="hljs-comment"># Mit return kann ein Wert zurück gegeben werden</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">maximum</span><span class="hljs-params">(a, b)</span>:</span>
<span class="hljs-keyword">if</span> a &lt; b:
<span class="hljs-keyword">return</span> b
<span class="hljs-keyword">else</span>:
<span class="hljs-keyword">return</span> a
result = maximum(<span class="hljs-number">4</span>, <span class="hljs-number">5</span>)
print(result)
</div></code></pre>
<h3 id="32-objekte">3.2 Objekte</h3>
<p>Vor dem Punkt handelt es sich um ein Objekt und nach dem Punkt um eine Funktion.</p>
<pre class="hljs"><code><div>liste = [<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>]
liste.append(<span class="hljs-number">4</span>)
<span class="hljs-string">"Hallo Welt"</span>.split(<span class="hljs-string">","</span>)
</div></code></pre>
<div style='page-break-after: always'></div>
<h3 id="33-beispiele">3.3 Beispiele</h3>
<pre class="hljs"><code><div>cart_prices = [<span class="hljs-number">20</span>, <span class="hljs-number">3.5</span>, <span class="hljs-number">6.49</span>, <span class="hljs-number">8.99</span>, <span class="hljs-number">9.99</span>, <span class="hljs-number">14.98</span>]
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">list_sum</span><span class="hljs-params">(l)</span>:</span>
s = <span class="hljs-number">0</span>
<span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> l:
s += i
print(s)
list_sum(cart_prices)
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">prices_list</span><span class="hljs-params">(name, price)</span>:</span>
liste = []
<span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> range(<span class="hljs-number">1</span>, <span class="hljs-number">11</span>)
liste.append(str(i) + <span class="hljs-string">" x "</span> + name + <span class="hljs-string">": "</span> + str(price * i))
<span class="hljs-keyword">return</span> liste
print(prices_list(<span class="hljs-string">"Wunderkeks"</span>, <span class="hljs-number">0.79</span>))
shelf = [<span class="hljs-string">"Zaubersäge"</span>, <span class="hljs-string">"leer"</span>, <span class="hljs-string">"Wunderkekse"</span>, <span class="hljs-string">"Trickarten"</span>, <span class="hljs-string">"leer"</span>]
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">add_shelf</span><span class="hljs-params">(article)</span>:</span>
<span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> range(<span class="hljs-number">0</span>, len(shelf)):
<span class="hljs-keyword">if</span> shelf[i] == <span class="hljs-string">"leer"</span>:
shelf[i] = article
<span class="hljs-keyword">break</span>
add_shelf(<span class="hljs-string">"Rubik's Cube"</span>)
print(shelf)
</div></code></pre>
<div style='page-break-after: always'></div>
<h2 id="4-dateien">4. Dateien</h2>
<p>Damit Umlaute und Sonderzeichen richtig dargestellt werden, ist es am besten, immer das Encoding mit anzugeben beim lesen und schreiben.</p>
<h3 id="41-%C3%B6ffnen">4.1 Öffnen</h3>
<pre class="hljs"><code><div><span class="hljs-comment"># r = read; w = write; a = append</span>
myfile = open(<span class="hljs-string">"MyList.txt"</span>, <span class="hljs-string">"r"</span>, encoding=<span class="hljs-string">"utf-8"</span>)
<span class="hljs-keyword">for</span> line <span class="hljs-keyword">in</span> myfile:
<span class="hljs-comment"># strip entfernt Leerzeichen am Anfang und Ende </span>
<span class="hljs-comment"># und auch ein Zeilenumbruch</span>
print(line.strip())
<span class="hljs-comment"># Datei schließen</span>
myfile.close()
</div></code></pre>
<p>Den Inhalt einer Datei in einer Variable ablegen.</p>
<pre class="hljs"><code><div>text = open(<span class="hljs-string">'TempMail.txt'</span>, <span class="hljs-string">'r'</span>, encoding=<span class="hljs-string">"utf-8"</span>).read()
print(uws)
</div></code></pre>
<h3 id="42-schreiben">4.2 Schreiben</h3>
<pre class="hljs"><code><div><span class="hljs-comment"># r = read; w = write; a = append</span>
wfile = open(<span class="hljs-string">"MyWrite.txt"</span>, <span class="hljs-string">"w"</span>, encoding=<span class="hljs-string">"utf-8"</span>)
<span class="hljs-comment"># Ein Zeilenumbruch muss mit gegeben werder.</span>
wfile.write(<span class="hljs-string">"Der erste Text\n"</span>)
wfile.write(<span class="hljs-string">"Und der zweite Text\n"</span>)
wfile.close()
</div></code></pre>
<p>Oder auch als Funktion</p>
<pre class="hljs"><code><div><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">writeLogFile</span><span class="hljs-params">(content)</span>:</span>
filename = <span class="hljs-string">"./"</span> + logDate + <span class="hljs-string">"_SendMails.log"</span>
<span class="hljs-keyword">with</span> open(filename, <span class="hljs-string">'a'</span>, encoding=<span class="hljs-string">"utf-8"</span>) <span class="hljs-keyword">as</span> logFile:
logFile.write(content)
</div></code></pre>
<h3 id="43-with">4.3 With</h3>
<p>Wird eine Datei mit <strong>with</strong> geöffnet, so kümmert sich Python selbst um das schließen der Dateien. Die Datei ist nur innerhalb des <strong>with Blocks</strong> geöffnet</p>
<pre class="hljs"><code><div><span class="hljs-keyword">with</span> open(<span class="hljs-string">"MyList.txt"</span>, <span class="hljs-string">"r"</span>, encoding=<span class="hljs-string">"utf-8"</span>) <span class="hljs-keyword">as</span> file
<span class="hljs-keyword">for</span> line <span class="hljs-keyword">in</span> file:
print(line.strip())
</div></code></pre>
<div style='page-break-after: always'></div>
<h3 id="44-csv-datei-%C3%B6ffnen">4.4 CSV-Datei öffnen</h3>
<p>Siehe auch unter <strong>6.3</strong>. Informationen über das CSV-Modul gibt es hier: <a href="https://docs.python.org/3.10/library/csv.html">CsvModul</a></p>
<pre class="hljs"><code><div><span class="hljs-keyword">with</span> open(<span class="hljs-string">"data.csv"</span>, <span class="hljs-string">"r"</span>, encoding=<span class="hljs-string">"utf-8"</span>) <span class="hljs-keyword">as</span> file:
<span class="hljs-keyword">for</span> line <span class="hljs-keyword">in</span> file:
<span class="hljs-comment"># strip entfernt zeilenumbruch und split macht eine Liste daraus</span>
<span class="hljs-comment"># weil line ein string ist und die Funktion split daher zu</span>
<span class="hljs-comment"># zu Verfügung steht.</span>
print(line.strip().split(<span class="hljs-string">";"</span>))
data = line.strip().split(<span class="hljs-string">";"</span>)
print(data[<span class="hljs-number">0</span>] + <span class="hljs-string">": "</span> + data[<span class="hljs-number">1</span>])
</div></code></pre>
<p>Lesen der CSV-Datei mittels des Modules csv. Ebenso wird in dem nachfolgenden Beispiel die erste Zeile übersrungen.</p>
<pre class="hljs"><code><div><span class="hljs-keyword">import</span> sys
<span class="hljs-keyword">import</span> os
<span class="hljs-keyword">import</span> csv
<span class="hljs-keyword">with</span> open(<span class="hljs-string">"data.csv"</span>, <span class="hljs-string">"r"</span>, encoding=<span class="hljs-string">"utf-8"</span>) <span class="hljs-keyword">as</span> csvfile:
csvreader = csv.reader(csvfile)
<span class="hljs-comment"># skip next row</span>
next(csvreader)
<span class="hljs-keyword">for</span> row <span class="hljs-keyword">in</span> csvreader:
print(row)
<span class="hljs-comment"># Mit DictReader wird die erste Zeile automatisch übersprungen</span>
<span class="hljs-comment"># Beim einlesen der CSV-Datei sollte das Trennzeichen angegeben</span>
<span class="hljs-comment"># werden, da stabdardmäßig ein Komma genommen wird..</span>
<span class="hljs-keyword">with</span> open(<span class="hljs-string">"data.csv"</span>, <span class="hljs-string">"r"</span>, encoding=<span class="hljs-string">"utf-8"</span>) <span class="hljs-keyword">as</span> csvfile:
csvreader = csv.DictReader(csvfile, delimiter=<span class="hljs-string">';'</span>)
<span class="hljs-keyword">for</span> row <span class="hljs-keyword">in</span> csvreader:
print(row[<span class="hljs-string">"Vorname"</span>], row[<span class="hljs-string">"Nachname"</span>], row[<span class="hljs-string">"Mail"</span>])
</div></code></pre>
<div style='page-break-after: always'></div>
<p>Daten filtern.</p>
<pre class="hljs"><code><div><span class="hljs-keyword">with</span> open(<span class="hljs-string">"data.csv"</span>, <span class="hljs-string">"r"</span>, encoding=<span class="hljs-string">"utf-8"</span>) <span class="hljs-keyword">as</span> file:
<span class="hljs-keyword">for</span> line <span class="hljs-keyword">in</span> file:
data = line.strip().split(<span class="hljs-string">";"</span>)
<span class="hljs-keyword">if</span> data[<span class="hljs-number">2</span>] == <span class="hljs-string">"BER"</span> <span class="hljs-keyword">or</span> data[<span class="hljs-number">2</span>] == <span class="hljs-string">"BUD"</span>:
print(data[<span class="hljs-number">2</span>])
print(data)
<span class="hljs-comment"># continue</span>
<span class="hljs-keyword">with</span> open(<span class="hljs-string">"data.csv"</span>, <span class="hljs-string">"r"</span>, encoding=<span class="hljs-string">"utf-8"</span>) <span class="hljs-keyword">as</span> file:
<span class="hljs-keyword">for</span> line <span class="hljs-keyword">in</span> file:
data = line.strip().split(<span class="hljs-string">";"</span>)
<span class="hljs-keyword">if</span> int(data[<span class="hljs-number">1</span>]) &lt; <span class="hljs-number">2000000</span>:
<span class="hljs-keyword">continue</span>
print(data)
name = <span class="hljs-string">"Max"</span>
state = <span class="hljs-string">"CA"</span>
total= <span class="hljs-number">0</span>
<span class="hljs-comment">#</span>
<span class="hljs-keyword">with</span> open(<span class="hljs-string">"./Documents/Kursmaterialien/Kursmaterialien/data/names.csv"</span>, <span class="hljs-string">"r"</span>, encoding=<span class="hljs-string">"utf-8"</span>) <span class="hljs-keyword">as</span> file:
<span class="hljs-keyword">for</span> line <span class="hljs-keyword">in</span> file:
splitted = line.strip().split(<span class="hljs-string">","</span>)
<span class="hljs-keyword">if</span> splitted[<span class="hljs-number">2</span>] == <span class="hljs-string">"Year"</span>:
<span class="hljs-keyword">continue</span>
year = int(splitted[<span class="hljs-number">2</span>])
<span class="hljs-keyword">if</span> splitted[<span class="hljs-number">1</span>] == name <span class="hljs-keyword">and</span> splitted[<span class="hljs-number">4</span>] == state <span class="hljs-keyword">and</span> year &gt;= <span class="hljs-number">1950</span> <span class="hljs-keyword">and</span> year &lt;= <span class="hljs-number">2000</span> <span class="hljs-keyword">and</span> splitted[<span class="hljs-number">3</span>] == <span class="hljs-string">"M"</span>:
<span class="hljs-comment">#print(splitted)</span>
total += int(splitted[<span class="hljs-number">5</span>])
print(total)
</div></code></pre>
<div style='page-break-after: always'></div>
<h3 id="45-ini-datei-einlesen">4.5 Ini-Datei einlesen</h3>
<pre class="hljs"><code><div><span class="hljs-keyword">import</span> configparser <span class="hljs-comment"># For read an write ini files</span>
<span class="hljs-keyword">import</span> os.path
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Ini</span><span class="hljs-params">()</span>:</span>
<span class="hljs-string">'''
Read Ini-File
'''</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, IniFile)</span>:</span>
self.IniFile = IniFile
self.Data = {}
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">ReadIni</span><span class="hljs-params">(self)</span>:</span>
<span class="hljs-keyword">try</span>:
<span class="hljs-keyword">if</span> os.path.exists(self.IniFile):
Config = configparser.ConfigParser()
<span class="hljs-comment">#Config</span>
Config._interpolation = configparser.ExtendedInterpolation()
Config.read(self.IniFile)
Config.sections()
<span class="hljs-keyword">for</span> element <span class="hljs-keyword">in</span> Config.sections():
<span class="hljs-keyword">for</span> k, v <span class="hljs-keyword">in</span> Config.items(element):
self.Data[k] = v
<span class="hljs-keyword">else</span>:
print(<span class="hljs-string">"Error-001: Ini File not exist."</span>)
<span class="hljs-keyword">except</span>:
print(<span class="hljs-string">"Error-001: Ini File not exist."</span>)
IniData = Ini(<span class="hljs-string">r"T:\Privat\Programming\Python\FTP\cfg\example_import1.ini"</span>)
IniData.ReadIni()
print(IniData.Data)
<span class="hljs-keyword">if</span> <span class="hljs-string">"description"</span> <span class="hljs-keyword">in</span> IniData.Data:
print(<span class="hljs-string">"\nDescription: {}"</span>.format(IniData.Data[<span class="hljs-string">"description"</span>]))
<span class="hljs-keyword">else</span>:
print(<span class="hljs-string">"Wert ist nicht enthalten."</span>)
</div></code></pre>
<div style='page-break-after: always'></div>
<h3 id="46-yaml-datei">4.6 Yaml-Datei</h3>
<p>Damit man in Python Yaml-Dateien verarbeiten kann, muss das Paket <strong>pyyaml</strong> installiert werden.</p>
<pre class="hljs"><code><div>uws@tux&gt;pip3 install pyyaml
</div></code></pre>
<h4 id="461-einlesen">4.6.1 Einlesen</h4>
<pre class="hljs"><code><div><span class="hljs-keyword">import</span> yaml
ServerFile = <span class="hljs-string">"./MailServer.yaml"</span>
<span class="hljs-keyword">global</span> ValuesYamlMailServer
<span class="hljs-keyword">with</span> open(ServerFile, <span class="hljs-string">'r'</span>, encoding=<span class="hljs-string">"utf-8"</span>) <span class="hljs-keyword">as</span> f:
ValuesYamlMailServer = yaml.load(f, Loader=yaml.FullLoader)
print(<span class="hljs-string">" smtpServer: %s"</span> % (ValuesYamlMailServer[<span class="hljs-string">'MailServer'</span>][<span class="hljs-string">'Server'</span>]))
</div></code></pre>
<h4 id="461-schreiben">4.6.1 Schreiben</h4>
<pre class="hljs"><code><div><span class="hljs-comment"># -*- coding: utf-8 -*-</span>
<span class="hljs-keyword">import</span> yaml
<span class="hljs-keyword">import</span> io
<span class="hljs-comment"># Define data</span>
data = {
<span class="hljs-string">'a list'</span>: [
<span class="hljs-number">1</span>,
<span class="hljs-number">42</span>,
<span class="hljs-number">3.141</span>,
<span class="hljs-number">1337</span>,
<span class="hljs-string">'help'</span>,
<span class="hljs-string">u'€'</span>
],
<span class="hljs-string">'a string'</span>: <span class="hljs-string">'bla'</span>,
<span class="hljs-string">'another dict'</span>: {
<span class="hljs-string">'foo'</span>: <span class="hljs-string">'bar'</span>,
<span class="hljs-string">'key'</span>: <span class="hljs-string">'value'</span>,
<span class="hljs-string">'the answer'</span>: <span class="hljs-number">42</span>
}
}
<span class="hljs-comment"># Write YAML file</span>
<span class="hljs-keyword">with</span> io.open(<span class="hljs-string">'data.yaml'</span>, <span class="hljs-string">'w'</span>, encoding=<span class="hljs-string">'utf8'</span>) <span class="hljs-keyword">as</span> outfile:
yaml.dump(data, outfile, default_flow_style=<span class="hljs-literal">False</span>, allow_unicode=<span class="hljs-literal">True</span>)
<span class="hljs-comment"># Read YAML file</span>
<span class="hljs-keyword">with</span> open(<span class="hljs-string">"data.yaml"</span>, <span class="hljs-string">'r'</span>, encoding=<span class="hljs-string">"utf-8"</span>) <span class="hljs-keyword">as</span> stream:
data_loaded = yaml.safe_load(stream)
print(data == data_loaded)
</div></code></pre>
<p>Inhalt der Yaml-Datei</p>
<pre class="hljs"><code><div>uws@tux&gt;cat data.yaml
a list:
- 1
- 42
- 3.141
- 1337
- <span class="hljs-built_in">help</span>
- €
a string: bla
another dict:
foo: bar
key: value
the answer: 42
</div></code></pre>
<div style='page-break-after: always'></div>
<h2 id="5-graphiken">5. Graphiken</h2>
<pre class="hljs"><code><div><span class="hljs-comment"># Matplotlib konfigurieren. inline öffnet kein neues fenster</span>
%matplotlib inline
<span class="hljs-comment"># Module laden</span>
<span class="hljs-keyword">import</span> matplotlib.pyplot <span class="hljs-keyword">as</span> plt
xs = [<span class="hljs-number">1</span>,<span class="hljs-number">2</span>,<span class="hljs-number">3</span>,<span class="hljs-number">4</span>]
ys = [<span class="hljs-number">5</span>,<span class="hljs-number">8</span>,<span class="hljs-number">5</span>,<span class="hljs-number">8</span>]
plt.plot(xs,ys)
plt.show()
</div></code></pre>
<p>Geburtsstatistiken Beispiel</p>
<pre class="hljs"><code><div><span class="hljs-comment"># Daten in der CSV</span>
<span class="hljs-comment">#12345,Anna,1910,F,CA,999</span>
<span class="hljs-comment">#32345,Anna,1911,F,CA,555</span>
xs = []
ys = []
name = <span class="hljs-string">"Anna"</span>
gender = <span class="hljs-string">"F"</span>
state = <span class="hljs-string">"CA"</span>
<span class="hljs-keyword">with</span> open(<span class="hljs-string">"../data/names.csv"</span>, <span class="hljs-string">"r"</span>) <span class="hljs-keyword">as</span> file:
<span class="hljs-keyword">for</span> line <span class="hljs-keyword">in</span> file:
line_splitted = line.strip().split(<span class="hljs-string">","</span>)
<span class="hljs-keyword">if</span> line_splitted[<span class="hljs-number">1</span>] == name <span class="hljs-keyword">and</span> line_splitted[<span class="hljs-number">3</span>] == gender <span class="hljs-keyword">and</span> line_splitted[<span class="hljs-number">4</span>] == state:
xs.append(int(line_splitted[<span class="hljs-number">2</span>]))
ys.append(int(line_splitted[<span class="hljs-number">5</span>]))
%matplotlib inline
<span class="hljs-keyword">import</span> matplotlib.pyplot <span class="hljs-keyword">as</span> plt
plt.plot(xs, ys)
plt.show()
</div></code></pre>
<div style='page-break-after: always'></div>
<h2 id="6-objektorientierung">6. Objektorientierung</h2>
<h3 id="61-klasse">6.1 Klasse</h3>
<pre class="hljs"><code><div><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Student</span><span class="hljs-params">()</span>:</span>
<span class="hljs-comment"># Muss den Namen self haben. Hier wird ausgelesen</span>
<span class="hljs-comment"># was vor dem . steht.</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">name</span><span class="hljs-params">(self)</span>:</span>
print(self.firstname + <span class="hljs-string">" "</span> + self.lastname)
erik = Student() <span class="hljs-comment"># Zuweisung der Klasse</span>
erik.firstname = <span class="hljs-string">"Erik"</span>
erik.lastname = <span class="hljs-string">"Mustermann"</span>
erik.name()
monika = Student()
monika.firstname = <span class="hljs-string">"Monika"</span>
monika.lastname = <span class="hljs-string">"Musterfrau"</span>
monika.name()
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Company</span><span class="hljs-params">()</span>:</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">name</span><span class="hljs-params">(self)</span>:</span>
print(self.legal_name + <span class="hljs-string">" "</span> + self.legal_type)
c = Company()
c.legal_name = <span class="hljs-string">"Harry Hirsch"</span>
c.legal_type = <span class="hljs-string">"GmbH &amp; Co KG"</span>
c.name()
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">name_5x</span><span class="hljs-params">(v)</span>:</span>
v.name()
v.name()
v.name()
v.name()
v.name()
name_5x(monika)
name_5x(c)
</div></code></pre>
<p>Weitere Informationen zu dem Thema gibt es hier:</p>
<p>https://www.python-kurs.eu/klassen.php <br>
https://www.python-lernen.de/loesung-uebung-klasse-auto-erstellen.htm</p>
<div style='page-break-after: always'></div>
<h3 id="62-constructor-eigenschaften-ab%C3%A4ndern">6.2 Constructor, Eigenschaften abändern</h3>
<pre class="hljs"><code><div><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Student</span><span class="hljs-params">()</span>:</span>
<span class="hljs-comment"># __init__ wird dem Objekt zugeordnet</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, firstname, lastname)</span>:</span>
self.firstname = firstname
self.lastname = lastname
<span class="hljs-comment"># Es können auch Werte definiert werden, die nicht übergeben werden</span>
self.term = <span class="hljs-number">1</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">increase_term</span><span class="hljs-params">(self)</span>:</span>
self.term = self.term +<span class="hljs-number">1</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">name</span><span class="hljs-params">(self)</span>:</span>
print(self.firstname + <span class="hljs-string">" "</span> + self.lastname + <span class="hljs-string">" (Semester: "</span> + str(self.term) + <span class="hljs-string">")"</span>)
erik = Student(<span class="hljs-string">"Erik"</span>, <span class="hljs-string">"Mustermann"</span>)
erik.increase_term()
erik.name()
erik.lastname
monika = Student(<span class="hljs-string">"Monika"</span>, <span class="hljs-string">"Musterfrau"</span>)
monika.name()
</div></code></pre>
<div style='page-break-after: always'></div>
<h3 id="63-sichtbarkeit-von-methoden--variablen">6.3 Sichtbarkeit von Methoden &amp; Variablen</h3>
<p>Steht vor dem Namen einer Eigenschaft oder Methode zwei Unterstriche, so ist die Eigenschaft / Methode Privat und kann nur innerhalb der Klasse aufgerufen werden.</p>
<pre class="hljs"><code><div><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Student</span><span class="hljs-params">()</span>:</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, firstname, lastname)</span>:</span>
self.firstname = firstname
self.lastname = lastname
<span class="hljs-comment"># Steht vor dem Namen zwei unterstriche, so kann man von aussen nicht darauf zugreifen.</span>
<span class="hljs-comment"># Sie ist somit nur in dem Class Block aktiv.</span>
self.__term = <span class="hljs-number">1</span>
<span class="hljs-comment"># Innerhalb der Klasse funktioniert der Aufruf.</span>
self.__do_something()
<span class="hljs-comment"># Auch der Methoden Name kann mit zwei Unterstrichen definiert werden</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__do_something</span><span class="hljs-params">(self)</span>:</span>
print(<span class="hljs-string">"Mach irgendwas."</span>)
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">increase_term</span><span class="hljs-params">(self)</span>:</span>
<span class="hljs-keyword">if</span> self.__term &gt;= <span class="hljs-number">9</span>:
<span class="hljs-keyword">return</span>
self.__term = self.__term +<span class="hljs-number">1</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">get_term</span><span class="hljs-params">(self)</span>:</span>
<span class="hljs-keyword">return</span> self.__term
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">name</span><span class="hljs-params">(self)</span>:</span>
print(self.firstname + <span class="hljs-string">" "</span> + self.lastname + <span class="hljs-string">" (Semester: "</span> + str(self.__term) + <span class="hljs-string">")"</span>)
erik = Student(<span class="hljs-string">"Erik"</span>, <span class="hljs-string">"Mustermann"</span>)
erik.increase_term()
<span class="hljs-comment"># Nachfolgende Aufrufe funktionieren nicht</span>
erik.__term = <span class="hljs-number">100</span>
print(erik.__term)
<span class="hljs-comment"># Dieser funktioniert</span>
print(erik.get_term())
erik.name()
</div></code></pre>
<div style='page-break-after: always'></div>
<pre class="hljs"><code><div><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">PhoneBook</span><span class="hljs-params">()</span>:</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self)</span>:</span>
self.__entries = {}
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">add</span><span class="hljs-params">(self, name, phone_number)</span>:</span>
self.__entries[name] = phone_number
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">get</span><span class="hljs-params">(self, name)</span>:</span>
<span class="hljs-keyword">if</span> name <span class="hljs-keyword">in</span> self.__entries:
<span class="hljs-keyword">return</span> self.__entries[name]
<span class="hljs-keyword">else</span>:
<span class="hljs-comment"># None ist in Python definiert und gibt das Wort None zurück</span>
<span class="hljs-keyword">return</span> <span class="hljs-literal">None</span>
book = PhoneBook()
book.add(<span class="hljs-string">"Musterfrau"</span>, <span class="hljs-string">"+4947110815"</span>)
book.add(<span class="hljs-string">"Mai"</span>, <span class="hljs-string">"+4908154711"</span>)
print(book.get(<span class="hljs-string">"Musterfrau"</span>))
print(book.get(<span class="hljs-string">"Hirsch"</span>))
+<span class="hljs-number">4947110815</span>
<span class="hljs-literal">None</span>
</div></code></pre>
<div style='page-break-after: always'></div>
<p>Eine Klasse direkt ausgeben.</p>
<pre class="hljs"><code><div><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">PhoneBook</span><span class="hljs-params">()</span>:</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self)</span>:</span>
self.__entries = {}
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">add</span><span class="hljs-params">(self, name, phone_number)</span>:</span>
self.__entries[name] = phone_number
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">get</span><span class="hljs-params">(self, name)</span>:</span>
<span class="hljs-keyword">if</span> name <span class="hljs-keyword">in</span> self.__entries:
<span class="hljs-keyword">return</span> self.__entries[name]
<span class="hljs-keyword">else</span>:
<span class="hljs-comment"># None ist in Python definiert und gibt das Wort None zurück</span>
<span class="hljs-keyword">return</span> <span class="hljs-literal">None</span>
<span class="hljs-comment"># Gibt es in der Klasse die Funktion __str__</span>
<span class="hljs-comment"># so kann man damit einen Rückgabe vornehmen. </span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__str__</span><span class="hljs-params">(self)</span>:</span>
<span class="hljs-keyword">return</span> <span class="hljs-string">"PhoneBook("</span> + str(self.__entries) + <span class="hljs-string">")"</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__repr__</span><span class="hljs-params">(self)</span>:</span>
<span class="hljs-keyword">return</span> self.__str__()
<span class="hljs-comment"># Anzahl der Einträge zurückgeben</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__len__</span><span class="hljs-params">(self)</span>:</span>
<span class="hljs-keyword">return</span> len(self.__entries)
book = PhoneBook()
book.add(<span class="hljs-string">"Musterfrau"</span>, <span class="hljs-string">"+4947110815"</span>)
book.add(<span class="hljs-string">"Mai"</span>, <span class="hljs-string">"+4908154711"</span>)
<span class="hljs-comment"># Ruft die Methode __str__ auf</span>
print(book)
PhoneBook({<span class="hljs-string">'Musterfrau'</span>: <span class="hljs-string">'+4947110815'</span>, <span class="hljs-string">'Mai'</span>: <span class="hljs-string">'+4908154711'</span>})
<span class="hljs-comment"># Ruft die Methode __repr__ auf</span>
book
PhoneBook({<span class="hljs-string">'Musterfrau'</span>: <span class="hljs-string">'+4947110815'</span>, <span class="hljs-string">'Mai'</span>: <span class="hljs-string">'+4908154711'</span>})
<span class="hljs-comment"># Anzahl der Einträge</span>
print(len(book))
<span class="hljs-number">2</span>
</div></code></pre>
<div style='page-break-after: always'></div>
<h3 id="64-vererbung">6.4 Vererbung</h3>
<p>Soll eine Klasse Vererbung erhalten, so gibt man in den Klammern des Klassennamens den Namen der Klasse an. Mit <strong>super()</strong> innerhalb einer Klasse kann man Definitionen oder auch Funktionen aus der Refernzierten Klasse aufrufen.</p>
<pre class="hljs"><code><div><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Student</span><span class="hljs-params">()</span>:</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, firstname, surname)</span>:</span>
self.firstname = firstname
self.surname = surname
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">name</span><span class="hljs-params">(self)</span>:</span>
<span class="hljs-keyword">return</span> self.firstname + <span class="hljs-string">" "</span> + self.surname
<span class="hljs-comment"># Die Klasse WorkingStudent erbt die Eigenschaften (Methoden) der Klasse Student</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">WorkingStudent</span><span class="hljs-params">(Student)</span>:</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, firstname, surname, company)</span>:</span>
<span class="hljs-comment"># Mit super() wird in die Referenzierten Klasse nachgeschaut.</span>
<span class="hljs-comment"># Die Eigenschaften von firstname und surname sollen übernommen werden.</span>
super().__init__(firstname, surname)
self.company = company
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">name</span><span class="hljs-params">(self)</span>:</span>
<span class="hljs-comment"># Ruft die Methode name von der Ref. auf</span>
<span class="hljs-keyword">return</span> super().name() + <span class="hljs-string">" ("</span> + self.company + <span class="hljs-string">")"</span>
students = [
WorkingStudent(<span class="hljs-string">"Max"</span>, <span class="hljs-string">"Müller"</span>, <span class="hljs-string">"ABCDEF Gmbh"</span>),
Student(<span class="hljs-string">"Monika"</span>, <span class="hljs-string">"Mustermann"</span>),
Student(<span class="hljs-string">"Erik"</span>, <span class="hljs-string">"Müller"</span>),
WorkingStudent(<span class="hljs-string">"Andrea"</span>, <span class="hljs-string">"Hase"</span>, <span class="hljs-string">"Baumschule GmbH"</span>)
]
<span class="hljs-keyword">for</span> student <span class="hljs-keyword">in</span> students:
print(student.name())
student= WorkingStudent(<span class="hljs-string">"Harry"</span>, <span class="hljs-string">"Hirsch"</span>, <span class="hljs-string">"Rehrücken GmbH"</span>)
print(student.name())
</div></code></pre>
<div style='page-break-after: always'></div>
<pre class="hljs"><code><div><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">FileReader</span><span class="hljs-params">()</span>:</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, filename)</span>:</span>
self.filename = filename
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">lines</span><span class="hljs-params">(self)</span>:</span>
lines = []
<span class="hljs-keyword">with</span> open(self.filename, <span class="hljs-string">"r"</span>) <span class="hljs-keyword">as</span> file:
<span class="hljs-keyword">for</span> line <span class="hljs-keyword">in</span> file:
<span class="hljs-comment"># strip löscht \n am ende</span>
lines.append(line.strip())
<span class="hljs-keyword">return</span> lines
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">CsvReader</span><span class="hljs-params">(FileReader)</span>:</span>
def__init__(self, filename):
super().__init__(filename)
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">lines</span><span class="hljs-params">(self)</span>:</span>
lines = super().lines()
<span class="hljs-comment"># kurze Version</span>
<span class="hljs-keyword">return</span> [line.split(<span class="hljs-string">","</span>) <span class="hljs-keyword">for</span> line <span class="hljs-keyword">in</span> lines]
<span class="hljs-comment"># oder noch kürzer, dann fällt auch die erste Zeile weg.</span>
<span class="hljs-comment">#return [line.split(",") for line in super().lines()]</span>
<span class="hljs-comment"># lange Version</span>
<span class="hljs-comment">#lines_splitted = []</span>
<span class="hljs-comment">#for line in lines:</span>
<span class="hljs-comment"># lines_splitted.append(line.split(","))</span>
<span class="hljs-comment"># return lines_splitted</span>
f = FileReader(<span class="hljs-string">"./datei.csv"</span>)
print(f.lines())
f = CsvReader(<span class="hljs-string">"./datei.csv"</span>)
print(f.lines())
</div></code></pre>
<div style='page-break-after: always'></div>
<h3 id="65-typ-feststellen">6.5 Typ feststellen</h3>
<p>Bei <strong>isinstance</strong> wird die Vererbung mit betrachtet und bei <strong>Type</strong> nicht. Dafür gibt <strong>Type</strong> den Namen des Types aus, bei <strong>isinstance</strong> einen Boolchen Wert.</p>
<pre class="hljs"><code><div><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Student</span><span class="hljs-params">()</span>:</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, firstname, surname)</span>:</span>
self.firstname = firstname
self.surname = surname
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">name</span><span class="hljs-params">(self)</span>:</span>
<span class="hljs-keyword">return</span> self.firstname + <span class="hljs-string">" "</span> + self.surname
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">WorkingStudent</span><span class="hljs-params">(Student)</span>:</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, firstname, surname, company)</span>:</span>
super().__init__(firstname, surname)
self.company = company
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">name</span><span class="hljs-params">(self)</span>:</span>
<span class="hljs-keyword">return</span> super().name() + <span class="hljs-string">" ("</span> + self.company + <span class="hljs-string">")"</span>
w_student = WorkingStudent(<span class="hljs-string">"Harry"</span>, <span class="hljs-string">"Hirsch"</span>, <span class="hljs-string">"OMW GmbH"</span>)
student = Student(<span class="hljs-string">"Susanne"</span>, <span class="hljs-string">"Fuchs"</span>)
<span class="hljs-comment"># Mit type wird der Typ ausgegeben</span>
print(type(w_student))
print(type(student))
&lt;<span class="hljs-class"><span class="hljs-keyword">class</span> '<span class="hljs-title">__main__</span>.<span class="hljs-title">WorkingStudent</span>'&gt;
&lt;<span class="hljs-title">class</span> '<span class="hljs-title">__main__</span>.<span class="hljs-title">Student</span>'&gt;
<span class="hljs-title">if</span> <span class="hljs-title">type</span><span class="hljs-params">(student)</span> == <span class="hljs-title">Student</span>:</span>
print(<span class="hljs-string">"Student ist definiert"</span>)
<span class="hljs-comment"># Mit isinstance wird ein True oder False zurückgegeben</span>
<span class="hljs-comment"># Der w_student ist ein WorkingStudent und auch ein Student, da der WorkStudent </span>
<span class="hljs-comment"># die Klasse Student geerbt hat.</span>
print(isinstance(w_student, WorkingStudent))
print(isinstance(w_student, Student))
print(isinstance(student, WorkingStudent))
print(isinstance(student, Student))
<span class="hljs-literal">True</span>
<span class="hljs-literal">True</span>
<span class="hljs-literal">False</span>
<span class="hljs-literal">True</span>
students = [
WorkingStudent(<span class="hljs-string">"Max"</span>, <span class="hljs-string">"Müller"</span>, <span class="hljs-string">"ABCDEF Gmbh"</span>),
Student(<span class="hljs-string">"Monika"</span>, <span class="hljs-string">"Mustermann"</span>),
Student(<span class="hljs-string">"Erik"</span>, <span class="hljs-string">"Müller"</span>),
WorkingStudent(<span class="hljs-string">"Andrea"</span>, <span class="hljs-string">"Hase"</span>, <span class="hljs-string">"Baumschule GmbH"</span>)
]
<span class="hljs-keyword">for</span> student <span class="hljs-keyword">in</span> students:
<span class="hljs-comment"># Alternative</span>
<span class="hljs-comment">#if type(student) == WorkingStudent:</span>
<span class="hljs-keyword">if</span> isinstance(student, WorkingStudent):
print(student.name())
</div></code></pre>
<div style='page-break-after: always'></div>
<h3 id="66-alles-ist-ein-objekt">6.6 Alles ist ein Objekt</h3>
<pre class="hljs"><code><div>a = <span class="hljs-string">"Susanne"</span>
b = <span class="hljs-number">2</span>
c = <span class="hljs-number">12.5</span>
print(type(a))
print(type(b))
print(type(c))
&lt;<span class="hljs-class"><span class="hljs-keyword">class</span> '<span class="hljs-title">str</span>'&gt;
&lt;<span class="hljs-title">class</span> '<span class="hljs-title">int</span>'&gt;
&lt;<span class="hljs-title">class</span> '<span class="hljs-title">float</span>'&gt;
<span class="hljs-title">c</span>.<span class="hljs-title">__add__</span><span class="hljs-params">(<span class="hljs-number">5</span>)</span>
17.5
# <span class="hljs-title">F</span>ü<span class="hljs-title">r</span> <span class="hljs-title">die</span> <span class="hljs-title">bessere</span> <span class="hljs-title">Lesbarkeit</span> <span class="hljs-title">wird</span> <span class="hljs-title">die</span> <span class="hljs-title">Zahl</span> <span class="hljs-title">in</span> <span class="hljs-title">Klammern</span> <span class="hljs-title">geschrieben</span>, <span class="hljs-title">muss</span> <span class="hljs-title">man</span> <span class="hljs-title">aber</span> <span class="hljs-title">nicht</span>.
<span class="hljs-params">(<span class="hljs-number">12.5</span>)</span>.<span class="hljs-title">__add__</span><span class="hljs-params">(<span class="hljs-number">5</span>)</span>
17.5
# <span class="hljs-title">len</span> <span class="hljs-title">ruft</span> <span class="hljs-title">die</span> <span class="hljs-title">Funktion</span> <span class="hljs-title">__len__</span> <span class="hljs-title">auf</span>
<span class="hljs-title">len</span><span class="hljs-params">(a)</span>
7
<span class="hljs-title">a</span>.<span class="hljs-title">__len__</span><span class="hljs-params">()</span>
7
# <span class="hljs-title">Man</span> <span class="hljs-title">kann</span> <span class="hljs-title">Build</span> <span class="hljs-title">in</span> <span class="hljs-title">Methoden</span> ü<span class="hljs-title">berschreiben</span> <span class="hljs-title">und</span> <span class="hljs-title">sich</span> <span class="hljs-title">einklinken</span>.
# <span class="hljs-title">Das</span> <span class="hljs-title">kann</span> <span class="hljs-title">man</span> <span class="hljs-title">auch</span> <span class="hljs-title">mit</span> <span class="hljs-title">referenzierten</span> <span class="hljs-title">Methoden</span> <span class="hljs-title">machen</span>.
<span class="hljs-title">class</span> <span class="hljs-title">D</span>:</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__len__</span><span class="hljs-params">(self)</span>:</span>
<span class="hljs-keyword">return</span> <span class="hljs-number">10</span>
inst = D()
len(inst)
<span class="hljs-number">10</span>
</div></code></pre>
<div style='page-break-after: always'></div>
<h3 id="67-benennung-von-klassen-und-variablen">6.7 Benennung von Klassen und Variablen</h3>
<p>Um einen schönen Code zu schreiben, sollte <strong>PascalCase</strong> verwendet werden. Ein Style Guide gibt es hier: https://peps.python.org/pep-0008/</p>
<ul>
<li>PascalCase (IchBesteheAus)</li>
<li>camelCase (ichBesteheAus)</li>
<li>sneak_case (ich_bestehe_aus)
Für Funktionen und Variablen kann auch sneakCase verwendet werden. Lange Namen sollten vermieden werden.</li>
</ul>
<div style='page-break-after: always'></div>
<h3 id="68-statische-variablen">6.8 Statische Variablen</h3>
<pre class="hljs"><code><div><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Car</span>:</span>
<span class="hljs-comment"># Variable ist Statisch für alle Objekte</span>
price = <span class="hljs-string">"expensive"</span>
a = Car()
b = Car()
print(a.price)
print(b.price)
expensive
expensive
Car.price = <span class="hljs-string">"cheap"</span>
print(a.price)
print(b.price)
cheap
cheap
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Car</span>:</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self)</span>:</span>
<span class="hljs-comment"># Variable ist Statisch für eine Instanz</span>
self.price = <span class="hljs-string">"expensive"</span>
a = Car()
b = Car()
print(a.price)
print(b.price)
b.price = <span class="hljs-string">"cheap"</span>
print(a.price)
print(b.price)
expensive
expensive
expensive
cheap
</div></code></pre>
<div style='page-break-after: always'></div>
<h3 id="69-beispiele">6.9 Beispiele</h3>
<pre class="hljs"><code><div><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Account</span><span class="hljs-params">()</span>:</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, start, pin)</span>:</span>
self.credits = start
self.pin = pin
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">display</span><span class="hljs-params">(self)</span>:</span>
print(<span class="hljs-string">"Kontostand: "</span> + str(self.cedits) + <span class="hljs-string">"€"</span>)
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">pay_in</span><span class="hljs-params">(self, money)</span>:</span>
print(<span class="hljs-string">"Einzahlung von: "</span> + str(money) + <span class="hljs-string">"€"</span>)
self.credits += money
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">withdraw</span><span class="hljs-params">(self, money, pin)</span>:</span>
<span class="hljs-keyword">if</span> pin == self.pin:
<span class="hljs-keyword">if</span> self.credits &gt;= money:
self.credits -= money
<span class="hljs-keyword">else</span>:
print(<span class="hljs-string">"Du kannst nur noch "</span> + str(self.credits) + <span class="hljs-string">"€ abheben!"</span>)
<span class="hljs-keyword">else</span>:
print(<span class="hljs-string">"Falsche PIN!! Konto wird gesperrt.)
KundeMax = Account(600, "</span><span class="hljs-number">0815</span><span class="hljs-string">")
KundeMax.display()
KundeMax.pay_in(50)
KundeMax.display()
KundeMax.withdraw(125, "</span><span class="hljs-number">0815</span><span class="hljs-string">")
KundeMax.display()
KundeMax.withdraw(600, "</span><span class="hljs-number">08155</span><span class="hljs-string">")
</span></div></code></pre>
<div style='page-break-after: always'></div>
<pre class="hljs"><code><div><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Train</span><span class="hljs-params">()</span>:</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, route, start)</span>:</span>
self.route = route
self.position = start
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">show_station</span><span class="hljs-params">(self)</span>:</span>
print(self.route[self.position])
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">move</span><span class="hljs-params">(self)</span>:</span>
<span class="hljs-keyword">if</span> self.position &lt; len(self.route) - <span class="hljs-number">1</span>:
self.position += <span class="hljs-number">1</span>
<span class="hljs-keyword">else</span>:
print(<span class="hljs-string">"Endstation! Alle aussteigen"</span>)
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">move_back</span><span class="hljs-params">(self)</span>:</span>
<span class="hljs-keyword">if</span> self.position &gt; <span class="hljs-number">0</span>:
self.position -= <span class="hljs-number">1</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">bypass_station</span><span class="hljs-params">(self, station)</span>:</span>
<span class="hljs-keyword">if</span> station <span class="hljs-keyword">in</span> self.route:
self.route.remove(station)
self.position = <span class="hljs-number">0</span>
Way1 = Train([<span class="hljs-string">"Paris"</span>, <span class="hljs-string">"Berlin"</span>, <span class="hljs-string">"Budapest"</span>, <span class="hljs-string">"Bukarest"</span>], <span class="hljs-number">0</span>)
Way1.show_station()
Way1.move()
Way1.show_station()
Way1.bypass_station(<span class="hljs-string">"Budapest"</span>)
Way1.show_station()
</div></code></pre>
<div style='page-break-after: always'></div>
<h2 id="7-module">7. Module</h2>
<p>Mit Module kann den Code auf verschiedene Dateien aufteilen.</p>
<h3 id="71-module-laden">7.1 Module laden</h3>
<pre class="hljs"><code><div><span class="hljs-comment"># ganzes Modul laden</span>
<span class="hljs-comment"># Die Datei hallo.py muss / sollte sich im gleichen Verzeichnis befinden wie die Haupt Datei.</span>
<span class="hljs-keyword">import</span> hallo <span class="hljs-comment"># Die Endung nicht mit angegeben</span>
hallo.welt()
hallo.mars()
<span class="hljs-comment"># Einzelne Module laden.</span>
<span class="hljs-keyword">from</span> hallo <span class="hljs-keyword">import</span> welt, mars
welt()
mars()
<span class="hljs-comment"># * geht auch, sollte aber nicht gemacht werden.</span>
<span class="hljs-keyword">from</span> hallo <span class="hljs-keyword">import</span> *
</div></code></pre>
<pre class="hljs"><code><div>%matplotlib inline
<span class="hljs-comment"># Es gibt 3 verschiedene Möglichkeiten Module zu laden</span>
<span class="hljs-comment"># Import eines Modules aus der Datei matplotlib </span>
<span class="hljs-comment"># und ein Alias wird vergeben, den man dann benutzen kann.</span>
<span class="hljs-keyword">import</span> matplotlib.pyplot <span class="hljs-keyword">as</span> plt
plt.plot([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>], [<span class="hljs-number">5</span>, <span class="hljs-number">4</span>, <span class="hljs-number">6</span>])
plt.show()
<span class="hljs-comment"># Alternative wie oben, aber ohne Alias</span>
<span class="hljs-keyword">from</span> matplotlib <span class="hljs-keyword">import</span> pyplot
pyplot.plot([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>], [<span class="hljs-number">5</span>, <span class="hljs-number">4</span>, <span class="hljs-number">6</span>])
plt.show()
<span class="hljs-comment"># Alles laden aus der Datei</span>
<span class="hljs-keyword">import</span> matplotlib
matplotlib.pyplot.plot([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>], [<span class="hljs-number">5</span>, <span class="hljs-number">4</span>, <span class="hljs-number">6</span>])
plt.show()
</div></code></pre>
<div style='page-break-after: always'></div>
<h3 id="72-module-in-einem-ordner-erstellen">7.2 Module in einem Ordner erstellen</h3>
<p>Sollen sich die zu ladenen Module nicht im Source Ordner befinden, sondern in einem Unterordner, so muss sich in dem zu verwendeten Verzeichnis die Datei <strong>__init__.py</strong> befinden. Diese Datei kann am Anfang leer sein. Dadurch weiß Python, das es sich um ein Modul Ordner handelt. Das Verzeichnis sollte sich im Source Programm befinden. Am besten ist die erste Möglichkeit.</p>
<pre class="hljs"><code><div><span class="hljs-comment"># Syntax: </span>
<span class="hljs-comment"># from &lt;VerzeichnisName&gt; import &lt;DateiName&gt;</span>
<span class="hljs-keyword">from</span> Module <span class="hljs-keyword">import</span> MyMod, ZipMod
<span class="hljs-comment"># Möchte man alle Dateien mit einem * laden,</span>
<span class="hljs-comment"># so muss in der __init__.py Datei folgendes</span>
<span class="hljs-comment"># eingetragen sein. Es werden dann nur die Module</span>
<span class="hljs-comment"># geladen, die in der Liste stehen.</span>
__all__ = [<span class="hljs-string">"MyMod"</span>, <span class="hljs-string">"ZipMod"</span>]
<span class="hljs-comment"># Dann können alle Module geladen werden</span>
<span class="hljs-keyword">from</span> Module <span class="hljs-keyword">import</span> *
<span class="hljs-comment"># Alle Module aus dem Verzeichnis laden.</span>
<span class="hljs-comment"># In der **__init__.py** folgendes ergänzen</span>
<span class="hljs-keyword">from</span> . <span class="hljs-keyword">import</span> MyMod, ZipMod
<span class="hljs-comment"># Module laden und ausführen.</span>
<span class="hljs-keyword">import</span> Module
Module.MyMod.uschi()
</div></code></pre>
<div style='page-break-after: always'></div>
<h3 id="73-csv-modul">7.3 CSV Modul</h3>
<p>Eine Auflistung, welche Module es in Python gibt, kann man hier nachschauen: http://docs.python.org/3/py_modindex.html</p>
<pre class="hljs"><code><div> <span class="hljs-comment">#Inhalt CSV Datei</span>
Hans;Wurst;<span class="hljs-string">"Moin;zusammen"</span>
Peter;Hase;<span class="hljs-string">"Hoppel"</span>
<span class="hljs-comment"># delimiter =&gt; Trennzeichen</span>
<span class="hljs-comment"># quotachar =&gt; Quotazeichen</span>
<span class="hljs-keyword">import</span> csv
<span class="hljs-keyword">with</span> open(<span class="hljs-string">"datei.csv"</span>, newline=<span class="hljs-string">''</span>) <span class="hljs-keyword">as</span> file:
csv_file = csv.reader(file, delimiter=<span class="hljs-string">";"</span>, quotechar=<span class="hljs-string">'"'</span>)
<span class="hljs-keyword">for</span> line <span class="hljs-keyword">in</span> csv_file:
print(line)
</div></code></pre>
<div style='page-break-after: always'></div>
<h3 id="74-web-crawler">7.4 Web Crawler</h3>
<p>Um einen Crawler zu Programmieren, werden die Python Module <strong>Request</strong> und <strong>Beautifulsoup</strong> verwendet.</p>
<h4 id="741-allgemeine-beispiele">7.4.1 Allgemeine Beispiele</h4>
<pre class="hljs"><code><div><span class="hljs-comment"># Web Seite holen</span>
<span class="hljs-keyword">import</span> requests
r = requests.get(<span class="hljs-string">"hhtp://python.beispiel.programmierenlernen.io/index.php"</span>)
<span class="hljs-comment"># Informationen abfragen</span>
print(r.__dict__) <span class="hljs-comment"># Anzeigen aller Methoden</span>
print(r.status_code)
print(r.headers)
print(r.text)
<span class="hljs-keyword">from</span> bs4 <span class="hljs-keyword">import</span> BeautifulSoup
html = <span class="hljs-string">"""
&lt;html&gt;
&lt;body&gt;
&lt;p class="ZeileOne"&gt;Das ist die erste Zeile&lt;/p&gt;
&lt;p&gt;Hier koente ihre Werbung stehen&lt;/p&gt;
&lt;/body&gt;
&lt;/html&gt;
"""</span>
doc = BeautifulSoup(html, <span class="hljs-string">"html.parser"</span>)
print(doc)
print(doc.find_all(<span class="hljs-string">"p"</span>))
<span class="hljs-keyword">for</span> p <span class="hljs-keyword">in</span> doc.find_all(<span class="hljs-string">"p):
print(p.attrs)
print(p.text)
</span></div></code></pre>
<div style='page-break-after: always'></div>
<h4 id="742-css-selectors">7.4.2 CSS-Selectors</h4>
<p>Stylesheet Vorlagen gibt es <a href="https://skeleton-framework.github.io/">hier</a>.</p>
<pre class="hljs"><code><div><span class="hljs-tag">&lt;<span class="hljs-name">html</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">head</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">title</span>&gt;</span>Ich bin der Seitentitel<span class="hljs-tag">&lt;/<span class="hljs-name">title</span>&gt;</span>
<span class="hljs-comment">&lt;!-- style kann in der html Datei stehen oder in einer separaten Datei --&gt;</span>
<span class="hljs-comment">&lt;!-- Es können auch mehrere stylesheets angegeben werden --&gt;</span>
<span class="hljs-comment">&lt;!-- &lt;link rel="stylesheet" href="./style.css"&gt; --&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">style</span> <span class="hljs-attr">type</span>=<span class="hljs-string">"text/css"</span>&gt;</span><span class="xml">
<span class="hljs-comment">&lt;!-- Filter auf alle Elemnte --&gt;</span>
p {
color: blue;
}
<span class="hljs-comment">&lt;!-- Filtert nach class --&gt;</span>
.important {
color: red;
}
<span class="hljs-comment">&lt;!-- Filtert nach id --&gt;</span>
#uws06 {
color: orange;
}
<span class="hljs-comment">&lt;!--- Filtert nach tag --&gt;</span>
span {
color: green;
}
<span class="hljs-comment">&lt;!--- Filtert nach Class und Element ---&gt;</span>
.absatz1 p {
color: gray;
font-weight: bolt;
}
.absatz .important {
color: yellow;
}
</span><span class="hljs-tag">&lt;/<span class="hljs-name">style</span>&gt;</span>
<span class="hljs-tag">&lt;/<span class="hljs-name">head</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">body</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">div</span> <span class="hljs-attr">class</span>=<span class="hljs-string">"absatz1"</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">p</span>&gt;</span>Absatz1: Erster Text<span class="hljs-tag">&lt;/<span class="hljs-name">p</span>&gt;</span>
<span class="hljs-tag">&lt;/<span class="hljs-name">div</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">div</span> <span class="hljs-attr">class</span>=<span class="hljs-string">"absatz2"</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">p</span> <span class="hljs-attr">class</span>=<span class="hljs-string">"important"</span>&gt;</span>Absatz2: Erster Text<span class="hljs-tag">&lt;/<span class="hljs-name">p</span>&gt;</span>
<span class="hljs-tag">&lt;/<span class="hljs-name">div</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">p</span> <span class="hljs-attr">class</span>=<span class="hljs-string">"important"</span>&gt;</span>Die erste Zeile<span class="hljs-tag">&lt;/<span class="hljs-name">p</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">p</span> <span class="hljs-attr">id</span>=<span class="hljs-string">"uws06"</span>&gt;</span>Die zweite Zeile<span class="hljs-tag">&lt;/<span class="hljs-name">p</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">p</span> <span class="hljs-attr">class</span>=<span class="hljs-string">"important"</span>&gt;</span>Und die dritte Zeile<span class="hljs-tag">&lt;/<span class="hljs-name">p</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">span</span>&gt;</span>Und ein neuer Text<span class="hljs-tag">&lt;/<span class="hljs-name">span</span>&gt;</span>
<span class="hljs-tag">&lt;/<span class="hljs-name">body</span>&gt;</span>
<span class="hljs-tag">&lt;/<span class="hljs-name">html</span>&gt;</span>
</div></code></pre>
<div style='page-break-after: always'></div>
<h4 id="743-elemente-finden">7.4.3 Elemente finden</h4>
<pre class="hljs"><code><div><span class="hljs-keyword">import</span> requests
<span class="hljs-keyword">from</span> bs4 <span class="hljs-keyword">import</span> BeautifulSoup
r = requests.get(<span class="hljs-string">"http://python.beispiel.programmierenlernen.io/index.php"</span>)
doc = BeautifulSoup(r.text, <span class="hljs-string">"html.parser"</span>)
<span class="hljs-comment"># Alle Elemente holen mit der Class card</span>
<span class="hljs-keyword">for</span> card <span class="hljs-keyword">in</span> doc.select(<span class="hljs-string">".card"</span>):
<span class="hljs-comment"># select findet alle Einträge in einem Card Block</span>
<span class="hljs-comment"># Der Inhalt befindet sich immer im Attribute text</span>
print(card.select_one(<span class="hljs-string">".emoji"</span>).text)
emoji = card.select_one(<span class="hljs-string">".card"</span>).text
content = card.select_one(<span class="hljs-string">".card-text"</span>).text
<span class="hljs-comment"># Ist eine Liste, title_spans nur zur Veranschaulichung</span>
title_spans = card.select(<span class="hljs-string">"card-title span"</span>)
title = card.select(<span class="hljs-string">".card-title span"</span>)[<span class="hljs-number">1</span>].text
<span class="hljs-comment"># Ist ein Dictionary</span>
image = card.select_one(<span class="hljs-string">"img"</span>).attrs[<span class="hljs-string">"src"</span>]
print(emoji)
print(title)
print(content)
print(image)
<span class="hljs-comment"># Zum nachschauen</span>
print(card)
print(title_spans)
</div></code></pre>
<div style='page-break-after: always'></div>
<p>Eine andere Version mit Klassen und Pfad zu den Bildern.</p>
<pre class="hljs"><code><div><span class="hljs-keyword">import</span> requests
<span class="hljs-keyword">from</span> bs4 <span class="hljs-keyword">import</span> BeautifulSoup
<span class="hljs-comment"># Pfade ermitteln und zusammenfügen</span>
<span class="hljs-keyword">from</span> urllib.parse <span class="hljs-keyword">import</span> urljoin
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">CrawledArticle</span><span class="hljs-params">()</span>:</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, title, emoji, content, image)</span>:</span>
self.title = title
self.emoji = emoji
self.content = content
self.image = image
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">ArticleFetcher</span><span class="hljs-params">()</span>:</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">fetch</span><span class="hljs-params">(self)</span>:</span>
url = <span class="hljs-string">"http://python.beispiel.programmierenlernen.io/index.php"</span>
r = requests.get(url)
doc = BeautifulSoup(r.text, <span class="hljs-string">"html.parser"</span>)
articles = []
<span class="hljs-keyword">for</span> card <span class="hljs-keyword">in</span> doc.select(<span class="hljs-string">".card"</span>):
emoji = card.select_one(<span class="hljs-string">".emoji"</span>).text
content = card.select_one(<span class="hljs-string">".card-text"</span>).text
title = card.select(<span class="hljs-string">".card-title span"</span>)[<span class="hljs-number">1</span>].text
image = urljoin(url, card.select_one(<span class="hljs-string">"img"</span>).attrs[<span class="hljs-string">"src"</span>])
crawled = CrawledArticle(title, emoji, content, image)
articles.append(crawled)
<span class="hljs-keyword">return</span> articles
fetcher = ArticleFetcher()
articles = fetcher.fetch()
<span class="hljs-keyword">for</span> article <span class="hljs-keyword">in</span> articles:
print(article.title)
print(article.image)
</div></code></pre>
<div style='page-break-after: always'></div>
<p>Mehrere Seiten einlesen.</p>
<pre class="hljs"><code><div><span class="hljs-keyword">import</span> requests
<span class="hljs-keyword">from</span> bs4 <span class="hljs-keyword">import</span> BeautifulSoup
<span class="hljs-comment"># Pfade ermitteln und zusammenfügen</span>
<span class="hljs-keyword">from</span> urllib.parse <span class="hljs-keyword">import</span> urljoin
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">CrawledArticle</span><span class="hljs-params">()</span>:</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, title, emoji, content, image)</span>:</span>
self.title = title
self.emoji = emoji
self.content = content
self.image = image
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">ArticleFetcher</span><span class="hljs-params">()</span>:</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">fetch</span><span class="hljs-params">(self)</span>:</span>
url = <span class="hljs-string">"http://python.beispiel.programmierenlernen.io/index.php"</span>
articles = []
<span class="hljs-keyword">while</span> url != <span class="hljs-string">""</span>:
print(url)
r = requests.get(url)
doc = BeautifulSoup(r.text, <span class="hljs-string">"html.parser"</span>)
<span class="hljs-keyword">for</span> card <span class="hljs-keyword">in</span> doc.select(<span class="hljs-string">".card"</span>):
emoji = card.select_one(<span class="hljs-string">".emoji"</span>).text
content = card.select_one(<span class="hljs-string">".card-text"</span>).text
title = card.select(<span class="hljs-string">".card-title span"</span>)[<span class="hljs-number">1</span>].text
image = urljoin(url, card.select_one(<span class="hljs-string">"img"</span>).attrs[<span class="hljs-string">"src"</span>])
crawled = CrawledArticle(title, emoji, content, image)
articles.append(crawled)
<span class="hljs-comment"># Next link holen</span>
next_button = doc.select_one(<span class="hljs-string">".navigation .btn"</span>)
<span class="hljs-keyword">if</span> next_button:
next_href = doc.select_one(<span class="hljs-string">".navigation .btn"</span>).attrs(<span class="hljs-string">"href"</span>)
next_href = urljoin(url, next_href)
url = next_href
<span class="hljs-keyword">else</span>:
url = <span class="hljs-string">""</span>
<span class="hljs-keyword">return</span> articles
fetcher = ArticleFetcher()
articles = fetcher.fetch()
<span class="hljs-keyword">for</span> article <span class="hljs-keyword">in</span> articles:
print(article.imoji + <span class="hljs-string">": "</span> + article.title)
<span class="hljs-comment"># oder kürzer, ohne definition von articles</span>
<span class="hljs-keyword">for</span> article <span class="hljs-keyword">in</span> fetcher.fetch():
</div></code></pre>
<div style='page-break-after: always'></div>
<h4 id="744-encoding">7.4.4 Encoding</h4>
<p>Das Ergebnis in einer CSV-Datei schreiben. Hierzu kann es unter Windows vorkommen, das man das Schreiben des Smileys nicht machen kann. Es wird die Meldung <strong>UnicodeEncodeError</strong> ausgegeben.</p>
<pre class="hljs"><code><div><span class="hljs-keyword">import</span> requests
<span class="hljs-keyword">from</span> bs4 <span class="hljs-keyword">import</span> BeautifulSoup
<span class="hljs-keyword">from</span> urllib.parse <span class="hljs-keyword">import</span> urljoin
<span class="hljs-keyword">import</span> time
<span class="hljs-keyword">import</span> csv
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">CrawledArticle</span><span class="hljs-params">()</span>:</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, title, emoji, content, image)</span>:</span>
self.title = title
self.emoji = emoji
self.content = content
self.image = image
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">ArticleFetcher</span><span class="hljs-params">()</span>:</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">fetch</span><span class="hljs-params">(self)</span>:</span>
url = <span class="hljs-string">"http://python.beispiel.programmierenlernen.io/index.php"</span>
articles = []
<span class="hljs-keyword">while</span> url != <span class="hljs-string">""</span>:
print(url)
time.sleep(<span class="hljs-number">1</span>)
r = requests.get(url)
doc = BeautifulSoup(r.text, <span class="hljs-string">"html.parser"</span>)
<span class="hljs-keyword">for</span> card <span class="hljs-keyword">in</span> doc.select(<span class="hljs-string">".card"</span>):
emoji = card.select_one(<span class="hljs-string">".emoji"</span>).text
content = card.select_one(<span class="hljs-string">".card-text"</span>).text
title = card.select(<span class="hljs-string">".card-title span"</span>)[<span class="hljs-number">1</span>].text
image = urljoin(url, card.select_one(<span class="hljs-string">"img"</span>).attrs[<span class="hljs-string">"src"</span>])
crawled = CrawledArticle(title, emoji, content, image)
articles.append(crawled)
next_button = doc.select_one(<span class="hljs-string">".navigation .btn"</span>)
<span class="hljs-keyword">if</span> next_button:
next_href = next_button.attrs[<span class="hljs-string">"href"</span>]
next_href = urljoin(url, next_href)
url = next_href
<span class="hljs-keyword">else</span>:
url = <span class="hljs-string">""</span>
<span class="hljs-keyword">return</span> articles
fetcher = ArticleFetcher()
articles = fetcher.fetch()
csvFile = <span class="hljs-string">"./WebCrawler.csv"</span>
<span class="hljs-keyword">with</span> open(csvFile, <span class="hljs-string">'a'</span>, newline=<span class="hljs-string">''</span>, encoding=<span class="hljs-string">'utf-8'</span>) <span class="hljs-keyword">as</span> file:
writer = csv.writer(file, delimiter=<span class="hljs-string">';'</span>, quotechar=<span class="hljs-string">'"'</span>, quoting=csv.QUOTE_MINIMAL)
<span class="hljs-keyword">for</span> article <span class="hljs-keyword">in</span> articles:
writer.writerow([article.emoji, article.title, article.content, article.image])
print(<span class="hljs-string">"Finished."</span>)
</div></code></pre>
<div style='page-break-after: always'></div>
<h4 id="745-generatoren">7.4.5 Generatoren</h4>
<p>Mit Generatoren wird erst zur Laufzeit die Werte gebildet und nicht erst die komplette Liste.</p>
<pre class="hljs"><code><div><span class="hljs-comment"># Klassische definition</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">gen_list</span><span class="hljs-params">()</span>:</span>
liste[]
<span class="hljs-keyword">for</span> i im range(<span class="hljs-number">0</span>, <span class="hljs-number">10</span>):
liste.append(i)
<span class="hljs-keyword">for</span> element <span class="hljs-keyword">in</span> gen_liste():
print(element)
<span class="hljs-comment"># Liste mit einem Generator</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">gen_generator</span><span class="hljs-params">()</span>:</span>
<span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> range(<span class="hljs-number">0</span>, <span class="hljs-number">10</span>):
print(<span class="hljs-string">"gen: "</span> + str(i))
<span class="hljs-keyword">yield</span> i
<span class="hljs-keyword">for</span> element <span class="hljs-keyword">in</span> gen_generator():
print(<span class="hljs-string">"for: "</span> + str(element))
<span class="hljs-comment"># Nur 4 Werte ausgeben.</span>
<span class="hljs-keyword">for</span> wert <span class="hljs-keyword">in</span> gen_generator():
<span class="hljs-keyword">if</span> wert == <span class="hljs-number">4</span>:
<span class="hljs-keyword">break</span>
print(<span class="hljs-string">"for: "</span> + str(wert))
</div></code></pre>
<div style='page-break-after: always'></div>
<p>In dem WebCrawler wird der Generator eingebaut. Hierfür braucht man nur die articles zu entfernen und aus <strong>crawled yield</strong> machen.</p>
<pre class="hljs"><code><div><span class="hljs-keyword">import</span> requests
<span class="hljs-keyword">from</span> bs4 <span class="hljs-keyword">import</span> BeautifulSoup
<span class="hljs-keyword">from</span> urllib.parse <span class="hljs-keyword">import</span> urljoin
<span class="hljs-keyword">import</span> time
<span class="hljs-keyword">import</span> csv
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">CrawledArticle</span><span class="hljs-params">()</span>:</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, title, emoji, content, image)</span>:</span>
self.title = title
self.emoji = emoji
self.content = content
self.image = image
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">ArticleFetcher</span><span class="hljs-params">()</span>:</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">fetch</span><span class="hljs-params">(self)</span>:</span>
url = <span class="hljs-string">"http://python.beispiel.programmierenlernen.io/index.php"</span>
<span class="hljs-keyword">while</span> url != <span class="hljs-string">""</span>:
print(url)
time.sleep(<span class="hljs-number">1</span>)
r = requests.get(url)
doc = BeautifulSoup(r.text, <span class="hljs-string">"html.parser"</span>)
<span class="hljs-keyword">for</span> card <span class="hljs-keyword">in</span> doc.select(<span class="hljs-string">".card"</span>):
emoji = card.select_one(<span class="hljs-string">".emoji"</span>).text
content = card.select_one(<span class="hljs-string">".card-text"</span>).text
title = card.select(<span class="hljs-string">".card-title span"</span>)[<span class="hljs-number">1</span>].text
image = urljoin(url, card.select_one(<span class="hljs-string">"img"</span>).attrs[<span class="hljs-string">"src"</span>])
<span class="hljs-keyword">yield</span> CrawledArticle(title, emoji, content, image)
next_button = doc.select_one(<span class="hljs-string">".navigation .btn"</span>)
<span class="hljs-keyword">if</span> next_button:
next_href = next_button.attrs[<span class="hljs-string">"href"</span>]
next_href = urljoin(url, next_href)
url = next_href
<span class="hljs-keyword">else</span>:
url = <span class="hljs-string">""</span>
fetcher = ArticleFetcher()
counter = <span class="hljs-number">0</span>
<span class="hljs-keyword">for</span> article <span class="hljs-keyword">in</span> fetcher.fetch():
<span class="hljs-keyword">if</span> counter == <span class="hljs-number">8</span>:
<span class="hljs-keyword">break</span>
counter += <span class="hljs-number">1</span>
print(article.emoji + <span class="hljs-string">": "</span> + article.title)
</div></code></pre>
<div style='page-break-after: always'></div>
<h4 id="746-crawler-in-python-programm-umwandeln">7.4.6 Crawler in Python-Programm umwandeln</h4>
<p>Es wurden die einzellnen Klassen in separaten Dateien in eimen Modul Verzeichnis gespeichert. In der Hauptdatei war nur noch der Aufruf der Module.</p>
<pre class="hljs"><code><div><span class="hljs-comment"># Modul CrawlesArticle.py</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">CrawledArticle</span><span class="hljs-params">()</span>:</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, title, emoji, content, image)</span>:</span>
self.title = title
self.emoji = emoji
self.content = content
self.image = image
<span class="hljs-comment"># Modul ArticleFetcher.py</span>
<span class="hljs-keyword">import</span> time
<span class="hljs-keyword">import</span> requests
<span class="hljs-keyword">from</span> bs4 <span class="hljs-keyword">import</span> BeautifulSoup
<span class="hljs-keyword">from</span> urllib.parse <span class="hljs-keyword">import</span> urljoin
<span class="hljs-keyword">from</span> .CrawledArticle <span class="hljs-keyword">import</span> CrawledArticle
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">ArticleFetcher</span><span class="hljs-params">()</span>:</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">fetch</span><span class="hljs-params">(self)</span>:</span>
url = <span class="hljs-string">"http://python.beispiel.programmierenlernen.io/index.php"</span>
<span class="hljs-keyword">while</span> url != <span class="hljs-string">""</span>:
print(url)
time.sleep(<span class="hljs-number">1</span>)
r = requests.get(url)
doc = BeautifulSoup(r.text, <span class="hljs-string">"html.parser"</span>)
<span class="hljs-keyword">for</span> card <span class="hljs-keyword">in</span> doc.select(<span class="hljs-string">".card"</span>):
emoji = card.select_one(<span class="hljs-string">".emoji"</span>).text
content = card.select_one(<span class="hljs-string">".card-text"</span>).text
title = card.select(<span class="hljs-string">".card-title span"</span>)[<span class="hljs-number">1</span>].text
image = urljoin(url, card.select_one(<span class="hljs-string">"img"</span>).attrs[<span class="hljs-string">"src"</span>])
<span class="hljs-keyword">yield</span> CrawledArticle(title, emoji, content, image)
next_button = doc.select_one(<span class="hljs-string">".navigation .btn"</span>)
<span class="hljs-keyword">if</span> next_button:
next_href = next_button.attrs[<span class="hljs-string">"href"</span>]
next_href = urljoin(url, next_href)
url = next_href
<span class="hljs-keyword">else</span>:
url = <span class="hljs-string">""</span>
<span class="hljs-comment"># Inhalt __init__.py im Modul Verzeichnis</span>
__all__ = [<span class="hljs-string">"CrawledArticle"</span>, <span class="hljs-string">"ArticleFetcher"</span>]
<span class="hljs-keyword">from</span> .CrawledArticle <span class="hljs-keyword">import</span> CrawledArticle
<span class="hljs-keyword">from</span> .ArticleFetcher <span class="hljs-keyword">import</span> ArticleFetcher
<span class="hljs-comment"># Hauptprogramm Crawler.py</span>
<span class="hljs-keyword">import</span> Module
fetcher = Module.ArticleFetcher()
counter = <span class="hljs-number">0</span>
<span class="hljs-keyword">for</span> article <span class="hljs-keyword">in</span> fetcher.fetch():
<span class="hljs-keyword">if</span> counter == <span class="hljs-number">8</span>:
<span class="hljs-keyword">break</span>
counter += <span class="hljs-number">1</span>
print(article.emoji + <span class="hljs-string">": "</span> + article.title)
</div></code></pre>
<div style='page-break-after: always'></div>
<h2 id="8-exceptions">8. Exceptions</h2>
<p>Bei Exceptions handelt es sich um Fehlerbehandlung. Läuft etwas nicht in Python und es gibt eine Fehlermeldung, so kann man sie abfangen und einen eigenen Text ausgeben. Damit man Exceptions abfangen kann, macht man einen <strong>Try</strong> und <strong>Except</strong> Block. Beides kann mehrfach in dem Programm vorkommen.</p>
<pre class="hljs"><code><div>print(<span class="hljs-number">5</span> / <span class="hljs-number">0</span>)
print(<span class="hljs-number">5</span>)
---------------------------------------------------------------------------
ZeroDivisionError Traceback (most recent call last)
~\AppData\Local\Temp/ipykernel_5448/<span class="hljs-number">2714365857.</span>py <span class="hljs-keyword">in</span> &lt;module&gt;
----&gt; <span class="hljs-number">1</span> print(<span class="hljs-number">5</span> / <span class="hljs-number">0</span>)
<span class="hljs-number">2</span> print(<span class="hljs-number">5</span>)
ZeroDivisionError: division by zero
<span class="hljs-comment"># Nach dem ersten Fehler wird sofort der Try-Block verlassen</span>
<span class="hljs-comment"># und die exception wird ausgeführt.</span>
<span class="hljs-keyword">try</span>:
print(<span class="hljs-number">5</span> / <span class="hljs-number">0</span>)
print(<span class="hljs-number">4</span>)
<span class="hljs-keyword">except</span> ZeroDivisionError:
print(<span class="hljs-string">"Eine division durch null ist nicht erlaubt."</span>)
print(<span class="hljs-number">5</span>)
Eine division durch null ist nicht erlaubt.
<span class="hljs-number">5</span>
</div></code></pre>
<p>Mehrere Exceptions abfangen und eigene erstellen.</p>
<pre class="hljs"><code><div><span class="hljs-keyword">try</span>:
<span class="hljs-keyword">with</span> open(<span class="hljs-string">"datei.xyz"</span>, <span class="hljs-string">"r"</span>) <span class="hljs-keyword">as</span> file:
print(file)
print(<span class="hljs-number">7</span> / <span class="hljs-number">0</span>)
<span class="hljs-keyword">except</span> ZeroDivisionError:
print(<span class="hljs-string">"Eine division durch null ist nicht erlaubt."</span>)
<span class="hljs-keyword">except</span> FileNotFoundError:
print(<span class="hljs-string">"Die Datei kann nicht gefunden werden.)
# Anderes Beispiel
# Eine Exception kann man auch abfangen, wenn sie in einer Funktion erst auftritt.
def MachEtwas():
print(8 / 0)
try:
MachEtwas()
except ZeroDivisionError:
print("</span>Eine division durch null ist nicht erlaubt.<span class="hljs-string">")
# Eine eigene Exeption definieren
class InvalidEmailError(Exception): # erweitert die Exception Klasse
pass # erstmal ohne Anweisungen
def send_mail(email, subject, content):
if not "</span>@<span class="hljs-string">" in email:
# In Klammern steht der Ausgabe Text, wenn die Exception nicht abgefangen wird.
raise InvalidEmailError("</span>email does <span class="hljs-keyword">not</span> contain an @<span class="hljs-string">")
try:
send_mail("</span>Hallo<span class="hljs-string">", "</span>Betreff:<span class="hljs-string">", "</span>Inhalt<span class="hljs-string">")
except InvalidEmailError:
print("</span>Bitte eine gültige E-Mail angeben.)
</div></code></pre>
<p>Um Exception abzufangen, wird der Exception Name benötigt. Diesen bekommt man, wenn man das Programm startet und in der letzten Zeile steht dann am Anfang der Exception Name. In dem nachfolgenden Beispiel ein NameError.</p>
<pre class="hljs"><code><div> File <span class="hljs-string">"/daten/coding/python/SendMail.px"</span>, line <span class="hljs-number">95</span>, <span class="hljs-keyword">in</span> main
<span class="hljs-keyword">if</span> MailFile <span class="hljs-keyword">and</span> AdressFile:
^^^^^^^^^^
NameError: name <span class="hljs-string">'AdressFile'</span> <span class="hljs-keyword">is</span> <span class="hljs-keyword">not</span> defined
</div></code></pre>
<div style='page-break-after: always'></div>
<p>Es gibt auch noch einen <strong>Finally</strong> Block, der immer ausgeführt wird, auch wenn es eine Exception gegeben hat.</p>
<pre class="hljs"><code><div><span class="hljs-keyword">try</span>:
file = open(<span class="hljs-string">"exist.txt"</span>, <span class="hljs-string">"r"</span>)
print(file)
print(<span class="hljs-number">6</span> / <span class="hljs-number">0</span>)
<span class="hljs-keyword">except</span> FileNotFoundError:
print(<span class="hljs-string">"Datei wurde nicht gefunden!"</span>)
<span class="hljs-keyword">finally</span>:
print(<span class="hljs-string">"FINALLY!!"</span>)
file.close()
</div></code></pre>
<div style='page-break-after: always'></div>
<p>Nachfolgend eine Auswahl der Standard Exceptions</p>
<table>
<thead>
<tr>
<th>Exception Name</th>
<th>Beschreibung</th>
</tr>
</thead>
<tbody>
<tr>
<td>Exception</td>
<td>Base class for all exception</td>
</tr>
<tr>
<td>StopIteration</td>
<td>Raised when the next() method of an iteration does not point to any object</td>
</tr>
<tr>
<td>SystemExit</td>
<td>Raised by the sys.exit() function</td>
</tr>
<tr>
<td>StandardError</td>
<td>Base class for all built-in exceptions except StopIteration and SystemExit</td>
</tr>
<tr>
<td>ArithmeticError</td>
<td>Base class for all errors that occur for numeric calculation</td>
</tr>
<tr>
<td>OverflowError</td>
<td>Raised when a calculation exceeds maximum limit for a numeric type</td>
</tr>
<tr>
<td>FloatingPointError</td>
<td>Raised when a floating point calculation fails</td>
</tr>
<tr>
<td>ZeroDivisionErro</td>
<td>Raised when division or modulo by zero takes place for all numeric types</td>
</tr>
<tr>
<td>AssertionError</td>
<td>Raised in case of failure of the Assert statement</td>
</tr>
<tr>
<td>AttributeError</td>
<td>Raised in case of failure of attribute reference or assignment</td>
</tr>
<tr>
<td>EOFError</td>
<td>Raised when there is no input from either the raw_input() or input() function and the end of file is reached</td>
</tr>
<tr>
<td>ImportError</td>
<td>Raised when an import statements fails</td>
</tr>
<tr>
<td>KeyboardInterrupt</td>
<td>Raised when the User interrupts program execution, usually by pressing Ctrl + c</td>
</tr>
<tr>
<td>LookupError</td>
<td>Base Class for all lookup errors</td>
</tr>
<tr>
<td>IndexError</td>
<td>Raised when an index is not found in a sequence</td>
</tr>
<tr>
<td>KeyError</td>
<td>Raised when the specified key is not found in the dictionary.</td>
</tr>
<tr>
<td>NameError</td>
<td>Raised when an identifier is not found in the local or global namespace</td>
</tr>
<tr>
<td>UnboundLocalError</td>
<td>Raised when traing to access a local variable in a function or method but not value has been assigned to it</td>
</tr>
<tr>
<td>EnvironmentError</td>
<td>Base class for all exception that accur outside the Python environment</td>
</tr>
<tr>
<td>IOError</td>
<td>Raised when an input / output operation fails, such as print statement or the open() function when trying to open a file that does not exist</td>
</tr>
<tr>
<td>SyntaxError</td>
<td>Raised when there is an error in Python syntax</td>
</tr>
<tr>
<td>IndentationError</td>
<td>Raised when indentation is not specified properly</td>
</tr>
<tr>
<td>SystemError</td>
<td>Raised when the interpreter finds an internal problem, but when this error is encountered the Python interpreter does not exit</td>
</tr>
<tr>
<td>SystemExit</td>
<td>Raised when Python interpreter is quit by using the sys.exit() function. If not handled in the code, causes the interpreter to exit</td>
</tr>
<tr>
<td>ValueError</td>
<td>Raised when the built-in function for a data type has a vaild type of arguments, but the arguments have invalid values specified</td>
</tr>
<tr>
<td>RuntimeError</td>
<td>Raised when a generated error does not fall into any Category</td>
</tr>
<tr>
<td>NotImplementedError</td>
<td>Raised when an abstract method that needs to be implemented in an inherited class is not actually implemented</td>
</tr>
</tbody>
</table>
<div style='page-break-after: always'></div>
<h2 id="9-datenstrukturen">9. Datenstrukturen</h2>
<p>Eine Datenstruktur ist ein Objekt, welches mehrere Elemente enthält, z.B. Liste, Dictionary.Es gibt verschiedene Einsatzzwecke:</p>
<ul>
<li>Liste: Geordnete Auflistung von Elementen [&quot;Hallo&quot;, &quot;Welt&quot;]
<ul>
<li>Kann nachträglich erweitert werden</li>
<li>Reihenfolge wird beibehalten</li>
<li>Elemente dürfen mehrfach vorkommen</li>
</ul>
</li>
<li>Dictionary: Zuordnung von Schlüssel zu Wert {&quot;Hallo&quot;: 6, &quot;Welt&quot;: 8}
<ul>
<li>Speichert eine Zuordnung von eimen Schlüssel (key) zu einem Wert (value)</li>
<li>Reihenfolge wird nicht beibehalten</li>
<li>Werte dürfen mehrfach vorkommen</li>
<li>Jeder Schlüssel darf aber nur 1x vorkommen</li>
</ul>
</li>
<li>Set: Ungeordnete Sammlung von Elementen, wo jedes Element nur einmal drinnen vorkommen darf {&quot;Element1&quot;}
<ul>
<li>Kann nachträglich erweitert werden</li>
<li>Reihenfolge wird nicht beibehalten</li>
<li>Index-Schreibweise s[15] wird nicht unterstützt</li>
<li>Jedes Element kommt nur 1x vor</li>
<li>Wenn man garantieren möchte, das jedes Element nur 1x vorkommt - ein Set ist hierauf optimiert und viel effizienter als eine Liste</li>
</ul>
</li>
<li>PriorityQueue(Prioritätswarteschlange): Automatische Sortierung der Elemente
<ul>
<li>Optimierte Datenstruktur, um Elemente nach einer Priorität zu sortieren</li>
<li>Elemente werden quasi automatisch nach ihrere Priorität sortiert</li>
<li>Man kann nur auf das erste Element zugreifen, bzw. das erste Element löschen</li>
</ul>
</li>
<li>Tupel: (&quot;Element1&quot;, &quot;Element2&quot;)
<ul>
<li>Ahnlich einer Liste</li>
<li>Kann aber nachträglich nicht erweitert werden.</li>
</ul>
</li>
</ul>
<div style='page-break-after: always'></div>
<h3 id="91-set">9.1 Set</h3>
<pre class="hljs"><code><div><span class="hljs-comment"># Ein Set definieren</span>
s = {<span class="hljs-string">"Hallo"</span>. <span class="hljs-string">"Welt"</span>}
s.add(<span class="hljs-string">"Jupiter"</span>)
print(s)
<span class="hljs-comment"># Der neue Eintrag wird ignoriert und es wird keine Fehlermeldung ausgegeben.</span>
s.add(<span class="hljs-string">"Jupiter"</span>)
<span class="hljs-comment"># Ein leeres Set anlegen</span>
text = <span class="hljs-string">"Hallo Welt Hallo Welt Hallo Welt"</span>
words = set()
<span class="hljs-keyword">for</span> word <span class="hljs-keyword">in</span> text.split(<span class="hljs-string">" "</span>):
words.add(word)
print(Words)
print(len(words))
<span class="hljs-comment"># Ausgabe</span>
{<span class="hljs-string">'Jupiter'</span>, <span class="hljs-string">'Welt'</span>, <span class="hljs-string">'Hallo'</span>}
<span class="hljs-number">3</span>
</div></code></pre>
<h3 id="92-queue">9.2 Queue</h3>
<p>Die <strong>Queue</strong> ist für folgende Operationen optimiert:</p>
<ul>
<li>Eintrag hinzufügen</li>
<li>Eintrag vom Anfang entfernen</li>
</ul>
<pre class="hljs"><code><div><span class="hljs-keyword">import</span> queue
q = queue.Queue()
<span class="hljs-comment"># Werte in die Queue schreiben</span>
q.put(<span class="hljs-string">"Hallo"</span>)
q.put(<span class="hljs-string">"Welt"</span>)
q.put(<span class="hljs-string">"Mars"</span>)
q.put(<span class="hljs-string">"Venus"</span>)
q.put(<span class="hljs-string">"Mond"</span>)
<span class="hljs-comment"># Nach einem get wird der Eintrag aus der Queue entfernt</span>
print(q.get())
print(q.get())
<span class="hljs-comment"># Alle Werte aus der Queue holen</span>
<span class="hljs-keyword">while</span> <span class="hljs-keyword">not</span> q.empty():
element = q.get()
print(element)
</div></code></pre>
<div style='page-break-after: always'></div>
<h3 id="93-priorityqueue">9.3 PriorityQueue</h3>
<p>Eine <strong>PriorityQueue</strong> ist eine Warteschlange, die Einträge automatisch sortiert.</p>
<pre class="hljs"><code><div><span class="hljs-keyword">import</span> queue
q = queue.PriorityQueue()
<span class="hljs-comment"># Als Werte wird ein Tupel angegeben, der erste Wert ist</span>
<span class="hljs-comment"># die Priority</span>
q.put((<span class="hljs-number">10</span>, <span class="hljs-string">"Hallo Welt"</span>))
q.put((<span class="hljs-number">15</span>, <span class="hljs-string">"Mars"</span>))
q.put((<span class="hljs-number">5</span>, <span class="hljs-string">"Wichtig"</span>))
<span class="hljs-comment"># Beispiel, wie häufig kommt ein Buchstabe vor</span>
text = <span class="hljs-string">"A A A A B B B C C C C C D D D D d D D"</span>
d = {}
<span class="hljs-keyword">for</span> word <span class="hljs-keyword">in</span> text.split(<span class="hljs-string">" "</span>):
<span class="hljs-keyword">if</span> word <span class="hljs-keyword">in</span> d:
d[word] = d[word] + <span class="hljs-number">1</span>
<span class="hljs-keyword">else</span>:
d[word] = <span class="hljs-number">1</span>
pq = queue.PriorityQueue()
<span class="hljs-keyword">for</span> word, number <span class="hljs-keyword">in</span> d.items():
<span class="hljs-comment"># Steht vor der Priority ein Minus, so wird absteigend sortiert.</span>
<span class="hljs-comment"># Standard ist aufsteigend.</span>
pq.put((-number, word))
print(pq.get())
print(pq.get())
print(pq.get())
</div></code></pre>
<div style='page-break-after: always'></div>
<p>Beispiel, die 5 häufigsten Namen aus einer CSV-Datei.</p>
<pre class="hljs"><code><div><span class="hljs-keyword">import</span> csv
<span class="hljs-keyword">import</span> queue
names = {}
<span class="hljs-keyword">with</span> open(<span class="hljs-string">r"..\data\names.csv"</span>, <span class="hljs-string">"r"</span>) <span class="hljs-keyword">as</span> csvfile:
namereader = csv.reader(csvfile, delimiter=<span class="hljs-string">','</span>, quotechar=<span class="hljs-string">'"'</span>)
counter = <span class="hljs-number">0</span>
<span class="hljs-keyword">for</span> line <span class="hljs-keyword">in</span> namereader:
<span class="hljs-keyword">if</span> counter != <span class="hljs-number">0</span>:
number = int(line[<span class="hljs-number">5</span>])
name = line[<span class="hljs-number">1</span>]
<span class="hljs-keyword">if</span> name <span class="hljs-keyword">in</span> names:
names[name] = names[name] + number
<span class="hljs-keyword">else</span>:
names[name] = number
<span class="hljs-comment"># next 2 lines for debug</span>
print(line)
<span class="hljs-keyword">break</span>
counter += <span class="hljs-number">1</span>
<span class="hljs-comment"># next line for debug</span>
print(names)
<span class="hljs-comment"># Berechnen der Reihenfolge</span>
pq = queue.PriorityQueue()
<span class="hljs-keyword">for</span> name, number <span class="hljs-keyword">in</span> names.items():
pq.put((-number, name))
<span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> range(<span class="hljs-number">0</span>, <span class="hljs-number">5</span>):
print(pq.get())
</div></code></pre>
<div style='page-break-after: always'></div>
<h2 id="10-diverses--expertenwissen">10. Diverses / Expertenwissen</h2>
<p>Folgende Themen werden hier behandelt:</p>
<ul>
<li>Variable Funktionsparameter</li>
<li>Daten sortieren</li>
<li>Arbeiten mit Datumsangaben</li>
<li>Lambda Funktionen</li>
<li>Reguläre Ausdrücke</li>
<li>Zeitdifferenzen</li>
<li>Strings formatieren</li>
<li>DefaultDict</li>
</ul>
<h3 id="101-variable-funktionsparameter">10.1 Variable Funktionsparameter</h3>
<pre class="hljs"><code><div><span class="hljs-comment"># Nach dem = wird der Standard Wert gesetzt der dann genommen</span>
<span class="hljs-comment"># wird, wenn bei dem Aufruf kein Wert übergeben wird.</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">multi_print</span><span class="hljs-params">(number = <span class="hljs-number">3</span>, word = <span class="hljs-string">"Hallo"</span>)</span>:</span>
<span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> range(<span class="hljs-number">0</span>, number):
print(word)
<span class="hljs-comment"># Die Angabe der Werte muss immer in der Reihenfolge erfolgen,</span>
<span class="hljs-comment"># wie sie in der Funktion definiert worden ist.</span>
multi_print(<span class="hljs-number">5</span>)
multi_print(<span class="hljs-number">5</span>, <span class="hljs-string">"Moin Moin"</span>)
<span class="hljs-comment"># Nur ein bestimmter Wert wird übergeben</span>
multi_print(word = <span class="hljs-string">"Servus"</span>)
</div></code></pre>
<div style='page-break-after: always'></div>
<p>In Python unterscheidet man zwischen 2 Arten von Variablen:</p>
<ul>
<li>Primitive Dattentypen (Zhl, Strig, Booleans, ...)</li>
<li>Datenstrukturen / Datenstruktur</li>
</ul>
<pre class="hljs"><code><div><span class="hljs-comment"># Der Inhalt der variable a wird nur in der Funktion geändert</span>
a = <span class="hljs-number">5</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">f</span><span class="hljs-params">(x)</span>:</span>
x = <span class="hljs-number">3</span>
print(x)
f(a)
print(a)
<span class="hljs-comment"># Nächstes Beispiel</span>
l = [<span class="hljs-string">"Servus"</span>, <span class="hljs-string">"Sonne"</span>]
<span class="hljs-comment"># Der Inhalt der Liste wird geändert</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">f</span><span class="hljs-params">(x)</span>:</span>
x.append(<span class="hljs-string">"XXX"</span>)
print(x)
<span class="hljs-comment"># Der Inhalt der Liste wird verändert</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">g</span><span class="hljs-params">(x)</span>:</span>
x = [<span class="hljs-string">"Servus"</span>, <span class="hljs-string">"Sonne"</span>, <span class="hljs-string">"!!!"</span>]
print(x)
f(l)
g(l)
print(l)
</div></code></pre>
<div style='page-break-after: always'></div>
<p>Variable Funktionsparameter übergeben.</p>
<pre class="hljs"><code><div><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">f</span><span class="hljs-params">(a, b, c)</span>:</span>
print(a)
print(b)
print(c)
l = [<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>]
f(l[<span class="hljs-number">0</span>], l[<span class="hljs-number">1</span>], l[<span class="hljs-number">2</span>])
<span class="hljs-comment"># Python wird die Liste übergeben und mit dem Stern wird automatisch</span>
<span class="hljs-comment"># zerlegt.</span>
f(*l)
<span class="hljs-comment"># Mit dem * wird ein Tupel definiert.</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">g</span><span class="hljs-params">(*params)</span>:</span>
print(params)
current_max = params[<span class="hljs-number">0</span>]
<span class="hljs-keyword">for</span> item <span class="hljs-keyword">in</span> params:
<span class="hljs-keyword">if</span> item &gt; current_max:
current_max = item
<span class="hljs-keyword">return</span> current_max
g(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>)
<span class="hljs-comment"># Der erste Übergebene Parameter landet in dem ersten Funktionsparameter,</span>
<span class="hljs-comment"># die anderen werden in ein Tupel heschrieben.</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">g</span><span class="hljs-params">(current_max, *params)</span>:</span>
print(current_max)
print(params)
current_max = params[<span class="hljs-number">0</span>]
<span class="hljs-keyword">for</span> item <span class="hljs-keyword">in</span> params:
<span class="hljs-keyword">if</span> item &gt; current_max:
current_max = item
<span class="hljs-keyword">return</span> current_max
g(<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>)
<span class="hljs-comment"># Ein Dictionary wird als Parameter erstellt.</span>
<span class="hljs-comment"># Dieses geschieht mit den zwei Sternen vor der Variable</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">f</span><span class="hljs-params">(**args)</span>:</span>
print(args)
f(key = <span class="hljs-string">"Servus"</span>, key2 = <span class="hljs-string">"Walter"</span>)
</div></code></pre>
<div style='page-break-after: always'></div>
<pre class="hljs"><code><div><span class="hljs-comment"># Anderes Beispiel</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">g</span><span class="hljs-params">(key, param2)</span>:</span>
print(key)
print(param2)
d = {<span class="hljs-string">"key"</span>: <span class="hljs-string">"Werbung"</span>, <span class="hljs-string">"param2"</span>: <span class="hljs-string">"Sonne"</span>}
g(key=d[<span class="hljs-string">"key"</span>], param2=d[<span class="hljs-string">"param2"</span>])
<span class="hljs-comment"># Kürzer</span>
g(**d)
<span class="hljs-comment"># Und noch ein Beispiel</span>
%matplotlib inline
<span class="hljs-keyword">import</span> matplotlib.pyplot <span class="hljs-keyword">as</span> plt
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">create_plot</span><span class="hljs-params">(**plot_params)</span>:</span>
print(plot_params)
plt.plot([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>] [<span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">5</span>], **plot_params)
plt.show()
create_plot(color=<span class="hljs-string">"r"</span>, linewidth=<span class="hljs-number">8</span>)
</div></code></pre>
<div style='page-break-after: always'></div>
<h3 id="102-daten-sortieren">10.2 Daten sortieren</h3>
<p>Mit <strong>sort</strong> wird ein Inplace gemacht und bei <strong>sorted</strong> nur die Ausgabe.</p>
<pre class="hljs"><code><div>l = [<span class="hljs-string">"Klaus"</span>, <span class="hljs-string">"Andrea"</span>, <span class="hljs-string">"Harry"</span>, <span class="hljs-string">"Walter"</span>]
l.sort()
print(l)
<span class="hljs-comment"># Sortieren Absteigend</span>
l = [<span class="hljs-string">"Klaus"</span>, <span class="hljs-string">"Andrea"</span>, <span class="hljs-string">"Harry"</span>, <span class="hljs-string">"Walter"</span>]
l.sort(reverse=<span class="hljs-literal">True</span>)
print(l)
<span class="hljs-comment"># Eigene Sortierkriterium definieren</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">get_length</span><span class="hljs-params">(item)</span>:</span>
<span class="hljs-keyword">return</span> len(item)
l = [<span class="hljs-string">"Klaus"</span>, <span class="hljs-string">"Andrea"</span>, <span class="hljs-string">"Harry"</span>, <span class="hljs-string">"Walter"</span>]
<span class="hljs-comment"># Wichtig ist hierbei, nach der Angabe der Funktion kein () angeben.</span>
l.sort(key=get_length)
print(l)
<span class="hljs-comment"># Kürzer ist, da len auch eine Python Funktion ist</span>
l.sort(key=len)
print(l)
<span class="hljs-comment"># Daten sind nicht imme eine Liste</span>
d = {<span class="hljs-string">"Köln"</span>: <span class="hljs-string">"CGN"</span>, <span class="hljs-string">"Budapest"</span>: <span class="hljs-string">"BUD"</span>, <span class="hljs-string">"Saigon"</span>: <span class="hljs-string">"SGN"</span>}
print(sorted(d, reverse = <span class="hljs-literal">True</span>))
l = [<span class="hljs-string">"Klaus"</span>, <span class="hljs-string">"Andrea"</span>, <span class="hljs-string">"Harry"</span>, <span class="hljs-string">"Walter"</span>]
l2 = sorted(l)
print(l)
print(l2)
</div></code></pre>
<div style='page-break-after: always'></div>
<pre class="hljs"><code><div><span class="hljs-comment"># Short length</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">shortest_word</span><span class="hljs-params">(first, *words)</span>:</span>
shortest = first
<span class="hljs-keyword">for</span> word <span class="hljs-keyword">in</span> words:
<span class="hljs-keyword">if</span> len(word) &lt; len(shortest):
shortest = word
<span class="hljs-keyword">return</span> shortest
print(shortest_word(<span class="hljs-string">"Max"</span>, <span class="hljs-string">"Klaus"</span>, <span class="hljs-string">"Andreas"</span>, <span class="hljs-string">"Pauline"</span>, <span class="hljs-string">"Jo"</span>))
<span class="hljs-comment"># Aufsteigend nach ihrer Summe mit einem Tupel</span>
tupels = [(<span class="hljs-number">10</span>, <span class="hljs-number">2</span>), (<span class="hljs-number">4</span>, <span class="hljs-number">1</span>), (<span class="hljs-number">0</span>, <span class="hljs-number">17</span>), (<span class="hljs-number">3</span>, <span class="hljs-number">3</span>), (<span class="hljs-number">5</span>, <span class="hljs-number">7</span>), (<span class="hljs-number">11</span>, <span class="hljs-number">3</span>)]
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">tupels_sort</span><span class="hljs-params">(a)</span>:</span>
<span class="hljs-keyword">return</span> a[<span class="hljs-number">0</span>] + a[<span class="hljs-number">1</span>]
tupels.sort(key = tupels_sort)
print(tupels)
<span class="hljs-comment"># Mit Lambda</span>
tupels.sort(key = <span class="hljs-keyword">lambda</span> t: t[<span class="hljs-number">0</span>] + t[<span class="hljs-number">1</span>])
print(tupels)
<span class="hljs-comment"># Von einer Liste den Nachnamen ausgeben.</span>
names = [<span class="hljs-string">"Harry Hirsch"</span>, <span class="hljs-string">"Karl May"</span>, <span class="hljs-string">"Walter Mustermann"</span>, <span class="hljs-string">"Rudi Maus"</span>]
names.sort(key = <span class="hljs-keyword">lambda</span> s: s.split()[<span class="hljs-number">1</span>])
print(names)
<span class="hljs-comment"># Sortieren nach der Anzahl der Wörter</span>
text = [<span class="hljs-string">"Sie lachte"</span>, <span class="hljs-string">"Der Hund bellte laut"</span>, <span class="hljs-string">"Sie liefen weiter am Strand entlang"</span>, <span class="hljs-string">"Er rutschte aus"</span>]
text.sort(key = <span class="hljs-keyword">lambda</span> s: len(s.split()), reverse = <span class="hljs-literal">True</span>)
print(text)
</div></code></pre>
<div style='page-break-after: always'></div>
<h3 id="103-datumsangaben">10.3 Datumsangaben</h3>
<pre class="hljs"><code><div><span class="hljs-comment"># Modul laden</span>
<span class="hljs-keyword">from</span> datetime <span class="hljs-keyword">import</span> datetime
now = datetime.now()
print(now.year)
print(now.month)
print(now.day)
print(now.hour)
print(now.minute)
print(now.second)
print(now.timestamp())
<span class="hljs-keyword">from</span> datetime <span class="hljs-keyword">import</span> date, time
d = date(<span class="hljs-number">2021</span>, <span class="hljs-number">5</span>, <span class="hljs-number">31</span>)
t = time(<span class="hljs-number">18</span>, <span class="hljs-number">45</span>, <span class="hljs-number">32</span>)
print(d)
print(t)
print(date(<span class="hljs-number">2021</span>, <span class="hljs-number">5</span>, <span class="hljs-number">31</span>) == date(<span class="hljs-number">2021</span>, <span class="hljs-number">5</span>, <span class="hljs-number">30</span>))
dt = datetime(<span class="hljs-number">2021</span>, <span class="hljs-number">5</span>, <span class="hljs-number">31</span>, <span class="hljs-number">18</span>, <span class="hljs-number">29</span>, <span class="hljs-number">15</span>)
print(dt.time())
print(dt.date())
print(datetimeombine(date(<span class="hljs-number">2019</span>, <span class="hljs-number">7</span>, <span class="hljs-number">23</span>), time(<span class="hljs-number">15</span>, <span class="hljs-number">36</span>, <span class="hljs-number">0</span>)))
<span class="hljs-comment"># Datum in Germany ausgeben</span>
<span class="hljs-keyword">import</span> locale
locale.setlocale(locale.LC_ALL, <span class="hljs-string">'de_DE'</span>)
</div></code></pre>
<p>Datumswerte formatiert ausgeben. Eine Liste über die <strong>strftime</strong> Parameter gibt es <a href="https://docs.python.org/3/library/datetime.html#strftime-strptime-behavior">hier</a>.</p>
<pre class="hljs"><code><div><span class="hljs-keyword">from</span> datetime <span class="hljs-keyword">import</span> datetime
<span class="hljs-comment"># %d = Tag</span>
<span class="hljs-comment"># %m = Monat</span>
<span class="hljs-comment"># %Y = jahr</span>
now.strftime(<span class="hljs-string">"%d.%m.%Y"</span>)
<span class="hljs-comment"># Datumswerte einlesen</span>
d = <span class="hljs-string">"19.09.2019"</span>
print(datetime.strptime(d, <span class="hljs-string">"%d.%m.%Y))
</span></div></code></pre>
<div style='page-break-after: always'></div>
<h3 id="104-lambda">10.4 Lambda</h3>
<pre class="hljs"><code><div><span class="hljs-comment"># Beispiel mit einem Tupel</span>
students = [
(<span class="hljs-string">"Max"</span>, <span class="hljs-number">3</span>),
(<span class="hljs-string">"Monika"</span>, <span class="hljs-number">2</span>),
(<span class="hljs-string">"Erik"</span>, <span class="hljs-number">3</span>),
(<span class="hljs-string">"Franz"</span>, <span class="hljs-number">1</span>)
]
<span class="hljs-comment"># Inline Funktion definieren. Nach dem Funktionsaufruf von Lambda</span>
<span class="hljs-comment"># wird ein eigener Funktionsname definiert mit dem, was gemacht </span>
<span class="hljs-comment"># werden soll.</span>
students.sort()key=<span class="hljs-keyword">lambda</span> student: student[<span class="hljs-number">1</span>]
print(students)
f = <span class="hljs-keyword">lambda</span> student: student[<span class="hljs-number">1</span>]
d((<span class="hljs-string">"Max"</span>, <span class="hljs-number">3</span>))
</div></code></pre>
<div style='page-break-after: always'></div>
<h3 id="105-regul%C3%A4re-ausdr%C3%BCcke">10.5 Reguläre Ausdrücke</h3>
<p>Unter den beiden Seiten <a href="https://pythex.org/">Pythex</a> und <a href="https://regexr.com">RegExr</a> kann man interactive die Regulären Ausdrücke ausprobieren.</p>
<pre class="hljs"><code><div><span class="hljs-keyword">import</span> re
text = <span class="hljs-string">"Ich habe 30 Hunde, die jeweils 4 Liter Wasser brauchen und 2 kg Futter"</span>
re.findall(<span class="hljs-string">"[0-9]+"</span>, text)
[<span class="hljs-string">'30'</span>, <span class="hljs-string">'4'</span>, <span class="hljs-string">'2'</span>]
re.search(<span class="hljs-string">"[0-9]+"</span>, text)
&lt;_sre.SRE_Match object; span=(<span class="hljs-number">9</span>, <span class="hljs-number">11</span>), match=<span class="hljs-string">'30'</span>&gt;
<span class="hljs-comment"># Mit dem ? wird alles gefunden, mit oder ohne den Character</span>
<span class="hljs-comment"># vor dem ?</span>
print(re.search(<span class="hljs-string">"der?"</span>, <span class="hljs-string">"Hallo de Hallo"</span>))
print(re.search(<span class="hljs-string">"der?"</span>, <span class="hljs-string">"Hallo der Hallo"</span>))
print(re.search(<span class="hljs-string">"der?"</span>, <span class="hljs-string">"Hallo derrr Hallo"</span>))
print(<span class="hljs-string">"="</span> * <span class="hljs-number">20</span>)
<span class="hljs-comment"># Der Character vor dem ? kann enthalten sein, auch mehrfach</span>
print(re.search(<span class="hljs-string">"der*"</span>, <span class="hljs-string">"Hallo de Hallo"</span>))
print(re.search(<span class="hljs-string">"der*"</span>, <span class="hljs-string">"Hallo der Hallo"</span>))
print(re.search(<span class="hljs-string">"der*"</span>, <span class="hljs-string">"Hallo derrr Hallo"</span>))
print(<span class="hljs-string">"="</span> * <span class="hljs-number">20</span>)
<span class="hljs-comment"># Der Character vor dem ? muss enthalten sein, kann auch</span>
<span class="hljs-comment"># mehrfach vorkommen.</span>
print(re.search(<span class="hljs-string">"der+"</span>, <span class="hljs-string">"Hallo de Hallo"</span>))
print(re.search(<span class="hljs-string">"der+"</span>, <span class="hljs-string">"Hallo der Hallo"</span>))
print(re.search(<span class="hljs-string">"der+"</span>, <span class="hljs-string">"Hallo derrr Hallo"</span>))
&lt;re.Match object; span=(<span class="hljs-number">6</span>, <span class="hljs-number">8</span>), match=<span class="hljs-string">'de'</span>&gt;
&lt;re.Match object; span=(<span class="hljs-number">6</span>, <span class="hljs-number">9</span>), match=<span class="hljs-string">'der'</span>&gt;
&lt;re.Match object; span=(<span class="hljs-number">6</span>, <span class="hljs-number">9</span>), match=<span class="hljs-string">'der'</span>&gt;
====================
&lt;re.Match object; span=(<span class="hljs-number">6</span>, <span class="hljs-number">8</span>), match=<span class="hljs-string">'de'</span>&gt;
&lt;re.Match object; span=(<span class="hljs-number">6</span>, <span class="hljs-number">9</span>), match=<span class="hljs-string">'der'</span>&gt;
&lt;re.Match object; span=(<span class="hljs-number">6</span>, <span class="hljs-number">11</span>), match=<span class="hljs-string">'derrr'</span>&gt;
====================
<span class="hljs-literal">None</span>
&lt;re.Match object; span=(<span class="hljs-number">6</span>, <span class="hljs-number">9</span>), match=<span class="hljs-string">'der'</span>&gt;
&lt;re.Match object; span=(<span class="hljs-number">6</span>, <span class="hljs-number">11</span>), match=<span class="hljs-string">'derrr'</span>&gt;
</div></code></pre>
<div style='page-break-after: always'></div>
<h3 id="106-zeitdifferenzen">10.6 Zeitdifferenzen</h3>
<p>Zeitdifferenzen lassen sich mit **timedelta berechnen.</p>
<pre class="hljs"><code><div><span class="hljs-keyword">from</span> datetime <span class="hljs-keyword">import</span> datetime, timedelta
now = datetime.now()
print(now)
print(now + timedelta(days = <span class="hljs-number">20</span>, hours = <span class="hljs-number">4</span> , minutes = <span class="hljs-number">3</span>, seconds = <span class="hljs-number">1</span>))
day = datetime(<span class="hljs-number">2017</span>, <span class="hljs-number">8</span> <span class="hljs-number">20</span>)
td = day - now
<span class="hljs-comment"># td.total_seconds() = Ausgabe in Sekunden</span>
<span class="hljs-comment"># td.total_minutes() = Ausgabe in Minuten</span>
<span class="hljs-comment"># td.total_hour() = Ausgabe in Stunden</span>
print(td)
print(datetime(<span class="hljs-number">2019</span>, <span class="hljs-number">1</span>, <span class="hljs-number">1</span>) + td)
</div></code></pre>
<div style='page-break-after: always'></div>
<h3 id="107-strings-formatieren">10.7 Strings formatieren</h3>
<p>Beispiele und Informationen über das Thema gibt es <a href="https://python-course.eu/python-tutorial/formatted-output.php" target="_blank">hier.</a></p>
<pre class="hljs"><code><div>n = <span class="hljs-number">5</span>
translation = {
<span class="hljs-string">"text1"</span>: <span class="hljs-string">"Ich habe {0} Hunde"</span>
}
print(translation[<span class="hljs-string">"text1"</span>].format(n))
<span class="hljs-comment"># oder auch</span>
print(<span class="hljs-string">"Ich habe {0} Hunde."</span>.format(<span class="hljs-number">3</span>))
print(<span class="hljs-string">"Ich habe {0} {1}."</span>.format(<span class="hljs-number">3</span>, <span class="hljs-string">"Hunde"</span>))
print(<span class="hljs-string">"Ich habe {0} {1} {0}."</span>.format(<span class="hljs-number">3</span>, <span class="hljs-string">"Hunde"</span>))
print(<span class="hljs-string">"Ich habe {number:.3f} {animal}."</span>.format(number = <span class="hljs-number">3</span>, animal = <span class="hljs-string">"Hunde"</span>))
<span class="hljs-comment"># Zahlen formatieren, Zahl mit 3 Nachkommastellen</span>
print(<span class="hljs-string">"Pi hat den Wert: {0:.3f}"</span>.format(<span class="hljs-number">3.1425926</span>))
</div></code></pre>
<p>Eine Übersicht über die verschiedenen Typen werden in der nächsten Tabelle aufgelistet.</p>
<table>
<thead>
<tr>
<th style="text-align:center">Typ</th>
<th>Beschreibung</th>
</tr>
</thead>
<tbody>
<tr>
<td style="text-align:center">d</td>
<td>Signed integer decimal</td>
</tr>
<tr>
<td style="text-align:center">i</td>
<td>Signed integer decimal</td>
</tr>
<tr>
<td style="text-align:center">o</td>
<td>Unsigned octal</td>
</tr>
<tr>
<td style="text-align:center">u</td>
<td>Obsolete and equivalent to d,i.e, signed integer decimal</td>
</tr>
<tr>
<td style="text-align:center">x</td>
<td>Unsigned hexadecimal (lowercase)</td>
</tr>
<tr>
<td style="text-align:center">X</td>
<td>Unsigned hexadecimal (uppercase)</td>
</tr>
<tr>
<td style="text-align:center">e</td>
<td>Foating point exponential format (lowercase)</td>
</tr>
<tr>
<td style="text-align:center">E</td>
<td>Foating point exponential format (uppercase)</td>
</tr>
<tr>
<td style="text-align:center">f</td>
<td>Floating point decimal format</td>
</tr>
<tr>
<td style="text-align:center">F</td>
<td>Floating point decimal format</td>
</tr>
<tr>
<td style="text-align:center">g</td>
<td>Same as &quot;e&quot; if exponent is greater than -4 or less than precision, &quot;f&quot; otherwise</td>
</tr>
<tr>
<td style="text-align:center">G</td>
<td>Same as &quot;E&quot; if exponent is greater than -4 or less than precision, &quot;F&quot; otherwise</td>
</tr>
<tr>
<td style="text-align:center">c</td>
<td>Single character (accepts integer or single character string)</td>
</tr>
<tr>
<td style="text-align:center">r</td>
<td>String (converts any python object using repr())</td>
</tr>
<tr>
<td style="text-align:center">s</td>
<td>String (converts any python object using str())</td>
</tr>
<tr>
<td style="text-align:center">%</td>
<td>No argument is converted, results in a &quot;%&quot; character in the result</td>
</tr>
</tbody>
</table>
<p>Weitere Beispiele</p>
<pre class="hljs"><code><div><span class="hljs-comment"># &lt; = left justify (default for strings), &gt; = right justify (default for numbers)</span>
print(<span class="hljs-string">"{0:&lt;20s} {1:6.2f}"</span>.format(<span class="hljs-string">"Himmel &amp; Hölle:"</span>, <span class="hljs-number">7.58</span>))
<span class="hljs-comment"># Die zwei * bei data </span>
data = dict(province=<span class="hljs-string">"Ontario"</span>,capital=<span class="hljs-string">"Toronto"</span>)
print(<span class="hljs-string">"The capital of {province} is {capital}"</span>.format(**data))
</div></code></pre>
<div style='page-break-after: always'></div>
<h3 id="108-defaultdict">10.8 DefaultDict</h3>
<p>Mit <strong>defaultdict</strong> kann man Einträge in ein Dictionary einfügen, wenn sie dort nicht vorhanden sind.</p>
<pre class="hljs"><code><div><span class="hljs-keyword">from</span> collections <span class="hljs-keyword">import</span> defaultdict
<span class="hljs-comment"># Beispiel 1</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">generate</span><span class="hljs-params">()</span>:</span>
print(<span class="hljs-string">"generate() wurde aufgerufen!"</span>)
<span class="hljs-keyword">return</span> <span class="hljs-number">0</span>
<span class="hljs-comment"># generate wird ohne die () geschrieben, ansonsten wird die Funktion</span>
<span class="hljs-comment"># sofort gestartet.</span>
d = defaultdict(generate)
d[<span class="hljs-string">"existiertNicht"</span>] = d[<span class="hljs-string">"existiertNicht"</span>] + <span class="hljs-number">5</span>
<span class="hljs-comment"># Beispiel 2</span>
<span class="hljs-comment"># int ist auch eine Funktion int()</span>
p = defaultdict(int)
words = [<span class="hljs-string">"Harry"</span>, <span class="hljs-string">"Paul"</span>, <span class="hljs-string">"Harry"</span>]
<span class="hljs-keyword">for</span> word <span class="hljs-keyword">in</span> words:
p[word] = p[word] + <span class="hljs-number">1</span>
print(p)
</div></code></pre>
<div style='page-break-after: always'></div>
<h3 id="109-tabellen">10.9 Tabellen</h3>
<p>In kombination von <strong>pandas</strong> und <strong>tabulate</strong> kann man schöne Tabellen erstellen. Das Module tabulate muss mit pip installiert werden, gegebenenfalls auch pandas. Das Datenquelle kann eine Liste sein oder auch eine CSV-Datei.<br>
Hier kommt ein Beispiel mit einer Liste:</p>
<pre class="hljs"><code><div><span class="hljs-comment">#!/usr/bin/env python3</span>
<span class="hljs-comment">#-*- coding: utf-8 -*-</span>
<span class="hljs-keyword">import</span> os, sys, sqlite3
<span class="hljs-keyword">import</span> pandas <span class="hljs-keyword">as</span> pd
<span class="hljs-comment"># Laden mit: pip install tabulate</span>
<span class="hljs-keyword">from</span> tabulate <span class="hljs-keyword">import</span> tabulate <span class="hljs-keyword">as</span> tb
data = [(<span class="hljs-string">'d'</span>,<span class="hljs-string">'Signed integer decimal'</span>),
(<span class="hljs-string">'i'</span>,<span class="hljs-string">'Signed integer decimal'</span>),
(<span class="hljs-string">'o'</span>,<span class="hljs-string">'Unsigned octal'</span>),
(<span class="hljs-string">'u'</span>,<span class="hljs-string">'Obsolete and equivalent to d,i.e, signed integer decimal'</span>),
(<span class="hljs-string">'x'</span>,<span class="hljs-string">'Unsigned hexadecimal (lowercase)'</span>),
(<span class="hljs-string">'X'</span>,<span class="hljs-string">'Unsigned hexadecimal (uppercase)'</span>),
(<span class="hljs-string">'e'</span>,<span class="hljs-string">'Foating point exponential format (lowercase)'</span>),
(<span class="hljs-string">'E'</span>,<span class="hljs-string">'Foating point exponential format (lowercase)'</span>),
(<span class="hljs-string">'f'</span>,<span class="hljs-string">'Floating point decimal format'</span>),
(<span class="hljs-string">'F'</span>,<span class="hljs-string">'Floating point decimal format'</span>),
(<span class="hljs-string">'g'</span>,<span class="hljs-string">'Same as "e" if exponent is greater than -4 or less than precision, "f" otherwise.'</span>),
(<span class="hljs-string">'G'</span>,<span class="hljs-string">'Same as "E" if exponent is greater than -4 or less than precision, "F" otherwise.'</span>),
(<span class="hljs-string">'c'</span>,<span class="hljs-string">'Single character (accepts integer or single character string).'</span>),
(<span class="hljs-string">'r'</span>,<span class="hljs-string">'String (converts any python object using repr()).'</span>),
(<span class="hljs-string">'s'</span>,<span class="hljs-string">'String (converts any python object using str()).'</span>),
(<span class="hljs-string">'%'</span>,<span class="hljs-string">'No argument is converted, results in a "%" character in the result.'</span>)]
pd.set_option(<span class="hljs-string">"display.colheader_justify"</span>, <span class="hljs-string">"left"</span>) <span class="hljs-comment"># left, right, center</span>
pd.set_option(<span class="hljs-string">"display.max_rows"</span>, <span class="hljs-literal">None</span>) <span class="hljs-comment"># display all rows</span>
<span class="hljs-comment"># Ausgabe nur mit pandas</span>
col = [ <span class="hljs-string">'Type'</span>, <span class="hljs-string">' Description'</span>]
print(pd.DataFrame(data, columns=col))
<span class="hljs-comment"># Ausgabe mit tabulate</span>
df = pd.DataFrame(data, columns=col)
<span class="hljs-comment"># Mit tabulate kann man eine Tabelle erzeugen</span>
print(tb(df, showindex=<span class="hljs-literal">False</span>, headers=df.columns))
</div></code></pre>
<div style='page-break-after: always'></div>
<h2 id="11-diverses">11. Diverses</h2>
<p>Folgende Themen werden hier beschrieben:</p>
<ul>
<li>Eingaben von der Kommandozeile einlesen und verarbeiten</li>
<li>Parameter übergeben (sys.argv und argparse)</li>
<li>Mit Pfadangaben arbeiten</li>
<li>Umlaute und Kodierungen</li>
</ul>
<h3 id="111-eingaben-einlesen">11.1 Eingaben einlesen</h3>
<p>Eingaben werden mit der Funktion <strong>input()</strong> eingelesen.</p>
<pre class="hljs"><code><div>age = input(<span class="hljs-string">"Bitte gebe dein Alter ein: "</span>)
print(<span class="hljs-string">"Du bist {0} Jahre alt"</span>.format(age))
<span class="hljs-comment"># Anderes Beispiel</span>
age1 = input(<span class="hljs-string">"Gebe das Alter von Person A ein: "</span>)
age2 = input(<span class="hljs-string">"Gebe das Alter von Person B ein: "</span>)
print(age1)
print(age2)
print(<span class="hljs-string">"Person A + Person B"</span>)
print(int(age1) + int(age2))
print(float(age1) + float(age2))
<span class="hljs-comment"># Noch ein Beispiel</span>
hight_str = input(<span class="hljs-string">"Körpergröße eingeben (m): "</span>)
weight_str = input(<span class="hljs-string">" Gewicht eingeben: "</span>)
<span class="hljs-comment"># Größe und Gewicht kann auch mit Komma eingeben werden</span>
hight = float(hight_str.replace(<span class="hljs-string">","</span>, <span class="hljs-string">"."</span>))
weight = float(weight_str.replace(<span class="hljs-string">","</span>, <span class="hljs-string">"."</span>))
bmi = weight / hight ** <span class="hljs-number">2</span>
print(<span class="hljs-string">"Der BMI ist: "</span> + str(round(bmi, <span class="hljs-number">1</span>)))
</div></code></pre>
<div style='page-break-after: always'></div>
<h3 id="112-parameter-%C3%BCbergeben">11.2 Parameter übergeben</h3>
<h4 id="1121-sysargs">11.2.1 sys.args</h4>
<p>Parameter werden mit <strong>sys.argv</strong> eingelesen und verarbeitet.</p>
<pre class="hljs"><code><div><span class="hljs-keyword">import</span> sys
print(sys.argv)
<span class="hljs-keyword">if</span> len(sys.argv) &gt;= <span class="hljs-number">2</span>:
filename = sys.argv[<span class="hljs-number">1</span>]
<span class="hljs-keyword">with</span> open(filename, <span class="hljs-string">"r"</span>) <span class="hljs-keyword">as</span> file:
counter = <span class="hljs-number">0</span>
<span class="hljs-keyword">for</span> line <span class="hljs-keyword">in</span> file:
counter += <span class="hljs-number">1</span>
print(<span class="hljs-string">"Anzahl Zeilen: {0}"</span>.format(counter))
<span class="hljs-keyword">else</span>:
print(<span class="hljs-string">"Filename missing!"</span>)
</div></code></pre>
<h4 id="1122-argsparse">11.2.2 argsparse</h4>
<p>Eine Alternative zu <strong>sys.argv</strong> ist <strong>argparse</strong> zu verwenden. Dieses hat den Vorteil, das z.B. automatisch eine Hilfe Funktion zu Verfügung steht. Hier ein erstes Beispiel für argparse.</p>
<pre class="hljs"><code><div><span class="hljs-keyword">import</span> argparse
parser = argparse.ArgumentParser(description=<span class="hljs-string">'Mein erstes Programm.'</span>)
parser.add_argument(
<span class="hljs-string">"-v"</span>,
<span class="hljs-string">"--version"</span>,
help=<span class="hljs-string">"Zeigt die Version an."</span>
)
args = parser.parse_args()
print(<span class="hljs-string">"args.version)
</span></div></code></pre>
<p>Folgende Parameter können für <strong>argparse.ArgumentParser</strong> verwendet werden:
|--|--|</p>
<table>
<thead>
<tr>
<th>Parameter</th>
<th>Beschreigung</th>
</tr>
</thead>
<tbody>
<tr>
<td>prog</td>
<td>Name des Programms, überschreibt den Standardwert os.path.basename(sys.argv[0])</td>
</tr>
<tr>
<td>usage</td>
<td>Usage des Programms, überschreibt den Standard der automatisch erstellt wird</td>
</tr>
<tr>
<td>description</td>
<td>Beschreibung des Programms</td>
</tr>
<tr>
<td>epilog</td>
<td>Am Ende der Hilfe auzugebener Text</td>
</tr>
<tr>
<td>parents</td>
<td></td>
</tr>
<tr>
<td>formatter_class</td>
<td></td>
</tr>
<tr>
<td>prefix_chars</td>
<td>Setzt des Prefix für die Optionalen Parameter, default '-'</td>
</tr>
</tbody>
</table>
<h3 id="113-mit-pfadangaben-arbeiten">11.3 Mit Pfadangaben arbeiten</h3>
<pre class="hljs"><code><div><span class="hljs-keyword">import</span> os
print(os.listdir(<span class="hljs-string">"."</span>))
<span class="hljs-comment"># Pfad und Name der aktuellen Datei</span>
<span class="hljs-comment"># __file__ gibt den Pfad aus, wo die aktuelle Datei sich befindet.</span>
print(__file__)
print(os.path.dirname(__file__))
<span class="hljs-keyword">with</span> open(os.path.join(os.path.dirname(__file__), <span class="hljs-string">"datei.txt"</span>), <span class="hljs-string">"r"</span>) <span class="hljs-keyword">as</span> file:
<span class="hljs-keyword">for</span> line <span class="hljs-keyword">in</span> file:
print(line)
<span class="hljs-comment"># List Directory mit Angabe Pfad</span>
<span class="hljs-comment"># os.path.join können auch mehrere Werte angegeben werden</span>
<span class="hljs-comment"># Beispiel:</span>
<span class="hljs-comment"># os.path.join(os.path.dirname(__file__), "ordner", "unterordner", "datei.txt")</span>
folder = os.path.join(os.path.dirname(__file__), <span class="hljs-string">".."</span>)
<span class="hljs-keyword">for</span> file <span class="hljs-keyword">in</span> os.listdir(folder):
file_path = os.path.join(folder, file)
print(file_path)
<span class="hljs-keyword">if</span> os.path.isdir(file_path):
print(file + <span class="hljs-string">" ist ein Ordner"</span>)
<span class="hljs-keyword">else</span>:
print(file + <span class="hljs-string">" ist eine Datei"</span>)
</div></code></pre>
<p>Alle Dateien auflisten, öffnen und nach einem Vornamen suchen.</p>
<pre class="hljs"><code><div><span class="hljs-keyword">import</span> os
folder = <span class="hljs-string">r"C:\Users\uws\Documents\PythonProjekt\names"</span>
counter = <span class="hljs-number">0</span>
<span class="hljs-keyword">for</span> file <span class="hljs-keyword">in</span> os.listdir(folder):
<span class="hljs-comment"># nex 2 lines for debug</span>
<span class="hljs-comment">#file_path = os.path.join(folder, file)</span>
<span class="hljs-comment">#print(file_path)</span>
<span class="hljs-keyword">with</span> open(os.path.join(folder, file), <span class="hljs-string">"r"</span>, encoding=<span class="hljs-string">"utf-8"</span>) <span class="hljs-keyword">as</span> file:
<span class="hljs-keyword">for</span> line <span class="hljs-keyword">in</span> file:
<span class="hljs-keyword">if</span> line.strip().split(<span class="hljs-string">" "</span>)[<span class="hljs-number">0</span>] == <span class="hljs-string">"Max"</span>:
counter += <span class="hljs-number">1</span>
print(<span class="hljs-string">" --&gt; Max found."</span>)
print(counter)
</div></code></pre>
<div style='page-break-after: always'></div>
<h3 id="114-umlaute-und-kodierungen">11.4 Umlaute und Kodierungen</h3>
<p>Bei dem lesen und schreiben einer Datei sollte die <strong>encoding</strong> angegeben werden.</p>
<pre class="hljs"><code><div><span class="hljs-keyword">import</span> os
filename = os.path.join(os.path.dirname(__file__), <span class="hljs-string">"datei.txt"</span>)
<span class="hljs-keyword">with</span> open(filename, <span class="hljs-string">"r"</span>, encoding=<span class="hljs-string">"utf-8"</span>) <span class="hljs-keyword">as</span> file:
<span class="hljs-keyword">for</span> line <span class="hljs-keyword">in</span> file:
print(line)
filename_out = os.path.join(os.path.dirname(__file__), <span class="hljs-string">"umlaute.txt"</span>)
<span class="hljs-keyword">with</span> open(filename_out, <span class="hljs-string">"a"</span>, encoding=<span class="hljs-string">"utf-8"</span>) <span class="hljs-keyword">as</span> file:
file.write(<span class="hljs-string">"Müller"</span>)
</div></code></pre>
<div style='page-break-after: always'></div>
<h2 id="12-jupyter-notebook">12. Jupyter Notebook</h2>
<h3 id="121-widgets">12.1 Widgets</h3>
<p>In einem Jupyter Notebook Buttons zu platzieren. Eine Übersicht aller Widgets gibt es <a href="https://ipywidgets.readthedocs.io/en/stable/examples/Widget%20List.html#Complete-list">hier</a></p>
<pre class="hljs"><code><div><span class="hljs-keyword">import</span> ipywidgets <span class="hljs-keyword">as</span> widgets
<span class="hljs-keyword">from</span> IPython.display impoer display
widgets.Button(description=<span class="hljs-string">"Mein Text"</span>)
widgets.Text(description=<span class="hljs-string">"Mein Text"</span>, value=<span class="hljs-string">"123"</span>)
widgets.IntText(description=<span class="hljs-string">"Mein Text"</span>, value=<span class="hljs-string">"123"</span>)
widgets.FloatText(description=<span class="hljs-string">"Mein Text"</span>, value=<span class="hljs-string">"123.5"</span>)
widgets.Checkbox(description=<span class="hljs-string">"Beschriftung"</span>, value=<span class="hljs-literal">False</span>)
widgets.RadioButtons(
options=[<span class="hljs-string">"Herne"</span>, <span class="hljs-string">"Goch"</span>, <span class="hljs-string">"Hilden"</span>],
description=<span class="hljs-string">'Welche Stadt.'</span>,
disable=<span class="hljs-literal">False</span>
)
widgets.Dropdown(
options=[<span class="hljs-string">"Herne"</span>, <span class="hljs-string">"Goch"</span>, <span class="hljs-string">"Hilden"</span>],
description=<span class="hljs-string">"Stadt auswählen."</span>,
disable=<span class="hljs-literal">False</span>
)
</div></code></pre>
<div style='page-break-after: always'></div>
<h3 id="122-interaktion-mit-widgets">12.2 Interaktion mit Widgets</h3>
<pre class="hljs"><code><div><span class="hljs-keyword">import</span> ipywidgets <span class="hljs-keyword">as</span> widgets
<span class="hljs-keyword">from</span> IPython.display impoer display
age = widgets.InText(description=<span class="hljs-string">"Alter: "</span>, value=<span class="hljs-number">25</span>)
<span class="hljs-comment"># Mit display wird die Variable aufgerufen und dadurch auch das Objekt.</span>
display(age)
<span class="hljs-comment"># In value steht dann der Wert drin</span>
print(age.value)
button = widgets.Button(description=<span class="hljs-string">"Ok"</span>)
display(button)
<span class="hljs-comment"># Ein Parameter wird bei dem Aufruf der Funktion übergeben.</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">on_button_click</span><span class="hljs-params">(p)</span>:</span>
print(p)
print(<span class="hljs-string">"on_button_click()"</span>)
<span class="hljs-comment"># Wenn geklickt wird: on_button_click(button)</span>
button.on_click(on_button_click)
</div></code></pre>
<div style='page-break-after: always'></div>
<p>Beispiel eine CSV-Datei schreiben mit Eingabe in Felder.</p>
<pre class="hljs"><code><div><span class="hljs-keyword">import</span> csv
<span class="hljs-keyword">import</span> ipywidgets <span class="hljs-keyword">as</span> widgets
<span class="hljs-keyword">from</span> IPython.display <span class="hljs-keyword">import</span> display
firstname = widgets.Text(description=<span class="hljs-string">"Vorname:"</span>, value=<span class="hljs-string">""</span>)
display(firstname)
lastname = widgets.Text(description=<span class="hljs-string">"Nachname:"</span>, value=<span class="hljs-string">""</span>)
display(lastname)
subjects_options = [
<span class="hljs-string">"---"</span>,
<span class="hljs-string">"Mathe"</span>,
<span class="hljs-string">"Informatic"</span>,
<span class="hljs-string">"Philosophie"</span>,
<span class="hljs-string">"Kulturwissenschaften"</span>,
<span class="hljs-string">"Chemie"</span>
]
subject = widgets.Dropdown(description=<span class="hljs-string">"Fach:"</span>, options=subjects_options)
display(subject)
button = widgets.Button(description=<span class="hljs-string">"Speichern"</span>)
display(button)
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">button_click</span><span class="hljs-params">(event)</span>:</span>
firstname_value = firstname.value
lastname_value = lastname.value
subject_value = subject.value
<span class="hljs-keyword">if</span> firstname_value != <span class="hljs-string">""</span> <span class="hljs-keyword">and</span> lastname_value != <span class="hljs-string">""</span> <span class="hljs-keyword">and</span> subject_value != <span class="hljs-string">"---"</span>:
<span class="hljs-keyword">with</span> open(<span class="hljs-string">"./students.csv"</span>, <span class="hljs-string">"a"</span>, newline=<span class="hljs-string">""</span>, encoding=<span class="hljs-string">"utf-8"</span>) <span class="hljs-keyword">as</span> f:
writer = csv.writer(f, delimiter=<span class="hljs-string">";"</span>)
writer.writerow([firstname_value, lastname_value, subject_value])
firstname.value = <span class="hljs-string">""</span>
lastname.value = <span class="hljs-string">""</span>
subject.value = <span class="hljs-string">"---"</span>
<span class="hljs-keyword">else</span>:
print(<span class="hljs-string">"Bitte das Formular korrekt ausfüllen!"</span>)
button.on_click(button_click)
</div></code></pre>
<div style='page-break-after: always'></div>
<h2 id="13-flask">13. Flask</h2>
<p>Mit <strong>Flask</strong> kann man mit Python Web-Seiten erstellen. Flask benutzt für die Templates <strong>Jinja2</strong>. weitere Informationen gibt es <a href="https://pypi.org/project/Jinja2/">hier</a> und <a href="http://jinja.octoprint.org/">hier</a>. Die Vorlagen müssen sich in dem Verzeichnis <strong>templates</strong> sich befinden und die Stylesheets in dem Verzeichnis <strong>static</strong>. Das <strong>Skeleton Framework</strong> für das CSS gibt es <a href="https://skeleton-framework.github.io/">hier</a>. Das Framework <strong>SQLAlchemy</strong> ist dazu da, sich mit relationalen Datenbanken zu Verbinden und mit diesen zu interagieren. <a href="https://www.sqlalchemy.org/">Hier</a> geht es zur Projekt Seite. <br>
Um den Flask Entwicklungs Web-Server zu starten, wechselt man in der Dos-Shell in das Projekt Verzeichnis und gibt folgendes ein:</p>
<pre class="hljs"><code><div>set FLASK_APP=WebSite.py
:: FLASK_DEBUG=1 -&gt; aktualisiert automatisch die Web-Seiten
:: Steht der Parameter auf 0, so muss der Web-Server neu gestartet
:: werden, wenn es Änderungen im Programm gibt.
set FLASK_DEBUG=1
flask run
</div></code></pre>
<p>Eine Übersicht der Verzeichnisse, die für die Webseite benötigt werden und die Einstellungen in PyCharm. <br>
<img src="FlaskDirectory.png" title="Flask Projekt Verzeichnisse" />
<img src="FlaskConfigPyCharm.png" title="Flask Config PyCharm" /></p>
<div style='page-break-after: always'></div>
<h3 id="131-web-seite">13.1 Web-Seite</h3>
<p>templates/layouts/main.html</p>
<pre class="hljs"><code><div><span class="hljs-meta">&lt;!DOCTYPE <span class="hljs-meta-keyword">html</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">html</span> <span class="hljs-attr">lang</span>=<span class="hljs-string">"en"</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">head</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">meta</span> <span class="hljs-attr">charset</span>=<span class="hljs-string">"UTF-8"</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">link</span> <span class="hljs-attr">rel</span>=<span class="hljs-string">"stylesheet"</span> <span class="hljs-attr">href</span>=<span class="hljs-string">"static/style.css"</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">link</span> <span class="hljs-attr">rel</span>=<span class="hljs-string">"stylesheet"</span> <span class="hljs-attr">href</span>=<span class="hljs-string">"static/skeleton/skeleton.css"</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">link</span> <span class="hljs-attr">rel</span>=<span class="hljs-string">"stylesheet"</span> <span class="hljs-attr">href</span>=<span class="hljs-string">"static/skelton/normalize.css"</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">title</span>&gt;</span>Seab@er Software Blog<span class="hljs-tag">&lt;/<span class="hljs-name">title</span>&gt;</span>
<span class="hljs-tag">&lt;/<span class="hljs-name">head</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">body</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">div</span> <span class="hljs-attr">class</span>=<span class="hljs-string">"container"</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">ul</span> <span class="hljs-attr">class</span>=<span class="hljs-string">"navigation"</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">li</span> <span class="hljs-attr">class</span>=<span class="hljs-string">"navigation-item"</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">a</span> <span class="hljs-attr">href</span>=<span class="hljs-string">"/"</span>&gt;</span>Startseite<span class="hljs-tag">&lt;/<span class="hljs-name">a</span>&gt;</span>
<span class="hljs-tag">&lt;/<span class="hljs-name">li</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">li</span> <span class="hljs-attr">class</span>=<span class="hljs-string">"navigation-item"</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">a</span> <span class="hljs-attr">href</span>=<span class="hljs-string">"/test"</span>&gt;</span>Testseite<span class="hljs-tag">&lt;/<span class="hljs-name">a</span>&gt;</span>
<span class="hljs-tag">&lt;/<span class="hljs-name">li</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">li</span> <span class="hljs-attr">class</span>=<span class="hljs-string">"navigation-item"</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">a</span> <span class="hljs-attr">href</span>=<span class="hljs-string">"/table"</span>&gt;</span>Tabelle<span class="hljs-tag">&lt;/<span class="hljs-name">a</span>&gt;</span>
<span class="hljs-tag">&lt;/<span class="hljs-name">li</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">li</span> <span class="hljs-attr">class</span>=<span class="hljs-string">"navigation-item"</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">a</span> <span class="hljs-attr">href</span>=<span class="hljs-string">"/currency"</span>&gt;</span>Currency<span class="hljs-tag">&lt;/<span class="hljs-name">a</span>&gt;</span>
<span class="hljs-tag">&lt;/<span class="hljs-name">li</span>&gt;</span>
<span class="hljs-tag">&lt;/<span class="hljs-name">ul</span>&gt;</span>
<span class="hljs-comment">&lt;!-- &amp;nbsp ist ein Leerzeichen --&gt;</span>
<span class="hljs-comment">&lt;!-- Mit clear werden die Eigenschaften zurückgesetzt --&gt;</span>
<span class="hljs-comment">&lt;!-- navigation und navigation-item --&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">div</span> <span class="hljs-attr">style</span>=<span class="hljs-string">"clear: both;"</span>&gt;</span><span class="hljs-symbol">&amp;nbsp;</span><span class="hljs-tag">&lt;/<span class="hljs-name">div</span>&gt;</span>
{% block content %}{% endblock %}
{% extends "layouts/footer.html" %}
<span class="hljs-tag">&lt;/<span class="hljs-name">div</span>&gt;</span>
<span class="hljs-tag">&lt;/<span class="hljs-name">body</span>&gt;</span>
<span class="hljs-tag">&lt;/<span class="hljs-name">html</span>&gt;</span>
</div></code></pre>
<div style='page-break-after: always'></div>
<p>templates/layouts/footer.html</p>
<pre class="hljs"><code><div><span class="hljs-tag">&lt;<span class="hljs-name">p</span>&gt;</span>Footer: {{ company }}<span class="hljs-tag">&lt;/<span class="hljs-name">p</span>&gt;</span>
</div></code></pre>
<p>templates/start.html</p>
<pre class="hljs"><code><div>{% extends "layouts/main.html" %}
{% block content %}
<span class="hljs-tag">&lt;<span class="hljs-name">h1</span>&gt;</span>Ich bin die start.html - Datei.<span class="hljs-tag">&lt;/<span class="hljs-name">h1</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">p</span>&gt;</span>{{ name }}<span class="hljs-tag">&lt;/<span class="hljs-name">p</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">p</span>&gt;</span>{{ person[1] }}, {{ person[0] }}<span class="hljs-tag">&lt;/<span class="hljs-name">p</span>&gt;</span>
<span class="hljs-comment">&lt;!-- Liste ausgeben --&gt;</span>
{% for item in items %}
<span class="hljs-tag">&lt;<span class="hljs-name">p</span> <span class="hljs-attr">class</span>=<span class="hljs-string">"wichtig"</span>&gt;</span>{{ item }}<span class="hljs-tag">&lt;/<span class="hljs-name">p</span>&gt;</span>
{% endfor %}
<span class="hljs-comment">&lt;!-- Dictionary ausgeben --&gt;</span>
{% for item in dict1 %}
<span class="hljs-tag">&lt;<span class="hljs-name">p</span> <span class="hljs-attr">class</span>=<span class="hljs-string">"wichtig"</span>&gt;</span>{{ item.name }} (Anzahl: {{ item.amount }} mal)<span class="hljs-tag">&lt;/<span class="hljs-name">p</span>&gt;</span>
{% endfor %}
{% for item in dict2 %}
<span class="hljs-tag">&lt;<span class="hljs-name">p</span> <span class="hljs-attr">class</span>=<span class="hljs-string">"obst"</span>&gt;</span>{{ item.name }} (Anzahl: {{ item.amount }} Stück)<span class="hljs-tag">&lt;/<span class="hljs-name">p</span>&gt;</span>
{% endfor %}
<span class="hljs-tag">&lt;<span class="hljs-name">p</span>&gt;</span>{{ text1 }}<span class="hljs-tag">&lt;/<span class="hljs-name">p</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">p</span>&gt;</span>{{ text2 }}<span class="hljs-tag">&lt;/<span class="hljs-name">p</span>&gt;</span>
{% endblock %}
</div></code></pre>
<div style='page-break-after: always'></div>
<p>templates/test.html</p>
<pre class="hljs"><code><div>{% extends "layouts/main.html" %}
{% block content %}
{% if name != None: %}
<span class="hljs-tag">&lt;<span class="hljs-name">h1</span>&gt;</span>Der Name ist: {{ name }} und du bist {{ age }} alt.<span class="hljs-tag">&lt;/<span class="hljs-name">h1</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">p</span>&gt;</span>Dein Passwort lautet: {{ passwd }}<span class="hljs-tag">&lt;/<span class="hljs-name">p</span>&gt;</span>
{% endif %}
<span class="hljs-tag">&lt;<span class="hljs-name">form</span> <span class="hljs-attr">method</span>=<span class="hljs-string">"get"</span>&gt;</span>
<span class="hljs-comment">&lt;!-- Die Angabe nach for bezieht sich auf die id --&gt;</span>
<span class="hljs-comment">&lt;!-- Folgende Input Typen gibt es:
button, checkbox, color, date, datetime-local, email, file, hidden,
image, month, number, password, radio, range, reset, search, submit,
tel, text, time, url, week.
https://www.w3schools.com/html/html_form_input_types.asp
--&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">label</span> <span class="hljs-attr">for</span>=<span class="hljs-string">"name"</span>&gt;</span>Name: <span class="hljs-tag">&lt;/<span class="hljs-name">label</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">input</span> <span class="hljs-attr">type</span>=<span class="hljs-string">"text"</span> <span class="hljs-attr">name</span>=<span class="hljs-string">"name"</span> <span class="hljs-attr">id</span>=<span class="hljs-string">"name"</span> <span class="hljs-attr">value</span>=<span class="hljs-string">"{% if name != None %}{{ name }}{% endif %}"</span> /&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">label</span> <span class="hljs-attr">for</span>=<span class="hljs-string">"age"</span>&gt;</span>Alter: <span class="hljs-tag">&lt;/<span class="hljs-name">label</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">input</span> <span class="hljs-attr">type</span>=<span class="hljs-string">"text"</span> <span class="hljs-attr">name</span>=<span class="hljs-string">"age"</span> <span class="hljs-attr">id</span>=<span class="hljs-string">"age"</span> <span class="hljs-attr">value</span>=<span class="hljs-string">"{% if age != None %}{{ age }}{% endif %}"</span> /&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">label</span> <span class="hljs-attr">for</span>=<span class="hljs-string">"passwd"</span>&gt;</span>Passwort:<span class="hljs-tag">&lt;/<span class="hljs-name">label</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">input</span> <span class="hljs-attr">type</span>=<span class="hljs-string">"password"</span> <span class="hljs-attr">name</span>=<span class="hljs-string">"passwd"</span> <span class="hljs-attr">id</span>=<span class="hljs-string">"passwd"</span> /&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">br</span> /&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">input</span> <span class="hljs-attr">type</span>=<span class="hljs-string">"submit"</span> <span class="hljs-attr">value</span>=<span class="hljs-string">"Formular abschicken!"</span> /&gt;</span>
<span class="hljs-tag">&lt;/<span class="hljs-name">form</span>&gt;</span>
{% endblock %}
</div></code></pre>
<div style='page-break-after: always'></div>
<p>templates/table.html</p>
<pre class="hljs"><code><div>{% extends "layouts/main.html" %}
{% block content %}
<span class="hljs-comment">&lt;!-- Zwei Tabellen nebeneinander --&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">div</span> <span class="hljs-attr">class</span>=<span class="hljs-string">"row"</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">div</span> <span class="hljs-attr">class</span>=<span class="hljs-string">"six columns"</span>&gt;</span>
Erste Tabelle
<span class="hljs-tag">&lt;<span class="hljs-name">table</span> <span class="hljs-attr">class</span>=<span class="hljs-string">"u-full-width"</span>&gt;</span>
<span class="hljs-comment">&lt;!-- Überschrift --&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">thead</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">tr</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">th</span>&gt;</span>Text<span class="hljs-tag">&lt;/<span class="hljs-name">th</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">th</span>&gt;</span>Parameter<span class="hljs-tag">&lt;/<span class="hljs-name">th</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">th</span>&gt;</span>Beschreibung<span class="hljs-tag">&lt;/<span class="hljs-name">th</span>&gt;</span>
<span class="hljs-tag">&lt;/<span class="hljs-name">tr</span>&gt;</span>
<span class="hljs-tag">&lt;/<span class="hljs-name">thead</span>&gt;</span>
<span class="hljs-comment">&lt;!-- Inhalt der Tabelle --&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">body</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">tr</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">td</span>&gt;</span>Zelle 1<span class="hljs-tag">&lt;/<span class="hljs-name">td</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">td</span>&gt;</span>-p<span class="hljs-tag">&lt;/<span class="hljs-name">td</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">td</span>&gt;</span>Print Dokument<span class="hljs-tag">&lt;/<span class="hljs-name">td</span>&gt;</span>
<span class="hljs-tag">&lt;/<span class="hljs-name">tr</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">tr</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">td</span>&gt;</span>Harry<span class="hljs-tag">&lt;/<span class="hljs-name">td</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">td</span>&gt;</span>Hirsch<span class="hljs-tag">&lt;/<span class="hljs-name">td</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">td</span>&gt;</span>Waldweg<span class="hljs-tag">&lt;/<span class="hljs-name">td</span>&gt;</span>
<span class="hljs-tag">&lt;/<span class="hljs-name">tr</span>&gt;</span>
<span class="hljs-tag">&lt;/<span class="hljs-name">body</span>&gt;</span>
<span class="hljs-tag">&lt;/<span class="hljs-name">table</span>&gt;</span>
<span class="hljs-tag">&lt;/<span class="hljs-name">div</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">div</span> <span class="hljs-attr">class</span>=<span class="hljs-string">"six columns"</span>&gt;</span>
Zweite Tabelle
<span class="hljs-tag">&lt;/<span class="hljs-name">div</span>&gt;</span>
<span class="hljs-tag">&lt;/<span class="hljs-name">div</span>&gt;</span>
{% endblock %}
</div></code></pre>
<div style='page-break-after: always'></div>
<p>templates/currency.html</p>
<pre class="hljs"><code><div>{% extends "layouts/main.html" %}
{% block content %}
<span class="hljs-tag">&lt;<span class="hljs-name">div</span> <span class="hljs-attr">class</span>=<span class="hljs-string">"row"</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">div</span> <span class="hljs-attr">class</span>=<span class="hljs-string">"four columns"</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">form</span> <span class="hljs-attr">methode</span>=<span class="hljs-string">"get"</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">label</span> <span class="hljs-attr">for</span>=<span class="hljs-string">"curency1"</span>&gt;</span>Währung: <span class="hljs-tag">&lt;/<span class="hljs-name">label</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">input</span> <span class="hljs-attr">type</span>=<span class="hljs-string">"text"</span> <span class="hljs-attr">name</span>=<span class="hljs-string">"currency1"</span> <span class="hljs-attr">value</span>=<span class="hljs-string">"{{ currency1 }}"</span> <span class="hljs-attr">id</span>=<span class="hljs-string">"currency1"</span> /&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">label</span> <span class="hljs-attr">for</span>=<span class="hljs-string">"curency2"</span>&gt;</span>Währung: <span class="hljs-tag">&lt;/<span class="hljs-name">label</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">input</span> <span class="hljs-attr">type</span>=<span class="hljs-string">"text"</span> <span class="hljs-attr">name</span>=<span class="hljs-string">"currency2"</span> <span class="hljs-attr">value</span>=<span class="hljs-string">"{{ currency2 }}"</span> <span class="hljs-attr">id</span>=<span class="hljs-string">"currency2"</span> /&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">label</span> <span class="hljs-attr">for</span>=<span class="hljs-string">"rate"</span>&gt;</span>Wechselkurs: <span class="hljs-tag">&lt;/<span class="hljs-name">label</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">input</span> <span class="hljs-attr">type</span>=<span class="hljs-string">"text"</span> <span class="hljs-attr">name</span>=<span class="hljs-string">"rate"</span> <span class="hljs-attr">value</span>=<span class="hljs-string">"{{ rate }}"</span> <span class="hljs-attr">id</span>=<span class="hljs-string">"rate"</span> /&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">br</span> /&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">input</span> <span class="hljs-attr">type</span>=<span class="hljs-string">"submit"</span> <span class="hljs-attr">value</span>=<span class="hljs-string">"Währung umrechnen!"</span> /&gt;</span>
<span class="hljs-tag">&lt;/<span class="hljs-name">form</span>&gt;</span>
<span class="hljs-tag">&lt;/<span class="hljs-name">div</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">div</span> <span class="hljs-attr">class</span>=<span class="hljs-string">"four columns"</span>&gt;</span>
Umrechnung {{ currency1 }} nach {{ currency2 }}.
<span class="hljs-tag">&lt;<span class="hljs-name">table</span> <span class="hljs-attr">class</span>=<span class="hljs-string">"u-full-width"</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">thead</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">tr</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">th</span>&gt;</span>{{ currency1 }}<span class="hljs-tag">&lt;/<span class="hljs-name">th</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">th</span>&gt;</span>{{ currency2 }}<span class="hljs-tag">&lt;/<span class="hljs-name">th</span>&gt;</span>
<span class="hljs-tag">&lt;/<span class="hljs-name">tr</span>&gt;</span>
<span class="hljs-tag">&lt;/<span class="hljs-name">thead</span>&gt;</span>
<span class="hljs-tag">&lt;/<span class="hljs-name">tbody</span>&gt;</span>
{% for row in table1 %}
<span class="hljs-tag">&lt;<span class="hljs-name">tr</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">td</span>&gt;</span>{{ row[0] }}<span class="hljs-tag">&lt;/<span class="hljs-name">td</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">td</span>&gt;</span>{{ row[1] }}<span class="hljs-tag">&lt;/<span class="hljs-name">td</span>&gt;</span>
<span class="hljs-tag">&lt;/<span class="hljs-name">tr</span>&gt;</span>
{% endfor %}
<span class="hljs-tag">&lt;/<span class="hljs-name">tbody</span>&gt;</span>
<span class="hljs-tag">&lt;/<span class="hljs-name">table</span>&gt;</span>
<span class="hljs-tag">&lt;/<span class="hljs-name">div</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">div</span> <span class="hljs-attr">class</span>=<span class="hljs-string">"four columns"</span>&gt;</span>
Umrechnung {{ currency2 }} nach {{ currency1 }}.
<span class="hljs-tag">&lt;<span class="hljs-name">table</span> <span class="hljs-attr">class</span>=<span class="hljs-string">"u-full-width"</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">thead</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">tr</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">th</span>&gt;</span>{{ currency2 }}<span class="hljs-tag">&lt;/<span class="hljs-name">th</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">th</span>&gt;</span>{{ currency1 }}<span class="hljs-tag">&lt;/<span class="hljs-name">th</span>&gt;</span>
<span class="hljs-tag">&lt;/<span class="hljs-name">tr</span>&gt;</span>
<span class="hljs-tag">&lt;/<span class="hljs-name">thead</span>&gt;</span>
<span class="hljs-tag">&lt;/<span class="hljs-name">tbody</span>&gt;</span>
{% for row in table2 %}
<span class="hljs-tag">&lt;<span class="hljs-name">tr</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">td</span>&gt;</span>{{ row[0] }}<span class="hljs-tag">&lt;/<span class="hljs-name">td</span>&gt;</span>
<span class="hljs-tag">&lt;<span class="hljs-name">td</span>&gt;</span>{{ row[1] }}<span class="hljs-tag">&lt;/<span class="hljs-name">td</span>&gt;</span>
<span class="hljs-tag">&lt;/<span class="hljs-name">tr</span>&gt;</span>
{% endfor %}
<span class="hljs-tag">&lt;/<span class="hljs-name">tbody</span>&gt;</span>
<span class="hljs-tag">&lt;/<span class="hljs-name">table</span>&gt;</span>
<span class="hljs-tag">&lt;/<span class="hljs-name">div</span>&gt;</span>
<span class="hljs-tag">&lt;/<span class="hljs-name">div</span>&gt;</span>
{% endblock %}
</div></code></pre>
<div style='page-break-after: always'></div>
<p>static/style.css</p>
<pre class="hljs"><code><div><span class="hljs-selector-class">.wichtig</span> {
<span class="hljs-attribute">color</span>: red;
}
<span class="hljs-selector-class">.obst</span> {
<span class="hljs-attribute">color</span>: green;
<span class="hljs-attribute">font-size</span>: <span class="hljs-number">1.2em</span>;
}
<span class="hljs-selector-class">.test</span> {
<span class="hljs-attribute">text-decoration</span>: underline;
}
<span class="hljs-selector-class">.navigation</span> {
<span class="hljs-attribute">list-style-type</span>: none;
}
<span class="hljs-selector-class">.navigation-item</span> {
<span class="hljs-attribute">float</span>: left;
<span class="hljs-attribute">padding-left</span>: <span class="hljs-number">10px</span>;
<span class="hljs-attribute">padding-right</span>: <span class="hljs-number">10px</span>;
}
<span class="hljs-selector-class">.myheader</span> {
<span class="hljs-attribute">text-align</span>: center;
<span class="hljs-attribute">font-size</span>: <span class="hljs-number">1.8em</span>;
}
</div></code></pre>
<div style='page-break-after: always'></div>
<p>Website.py</p>
<pre class="hljs"><code><div><span class="hljs-comment"># coding=utf-8</span>
<span class="hljs-comment"># Die Stylesheets müssen immer in dem Verzeichnis static liegen</span>
<span class="hljs-comment"># und die Vorlagen im Verzeichnis templates</span>
<span class="hljs-comment">#</span>
<span class="hljs-keyword">from</span> flask <span class="hljs-keyword">import</span> Flask, render_template, request
app = Flask(__name__)
company = <span class="hljs-string">"Seab@er Software"</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Item</span><span class="hljs-params">()</span>:</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self, name, amount)</span>:</span>
self.name = name
self.amount = amount
<span class="hljs-comment"># app.route() ruft immer die nachfolgende Funktion auf.</span>
<span class="hljs-comment"># http://localhost:5000</span>
<span class="hljs-meta">@app.route("/")</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">index</span><span class="hljs-params">()</span>:</span>
items = [<span class="hljs-string">"Äpfel"</span>, <span class="hljs-string">"Birnen"</span>, <span class="hljs-string">"Erdbeeren"</span>, <span class="hljs-string">"Heidelbeeren"</span>, <span class="hljs-string">"Aprikose"</span>]
text1 = <span class="hljs-string">'''
A1: Project Exchange ist ein SharePoint-basierter Arbeitsbereich mit zahlreichen
automatisierten Workflows zur Überwachung des gesamten Personallebenszyklus von
der Bedarfserstellung, der Anwendung, dem Feedback bis hin zur Zuweisung und
Schließung des Bedarfs. Project Exchange beherbergt außerdem die gesamte
Subunternehmerverwaltung und das Practice Enrolment Tooling.
'''</span>
dict1 = [
Item(<span class="hljs-string">"Computer"</span>, <span class="hljs-number">6</span>),
Item(<span class="hljs-string">"Laptop"</span>, <span class="hljs-number">3</span>),
Item(<span class="hljs-string">"Smartphone"</span>, <span class="hljs-number">10</span>)
]
dict2 = [
{<span class="hljs-string">"name"</span>: <span class="hljs-string">"Äpfel"</span>, <span class="hljs-string">"amount"</span>: <span class="hljs-number">6</span>},
{<span class="hljs-string">"name"</span>: <span class="hljs-string">"Kiwi"</span>, <span class="hljs-string">"amount"</span>: <span class="hljs-number">10</span>}
]
person = (<span class="hljs-string">"Max"</span>, <span class="hljs-string">"Mustermann"</span>)
<span class="hljs-comment"># Berechnungen</span>
<span class="hljs-keyword">for</span> item <span class="hljs-keyword">in</span> dict2:
item[<span class="hljs-string">"amount"</span>] = item[<span class="hljs-string">"amount"</span>] * <span class="hljs-number">2</span>
<span class="hljs-keyword">return</span> render_template(<span class="hljs-string">"start.html"</span>, name=<span class="hljs-string">"Harry Hirsch"</span>, dict1=dict1, dict2=dict2,
text1=text1, items=items, company=<span class="hljs-string">"Seab@er Software"</span>, person=person)
<span class="hljs-comment"># http://localhost:5000/test</span>
<span class="hljs-comment"># Parameter werden in der URL mit einem ? übergeben:</span>
<span class="hljs-comment"># http://localhost:5000/test?name=Karl Mai&amp;age=43</span>
<span class="hljs-meta">@app.route("/test")</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">myfunc</span><span class="hljs-params">()</span>:</span>
name = request.args.get(<span class="hljs-string">"name"</span>)
age = request.args.get(<span class="hljs-string">"age"</span>)
passwd = request.args.get(<span class="hljs-string">"passwd"</span>)
<span class="hljs-keyword">return</span> render_template(<span class="hljs-string">"test.html"</span>, passwd=passwd, name=name, age=age, company=company)
<span class="hljs-meta">@app.route("/table")</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">mytable</span><span class="hljs-params">()</span>:</span>
<span class="hljs-keyword">return</span> render_template(<span class="hljs-string">"table.html"</span>,
company=company)
<span class="hljs-meta">@app.route("/currency")</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">currency</span><span class="hljs-params">()</span>:</span>
<span class="hljs-comment"># Der zweite Parameter nach dem Komma ist ein Standard</span>
<span class="hljs-comment"># Wert, der übergeben wird.</span>
currency1 = request.args.get(<span class="hljs-string">"currency1"</span>, <span class="hljs-string">"DM"</span>)
currency2 = request.args.get(<span class="hljs-string">"currency2"</span>, <span class="hljs-string">"EUR"</span>)
rate = float(request.args.get(<span class="hljs-string">"rate"</span>, <span class="hljs-string">"1.95583"</span>))
table1 = []
table2 = []
<span class="hljs-comment"># range(start, end, schritte). Die Angabe von Schritte ist</span>
<span class="hljs-comment"># optional.</span>
<span class="hljs-keyword">for</span> x <span class="hljs-keyword">in</span> range(<span class="hljs-number">1</span>, <span class="hljs-number">50</span>, <span class="hljs-number">10</span>):
table1.append((x, round( x * rate, <span class="hljs-number">2</span>)))
table2.append((x, round(x / rate, <span class="hljs-number">2</span>)))
<span class="hljs-keyword">return</span> render_template(<span class="hljs-string">"currency.html"</span>,
table1=table1,
table2=table2,
company=company,
rate=rate,
currency1=currency1,
currency2=currency2)
</div></code></pre>
<div style='page-break-after: always'></div>
<h2 id="14-decoratoren">14. Decoratoren</h2>
<p>Mit <strong>Decoratoren</strong> können Funktionen einer anderen Funktion übergeben werden.</p>
<pre class="hljs"><code><div><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">outer</span><span class="hljs-params">(func)</span>:</span>
counter = <span class="hljs-number">0</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">inner</span><span class="hljs-params">()</span>:</span>
<span class="hljs-comment"># Mit nonlocal kann auf die Variable außerhalb der Funktion</span>
<span class="hljs-comment"># zugegriffen werden.</span>
<span class="hljs-keyword">nonlocal</span> counter
print(<span class="hljs-string">"inner() wurde bisher ausgeführt: "</span> + str(counter))
counter += <span class="hljs-number">1</span>
func()
<span class="hljs-comment"># Es wird die Funktion inner zurückgegeben</span>
<span class="hljs-comment"># ohne sie auszuführen.</span>
<span class="hljs-keyword">return</span> inner
<span class="hljs-meta">@outer</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">do_something</span><span class="hljs-params">()</span>:</span>
print(<span class="hljs-string">"do_something() wurde ausgeführt."</span>)
<span class="hljs-comment"># Bei dem Aufruf der Funktion do_something wird durch den Decorator '@'</span>
<span class="hljs-comment"># die Funktion outer aufgerufen und die Funktion do_something übergeben.</span>
<span class="hljs-comment"># Als Rückgabe Wert kommt die Funktion inner.</span>
<span class="hljs-comment"># Das '@' ist das gleiche wie: do_something = outer(do_something)</span>
do_something()
do_something()
do_something()
do_something()
<span class="hljs-comment"># Ein weiteres Beispiel für eine Berechnung.</span>
<span class="hljs-comment"># Die Funktion calculate_something() wird nur einmal</span>
<span class="hljs-comment"># aufgerufen, wenn der Wert schon mal verarbeitet worden ist</span>
<span class="hljs-comment"># und sich im cached befindet.</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">cache</span><span class="hljs-params">(func)</span>:</span>
cached = {}
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">inner</span><span class="hljs-params">(x)</span>:</span>
<span class="hljs-keyword">if</span> x <span class="hljs-keyword">in</span> cached:
<span class="hljs-keyword">return</span> cached[x]
result = func(x)
cached[x] = result
<span class="hljs-keyword">return</span> result
<span class="hljs-keyword">return</span> inner
<span class="hljs-meta">@cache</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">calculate_something</span><span class="hljs-params">(x)</span>:</span>
print(<span class="hljs-string">"calculate_something("</span> + str(x) + <span class="hljs-string">")"</span>)
<span class="hljs-keyword">return</span> x * x
print(calculate_something(<span class="hljs-number">5</span>))
print(calculate_something(<span class="hljs-number">5</span>))
print(calculate_something(<span class="hljs-number">6</span>))
print(calculate_something(<span class="hljs-number">6</span>))
</div></code></pre>
<div style='page-break-after: always'></div>
<p>In dem nächsten Beispiel kann man dem Decorator Werte mitgegeben.</p>
<pre class="hljs"><code><div><span class="hljs-comment"># Um den Decorator wurde eine Funktion erstellt, die nun</span>
<span class="hljs-comment"># Parameter übergeben bekommen.</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">repeat</span><span class="hljs-params">(n)</span>:</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">deco</span><span class="hljs-params">(func)</span>:</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">inner</span><span class="hljs-params">()</span>:</span>
<span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> range(<span class="hljs-number">0</span>, n):
func()
<span class="hljs-keyword">return</span> inner
<span class="hljs-keyword">return</span> deco
<span class="hljs-meta">@repeat(5)</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">do_something</span><span class="hljs-params">()</span>:</span>
print(<span class="hljs-string">"do_something() wurde ausgeführt."</span>)
do_something()
</div></code></pre>
<div style='page-break-after: always'></div>
<h2 id="15-datascince-stack">15. Datascince-Stack</h2>
<h3 id="151-numpy">15.1 Numpy</h3>
<p>Mit <strong>Numpy</strong> kann man konfortabel mit Nummerische Arrays arbeiten.</p>
<pre class="hljs"><code><div><span class="hljs-keyword">import</span> numpy <span class="hljs-keyword">as</span> np
<span class="hljs-comment"># Ein paar Beispiele</span>
np.arange(<span class="hljs-number">10</span>)
np.arange(<span class="hljs-number">10</span>) * <span class="hljs-number">3</span>
np.array([<span class="hljs-number">1</span>,<span class="hljs-number">2</span>,<span class="hljs-number">3</span>,<span class="hljs-number">4</span>,<span class="hljs-number">5</span>,<span class="hljs-number">10</span>]) ** <span class="hljs-number">2</span>
np.zeros(<span class="hljs-number">10</span>)
np.array([<span class="hljs-number">1</span>,<span class="hljs-number">2</span>,<span class="hljs-number">3</span>,<span class="hljs-number">4</span>,<span class="hljs-number">5</span>,<span class="hljs-number">10</span>]).mean() <span class="hljs-comment"># Durchschnitt</span>
print(np.array([<span class="hljs-number">1</span>,<span class="hljs-number">2</span>,<span class="hljs-number">3</span>,<span class="hljs-number">4</span>,<span class="hljs-number">5</span>,<span class="hljs-number">10</span>]).min())
print(np.array([<span class="hljs-number">1</span>,<span class="hljs-number">2</span>,<span class="hljs-number">3</span>,<span class="hljs-number">4</span>,<span class="hljs-number">5</span>,<span class="hljs-number">10</span>]).max())
print(np.array([<span class="hljs-number">1</span>,<span class="hljs-number">2</span>,<span class="hljs-number">3</span>,<span class="hljs-number">4</span>,<span class="hljs-number">5</span>,<span class="hljs-number">10</span>]).std())
</div></code></pre>
<p>Eindimensionales Array.</p>
<pre class="hljs"><code><div><span class="hljs-keyword">import</span> numpy <span class="hljs-keyword">as</span> np
a = np.array([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>])
b = np.array([<span class="hljs-literal">False</span>, <span class="hljs-literal">True</span>, <span class="hljs-literal">True</span>, <span class="hljs-literal">False</span>])
<span class="hljs-comment"># Filtert das Array 'a' mit 'b', nur die True Werte werden</span>
<span class="hljs-comment"># ausgegeben.</span>
a[b]
out: array([<span class="hljs-number">2</span>, <span class="hljs-number">3</span>])
c = a &gt;= <span class="hljs-number">3</span>
print(c)
a(c)
[<span class="hljs-literal">False</span> <span class="hljs-literal">False</span> <span class="hljs-literal">True</span> <span class="hljs-literal">True</span>]
array([<span class="hljs-number">3</span>, <span class="hljs-number">4</span>])
<span class="hljs-comment"># Kürzer</span>
print(a[a &gt;= <span class="hljs-number">3</span>])
[<span class="hljs-number">3</span> <span class="hljs-number">4</span>]
</div></code></pre>
<div style='page-break-after: always'></div>
<p>Mehrdimensionale Arrays</p>
<pre class="hljs"><code><div><span class="hljs-keyword">import</span> numpy <span class="hljs-keyword">as</span> np
a = np.array([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>, <span class="hljs-number">7</span>, <span class="hljs-number">8</span>, <span class="hljs-number">9</span>, <span class="hljs-number">10</span>, <span class="hljs-number">11</span>, <span class="hljs-number">12</span>])
<span class="hljs-comment"># reshape macht aus dem Array 3 Zeilen mit 4 Spalten</span>
reshaped = a.reshape((<span class="hljs-number">4</span>, <span class="hljs-number">3</span>))
print(reshaped[<span class="hljs-number">0</span>])
print(reshaped[<span class="hljs-number">2</span>])
<span class="hljs-comment"># bei einer Angabe von '-1' teilt numpy die Zeilen</span>
<span class="hljs-comment"># selbstaändig auf. In dem Beispiel werden 3 Zeilen erstellt.</span>
a.reshape((<span class="hljs-number">-1</span>, <span class="hljs-number">4</span>))
<span class="hljs-comment"># Nun werden 2 Spalten erstellt</span>
a.reshape((<span class="hljs-number">6</span>, <span class="hljs-number">-1</span>))
<span class="hljs-comment"># Mehrdimensionales Array umwandeln in eine Dimension</span>
b = np.array([[<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>], [<span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>], [<span class="hljs-number">7</span>, <span class="hljs-number">8</span>, <span class="hljs-number">9</span>]])
b.reshape(<span class="hljs-number">-1</span>)
<span class="hljs-comment"># Anzeige, wie viele Zeilen und Spalten hat das Array</span>
b.shape
</div></code></pre>
<div style='page-break-after: always'></div>
<h3 id="152-pandas">15.2 Pandas</h3>
<p>Mit <strong>Pandas</strong> kann man komfortable CSV / Excel - Dateien einlesen, filtern und sortieren. Welche <strong>read</strong> Funktionen es gibt, kann man <a href="https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.read_excel.html">hier</a> nachschauen.</p>
<pre class="hljs"><code><div><span class="hljs-keyword">import</span> pandas <span class="hljs-keyword">as</span> pd
<span class="hljs-comment"># Rückgabe ist ein Pandas Data Frame und als</span>
<span class="hljs-comment"># Variable wird meistens df verwendet.</span>
df = pd.read_csv(<span class="hljs-string">r"..\Kursmaterialien\data\astronauts.csv"</span>, delimiter=<span class="hljs-string">","</span>)
df
<span class="hljs-comment"># Ausgabe der ersten 5 Zeilen</span>
df.head()
<span class="hljs-comment"># Anzahl der Einträge ausgeben</span>
print(len(df))
<span class="hljs-comment"># Auf einer Spalte zugreifen</span>
df[<span class="hljs-string">"Name"</span>]
<span class="hljs-keyword">for</span> name <span class="hljs-keyword">in</span> df[<span class="hljs-string">"Name"</span>]:
print(name)
<span class="hljs-comment"># Die erste Spalte der Data Frameworks ist der Index.</span>
<span class="hljs-comment"># Auf einem Eintrag eines Index kann man mit iloc zugreifen</span>
df.iloc[<span class="hljs-number">2</span>]
entry = df.iloc[<span class="hljs-number">2</span>]
print(entry[<span class="hljs-string">"Name"</span>] + <span class="hljs-string">" "</span> + str(entry[<span class="hljs-string">"Year"</span>]))
<span class="hljs-comment"># Ein Bereich kann mit iloc auch abgefragt werden.</span>
df.iloc[<span class="hljs-number">2</span>:<span class="hljs-number">5</span>]
<span class="hljs-comment"># Die letzten 5 Einträge</span>
df.iloc[<span class="hljs-number">-5</span>:]
</div></code></pre>
<div style='page-break-after: always'></div>
<p>Mit Pandas filtern.</p>
<pre class="hljs"><code><div><span class="hljs-keyword">import</span> pandas <span class="hljs-keyword">as</span> pd
df = pd.read_csv(<span class="hljs-string">r"..\Kursmaterialien\data\astronauts.csv"</span>, delimiter=<span class="hljs-string">","</span>)
<span class="hljs-comment"># Jede Zeile ausgeben, dabei handelt es sich um ein Tupel</span>
<span class="hljs-keyword">for</span> pos, d <span class="hljs-keyword">in</span> df.iterrows():
print(pos)
print(d)
print(d[<span class="hljs-string">"Name"</span>])
print(type(row))
<span class="hljs-keyword">break</span>
<span class="hljs-comment"># Nach dem Jahr filtern</span>
<span class="hljs-keyword">for</span> year <span class="hljs-keyword">in</span> df[<span class="hljs-string">"Year"</span>] &lt; <span class="hljs-number">1990</span>:
print(df[<span class="hljs-string">"Year"</span>])
<span class="hljs-comment"># Alternative</span>
df[df[<span class="hljs-string">"Year"</span>] &lt; <span class="hljs-number">1990</span>]
<span class="hljs-comment"># Anderes Beispiel</span>
df2 = df[df[<span class="hljs-string">"Year"</span>] &lt; <span class="hljs-number">1990</span>]
print(<span class="hljs-string">"="</span> * <span class="hljs-number">80</span>)
df3 = df2[df2[<span class="hljs-string">"Gender"</span>] == <span class="hljs-string">"Male"</span>]
df3.head()
</div></code></pre>
<div style='page-break-after: always'></div>
<p>Daten sortieren.</p>
<pre class="hljs"><code><div><span class="hljs-keyword">import</span> panda <span class="hljs-keyword">as</span> pd
df = pd.read_csv(<span class="hljs-string">r"..\Kursmaterialien\data\astronauts.csv"</span>, delimiter=<span class="hljs-string">","</span>)
<span class="hljs-comment"># Aufsteigend sortieren</span>
df.sort_values(<span class="hljs-string">"Name"</span>)
<span class="hljs-comment"># Absteigend sortieren</span>
df.sort_values(<span class="hljs-string">"Name"</span>, ascending=<span class="hljs-literal">False</span>)
<span class="hljs-comment"># Ausgabe alle Namen absteigend</span>
df2 = df.sort_values(<span class="hljs-string">"Name"</span>, ascending=<span class="hljs-literal">False</span>)
<span class="hljs-keyword">for</span> name <span class="hljs-keyword">in</span> df2[<span class="hljs-string">"Name"</span>]:
print(name)
</div></code></pre>
<p>Excel-Datei öffnen und eine Graphik zeichnen.</p>
<pre class="hljs"><code><div><span class="hljs-keyword">import</span> pandas <span class="hljs-keyword">as</span> pd
df = pd.read_excel(<span class="hljs-string">"daten.xlsx"</span>)
year = df[<span class="hljs-string">"Jahr"</span>]
sales = df[<span class="hljs-string">"Umsatz"</span>]
%matplotlib inline
<span class="hljs-keyword">import</span> matplotlib.pyplot <span class="hljs-keyword">as</span> plt
plt.plot(year, sales)
<span class="hljs-comment"># Anzeige der Legende</span>
plt.legend()
plt.show()
</div></code></pre>
<div style='page-break-after: always'></div>
<p>Musterlösung Datei einlesen und visualisieren.</p>
<pre class="hljs"><code><div><span class="hljs-keyword">import</span> pandas <span class="hljs-keyword">as</span> pd
name = <span class="hljs-string">"Anna"</span>
gender = <span class="hljs-string">"F"</span>
state = <span class="hljs-string">"CA"</span>
df = pd.read_csv(<span class="hljs-string">"../data/names.csv"</span>)
<span class="hljs-comment"># Anzeige der Spaltenüberschrift</span>
df.head()
df2 = df[df[<span class="hljs-string">"Name"</span>] == name]
df3 = df2[df2[<span class="hljs-string">"Gender"</span>] == gender]
df4 = df3[df3[<span class="hljs-string">"State"</span>] == state]
df4.head()
<span class="hljs-comment"># Sortieren</span>
df5 = df4.sort_values(<span class="hljs-string">"Year"</span>)
<span class="hljs-comment"># Graphik Ausgabe</span>
%matplotlib inline
<span class="hljs-keyword">import</span> matplotlib.pyplot <span class="hljs-keyword">as</span> plt
plt.plot(df5[<span class="hljs-string">"Year"</span>], df5[<span class="hljs-string">"Count"</span>])
plt.show()
</div></code></pre>
<div style='page-break-after: always'></div>
<h3 id="153-matplotlib">15.3 Matplotlib</h3>
<p>Bei <strong>%matplotlib inline</strong> ist für verschiedene Backends in einem Jupyter Notebook zuständig. Es gibt mehrere Backends in Jupyter Notebook.</p>
<ul>
<li>Inline</li>
<li>Notebook</li>
<li>tk (Tinker)
Man kann auch <strong>plt.plot()</strong> mehrfach definieren, es werden dann in der Graphik verschiedene Linien dargestellt.</li>
</ul>
<h4 id="1531-diagramme-konfigurieren">15.3.1 Diagramme konfigurieren</h4>
<p>Die Farbe einer Linie kann man einstellen und auch eine Legende der Graphok hinzufügen. Eine Dokumentation für Matplotlib gibt es <a href="https://matplotlib.org/2.0.2/api/pyplot_api.html">hier</a>.</p>
<pre class="hljs"><code><div>%matplotlib inline
<span class="hljs-keyword">from</span> matplotlib.pyplot <span class="hljs-keyword">as</span> plt
<span class="hljs-comment"># Die Color Werte werden in Hexadezimal angegeben.</span>
plt.plot([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>], [<span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">6</span>], color=<span class="hljs-string">"#ff00ff"</span>, linestyle=<span class="hljs-string">"dashed"</span>, marker=<span class="hljs-string">"o"</span>, label=<span class="hljs-string">"Umsatz"</span>)
plt.plot([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>], [<span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">5</span>], color=<span class="hljs-string">"#0000ff"</span>, linestyle=<span class="hljs-string">"dashed"</span>, marker=<span class="hljs-string">"o"</span>, label=<span class="hljs-string">"Gewinn"</span>)
<span class="hljs-comment"># Anzeige einer Legende, mit label wurde der Text vergeben.</span>
plt.legend()
plt.show()
</div></code></pre>
<h4 id="1532-diagrammtypen">15.3.2 Diagrammtypen</h4>
<p>In dem nächsten Beispiel werden die folgenden Diagrammtypen gezeigt:</p>
<ul>
<li>Kreisdiagramm</li>
<li>Balkendiagramm</li>
<li>Punktediagramm</li>
</ul>
<pre class="hljs"><code><div>%matplotlib inline
<span class="hljs-keyword">from</span> matplotlib.pyplot <span class="hljs-keyword">as</span> plt
<span class="hljs-comment"># Kreisdiagramm</span>
plt.pie([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>])
plt.show()
<span class="hljs-comment"># Balkendiagramm</span>
plt.bar([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>], [<span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">4</span>])
plt.show()
<span class="hljs-comment"># Punktediagramm</span>
plt.scatter([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>], [<span class="hljs-number">4</span>, <span class="hljs-number">5</span>, <span class="hljs-number">4</span>])
plt.show()
</div></code></pre>
<div style='page-break-after: always'></div>
<h2 id="16-bildverarbeitung-mit-opencv">16. Bildverarbeitung mit OpenCV</h2>
<p>Normalerweise werden Bildpunkte als RGB(Rot, Grün, Blau) definiert. In <strong>OpenCV</strong> ist es genau umgegehrt, nämlich in BGR(Blau, Grün, Rot).</p>
<h3 id="161-installation">16.1 Installation</h3>
<p>In einem Jupyter Notebook geben wir in einer Zeile folgendes ein: <strong>!pip install opencv-python</strong> und führen es aus.</p>
<h3 id="162-bild-in-opencv-laden">16.2 Bild in OpenCV laden</h3>
<pre class="hljs"><code><div>%matplotlib inline
<span class="hljs-keyword">import</span> matplotlib.pyplot <span class="hljs-keyword">as</span> plt
<span class="hljs-keyword">import</span> numpy <span class="hljs-keyword">as</span> np
<span class="hljs-keyword">import</span> cv2
img = cv2.imread(<span class="hljs-string">"bild.jpg"</span>)
img.shape
print(img[<span class="hljs-number">0</span>][<span class="hljs-number">0</span>])
<span class="hljs-comment"># Farbwerte von BGR nach RGB konvertieren</span>
i = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
print(i[<span class="hljs-number">0</span>][<span class="hljs-number">0</span>])
plt.imshow(i)
plt.show()
<span class="hljs-comment"># Nach Graustufen konvertieren</span>
g = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
plt.imshow(g, <span class="hljs-string">"gray"</span>)
plt.show()
</div></code></pre>
<div style='page-break-after: always'></div>
<h3 id="163-helligkeit-ver%C3%A4ndern">16.3 Helligkeit verändern</h3>
<pre class="hljs"><code><div>%matplotlib inline
<span class="hljs-keyword">import</span> matplotlib.pyplot <span class="hljs-keyword">as</span> plt
<span class="hljs-keyword">import</span> numpy <span class="hljs-keyword">as</span> np
<span class="hljs-keyword">import</span> cv2
img = cv2.imread(<span class="hljs-string">"bild.jpg"</span>)
<span class="hljs-comment"># uint8 kann nur Zahlen bis 255 speichern, also 0 - 254</span>
r = np.array([<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>, <span class="hljs-number">4</span>, <span class="hljs-number">100</span>], dtype=<span class="hljs-string">"uint8"</span>)
<span class="hljs-comment"># Wird der errechnete Wert größer 255, so wird wieder von Vorne</span>
<span class="hljs-comment"># angefangen. z.B. 100 + 250 = 94</span>
r = r + <span class="hljs-number">250</span>
print(r)
<span class="hljs-comment"># Bild verändern</span>
increased = img + <span class="hljs-number">50</span>
print(img[<span class="hljs-number">0</span>][<span class="hljs-number">0</span>])
print(increased[<span class="hljs-number">0</span>][<span class="hljs-number">0</span>])
<span class="hljs-comment"># Ausgabe Bild</span>
<span class="hljs-comment"># Bei den Farbfehlern handelt es sich um die Werte, die nach der Berechnung</span>
<span class="hljs-comment"># größer 255 wären und daher wieder bei 0 anfangen.</span>
i = cv2.cvtColor(increased, cv2.COLOR_BGR2RGB)
plt.imshow(i)
plt.show()
</div></code></pre>
<p>Es gibt noch eine andere Methode die Helligkeit eines Bildes zu erhöhen, ohne das es einen Overflow bei der Berechnung gibt.</p>
<pre class="hljs"><code><div>%matplotlib inline
<span class="hljs-keyword">import</span> matplotlib.pyplot <span class="hljs-keyword">as</span> plt
<span class="hljs-keyword">import</span> numpy <span class="hljs-keyword">as</span> np
<span class="hljs-keyword">import</span> cv2
img = cv2.imread(<span class="hljs-string">"bild.jpg"</span>)
print(img.shape)
<span class="hljs-comment"># Das Bild hat 1000 Zeilen, 1500 Spalten mit 3 Werten</span>
(<span class="hljs-number">1000</span>, <span class="hljs-number">1500</span>, <span class="hljs-number">3</span>)
<span class="hljs-comment"># Ein numpy Array wird erstellt, genauso groß wie das Bild</span>
z = np.zeros((<span class="hljs-number">1000</span>, <span class="hljs-number">1500</span>, <span class="hljs-number">3</span>), dtype=<span class="hljs-string">"uint8"</span>) + <span class="hljs-number">50</span>
<span class="hljs-comment"># Nun wird die Helligkeit des Bildes erhöht.</span>
<span class="hljs-comment"># Der Vorteil ist nun, wenn der Wert &gt; 255 wird bei der Berechnung,</span>
<span class="hljs-comment"># wird nicht bei 0 wieder angefangen, sondern der Wert ist 255</span>
increased = cv2.add(img, z)
print(img[<span class="hljs-number">0</span>][<span class="hljs-number">0</span>])
print(z[<span class="hljs-number">0</span>][<span class="hljs-number">0</span>])
print(increased[<span class="hljs-number">0</span>][<span class="hljs-number">0</span>])
i = cv2.cvtColor(increased, cv2.COLOR_BGR2RGB)
plt.imshow(i)
plt.show()
</div></code></pre>
<div style='page-break-after: always'></div>
<h3 id="164-rechteck-einzeichnen">16.4 Rechteck einzeichnen</h3>
<pre class="hljs"><code><div>%matplotlib inline
<span class="hljs-keyword">import</span> matplotlib.pyplot <span class="hljs-keyword">as</span> plt
<span class="hljs-keyword">import</span> numpy <span class="hljs-keyword">as</span> np
<span class="hljs-keyword">import</span> cv2
img = cv2.imread(<span class="hljs-string">"bild.jpg"</span>)
<span class="hljs-comment"># Syntax: Start, End, Farbwerte, Breite</span>
cv2.rectangle(img, (<span class="hljs-number">200</span>, <span class="hljs-number">200</span>), (<span class="hljs-number">500</span>, <span class="hljs-number">500</span>), (<span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">255</span>), <span class="hljs-number">20</span>)
i = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
plt.imshow(i)
plt.show()
</div></code></pre>
<h3 id="155-gesichtserkennung">15.5 Gesichtserkennung</h3>
<pre class="hljs"><code><div>%matplotlib inline
<span class="hljs-keyword">import</span> matplotlib.pyplot <span class="hljs-keyword">as</span> plt
<span class="hljs-keyword">import</span> numpy <span class="hljs-keyword">as</span> np
<span class="hljs-keyword">import</span> cv2
img = cv2.imread(<span class="hljs-string">"bild.jpg"</span>)
<span class="hljs-comment"># Das Bild muss in Graustufen umgewandelt werden</span>
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
<span class="hljs-comment"># Ladem der Konfigurations Datei</span>
classifier = cv2.CascadeClassifier(<span class="hljs-string">"./data/haarcascades/haarcascade_frontalface_alt2.xml"</span>)
<span class="hljs-comment"># Nach einem Gesicht suchen</span>
<span class="hljs-comment"># Mit dem Parameter kann man einstellen, wie genau nach Gesichtern gesucht</span>
<span class="hljs-comment"># werden soll. Je kleiner die Zahl, desto mehr Fehler können ausgegeben werden.</span>
faces = classifier.detectMultiScale(gray, minNeighbors=<span class="hljs-number">10</span>)
<span class="hljs-comment"># Die Ausgabe ist: x, y, breite, höhe</span>
print(faces)
c = img.copy()
<span class="hljs-keyword">for</span> face <span class="hljs-keyword">in</span> faces:
x, y, w, h = face
cv2.rectangle(c, (x, y), (x + w, y + h), (<span class="hljs-number">0</span>, <span class="hljs-number">255</span>, <span class="hljs-number">0</span>), <span class="hljs-number">10</span>)
print(face)
i = cv2.cvtColor(c, cv2.COLOR_BGR2RGB)
plt.imshow(i)
plt.show()
<span class="hljs-comment"># Syntax: Start, End, Farbwerte, Breite</span>
cv2.rectangle(img, (<span class="hljs-number">200</span>, <span class="hljs-number">200</span>), (<span class="hljs-number">500</span>, <span class="hljs-number">500</span>), (<span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">255</span>), <span class="hljs-number">20</span>)
i = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
plt.imshow(i)
plt.show()
</div></code></pre>
<div style='page-break-after: always'></div>
<h2 id="17-oberfl%C3%A4chen-mit-qt">17. Oberflächen mit QT</h2>
<h3 id="171-installation">17.1 Installation</h3>
<p>Die Source gibt es direkt von der Firma <a href="https://www.qt.io/download">QT</a>. Es muss bei QT ein Konto angelegt werden. Bei der Installation sollten unter QT in den ersten zwei QT-Vesionen die MinGW 64-bit ausgewählt werden. Unter Developer and Designer Tools die beiden Debugger Tools.</p>
<h3 id="172-projekt-anlegen">17.2 Projekt anlegen</h3>
<p>Als <strong>Base interpreter</strong> sollte pythonw.exe ausgewählt werden, da es sich um eine Graphisches Programm handelt und nicht ein Konsolen Programm. Ebenso erstellen wir ein New environment. <br>
<img src="PyQtConfig.png" title="Konfiguration PyQt" />
In PyCharm müssen die Packages <strong>PyQt5</strong> und <strong>QtPy</strong> installiert werden. <br>
<img src="ProjektPyQtConfig.png" title="Konfiguration Projekt PyQt" /> <br>
Alles weitere in der Online Schulung bei Udemy oder in den Kursmaterialien.</p>
<div style='page-break-after: always'></div>
<h3 id="173-oberfl%C3%A4che-%C3%BCbersetzen">17.3 Oberfläche übersetzen</h3>
<p>Die <strong>UI-Datei</strong>, die man im QT-Designer erstellt, sollte in das Python Projekt im Verzeichnis <strong>ui</strong> abgelegt werden. Aus dieser Datei kann man automatisch eine Python-Datei estellen. Hierzu wird die Datei <strong>build.py</strong> mit folgendem Inhalt erstellt.</p>
<pre class="hljs"><code><div><span class="hljs-keyword">from</span> qtpy <span class="hljs-keyword">import</span> uic
uic.compileUiDir(<span class="hljs-string">"ui"</span>)
</div></code></pre>
<div style='page-break-after: always'></div>
<h2 id="18-exe-datei-estellen">18. EXE-Datei estellen</h2>
<h3 id="181-pfadangaben">18.1 Pfadangaben</h3>
<pre class="hljs"><code><div><span class="hljs-comment"># Den Pfad zur aktuellen Datei holen</span>
<span class="hljs-keyword">import</span> os
<span class="hljs-keyword">import</span> pathlib
<span class="hljs-comment"># Das resolve() löst Symnks auf.</span>
projectPath = pathlib.Path(__file__).parent.resolve()
<span class="hljs-comment"># Da es sich bei der Variable projectPath um ein pathlib</span>
<span class="hljs-comment"># Objekt handelt, wird das '/' an dem Pfad angehangen.</span>
d = (projectPath / <span class="hljs-string">'daten.txt'</span>).resolve()
<span class="hljs-comment"># Datei öffnen</span>
<span class="hljs-keyword">with</span> d.open(<span class="hljs-string">'a'</span>) <span class="hljs-keyword">as</span> f:
f.write(<span class="hljs-string">"Eine Zeile.\n"</span>)
</div></code></pre>
<h3 id="182-exe-datei-erstellen">18.2 EXE-Datei erstellen</h3>
<p>Als erstes muss ein Modul nachinstalliert werden.</p>
<pre class="hljs"><code><div><span class="hljs-function">C:\<span class="hljs-title">python</span> -<span class="hljs-title">m</span> <span class="hljs-title">pip</span> <span class="hljs-title">install</span> -<span class="hljs-title">U</span> <span class="hljs-title">pyinstaller</span>
</span></div></code></pre>
<p>Ausführbare Datei erstellen</p>
<pre class="hljs"><code><div><span class="hljs-function">C:\<span class="hljs-title">cd</span> <span class="hljs-title">Daten</span>\<span class="hljs-title">Project</span>
:: <span class="hljs-title">Die</span> <span class="hljs-title">Option</span> -<span class="hljs-title">w</span> <span class="hljs-title">erstellt</span> <span class="hljs-title">ein</span> <span class="hljs-title">Programm</span> <span class="hljs-title">ohne</span> <span class="hljs-title">Graphische</span> <span class="hljs-title">Ausgabe</span>,
:: <span class="hljs-title">Wie</span> <span class="hljs-title">mit</span> <span class="hljs-title">pythonw</span> <span class="hljs-title">gestartet</span>.
<span class="hljs-title">C</span>:\<span class="hljs-title">python</span> -<span class="hljs-title">m</span> <span class="hljs-title">PyInstaller</span> [-<span class="hljs-title">w</span>] <span class="hljs-title">main.py</span>
:: <span class="hljs-title">Alles</span> <span class="hljs-title">in</span> <span class="hljs-title">einer</span> <span class="hljs-title">Exe</span>-<span class="hljs-title">Datei</span>
<span class="hljs-title">C</span>:\<span class="hljs-title">python</span> -<span class="hljs-title">m</span> <span class="hljs-title">PyInstaller</span> --<span class="hljs-title">onefile</span> <span class="hljs-title">main.py</span>
:: <span class="hljs-title">Hilfe</span> <span class="hljs-title">aufrufen</span>
<span class="hljs-title">C</span>:\<span class="hljs-title">python</span> -<span class="hljs-title">m</span> <span class="hljs-title">PyInstaller</span> --<span class="hljs-title">help</span>
</span></div></code></pre>
<p>Eine QT / PyQt als Exe-Datei estellen.</p>
<pre class="hljs"><code><div>C:\python -m pip install -U qtpy PyQt5
C:\python -m PyInstaller --onefile -w MyQT.py
</div></code></pre>
<div style='page-break-after: always'></div>
<h2 id="19-http-server-und-http-proxy">19. HTTP-Server und HTTP-Proxy</h2>
<pre class="hljs"><code><div><span class="hljs-comment"># HTTP-Proxy Programm</span>
<span class="hljs-keyword">from</span> http.server <span class="hljs-keyword">import</span> HTTPServer, BaseHTTPRequestHandler
<span class="hljs-keyword">import</span> request
<span class="hljs-keyword">from</span> socketserver <span class="hljs-keyword">import</span> ThreadingMixIn
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">MyRequestHandler</span><span class="hljs-params">(BaseHTTPRequestHandler)</span>:</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">do_GET</span><span class="hljs-params">(self)</span>:</span>
<span class="hljs-comment"># Holen der Seite</span>
<span class="hljs-comment"># stream=True holt die Daten komprimiert</span>
<span class="hljs-keyword">with</span> requests.get(self.path, stream=<span class="hljs-literal">True</span>) <span class="hljs-keyword">as</span> res:
<span class="hljs-comment"># Zurück an den Browser</span>
self.send_response(res.status_code)
<span class="hljs-comment"># Rückgabe des Headers an den Bowser</span>
<span class="hljs-keyword">for</span> key, value <span class="hljs-keyword">in</span> res.headers.items():
self.send_header(key, value)
self.end_headers()
<span class="hljs-comment"># Rückgabe an Browser</span>
sref.wfile.write(res.raw.read())
address = (<span class="hljs-string">"127.0.0.1"</span>, <span class="hljs-number">10080</span>)
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">ThreadingHTTPServer</span><span class="hljs-params">(ThreadingMixIn, HTTPServer)</span>:</span>
<span class="hljs-keyword">pass</span>
server = ThreadingHTTPServer(address, MyRequestHandler)
<span class="hljs-comment"># Starten des Proxy Server</span>
server.serve_forever()
</div></code></pre>
</body>
</html>
Reference in New Issue View Git Blame Copy Permalink