{
"cells": [
{
"cell_type": "markdown",
"id": "e1b51d56-61aa-4056-ab07-cec2b961c9ca",
"metadata": {},
"source": [
"# Python Grundlagen Workshop\n",
"\n",
"\n",
"\n",
"Auszug aus [prophinder](https://www.ph-online.ac.at/phsalzburg/ee/ui/ca2/app/desktop/#/slc.tm.cp/student/courses/265702?$ctx=design=ca;lang=en&$scrollTo=toc_overview): \n",
"\n",
"1. [Grundlagen der Programmierung](#basics)\n",
"1. [Variablen](#vars)\n",
"1. [Bedingungen](#conditions)\n",
"1. [Schleifen](#loops)\n",
"1. [Funktionen](#functions)\n",
"1. [Wrap Up Exercises](#wrapup)\n",
"\n",
"... mit viiielen Übungen dazwischen. :-)"
]
},
{
"cell_type": "markdown",
"id": "655e196e-3634-4ac3-b6d8-d02e9484f08f",
"metadata": {},
"source": [
"\n",
"## 1. Grundlagen der Programmierung"
]
},
{
"cell_type": "markdown",
"id": "8d8d4ff6-e034-4477-81c0-6eecf85a1f65",
"metadata": {},
"source": [
"### Hello, World!\n",
"Das Erste, dass in einer neuen Programmiersprache ausgeführt wird, ist der `Hello, World!` Starter code. In Python ist das nur eine einzige Zeile Code.\n",
"\n",
"Hierzu nutzen wir die `print(...)` Funktion. Die ist direkt in Python, ohne Zusatzbibliothek, verfügbar."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "ce616bca-3e55-4892-b3b6-1a13d7f3985a",
"metadata": {},
"outputs": [],
"source": [
"print(\"Hello World\")"
]
},
{
"cell_type": "markdown",
"id": "0ca9b745-b568-4216-b08b-6be24d4372d6",
"metadata": {},
"source": [
"### Basic Syntax\n",
"Der Python Syntax ist sauber und leicht zu lesen. Im Vergleich zu anderen Hochsprachen werden Blöcke nicht mit geschwungenen Klammern, sondern mit Einrückungen, angezeigt.\n",
"Eine Zeile, die einen Kommentar enthält, beginnt mit ``#``.\n",
"\n",
"__Quelle:__ https://docs.python.org/3.11/reference/lexical_analysis.html#line-structure"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "94e04732-9471-4e53-ad01-5bcac5c9d356",
"metadata": {},
"outputs": [],
"source": [
"# no semicolon at the end of a statement\n",
"x = 1\n",
"# colon at the end of conditions and loops\n",
"if x == 1:\n",
" # indentation to denote different levels of scope\n",
" print('x ist eins.') # this comment ends a line"
]
},
{
"cell_type": "markdown",
"id": "249625dd-32a2-445d-9a26-8d543072d493",
"metadata": {},
"source": [
"#### Übung 1\n",
"Geben Sie ihren Namen (oder einen anderen beliebigen Text) mit der ``print(...)``-Funktion aus."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "ff974982-3d44-4385-9711-be6561987c8a",
"metadata": {
"deletable": false,
"nbgrader": {
"cell_type": "code",
"checksum": "f3c0d85380d87c92f2f2c5cff60f7e0d",
"grade": true,
"grade_id": "cell-d453eb9567b6346a",
"locked": false,
"points": 0,
"schema_version": 3,
"solution": true,
"task": false
}
},
"outputs": [],
"source": [
"# YOUR CODE HERE\n",
"raise NotImplementedError()"
]
},
{
"cell_type": "markdown",
"id": "69696e4a-e6c5-43e4-93f2-9d7e65396627",
"metadata": {},
"source": [
"\n",
"## 2. Variablen"
]
},
{
"cell_type": "markdown",
"id": "f96089d7-9689-466b-99c3-74b8cc3d6dcb",
"metadata": {},
"source": [
"### Variablen und Typen\n",
"\n",
"Python ist eine dynamische Programmiersprache, d.h. es muss kein Datentyp beim Erstellen einer Variable angegeben werden. "
]
},
{
"cell_type": "markdown",
"id": "e7c9f2af-a7fc-4363-b937-316f7a30850d",
"metadata": {},
"source": [
"#### Zahlen\n",
"Python unterstützt von Haus aus zwei Arten von Zahlen - Ganzzahlen und Fließkommazahlen. Die Voreinstellung sind Ganzzahlen."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "e0fcb741-9351-4421-874c-a23adb5f6aeb",
"metadata": {},
"outputs": [],
"source": [
"int_number = 7\n",
"print(int_number)"
]
},
{
"cell_type": "markdown",
"id": "cd8fb42e-185a-4010-a389-b262293fd63b",
"metadata": {},
"source": [
"Eine der beiden folgenden Notationen kann zur Definition einer Gleitkommazahl verwendet werden:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "2697ab05-9c86-4519-a737-e83ee6cd8047",
"metadata": {},
"outputs": [],
"source": [
"float_number = 7.0\n",
"print(float_number)\n",
"\n",
"float_number = float(7)\n",
"print(float_number)"
]
},