eLegal Codingeinheit 5.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "from elegal_assert import *"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multiplikation\n",
    "\n",
    "Neben der Verkettung von Strings ist auch die Multiplikation moeglich, hierbei wird der String einfach `n`-mal wiederholt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HalloHalloHalloHalloHalloHalloHalloHalloHalloHallo\n"
     ]
    }
   ],
   "source": [
    "hallo = \"Hallo\"\n",
    "zehn_hallos = hallo * 10 # Hier n = 10\n",
    "print(zehn_hallos)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indexing\n",
    "Wie bereits bei Listen kann man auch bei Buchstaben und Teilstrings per Index extrahieren."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "str = \"eLegal Goettingen\"\n",
    "print(str[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Negatives Indizieren\n",
    "Analog ist auch negative Indizierung anwendbar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "str = \"eLegal Goettingen\"\n",
    "print(str[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Slicing\n",
    "Wie bei Listen ist der Doppelpunkt-Operator `:` mit Strings nutzbar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "start, end = 6 , 13\n",
    "str = \"Hallo Digitalisierung!\"\n",
    "print(str[start:end])\n",
    "print(str[start:])\n",
    "print(str[:end])\n",
    "print(str[:])\n",
    "print(str is str[:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## \"In\" Operator\n",
    "Mit dem `in` Keyword laesst sich feststellen, ob eine bestimmte Zeichenfolge in einem String enthalten ist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "str = 'eLegal Goettingen'\n",
    "print('Legal' in str) \n",
    "print('Goettingen' in str) \n",
    "if 'KPMG Law' not in str: \n",
    "    print(\"Hier laeuft irgendetwas falsch!!!!!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Escaping\n",
    "in Python ist \"\\\\\" ein besonderer Char. Er wird auch \"escape character\" genannt. \n",
    "\n",
    "Die wichtigsten \"escape characters\" sind\n",
    "- ``\"\\n\"`` = Newline\n",
    "- ``\"\\t\"`` = Tab\n",
    "- ``\"\\\\\"`` = Backslash\n",
    "- ``\"\\'\"`` = Einzel Anführungszeichen\n",
    "\n",
    "Der Folgende String ist nicht sehr übersichtlich, wenn man ihn ausgibt. Füge doch am Satzende eine neue Zeile an."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "string = \"eLegal ist ein toller Verein, denn er stellt Bier.Ich möchte nicht in dieser Zeile stehen.\"\n",
    "print(string)\n",
    "\n",
    "check_string_for_elegal(string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## String Methoden (Basics)\n",
    "- `upper()` konvertiert den String zu Grossbuchstaben\n",
    "- `lower()` konvertiert den String zu Kleinbuchstaben\n",
    "- `count(char)` Zaehlt die Buchstaben in einem String\n",
    "- `len()` Gibt die Menge an Buchstaben zurueck"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "str = 'eLegal Goettingen'\n",
    "print(str.upper())  \n",
    "print(str.lower()) \n",
    "print(str.count('e')) \n",
    "print(len(str)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## String Formatierung\n",
    "Mit der `format` Funktionen lassen sich *Werte* templaten."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "str = \"Hallo {name}! Lass uns doch um {zeit} {stunden} Stunden Zivilrecht lernen.\".format(name='Justus', zeit='09:00', stunden=16)\n",
    "\n",
    "print(str) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dictionaries\n",
    "Ein `dict` ist eine **Key-Value**-Datenstruktur mit der Syntax `{bezeichner : wert_hinter_dem_bezeichner}`.\n",
    "Als Beispiel:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "digitale_bibliothek = {\"BGB\" : \"Buch 1\\n Allgemeiner Teil\\n Abschnitt 1 ...\"}\n",
    "print(digitale_bibliothek[\"BGB\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Natuerlich kann ein Dictionary auch mehrere Key-Value-Paare haben."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "telefonbuch = [ \n",
    "    {\"name\": \"Heinz\", \"telefonnummer\": '+495512313'},\n",
    "    {\"name\": \"Sven\", \"telefonnummer\": '+49555123213'}\n",
    "]\n",
    "\n",
    "for eintrag in telefonbuch:\n",
    "    print(\"{} ist unter der Nummer {} erreichbar.\".format(eintrag[\"name\"], eintrag['telefonnummer']))\n",
    "   \n",
    "   \n",
    "\n",
    "# Im folgenden bezieht sich hier die 0 auf das erste Dictionary in der Telefonbuchliste.\n",
    "print(telefonbuch[0].keys()) \n",
    "print(telefonbuch[0].values()) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hierbei koennen unter anderem auch Listen als **Value** in einem Dictionary verwendet werden. Value eines Dictionaries kann auch erneut ein Dictionary sein."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict_1 = {\n",
    "    \"dein_dictionary\" : {\"key\" : \"value\"}\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Eines Besonderheit ist jedoch, dass diese Strukturen nicht als **Key** verwendet werden können.\n",
    "Führe zum testen folgenden Code aus:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = {[1,2]:[3,4]}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ein Dictionary kann auch ohne Inhalt definiert werden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "kopf_nach_klausur = {}\n",
    "kopf_nach_klausur[\"jura\"] = \"es kommt drauf an\"\n",
    "print(kopf_nach_klausur) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# Files\n",
    "Wir lernen in diesem Abschnitt die wesentlichen Interaktionen mit Textdateien kennen.\n",
    "\n",
    "## Textdatei lesen\n",
    "### Code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def lese_datei_ein(pfad_zur_datei):\n",
    "    # Hier fragen wir mit der open()-Funktion Zugriff auf die Datei an.\n",
    "    # Hierbei bedeuten die letzten beiden Parameter:\n",
    "    # 'r' = Art des Zugriffes \n",
    "    #   zB 'r' = 'read', 'w' = write, 'rw' = read-write\n",
    "    # encoding='utf-8' = Unterstuetzung fuer Umlaute. Einfach immer nutzen\n",
    "    referenz_auf_datei = open(pfad_zur_datei, 'r', encoding='utf-8')\n",
    "    # .read() liesst die ganze Datei als Zeichenkette ein.\n",
    "    print(referenz_auf_datei.read())\n",
    "    # WICHTIG:\n",
    "    # Eine Datei muss immer geschlossen werden.\n",
    "    # Hierbei wird dem System gesagt, dass diese nicht mehr gebraucht wird.\n",
    "    # Vergisst man dies, kann man zB die Datei nicht mehr loeschen,\n",
    "    # bis das Programm beendet ist.\n",
    "    referenz_auf_datei.close()\n",
    "\n",
    "lese_datei_ein('textfile.txt') "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Text schreiben\n",
    "### Code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!/usr/bin/env python3\n",
    "\n",
    "def main():\n",
    "    f = open('textfile.txt', 'w', encoding='utf-8') # Wichtig! Wir benutzen hier den Schreibmodus 'w'.\n",
    "    s = 'eLegal Goettingen ist cool!\\n'\n",
    "    f.write(s) \n",
    "    f.close()\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternativ mit `with`-Operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!/usr/bin/env python3\n",
    "\n",
    "def main():\n",
    "    with open('textfile.txt', 'w', encoding='utf-8') as f:\n",
    "        s = 'eLegal Goettingen ist cool!\\n'\n",
    "        f.write(s)\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.4"
  },
  "pycharm": {
   "stem_cell": {
    "cell_type": "raw",
    "source": [],
    "metadata": {
     "collapsed": false
    }
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}