Skip to content

Commit 6ddd2a1

Browse files
author
dodo
committed
Änderungen an den Metadaten der zellen.
1 parent ce1415c commit 6ddd2a1

1 file changed

Lines changed: 289 additions & 0 deletions

File tree

‎Level_02/Level_2.ipynb‎

Lines changed: 289 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,289 @@
1+
{
2+
"cells": [
3+
{
4+
"cell_type": "markdown",
5+
"metadata": {
6+
"slideshow": {
7+
"slide_type": "-"
8+
}
9+
},
10+
"source": [
11+
"# Level 2"
12+
]
13+
},
14+
{
15+
"cell_type": "markdown",
16+
"metadata": {
17+
"slideshow": {
18+
"slide_type": "-"
19+
}
20+
},
21+
"source": [
22+
"## Einstieg\n",
23+
"In diesem Level werden wir lernen, wie wir Bedingungen stellen, die erfüllt werden müssen, damit bestimmter Code ausgeführt wird. Dafür werden wir erst den Typ des __boolean__ einführen und im Anschluss unsere erste Kontrolstruktur, die if-Bedingung. Wir werden die Schlüsselwörter `True`, `False`, `if`, `elif`, `else` und `is` kennenlernen."
24+
]
25+
},
26+
{
27+
"cell_type": "code",
28+
"execution_count": null,
29+
"metadata": {
30+
"scrolled": false,
31+
"slideshow": {
32+
"slide_type": "-"
33+
}
34+
},
35+
"outputs": [],
36+
"source": [
37+
"eingabe = input(\"Bitte etwas eingeben: \")\n",
38+
"zahl = int(eingabe)\n",
39+
"print(zahl)"
40+
]
41+
},
42+
{
43+
"cell_type": "markdown",
44+
"metadata": {
45+
"slideshow": {
46+
"slide_type": "-"
47+
}
48+
},
49+
"source": [
50+
"Schauen wir uns obigen Code an. Wir erwarten eine Eingabe und versuchen aus dieser Eingabe einen integer zu entnehmen. Dies klappt auch, wenn der Benutzer eine ganze Zahl eingibt, gibt er jedoch keine ganze Zahl, sondern zum Beispiel eine Zeichenkette ein, wird ein `ValueError` geworfen. Ebenso wird ein Fehler geworfen, wenn der Benutzer nichts eingibt.\n",
51+
"Im Verlaufe dieses Levels werden wir lernen Benutzereingaben zu prüfen und entsprechend zu reagiern."
52+
]
53+
},
54+
{
55+
"cell_type": "markdown",
56+
"metadata": {
57+
"slideshow": {
58+
"slide_type": "-"
59+
}
60+
},
61+
"source": [
62+
"## Der Typ boolean\n",
63+
"Der __boolean__ ist ein Typ, der genau zwei Werte besitzt: `True` und `False`. In Python3 sind diese beiden Literale Schlüsselwörter und können somit nicht als Variablennamen benutzt werden. Mit der `bool()`Funktion kann ein Wert in einen boolean umgewandelt werden."
64+
]
65+
},
66+
{
67+
"cell_type": "code",
68+
"execution_count": null,
69+
"metadata": {
70+
"scrolled": false,
71+
"slideshow": {
72+
"slide_type": "-"
73+
}
74+
},
75+
"outputs": [],
76+
"source": [
77+
"b1 = True\n",
78+
"b2 = False\n",
79+
"print(type(b1))\n",
80+
"print(type(b2))"
81+
]
82+
},
83+
{
84+
"cell_type": "markdown",
85+
"metadata": {
86+
"slideshow": {
87+
"slide_type": "-"
88+
}
89+
},
90+
"source": [
91+
"Der Typ eines Objektes bestimmt, wie dieses in einen boolean umgewandelt wird. Für die bisherigen Typen integer, float und string gilt:\n",
92+
"* ein integer ist `True`, solange er nicht `0` ist\n",
93+
"* ein float ist `True`, solange er nicht `0.0` ist\n",
94+
"* ein string ist `True`, solange er nicht leer, d.h. `''` ist"
95+
]
96+
},
97+
{
98+
"cell_type": "code",
99+
"execution_count": null,
100+
"metadata": {
101+
"scrolled": false,
102+
"slideshow": {
103+
"slide_type": "-"
104+
}
105+
},
106+
"outputs": [],
107+
"source": [
108+
"print(bool(\"\"))\n",
109+
"print(bool(0))\n",
110+
"print(bool(0.0))"
111+
]
112+
},
113+
{
114+
"cell_type": "markdown",
115+
"metadata": {
116+
"slideshow": {
117+
"slide_type": "-"
118+
}
119+
},
120+
"source": [
121+
"Genauso wie integer und floats gibt es auch für booleans Operatoren:\n",
122+
"* `and` das logische \"und\"\n",
123+
"* `or` das logische \"oder\"\n",
124+
"* `not` die logische Negation"
125+
]
126+
},
127+
{
128+
"cell_type": "code",
129+
"execution_count": null,
130+
"metadata": {
131+
"scrolled": false,
132+
"slideshow": {
133+
"slide_type": "-"
134+
}
135+
},
136+
"outputs": [],
137+
"source": [
138+
"print(\"not True:\", not True)\n",
139+
"print(\"True or False:\", True or False)\n",
140+
"print(\"True and False:\", True and False)"
141+
]
142+
},
143+
{
144+
"cell_type": "markdown",
145+
"metadata": {
146+
"slideshow": {
147+
"slide_type": "-"
148+
}
149+
},
150+
"source": [
151+
"Häufig möchte man Werte mit einander vergleichen, dafür gibt es die Vergleichsoperatoren, die für viele Typen definiert sind:\n",
152+
"\n",
153+
"* `==`: prüft auf Äquivalenz\n",
154+
"* `!=`: prüft auf Nicht-Äquivalenz\n",
155+
"* `>`: echtes größer\n",
156+
"* `<`: echtes kleiner\n",
157+
"* `>=`: größer gleich\n",
158+
"* `<=`: kleiner gleich\n",
159+
"* `is`: prüft auf Gleichheit\n",
160+
"\n",
161+
"Diese Operatoren liefern alle einen boolschen Wert, d.h. einen Wert vom Typ boolean zurück."
162+
]
163+
},
164+
{
165+
"cell_type": "code",
166+
"execution_count": null,
167+
"metadata": {
168+
"scrolled": false,
169+
"slideshow": {
170+
"slide_type": "-"
171+
}
172+
},
173+
"outputs": [],
174+
"source": [
175+
"print(5 < 3)"
176+
]
177+
},
178+
{
179+
"cell_type": "markdown",
180+
"metadata": {},
181+
"source": [
182+
"### \"==\" und \"is\"\n",
183+
"`==` prüft, ob die Variablen auf die gleichen Objekte zeigen. <br>\n",
184+
"`is` prüft, ob die Variablen auf dasselbe Objekt zeigen."
185+
]
186+
},
187+
{
188+
"cell_type": "code",
189+
"execution_count": null,
190+
"metadata": {
191+
"scrolled": false
192+
},
193+
"outputs": [],
194+
"source": [
195+
"print(\"==:\", 10**3 == 1000)\n",
196+
"print(\"is:\", 10**3 is 1000)"
197+
]
198+
},
199+
{
200+
"cell_type": "markdown",
201+
"metadata": {},
202+
"source": [
203+
"## if-Bedingung\n",
204+
"Nun da wir gelernt haben, was boolean-Werte sind können wir diese in einer if-Abfrage benutzen, Codeteile nur dann auszuführen, wenn eine Bedingung erfüllt ist. Sehen wir uns zunächst die Syntax einer if-Abfrage in Python an:\n",
205+
"```\n",
206+
"if Bedingung:\n",
207+
" Befehle\n",
208+
"```\n",
209+
"Wir starten mit dem Schlüsselwort `if`, dann kommt eine Bedingung, diese sollte einen boolschen Ausdruck zurückgeben, wir können diesen explicit angeben, der Interpreter ruft allerdings auf unsere Bedingung `bool()` auf und führt unsere Befehle aus, wenn diese `True`zurück gibt. Nach der Bedingung folgt ein Doppelpunkt `:`. Die nächste Zeile wird nun eingerückt, hierbei hat man sich auf __vier Leerzeichen__ geeinigt."
210+
]
211+
},
212+
{
213+
"cell_type": "code",
214+
"execution_count": null,
215+
"metadata": {
216+
"scrolled": false
217+
},
218+
"outputs": [],
219+
"source": [
220+
"eingabe = input(\"Bitte etwas eingeben: \")\n",
221+
"if eingabe: # alternativ: bool(eingabe) oder eingabe != \"\"\n",
222+
" print(eingabe)"
223+
]
224+
},
225+
{
226+
"cell_type": "markdown",
227+
"metadata": {},
228+
"source": [
229+
"Im obigen Codebeispiel prüft die if-Bedingung ob der String `eingabe` leer ist. Dies geschieht implizit, d.h. es wird ausgenutzt, dass der Interpreter die Bedingung in einen boolean umwandelt. In dem Kommentar sind alternative Bedingungen beschrieben, die daselbe erreichen allerdings umständlicher sind. <br>\n",
230+
"Wenn wir uns aber an unser Problem aus der Einleitung erinnern, war unser Ziel eine Zahl aus der Eingabe zu lesen und Fehler durch falsche Benutzereingaben abzufangen. Wir wollen also darauf reagieren, wenn nichts eingegeben wurde, wenn eine Zahl eingegeben wurde und wenn eine Zeichenkette eingegeben wurde, die nicht als integer interpretiert werden kann."
231+
]
232+
},
233+
{
234+
"cell_type": "code",
235+
"execution_count": null,
236+
"metadata": {
237+
"scrolled": false
238+
},
239+
"outputs": [],
240+
"source": [
241+
"eingabe = input(\"Bitte etwas eingeben: \")\n",
242+
"\n",
243+
"if eingabe.isdigit():\n",
244+
" zahl = int(eingabe)\n",
245+
" print(zahl)\n",
246+
"\n",
247+
"else:\n",
248+
" print(\"Ungültige Eingabe:\", eingabe)"
249+
]
250+
},
251+
{
252+
"cell_type": "markdown",
253+
"metadata": {},
254+
"source": [
255+
"Wie wir sehen können passiert im obigen Codebeispiel eine Menge auf einmal, gehen wir es also in Ruhe durch.\n",
256+
"In der if-Abfrage wird mit der `str.isdigit()` Methode geprüft, ob der string `eingabe` nicht leer ist und nur aus Ziffern besteht, wenn dem so ist, erstellen wir einen integer `zahl` aus der Eingabe und geben diesen aus. In einem `else` Zweig, der ausgeführt wird, wenn die Bedingung der if-Abfrage nicht zutraf, geben wir dem Benutzer Feedback über seine falsche Eingabe zurück."
257+
]
258+
},
259+
{
260+
"cell_type": "code",
261+
"execution_count": null,
262+
"metadata": {},
263+
"outputs": [],
264+
"source": []
265+
}
266+
],
267+
"metadata": {
268+
"celltoolbar": "Raw Cell Format",
269+
"kernelspec": {
270+
"display_name": "Python 3",
271+
"language": "python",
272+
"name": "python3"
273+
},
274+
"language_info": {
275+
"codemirror_mode": {
276+
"name": "ipython",
277+
"version": 3
278+
},
279+
"file_extension": ".py",
280+
"mimetype": "text/x-python",
281+
"name": "python",
282+
"nbconvert_exporter": "python",
283+
"pygments_lexer": "ipython3",
284+
"version": "3.6.7"
285+
}
286+
},
287+
"nbformat": 4,
288+
"nbformat_minor": 2
289+
}

0 commit comments

Comments
 (0)