
{
"cell_type": "markdown",
"id": "cb89f8bd-ee5f-4542-9676-b534fc78649b",
"metadata": {},
"source": [
"#### Strings\n",
"Zeichenketten (Strings) werden entweder in einfachen oder in doppelten Anführungszeichen definiert:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "2759367f-2195-44fe-9f3e-52032d4695c7",
"metadata": {},
"outputs": [],
"source": [
"hello_string = 'hello'\n",
"print(hello_string)\n",
"\n",
"hello_string = \"hello\"\n",
"print(hello_string)"
]
},
{
"cell_type": "markdown",
"id": "1d89abaf-37eb-4093-bb1a-2e0c0920b852",
"metadata": {},
"source": [
"Der Unterschied zwischen den beiden besteht darin, dass die Verwendung von doppelten Anführungszeichen das Einfügen von Apostrophen erleichtert. (Bei der Verwendung von einfachen Anführungszeichen würden diese die Zeichenfolge abschließen)."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "06dbe21e-9df3-42d1-9ba9-110749a2e7c1",
"metadata": {},
"outputs": [],
"source": [
"apostrophe_sent = \"Don't worry about apostrophes.\"\n",
"print(apostrophe_sent)"
]
},
{
"cell_type": "markdown",
"id": "7446aa1d-3619-47fc-afe1-63759dfb543a",
"metadata": {},
"source": [
"Ein Backslash kann am Ende einer Zeile hinzugefügt werden, um den Zeilenumbruch zu ignorieren:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "916c316f-4a62-4f89-87b6-f2f07a857023",
"metadata": {},
"outputs": [],
"source": [
"'This string will not include \\\n",
"backslashes or newline characters.'"
]
},
{
"cell_type": "markdown",
"id": "8f925461-7ac2-46e5-b1c9-b9d87c6ee229",
"metadata": {},
"source": [
"Einfache Operatoren können auf Zahlen und Zeichenketten angewendet werden:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "155ca631-8e2e-4ffd-84f9-c6f0f1dac4e4",
"metadata": {},
"outputs": [],
"source": [
"one = 1\n",
"two = 2\n",
"three = one + two\n",
"print(three)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8e9f9050-91aa-492c-8734-5aeff4dbe3f1",
"metadata": {},
"outputs": [],
"source": [
"hello = \"hello\"\n",
"world = \"world\"\n",
"helloworld = hello + \" \" + world\n",
"print(helloworld)"
]
},
{
"cell_type": "markdown",
"id": "d184d457-d65d-4893-aec1-1e30fa9ec13d",
"metadata": {},
"source": [
"Das Mischen von Operatoren zwischen Zahlen und Strings wird nicht unterstützt (``TypeError``):"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "58590ce1-c2f2-421f-864d-2eef195aff84",
"metadata": {},
"outputs": [],
"source": [
"one = 1\n",
"two = 2\n",
"hello = \"hello\"\n",
"print(one + two + hello)"
]
},
{
"cell_type": "markdown",
"id": "61da0873-061a-4805-8d68-35936cfbceb7",
"metadata": {},
"source": [
"#### Übung 2\n",
"Erstellen Sie vier Variablen:\n",
"- die Variable `strasse` mit einem Straßennamen als Zeichenkette,\n",
"- die Variable `hausnummer` als Ganzzahl, \n",
"- die Variable `ort` enthält den Ortsnamen und\n",
"- die Variable mit dem Namen `plz` (als Ganzzahl).\n",
"\n",
"Geben Sie, ähnlich zu Übung 1, einen Adressblock aus, der alle Informationen zur Adresse enthält.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "a688fd75-052d-4c7a-9692-d20c3e8000b9",
"metadata": {
"deletable": false,
"nbgrader": {
"cell_type": "code",
"checksum": "1f3a637d535d96f8d2796399e3e5520b",
"grade": true,
"grade_id": "cell-229b80aa99dea608",
"locked": false,
"points": 0,
"schema_version": 3,
"solution": true,
"task": false
}
},
"outputs": [],
"source": [
"# YOUR CODE HERE\n",
"raise NotImplementedError()"
]
},
{
"cell_type": "markdown",
"id": "9f57c089-dc26-4d51-9564-f5564af19034",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"\n",
"## Lists\n",
"\n",
"Listen sind ein sehr wichtiger Datentyp in Python. Stellen Sie sich Listen wie Arrays vor. Sie können jede Art von Variablen und so viele Variablen wie nötig enthalten. Listen können auch auf einfache Art und Weise durchlaufen werden:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "2d95f835-b860-4f88-8139-2e866e3cd955",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"outputs": [],
"source": [
"number_list = [] # creates an empty list\n",
"number_list.append(1) # add elements at the end of the list\n",
"number_list.append(2)\n",
"number_list.append(3)\n",
"print(number_list)\n",
"print(number_list[0]) # accessing a single list element by its index\n",
"print(number_list[2])"
]
},
{
"cell_type": "markdown",
"id": "58ab61cc-300b-4270-ae99-d866b7e85d6f",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"Der Zugriff auf einen Index, der nicht existiert, erzeugt eine Ausnahme (``IndexError``):"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b1de4738-b433-478b-8f1f-4f2cbffbaec1",
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [],
"source": [
"number_list = [1, 2, 3]\n",
"print(number_list[9])"
]
},
{
"cell_type": "markdown",
"id": "6f4a34f0-62cc-48a8-8e03-01b08864d011",
"metadata": {},
"source": [
"#### Übung 3\n",
"Erstellen Sie eine Liste, mit den Quadraten von 1 bis 5 ($1^2 - 5^2$ ), speichern diese in die Variable `liste_quadrate` und geben Sie diese aus. Wir brauchen diese später dann noch."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d5de7814-199f-448d-892a-dbaf06e97bf4",
"metadata": {
"deletable": false,
"nbgrader": {
"cell_type": "code",
"checksum": "c064266e5cfdd2b50883e7947078c2e4",
"grade": true,
"grade_id": "cell-f755806c1b2bd547",
"locked": false,
"points": 0,
"schema_version": 3,
"solution": true,
"task": false
}
},
"outputs": [],
"source": [
"# YOUR CODE HERE\n",
"raise NotImplementedError()"
]
},
{
"cell_type": "markdown",
"id": "a5144b42-3d06-41c3-b286-64199d6adb11",
"metadata": {
"deletable": false,
"editable": false,
"nbgrader": {
"cell_type": "markdown",
"checksum": "528b145f0b273ea548bd6d618d2ad224",
"grade": false,
"grade_id": "cell-897e9dfc5f720dd3",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
},
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"### Negative Indizierung\n",
"Mit der negativen Indizierung ist es möglich, die Listenelemente beginnend mit -1 vom Ende der Liste aus zu zählen.\n",
"\n",
""
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "19437547-5bff-4fef-9851-03ce5902f268",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"outputs": [],
"source": [
"colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']\n",
"print('Letztes Element:')\n",
"print(colors[-1])\n",
"print('Vorletztes Element:')\n",
"print(colors[-2])"
]
},
{
"cell_type": "markdown",
"id": "76f97d78-19e4-421d-9fbc-e581ae03cef8",
"metadata": {
"deletable": false,
"editable": false,
"nbgrader": {
"cell_type": "markdown",
"checksum": "3c7dc7567b808cd67bf1ab0e018a2b5c",
"grade": false,
"grade_id": "cell-73ee847a103a3bba",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
},
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"### Listenaufteilung\n",
"Die Aufteilung einer Liste wird verwendet, wenn man nur einen Teil der Liste abrufen möchte. Die grundlegende Syntax ist ``start:stop``, wobei ``start`` inklusiv und ``stop`` exlusiv ist."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d486d3d5-2dc0-49b5-961d-c6d4e5fca4e1",
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [],
"source": [
"numbers = [10, 20, 30, 40, 50, 60, 70, 80, 90]\n",
"\n",
"# take elements with index 2 to 6\n",
"print(numbers[2:7])"
]
},
{
"cell_type": "markdown",
"id": "a6a05ae3-b1f2-410d-8fe3-3e564cdd4baa",
"metadata": {
"deletable": false,
"editable": false,
"nbgrader": {
"cell_type": "markdown",
"checksum": "94c507d44bb34e965961689914974a08",
"grade": false,
"grade_id": "cell-2b133d4efcd73631",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
},
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"Die vollständige Syntax für die Aufteilung lautet ``start:stop:step``. Schritt\" erlaubt es uns, nur jedes n-te Element aus der Liste zu nehmen:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "64319248-5796-4074-bbfa-3a89b403deb0",
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [],
"source": [
"# take every 2nd element\n",
"numbers[2:7:2]"
]
},
{
"cell_type": "markdown",
"id": "0f5a938b-88ab-4535-a90a-9b9e54d60caa",
"metadata": {
"deletable": false,
"editable": false,
"nbgrader": {
"cell_type": "markdown",
"checksum": "a9daaf56373424bb406b6ba6a41cd8c5",
"grade": false,
"grade_id": "cell-5166a0088bb3235b",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
},
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"Wenn ``start`` das erste oder ``stop`` das letzte Element ist, kann der Index weglassen werden:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "6f305859-2536-466d-89b8-a7cf65fbcf0c",
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [],
"source": [
"# take the first 5 elements\n",
"print(numbers[:5])\n",
"\n",
"# take all elements beginning from index 5\n",
"print(numbers[5:])"
]
},
{
"cell_type": "markdown",
"id": "fbbb24de-c45b-45c7-9b16-e8ecf77f4580",
"metadata": {},
"source": [
"#### Übung 4\n",
"Aus der Liste `liste_quadrate`, geben sie das 2., 3., 4. und 5. Element (nur das erste und das letzte Element werden ignoriert) der Liste mithilfe einer Listenaufteilung auf einmal aus.\n",
"\n",
"_Hinweis:_ wenn die Liste `liste_quadrate` richtig erstellt wurde, ist das Ergebnis `[4, 9, 16, 25]`."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "dccb5642-d889-4fe0-8f48-930bc2e19d6d",
"metadata": {},
"outputs": [],
"source": [
"liste_quadrate[1:5]"
]
},
{
"cell_type": "markdown",
"id": "648f1b75-648f-4999-be88-52860471cb39",
"metadata": {
"deletable": false,
"editable": false,
"nbgrader": {
"cell_type": "markdown",
"checksum": "2b8d4d2d5d1992f40c3b4637425d38fd",
"grade": false,
"grade_id": "cell-34ce2724627740af",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
},
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"\n",
"## Grundlegende Operatoren\n",
"Schauen wir uns nun einige grundlegende mathematische Operatoren wie ``+``, ``-`` oder ``*`` und ihr Verhalten an.\n",
"\n",
"Stellen Sie sich zunächst die Gleichung $x = 1+\\frac{2\\cdot3}{4}$ vor und was der Wert von ``x`` sein wird. Programmieren Sie dann diese Gleichung in Python-Syntax und geben Sie das Ergebnis aus."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c0893a67-a632-474f-9355-0f8b3da8e1be",
"metadata": {
"deletable": false,
"nbgrader": {
"cell_type": "code",
"checksum": "d0b5549ac74123bbc20e5eb126ed3eaa",
"grade": true,
"grade_id": "cell-fc32f384030efd59",
"locked": false,
"points": 0,
"schema_version": 3,
"solution": true,
"task": false
},
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [],
"source": [
"# YOUR CODE HERE\n",
"raise NotImplementedError()\n",
"print(x)"
]
},
{
"cell_type": "markdown",
"id": "502f1cd5-85ab-4604-b60f-ec5e3d7a973c",
"metadata": {
"deletable": false,
"editable": false,
"nbgrader": {
"cell_type": "markdown",
"checksum": "2d179b50cc211fb515c32ad0d60ae4e1",
"grade": false,
"grade_id": "cell-6d76611dc9a2c097",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
},
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"---\n",
"**FRAGEN**\n",
"\n",
"1. Sind Klammern erforderlich, um bestimmte Ausdrücke zu gruppieren?\n",
"1. Hält sich Python an die mathematische Reihenfolge/Hierarchie der Operationen?\n",
"1. erhält man eine Fließkommazahl als Ergebnis?\n",
"---\n",
"\n",
"#### Übung 5\n",
"Suchen Sie im Internet, was der Potenzoperator in Python ist. Wie kann die folgende Gleichung gelöst werden: $x = 7^2$?"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "4f29c6be-143f-4b29-9978-1af8fb1c5bcb",
"metadata": {
"deletable": false,
"nbgrader": {
"cell_type": "code",
"checksum": "e4d7646f542b0c5740b211b53e0949ef",
"grade": true,
"grade_id": "cell-5ec626fec1e93b16",
"locked": false,
"points": 0,
"schema_version": 3,
"solution": true,
"task": false
},
"slideshow": {
"slide_type": "subslide"
}
},
"outputs": [],
"source": [
"# YOUR CODE HERE\n",
"raise NotImplementedError()"
]
},
{
"cell_type": "markdown",
"id": "8f29de3b-2df5-4c8c-9f39-1a08c5bac799",
"metadata": {},
"source": [
"#### Übung 6\n",
"In der Informatik wird oft der Rest einer Division benötigt (Hinweis: den brauchen wir später noch). Suchen Sie im Internet, wie man den Rest einer Division berechnet."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "593fa2e0-48f4-459f-b784-8098d0d13611",
"metadata": {
"deletable": false,
"nbgrader": {
"cell_type": "code",
"checksum": "c6650bfbe8109425317dd2b7448ff5a8",
"grade": true,
"grade_id": "cell-77ea1c2c71c03005",
"locked": false,
"points": 0,
"schema_version": 3,
"solution": true,
"task": false
}
},
"outputs": [],
"source": [
"# YOUR CODE HERE\n",
"raise NotImplementedError()"
]
},
{
"cell_type": "markdown",
"id": "3b9ebefc-24a8-4257-a4dc-1f8619e6efa0",
"metadata": {
"deletable": false,
"editable": false,
"nbgrader": {
"cell_type": "markdown",
"checksum": "766d1b0596a73e7dbf3d0ddee3004b2b",
"grade": false,
"grade_id": "cell-3c80d279e70790f7",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
},
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"\n",
"## String-Operationen und Formatierung\n",
"Python verfügt über eine Vielzahl von eingebauten String-Operationen. Hier sind nur ein paar als Beispiel:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "89ad4fa0-29d0-40d5-9753-3c340b81445c",
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [],
"source": [
"sentence = 'Johnathan is 25 years old and lives in Boston, MA, USA.'\n",
"print(sentence.lower())\n",
"print(sentence.split(\" \"))\n",
"print(sentence.split(\" \")[0])"
]
},
{
"cell_type": "markdown",
"id": "84a6a77d-f7f8-40ba-9bf6-fbda80f3501c",
"metadata": {
"deletable": false,
"editable": false,
"nbgrader": {
"cell_type": "markdown",
"checksum": "7185dfac3430c5898c93698319956ef4",
"grade": false,
"grade_id": "cell-8e8c82fe7cd462dc",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
},
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"Mithilfe von sogenannten f-strings kann man Zeichenketten sogar noch einfacher mit Zahlen kombinieren. *Achtung*, hier ist ein `f'...'` vor den Anführungszeichen notwendig."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "fa08e392-4f09-437d-81cf-b0d6847d3288",
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [],
"source": [
"name = \"Johnathan\"\n",
"age = 25\n",
"height = 187.2\n",
"print(\n",
" f'{name} is {age} years old.\\nHe is {height:.2f} cm tall.\\nHis favourite number is {odd_numbers[1]}.'\n",
")"
]
},
{
"cell_type": "markdown",
"id": "77f3a590-aa34-47c0-b2a3-c7df16067294",
"metadata": {
"deletable": false,
"editable": false,
"nbgrader": {
"cell_type": "markdown",
"checksum": "e1911c951b4aaf6542276d7499a60000",
"grade": false,
"grade_id": "cell-ea5c68f1bfb35593",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
},
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"---\n",
"**FRAGEN**\n",
"\n",
"1. Was machen die Zeichen `'\\n'`?\n",
"2. Was passiert, wenn Sie ``{height:.2f}`` in ``{height:.4f}`` ändern?\n",
"---\n",
"\n",
"#### Übung 7\n",
"Jonathans Spitzname ist 'John'. Geben Sie dies mit einer einzigen Zeile Python-Code aus, indem Sie die erforderlichen Zeichen in der Zeichenfolge ``name`` direkt in der Druckanweisung indizieren."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "dfb23caf-3c70-43a5-965a-341aabd51bf3",
"metadata": {
"deletable": false,
"nbgrader": {
"cell_type": "code",
"checksum": "9926310532ffadd0bf7bb52e99e05fe8",
"grade": true,
"grade_id": "cell-565a5f96cc73ee3e",
"locked": false,
"points": 0,
"schema_version": 3,
"solution": true,
"task": false
},
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [],
"source": [
"# YOUR CODE HERE\n",
"raise NotImplementedError()"
]
},
{
"cell_type": "markdown",
"id": "38daab40-f286-4f02-be0c-448655e38729",
"metadata": {
"deletable": false,
"editable": false,
"nbgrader": {
"cell_type": "markdown",
"checksum": "83cecdc1080df6123c08b934060b5172",
"grade": false,
"grade_id": "cell-e5024379bddee850",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
},
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"---\n",
"**FRAGEN**\n",
"\n",
"3. Wie kann man die Stringfunktion ``count`` benutzen, um herauszufinden, wie viele ``a`` der ``sentence`` enthält?\n",
"4. Kann man Funktionen iterativ auf ein und dasselbe Objekt anwenden, z.B. ``lower`` und ``count``?\n",
"---"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "adbecefe-1767-4604-9330-88174167dec1",
"metadata": {
"deletable": false,
"nbgrader": {
"cell_type": "code",
"checksum": "0fa07baaa00a377b48a3732bd91452ba",
"grade": true,
"grade_id": "cell-ee7fdac581744f9d",
"locked": false,
"points": 0,
"schema_version": 3,
"solution": true,
"task": false
},
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [],
"source": [
"# YOUR CODE HERE\n",
"raise NotImplementedError()\n",
"print(f\"The sentence '{sentence}' contains {number_a} 'a's.\")"
]
},
{
"cell_type": "markdown",
"id": "e5241da4-9c8f-4f61-92e5-b975be4c8009",
"metadata": {
"deletable": false,
"editable": false,
"nbgrader": {
"cell_type": "markdown",
"checksum": "e9858f55c74492b69e8973a5ae58c593",
"grade": false,
"grade_id": "cell-cc13f130ab0f9963",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
},
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"\n",
"## 3. Bedingungen\n",
"Python verwendet boolesche Variablen, um Bedingungen auszuwerten. Die booleschen Werte ``True`` und ``False`` werden zurückgegeben, wenn ein Ausdruck verglichen oder ausgewertet wird. Zum Beispiel:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cde6ee7b-63c5-4c60-9fa3-c9509a6dcbf5",
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [],
"source": [
"x = 2 # value assignment\n",
"print(x == 2) # equals\n",
"print(x != 3) # is not equal to\n",
"print(x >= 3) # is greater than or equal to\n",
"print(x < 3) # is lower than"
]
},
{
"cell_type": "markdown",
"id": "7777f603-7a4e-448c-887d-e35d9ee531a8",
"metadata": {
"deletable": false,
"editable": false,
"nbgrader": {
"cell_type": "markdown",
"checksum": "5a819c91669f690b11932791ad600555",
"grade": false,
"grade_id": "cell-a0ec15d57941486a",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
},
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"### 3.1 Die if-Anweisung\n",
"Die vollständige Syntax einer if-Anweisung sieht wie folgt aus:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "4fbc14de-1ecd-4a72-9353-881635e8e655",
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [],
"source": [
"x = 5\n",
"if x > 5:\n",
" print(\"x is larger than 5.\")\n",
"elif x < 5:\n",
" print(\"x is smaller than 5.\")\n",
"else:\n",
" print(\"x is 5.\")"
]
},
{
"cell_type": "markdown",
"id": "ccd5366a-316d-4e04-a997-f907bd6b1c7a",
"metadata": {
"deletable": false,
"editable": false,
"nbgrader": {
"cell_type": "markdown",
"checksum": "b57acbb5823cad5b5d5f0f1adfdb7b40",
"grade": false,
"grade_id": "cell-32101507b4816869",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
},
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"### 3.2 Boolesche Operatoren\n",
"Die booleschen Operatoren ``and`` und ``or`` ermöglichen die Bildung komplexer boolescher Ausdrücke:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "9e398ee1-44f7-48d2-8d13-0e4fc012ef15",
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [],
"source": [
"name = \"John\"\n",
"age = 23\n",
"if name == \"John\" and age == 23:\n",
" print(\"Your name is John, and you are also 23 years old.\")\n",
"\n",
"if name == \"John\" or name == \"Rick\":\n",
" print(\"Your name is either John or Rick.\")"
]
},
{
"cell_type": "markdown",
"id": "f6d8c799-74ec-423d-8d0c-941eb0caa24b",
"metadata": {},
"source": [
"#### Übung 8\n",
"Implementieren Sie eine Abfrage für eine Fahrschule: Jugendliche dürfen ab 15 Jahren mit dem Moped-Führerschein beginnen, ab 16 Jahren mit dem Führerschein für die Klasse B (L17). Bei einer Abfrage muss überprüft werden, ob ein$\\cdot$e potenzielle$\\cdot$r Kunde$\\cdot$in alt genug ist.\n",
"\n",
"Erstellen Sie eine Variable, die ein Alter beinhaltet. Schreiben Sie eine Bedingung, die überprüft, für welche Klasse ein$\\cdot$e Kunde$\\cdot$in den Führerschein machen darf.\n",
"Ist die Kundschaft für keinen Führerschein alt genug ist, soll das auch ausgegeben werden.\n",
"\n",
"Überprüfen Sie alle Varianten durch.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "f959c770-8754-468d-ad93-b7c408a33250",
"metadata": {
"deletable": false,
"nbgrader": {
"cell_type": "code",
"checksum": "0345b196c19a8f70ac4fd0778d4205de",
"grade": true,
"grade_id": "cell-02706900a4861b43",
"locked": false,
"points": 0,
"schema_version": 3,
"solution": true,
"task": false
}
},
"outputs": [],
"source": [
"# YOUR CODE HERE\n",
"raise NotImplementedError()"
]
},
{
"cell_type": "markdown",
"id": "a345933b-7e7d-4f85-ad64-5997c99d6e7f",
"metadata": {},
"source": [
"#### Übung 9\n",
"Selbiges wie Übung 7, jedoch interessiert nun die Fahrschule, ob es ok ist, ob ein$\\cdot$e Interessent$\\cdot$in alt genug für einen gewissen Führerschein ist.\n",
"\n",
"Fügen Sie zusätzlich zum Alter noch eine zweite Variable hinzu, die die Führerscheinklasse angibt.\n",
"\n",
"_Hinweis:_ für die Variable der Führerscheinklasse dürfen Sie sich was überlegen - hier gibt es ganz viele Möglichkeiten. :-)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "08d63ded-ae02-42b3-8077-08f611f5216c",
"metadata": {
"deletable": false,
"nbgrader": {
"cell_type": "code",
"checksum": "ac088b22beccc9abb6f3aac67f22c54c",
"grade": true,
"grade_id": "cell-eef5ce6f7f094615",
"locked": false,
"points": 0,
"schema_version": 3,
"solution": true,
"task": false
}
},
"outputs": [],
"source": [
"# YOUR CODE HERE\n",
"raise NotImplementedError()"
]
},
{
"cell_type": "markdown",
"id": "f3f44df5-eb69-4ffe-bf70-0f6169fa2d67",
"metadata": {},
"source": [
"\n",
"## 4. Schleifen\n",
"In Python gibt es zwei Arten von Schleifen, ``for`` und ``while``.\n",
"\n",
"\n",
"### 4.1 For-Schleifen\n",
"For-Schleifen iterieren über eine bestimmte Sequenz, z. B. eine Liste. Hier ist (glücklicherweise) die Schreibweise sehr intuitiv und zeigt an, was gemacht wird und was in welcher Variable steht:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d8b575e2-2d4e-4625-8fec-f48f6818f3f0",
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [],
"source": [
"primes = [2, 3, 5, 7]\n",
"for prime in primes:\n",
" print(prime)"
]
},
{
"cell_type": "markdown",
"id": "c98f71cc-28db-4046-99b4-5fcc0fc729a5",
"metadata": {
"deletable": false,
"editable": false,
"nbgrader": {
"cell_type": "markdown",
"checksum": "379ea01e6e2ab8b14964d4a5a0fe0017",
"grade": false,
"grade_id": "cell-3c3f9582b2be9725",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
},
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"For-Schleifen können mit der Funktion ``range`` über eine Folge von Zahlen iterieren. Die Art und Weise, wie ``range`` funktioniert, ist der Listenaufteilung sehr ähnlich:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d7c5e3ec-e7b2-44fb-afa3-239e81046661",
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [],
"source": [
"for x in range(5):\n",
" print(x)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "de5d84f4-810e-4295-b5dd-c082417097b4",
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [],
"source": [
"for x in range(3, 6):\n",
" print(x)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "52e9776e-93c0-4a38-ace3-6ac85e870659",
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [],
"source": [
"for x in range(3, 8, 2):\n",
" print(x)"
]
},
{
"cell_type": "markdown",
"id": "04fa250a-5f4b-4a76-861d-ddd3099c2907",
"metadata": {},
"source": [
"#### Übung 10\n",
"Geben Sie alle Zahlen von 1 bis 20 so aus, dass alle geraden Zahlen einfach und alle ungeraden Zahlen negativ ausgegeben werden."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "485772a3-6c4f-4f7b-9105-9a8fef784c25",
"metadata": {
"deletable": false,
"nbgrader": {
"cell_type": "code",
"checksum": "52906341b002e51f60dc99896f76b8b6",
"grade": true,
"grade_id": "cell-b2c1aa188b21d57f",
"locked": false,
"points": 0,
"schema_version": 3,
"solution": true,
"task": false
}
},
"outputs": [],
"source": [
"# YOUR CODE HERE\n",
"raise NotImplementedError()"
]
},
{
"cell_type": "markdown",
"id": "ef5beee0-1edf-4b65-94d5-68b91283b74e",
"metadata": {
"deletable": false,
"editable": false,
"nbgrader": {
"cell_type": "markdown",
"checksum": "5613e879998576d494dd063c8bfde61f",
"grade": false,
"grade_id": "cell-fdafc812dbe446f6",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
},
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"### 4.2 while-Schleifen\n",
"While-Schleifen werden so lange wiederholt, wie eine bestimmte boolesche Bedingung erfüllt ist."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "ef0e7dff-67d3-4b07-8e97-107edce02151",
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [],
"source": [
"count = 0\n",
"while count < 5:\n",
" print(count)\n",
" count += 1"
]
},
{
"cell_type": "markdown",
"id": "8000dd03-4546-40b6-92bb-ba7818c92653",
"metadata": {
"deletable": false,
"editable": false,
"nbgrader": {
"cell_type": "markdown",
"checksum": "90f8b58bc759dce199543463abc86a44",
"grade": false,
"grade_id": "cell-870ee96b945965af",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
},
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"\n",
"## 5. Funktionen\n",
"\n",
"Funktionen in Python werden mit dem Block-Schlüsselwort ``def`` definiert, gefolgt vom Namen der Funktion. \n",
"Der Funktionsblock wird durch Einrückungen mit Leerzeichen gekennzeichnet."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "5692f8c8-ffd3-4032-9586-a120de32c6d2",
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [],
"source": [
"def greeting_function():\n",
" print(\"Greetings from this function.\")"
]
},
{
"cell_type": "markdown",
"id": "9443680e-7571-44ac-91dd-3b28b195de2f",
"metadata": {
"deletable": false,
"editable": false,
"nbgrader": {
"cell_type": "markdown",
"checksum": "0f3fed148628d7f251508966501642d5",
"grade": false,
"grade_id": "cell-8b567a0d56bf5058",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
},
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"Natürlich können Python-Funktionen auch Argumente und Rückgabewerte beinhalten:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "7f199733-c764-4499-bf44-d11192606f72",
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [],
"source": [
"def sum_two_numbers(a, b):\n",
" print(f'The sum of {a} + {b} is {a + b}.')\n",
" return a + b"
]
},
{
"cell_type": "markdown",
"id": "0cce3505-7835-4ef5-b482-5afffa366f63",
"metadata": {
"deletable": false,
"editable": false,
"nbgrader": {
"cell_type": "markdown",
"checksum": "8fcc7078446807465e43e626004e5042",
"grade": false,
"grade_id": "cell-bad2a110f4492a1c",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
},
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"Nun, rufen wir die Funktion auf!"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "e01180f7-6b24-4acb-bda9-fe3421309806",
"metadata": {
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [],
"source": [
"greeting_function()\n",
"result = sum_two_numbers(7, 3)"
]
},
{
"cell_type": "markdown",
"id": "13298e25-1889-4e91-8239-abff1e0edfcf",
"metadata": {
"deletable": false,
"editable": false,
"nbgrader": {
"cell_type": "markdown",
"checksum": "2b4e14728766ac39c2272c61b66231a2",
"grade": false,
"grade_id": "cell-f8c91cc11282a4c0",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
},
"slideshow": {
"slide_type": "fragment"
}
},
"source": [
"Beachten Sie, dass alle Python-Funktionen einen Wert zurückgeben. Der Rückgabewert ist ``None``, wenn die return-Anweisung weggelassen wird oder die Anweisung nur ``return`` lautet. Es ist auch möglich, mehrere Werte zurückzugeben."
]
},
{
"cell_type": "markdown",
"id": "ecabb24a-a112-4c88-8f71-f3fa8afbb7a1",
"metadata": {},
"source": [
"\n",
"## 6. Wrap Up Exercises\n",
"### 6.1. Einfache Mathematik\n",
"Schreiben Sie einen Codeschnipsel, der die folgende Wertzuweisung implementiert: $x = \\frac{5^3-4}{2+6}$. Geben Sie dann das Ergebnis mit genau 2 Nachkommastellen aus."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "86f3fc49-2d23-4481-949b-f93e49707f3f",
"metadata": {
"deletable": false,
"nbgrader": {
"cell_type": "code",
"checksum": "bc0a0b8723c3c28a9b2880ad1bd92fbc",
"grade": true,
"grade_id": "cell-b579208c785f960d",
"locked": false,
"points": 0,
"schema_version": 3,
"solution": true,
"task": false
},
"slideshow": {
"slide_type": "skip"
}
},
"outputs": [],
"source": [
"# YOUR CODE HERE\n",
"raise NotImplementedError()"
]
},
{
"cell_type": "markdown",
"id": "74cc04b9-a1d5-43b1-9eae-2a143ff821ff",
"metadata": {
"deletable": false,
"editable": false,
"nbgrader": {
"cell_type": "markdown",
"checksum": "473965f017f579e45ed577c173d7bd40",
"grade": false,
"grade_id": "cell-66fe3175f924eabf",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
},
"slideshow": {
"slide_type": "fragment"
}
},
"source": [
"### 6.2. Schleifen und Bedingungen\n",
"Schreiben Sie einen Codeausschnitt, der eine Schleife über alle Zahlen von 1 bis 105 durchläuft, prüft, ob die Zahl durch 7 teilbar ist, und wenn ja, die Zahl an eine Liste ``multiplies_of_seven`` anhängt. Gib die beiden letzten Elemente der Liste aus. Schließlich durchlaufen Sie eine Schleife über diese Liste und geben alle Multiplikationen von sieben aus. \n",
"\n",
"*Hinweis:* Sie brauchen vielleicht den Modulo-Operator ``%``.\n",
"\n",
"*Optional:* Überspringen Sie die ersten drei Einträge mit ``continue``. Was macht dieser Befehl überhaupt?\n",
"Auch hier gibt es wieder viele Varianten, wie die Aufgabe gelöst werden kann."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8416743e-215b-43a0-a7c8-4d38353d7c78",
"metadata": {
"deletable": false,
"nbgrader": {
"cell_type": "code",
"checksum": "1becfc90d222824ecf86e80fbe25230f",
"grade": true,
"grade_id": "cell-392219cbf44d364d",
"locked": false,
"points": 0,
"schema_version": 3,
"solution": true,
"task": false
},
"slideshow": {
"slide_type": "skip"
}
},
"outputs": [],
"source": [
"# YOUR CODE HERE\n",
"raise NotImplementedError()"
]
},
{
"cell_type": "markdown",
"id": "b5fdb559-7a96-4e0d-87cf-ba4552e4db80",
"metadata": {
"deletable": false,
"editable": false,
"nbgrader": {
"cell_type": "markdown",
"checksum": "81d27edc112c8eee216a8fd3faf49d78",
"grade": false,
"grade_id": "cell-18d5ebc5cda4719b",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
},
"slideshow": {
"slide_type": "fragment"
}
},
"source": [
"### 6.3. Input und Palindrom\n",
"Verwenden Sie die in Python eingebaute Funktion ``input``, um ein vom Benutzer eingegebenes Wort einzulesen. Prüfen Sie dann, ob dieses Wort ein Palindrom ist (= rückwärts und vorwärts gleich geschrieben). Dies geschieht durch Ausnutzung der negativen Indizierung und des Slicings. Geben Sie eine Antwort aus, die angibt, ob das Wort ein Palindrom ist oder nicht."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "aceb86da-4631-480c-90f7-4820ee531450",
"metadata": {
"deletable": false,
"nbgrader": {
"cell_type": "code",
"checksum": "2a397fdf3b07b47d221b6f622045acdf",
"grade": true,
"grade_id": "cell-de50cab6807fead8",
"locked": false,
"points": 0,
"schema_version": 3,
"solution": true,
"task": false
},
"slideshow": {
"slide_type": "skip"
}
},
"outputs": [],
"source": [
"# YOUR CODE HERE\n",
"raise NotImplementedError()"
]
},
{
"cell_type": "markdown",
"id": "f6877db5-f98b-45f0-b1d2-730197c3f4ca",
"metadata": {
"deletable": false,
"editable": false,
"nbgrader": {
"cell_type": "markdown",
"checksum": "ef67b8683f75d2dbabf0765bcbf03ff5",
"grade": false,
"grade_id": "cell-730c16702a12a979",
"locked": true,
"schema_version": 3,
"solution": false,
"task": false
},
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"### 6.4. Functions\n",
"Schreibe eine Funktion ``check_palindrome``, die eine Zeichenkette als Argument nimmt und ``True`` zurückgibt, wenn die Zeichenkette ein Palindrom ist, sonst ``False``."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "f19b4156-168f-45a9-b3c9-138e7f0d347a",
"metadata": {
"deletable": false,
"nbgrader": {
"cell_type": "code",
"checksum": "9e826a291ea4ac48c70a3169d6825932",
"grade": true,
"grade_id": "cell-af8d30adecfd27c3",
"locked": false,
"points": 0,
"schema_version": 3,
"solution": true,
"task": false
},
"slideshow": {
"slide_type": "skip"
}
},
"outputs": [],
"source": [
"# YOUR CODE HERE\n",
"raise NotImplementedError()"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.10.12"
}
},
"nbformat": 4,
"nbformat_minor": 5
}