{"id":533,"date":"2023-03-26T14:11:34","date_gmt":"2023-03-26T14:11:34","guid":{"rendered":"https:\/\/kastens.net\/WPSub\/dokumentation\/?page_id=533"},"modified":"2023-03-26T15:47:07","modified_gmt":"2023-03-26T15:47:07","slug":"python","status":"publish","type":"page","link":"https:\/\/www.kastens.net\/WPSub\/dokumentation\/?page_id=533","title":{"rendered":"Python"},"content":{"rendered":"\n

Python Konzepte<\/strong><\/h2>\n\n\n\n

Shebang Line<\/strong><\/h3>\n\n\n\n

Jedes Python Programm sollte eine Shebang Line haben, die vom Interpreter ausgewertet werden kann. Auf Windows mit Python 3 sollte diese Zeile wie folgt aussehen:<\/p>\n\n\n\n

#! python3.<\/code><\/pre>\n\n\n\n
Variablen<\/h2>\n\n\n\n
Eine Variable wird im einfachsten Fall erzeugt, indem Werte zugewiesen werden.<\/p>\n\n\n\n
Operationen mit Variablen<\/h3>\n\n\n\n
Operanden<\/h4>\n\n\n\n
    \n
  • + steht f\u00fcr Addition (float und integer) oder Konkatinierung, also Verkettung (string und Listen)<\/li>\n\n\n\n
  • – steht f\u00fcr Subtraktion<\/li>\n\n\n\n
  • * steht f\u00fcr Multiplikation<\/li>\n\n\n\n
  • \/ steht f\u00fcr Dividion<\/li>\n\n\n\n
  • % ist der ganzteilige Rest einer Division<\/li>\n<\/ul>\n\n\n\n
    Statt einer Variablen per „Variable = Variable + 5“ den Wert 5 zu addieren kann man den Ausdruck mit „Variable += 5“ verwenden. Gilt auch f\u00fcr die anderen Operanden!<\/p>\n\n\n\n
    Integer und Float<\/h3>\n\n\n\n
      \n
    • Bei Integer und Float gelten die normalen Rechenprozeduren (+, -, *, \/ etc.)<\/li>\n\n\n\n
    • Die Funktion str wandelt Integer oder float Werte in Strings um (typischerweise f\u00fcr Ausgabe)<\/li>\n<\/ul>\n\n\n\n
      Strings<\/strong><\/h3>\n\n\n\n
        \n
      • Strings werden mit einem einfachen Hochkomma eingleitet und beendet<\/li>\n\n\n\n
      • Alternativ ist auch die Verwendung des Doppelhochkommas m\u00f6glich<\/li>\n\n\n\n
      • Mehrere Strings kann man mit dem + Zeichen zu einem neuen Strings zusammensetzen<\/li>\n\n\n\n
      • Die Funktion int wandelt einen String (so er Zahlen enth\u00e4lt) oder einen Float Wert in einen Integer um<\/li>\n\n\n\n
      • Mit der Funktion len lassen sich L\u00e4ngen ermitteln. Bei Strings erh\u00e4lt man die Anzahl der Zeichen und bei Listen enth\u00e4lt man die Anzahl der Werte.<\/li>\n<\/ul>\n\n\n\n
        Escape Characters<\/h4>\n\n\n\n
        Um in Strings bestimmte Zeichen nutzen zu k\u00f6nnen ben\u00f6tigt man Escape Characters. Diese sind:<\/p>\n\n\n\n
        Escape Character<\/td>Bedeutet<\/td><\/tr>
        \\‘<\/td>Einfaches Anf\u00fchrungszeichen<\/td><\/tr>
        \\“<\/td>doppeltes Anf\u00fchrungszeichen<\/td><\/tr>
        \\t<\/td>Tabulator<\/td><\/tr>
        \\n<\/td>Zeilenvorschub (New Line)<\/td><\/tr>
        \\\\<\/td>Ein Backslash<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
        Man kann auch multiline Strings erzeugen. Diese werden mit 3 Anf\u00fchrungszeichen oder drei doppelten Anf\u00fchrungszeichen eingeleitet und beendet. Die normale Einr\u00fcckung f\u00fcr Python gilt dann nicht einzelne oder doppelte Anf\u00fchrungszeichen m\u00fcssen nicht escaped werden.<\/p>\n\n\n\n
        print('''Dear Alice,
        Eve's cat has been arrested for
        catnapping, cat burglary, and extortion.
        Sincerely, Bob''')<\/code><\/pre>\n\n\n\n
        Diese Multistring M\u00f6glichkeit kann man im Code auch nutzen, um Kommentare \u00fcber mehrere Zeilen zu schrieben. Einfach mit den Hochkommata einleiten und beenden!<\/p>\n\n\n\n
        Teilzeichenketten<\/h3>\n\n\n\n
        Auf Zeichen in Strings kann man \u00e4hnlich wie auf Werte in Listen zugreifen.<\/p>\n\n\n\n
        testString = 'Dies ist ein Test'
        print (testString [3]) # ergibt ein 's'
        print (testString [0:4]) # ergibt ein 'Dies'
        print (testString [-1]) # ergibt ein 't' (letzter Buchstabe)
        print (testString [-4:]) # ergibt ein 'Test'<\/code><\/pre>\n\n\n\n
        Auch das Auswerten mit in und not in erfolgt \u00e4hnlich zu Listen:<\/p>\n\n\n\n
        testString = 'Dies ist ein Test'
        print ('Dies' in testString) # ergibt true
        print ('dies' in testString) # ergibt false
        print ('Dies' not in testString) # ergibt false
        print ('dies' not in testString) # ergibt true<\/code><\/pre>\n\n\n\n
        Stringmanipulation<\/h3>\n\n\n\n
        Dann ist es h\u00e4ufig erforderlich, Leerzeichen und Steuerzeichen aus Texten zu entfernen.<\/p>\n\n\n\n
        testString = ' Dies ist ein Test '
        print (teststring.strip()) # entfernt entsprechende Zeichen rechts und links -> 'Dies ist ein Test'
        print (teststring.lstrip()) # entfernt entsprechende Zeichen links -> 'Dies ist ein Test '
        print (teststring.rstrip()) # entfernt entsprechende Zeichen rechts -> ' Dies ist ein Test'<\/code><\/pre>\n\n\n\n
        Man kann der Methode auch eine String \u00fcbergeben. Die Buchstaben werden dann links oder rechts entfernt, bis ein Buchstabe auftaucht, der nicht \u00fcbergeben wurde.<\/p>\n\n\n\n
        Listen<\/h2>\n\n\n\n
          \n
        • Listen stellen in Bezug auf eine Variable einen Wert da (die Liste). Es kann aber auf die Einzelwerte der Liste zugegriffen werden, wobei der erste Wert der Liste den Index 0 hat<\/li>\n\n\n\n
        • Bei Listen kann man mit dem Plus Operator ebenfalls Listen miteinander kombinieren.<\/li>\n\n\n\n
        • Listen k\u00f6nnen widerrum Listen enthalten<\/li>\n\n\n\n
        • Greift man auf Listen mit negativen Indizes zu, so werden die Werte von hinten nummeriert. So steht der Index -1 f\u00fcr den letzten und der Index -2 f\u00fcr den vorletzten Wert der Liste.<\/li>\n\n\n\n
        • Aus Listen kann man auch Slices entnehmen. Das sind Teile der Liste, die widerrum als Liste dargestellt werden. Dabei Gibt man an ab welchem Index und bis VOR welchem Index der Slice geht. Wenn man aus einer Liste mit 5 Werten die Werte 2 – 4 haben m\u00f6chte, lautet die Indexangabe [2:5]<\/li>\n\n\n\n
        • L\u00e4sst man im Index unter Nutzung des Doppelpunktes einen der Werte weg, so wird beim Weglassen des ersten Wertes die Liste von Anfang an \u00fcbernommen und bei Weglassen des zweiten Wertes die Liste bis zum Ende \u00fcbernommen<\/li>\n\n\n\n
        • Mit der Funktion del kann man einzelne Werte aus Listen l\u00f6schen<\/li>\n\n\n\n
        • Weist man eine Liste einer Variablen zu, so erstellt man keine Kopie der Werte, sondern eine Referenz. Sprich egal mit welchem der beiden Variablennamen man die Liste anspricht, man hantiert mit den gleichen Werte und bei \u00c4nderungen sind die \u00c4nderungen auch \u00fcber beide Variablennamen sichtbar.<\/li>\n\n\n\n
        • Die Funktion list kann ein Tuple oder einen String in eine Liste umwandeln<\/li>\n<\/ul>\n\n\n\n
          Tuple<\/h2>\n\n\n\n
            \n
          • Tuple sind \u00e4hnlich wie Listen, aber sind nicht \u00e4nderbar<\/li>\n\n\n\n
          • In der Zuweisung werden runde Klammern verwendet<\/li>\n\n\n\n
          • Die Funktion tuple kann eine Liste oder einen String in ein Tuple umwandeln<\/li>\n<\/ul>\n\n\n\n
            Dictionaries<\/h2>\n\n\n\n
              \n
            • Dictionaries sind auch \u00e4hnlich zu Listen zu sehen<\/li>\n\n\n\n
            • In der Zuweisung werden geschweifte Klammern verwendet<\/li>\n\n\n\n
            • Es handelt sich um Key -> Value Paare<\/li>\n\n\n\n
            • Was also bei einer Liste der Index ist, stellt bei Dictionaries der Key dar<\/li>\n\n\n\n
            • Daher sind Dictionaries auch nicht geordnet wie Listen (Index 0 – n) -> Das bedeutet zwei Listen sind nur gleich, wenn auch die Reihenfolge der Werte gleich ist. Bei Dictionaries ist die Reihenfolge der Werte nicht relevant in Bezug auf Gleichheit, es m\u00fcssen nur alle Key-Value Kombinationen in zwei Strings vorhanden sein, damit diese gleich sind<\/li>\n<\/ul>\n\n\n\n
              mutable und immutable Variablen<\/h3>\n\n\n\n
              Listen und Dictionarys sind mutable Variablen wohingegen Strings, Integer, Float, Tuples etc. immutable Typen sind. <\/p>\n\n\n\n
              Mutable Daten k\u00f6nnen \u00fcber Methoden ge\u00e4ndert werden. Immutable Daten k\u00f6nnen nur \u00fcber Zuweisungen in G\u00e4nze ge\u00e4ndert werden.<\/p>\n\n\n\n
              Zus\u00e4tzlich ist beim \u00fcbergeben von mutable Daten an Funktionen oder beim zuweisen an andere Variablen zu beachten, dass diese nur als Referenz \u00fcbergeben \/ „kopiert“ werden. \u00c4nderungen am \u00fcbergebenen Wert beziehen sich also auch immer auf den Ausgangswert. Will man das nicht, also tats\u00e4chlich eine Kopie einer Liste \u00fcbergeben, so muss man das Modul copy einbinden und die Funktion copy.copy() nutzen. Wenn eine Liste kopiert werden soll, die Ihrerseits Listen enth\u00e4lt, ist copy.deepcopy() erforderlich!<\/p>\n\n\n\n
              Hier einige Beispiele inkl. Transformation zwischen Datentypen:<\/p>\n\n\n\n
              Zahlen<\/h4>\n\n\n\n
              MeinInteger = 5 # Erzeugt eine Variable vom Typ Integer
              print (MeinInteger) # Zahl wird ausgegeben
              print ('Hallo', str(MeinInteger)) # Wegen Stringausgabe muss Zahl in String gewandelt werden
              #
              MeinFloat = 5.0 # Erzeugt eine Variable vom Typ Float, also Gleitkommazahl
              print (MeinFloat) # Zahl wird ausgegeben
              print ('Hallo', str(MeinFloat)) # Kombination String und Float in der Ausgabe<\/code><\/pre>\n\n\n\n
              String<\/h4>\n\n\n\n
              MeinString = 'Hallo' # Erzeugt eine Variable vom Typ String
              print (MeinString) # String wird ausgegeben
              print (len (MeinString)) # Anzahl Zeichen eines Strings
              print (MeinString)
              TestListe = list(MeinString)
              print (TestListe)
              TestListe.sort(key=str.lower)
              print (TestListe)<\/code><\/pre>\n\n\n\n
              Listen<\/h4>\n\n\n\n
              MeineListe = ['Hund', 'Katze', 'Maus', 'Floh'] # Erzeugt eine Variable vom Typ Liste
              print (MeineListe) # Gesamte Liste wird als Liste ausgegeben
              print (MeineListe[0]) # Erster Wert der Liste
              print (MeineListe[-1]) # Letzter Wert der Liste
              for i in MeineListe: # Einzelwerte der Liste werden ausgegeben
              print (i)
              print (MeineListe[0:2]) # Neue Liste mit den beiden ersten Werten der Ausgangsliste
              print (MeineListe[0:-1]) # Neue Liste mit allen Werten der Ausgangsliste au\u00dfer dem letzten
              print (MeineListe[1:]) # Neue Liste enth\u00e4lt alle Werte ab dem Index 1
              print (MeineListe[:2]) # Neue Liste enth\u00e4lt alle Werte bis vor dem Index 2
              #
              MeinegeschachtelteListe = [['Hund', 'Katze', 'Maus'],['Elephant', 'Ochse']]
              for i in MeinegeschachtelteListe: # Listen der Liste werden ausgegeben
              print (i)
              for i in MeinegeschachtelteListe: # Einzelwerte der Listen werden ausgegeben
              for j in i:
              print (j)
              print (len (MeinegeschachtelteListe)) # Anzahl der Werte der geschachtelten Liste
              print (MeinegeschachtelteListe + MeineListe) # Einzelwerte der Liste werden als Werte an die Liste angeh\u00e4ngt
              print (MeinegeschachtelteListe + [MeineListe]) # Gesamtliste wird als ein neuer Wert an die Liste angeh\u00e4ngt
              MeinegeschachtelteListe[1] = MeineListe
              print (MeinegeschachtelteListe)
              del MeinegeschachtelteListe[1]
              print (MeinegeschachtelteListe)<\/code><\/pre>\n\n\n\n
              Tuple<\/h4>\n\n\n\n
              MeinTuple = ('Hund', 'Katze', 'Maus', 'Floh') # Erzeugt eine Variable vom Typ Tuple
              print (MeinTuple) # Gesamtes Tuple wird als Liste ausgegeben<\/code><\/pre>\n\n\n\n
              Dictionaries<\/h4>\n\n\n\n
              MeinDictionary = {'Hammer': 'Nagel', 'S\u00e4ge': 'Brett','Schraubendreher':'Schraube'}
              print (MeinDictionary)
              print (MeinDictionary ['S\u00e4ge'])
              MeinDictionary ['Zange'] = 'Nagel'
              print (MeinDictionary)<\/code><\/pre>\n\n\n\n
              Beispiel zum Zugriff auf Key->Values in einer Schleife<\/h4>\n\n\n\n
              for k,v in MeinDictionary.items():
              print ('Werkzeug: ' + k + ' Material: ' + v)<\/code><\/pre>\n\n\n\n
              Methoden von Variablen<\/h3>\n\n\n\n
              Es gibt f\u00fcr Variablentypen Methoden mit denen die Variablen bearbeitet werden k\u00f6nnen. Der Aufruf der Methoden erfolgt mit „Variable.Methodenname“. Hier ein paar Beispiele:<\/p>\n\n\n\n
              Strings<\/h4>\n\n\n\n
              testString = 'Dies ist ein Test'
              print (testString.upper())<\/code><\/pre>\n\n\n\n
              ergibt ‚DIES IST EIN TEST‘<\/p>\n\n\n\n
              print (testString.lower())<\/code><\/pre>\n\n\n\n
              ergibt ‚dies ist ein test‘<\/p>\n\n\n\n
              weitere Methoden:<\/h5>\n\n\n\n
              .isupper() -> nur Gro\u00dfbuchstaben?\n.islower() -> nur Kleinbuchstaben?\n.isalpha() -> nur Buchstaben?\n.isalnum() -> nur alphanumerisch, also Ziffern und Buchstaben\n.isdecimal() -> nur Zahlen?\nisspace() -> nur Leerzeichen, Tabs und New Lines\n.istitle() -> Nur W\u00f6rter im String , die mit einem Gro\u00dfbuchstaben beginnen und danach nur noch Kleinbuchstaben enthalten\n.startswith(string) -> Es wird gepr\u00fcft, ob der string identisch mit dem Anfang der Variable ist deren Methode aufgerufen wird\n.endswith(string) -> Es wird gepr\u00fcft, ob der string identisch mit dem Ende der Variable ist deren Methode aufgerufen wird<\/code><\/pre>\n\n\n\n
              join<\/h6>\n\n\n\n
              testListe = ('Dies', 'ist', 'ein', 'Test')
              print (', '.join(testListe))<\/code><\/pre>\n\n\n\n
              Bildet aus einer Liste einen String und setzt den String auf den die Methode angewendet wird zwischen die Werte.
              Das kann insbesondere dann Sinn machen, wenn man mehrere Strings in einer Liste zusammenfassen m\u00f6chte und dabei einen Zeilenumbruch einf\u00fcgen will:<\/p>\n\n\n\n
              testString = '\\n'.join(testListe)
              print (testString)<\/code><\/pre>\n\n\n\n
              Split<\/h6>\n\n\n\n
              testString = 'Dies ist ein Test'\nprint (testString.split(' '))<\/code><\/pre>\n\n\n\n
              Trennt einen Text in eine Liste auf. Hier wird als Trennzeichen ein blank \u00fcbergeben, was aber Default ist<\/p>\n\n\n\n
              Listen<\/h4>\n\n\n\n
              MeineListe = ['Hund', 'katze', 'Maus', 'floh']<\/code><\/pre>\n\n\n\n
              Erzeugt eine Variable vom Typ Liste<\/p>\n\n\n\n
              print (MeineListe.index('Maus'))<\/code><\/pre>\n\n\n\n
              Liefert den Index zur\u00fcck, an dem der Wert in der Liste gefunden wird. Es wird das erste Aufkommen des Wertes zur\u00fcckgegeben – Ist der Wert nicht enthalten gibt es einen Fehler.<\/p>\n\n\n\n
              MeineListe.append('Fisch') # Ein weiterer Wert wird angeh\u00e4ngt
              print (MeineListe)
              MeineListe.insert(2,'Huhn')<\/code><\/pre>\n\n\n\n
              Ein weiterer Wert wird vor Index 2 eingef\u00fcgt<\/p>\n\n\n\n
              print (MeineListe)
              MeineListe.append('Huhn')
              MeineListe.remove('Huhn')<\/code><\/pre>\n\n\n\n
              Huhn wird in der Liste gesucht und das ERSTE vorkommen wird gel\u00f6scht. Ist Huhn nicht in der Liste, so entsteht ein Fehler.<\/p>\n\n\n\n
              print (MeineListe)\nMeineListe.sort()<\/code><\/pre>\n\n\n\n
              Sortieren einer Liste<\/p>\n\n\n\n
              print (MeineListe)
              MeineListe.sort(reverse=True)<\/code><\/pre>\n\n\n\n
              Sortieren einer Liste absteigend<\/p>\n\n\n\n
              print (MeineListe)
              MeineListe.sort(key=str.lower)<\/code><\/pre>\n\n\n\n
              Sortieren egal ob Gro\u00df- oder Kleinbuchstaben<\/p>\n\n\n\n
              print (MeineListe)<\/code><\/pre>\n\n\n\n
              Dictionaries<\/h4>\n\n\n\n
              MeinDictionary = {'Hammer': 'Nagel', 'S\u00e4ge': 'Brett','Schraubendreher':'Schraube'}
              for i in MeinDictionary.values():<\/code><\/pre>\n\n\n\n
              Hier werden die Werte des Dictionaries als Liste durchlaufen<\/p>\n\n\n\n
              print (i)
              for i in MeinDictionary.keys():<\/code><\/pre>\n\n\n\n
              Das geht auch mit den keys<\/p>\n\n\n\n
              print (i)
              for i in MeinDictionary.items():<\/code><\/pre>\n\n\n\n
              Oder man verarbeitet die Key->Values in G\u00e4nze als Liste<\/p>\n\n\n\n
              print (i)
              for i in MeinDictionary:<\/code><\/pre>\n\n\n\n
              Ohne Methodenangabe erh\u00e4lt man das gleiche Ergebnis wie bei der Ausgabe der Keys!<\/p>\n\n\n\n
              print (i)<\/code><\/pre>\n\n\n\n
              Der Begriff Liste in diesen Beispielen steht aber f\u00fcr eine Pseudoliste. F\u00fcr Ausgabe, aber nicht Bearbeitung geeignet Dies kann man wie folgt auch gut sehen, da ein Typ dict_keys ausgegeben wird<\/p>\n\n\n\n
              print (MeinDictionary.keys())<\/code><\/pre>\n\n\n\n
              Ausgabe des dict_keys<\/p>\n\n\n\n
              print (list(MeinDictionary.keys()))<\/code><\/pre>\n\n\n\n
              Hier wird eine echte Liste erzeugt. Diese kann man auch einer Variablen zur weiteren Bearbeitung zuweisen<\/p>\n\n\n\n
              print('Ist Hammer ein Key?: ' + str('Hammer' in MeinDictionary.keys()))<\/code><\/pre>\n\n\n\n
              Suchen eines Begriffes in den keys<\/p>\n\n\n\n
              print('Ist Nagel ein Key?: ' + str('Nagel' in MeinDictionary.keys()))
              print('Ist Hammer ein Value?: ' + str('Hammer' in MeinDictionary.values()))<\/code><\/pre>\n\n\n\n
              Suchen eines Begriffes in den values<\/p>\n\n\n\n
              print('Ist Nagel ein Value?: ' + str('Nagel' in MeinDictionary.values()))<\/code><\/pre>\n\n\n\n
              Mit der Get Methode kann man Werte eines Dictionaries ohne Fehlerhandling abfragen. <\/p>\n\n\n\n
              print (MeinDictionary.get('Hammer','nicht zugeordnet')) # liefert 'Nagel' zur\u00fcck
              print (MeinDictionary.get('Vorschlaghammer','nicht zugeordnet')) # liefert 'nicht zugeordnet' zur\u00fcck<\/code><\/pre>\n\n\n\n
              Mit SetDefault kann man einen Key abfragen und wenn dieser nicht existiert, wird er mit dem Standardwert angelegt. Beispiel Zeichen Z\u00e4hlen<\/p>\n\n\n\n
              MeinText = ' Dieser Text besteht aus verschiedenen Buchstaben und wir schauen mal, wieviele davon jeweils vorkommen'
              Alphabet = {}
              for Buchstabe in MeinText:
              Alphabet.setdefault(Buchstabe, 0)
              Alphabet[Buchstabe] +=1
              print (Alphabet.items())
              Sortierliste =list(Alphabet.items())
              Sortierliste.sort(key=lambda tup: tup[0].upper())<\/code><\/pre>\n\n\n\n
              Sortierung der Tuple nach Wert 1 als Gro\u00dfbuchstabe<\/p>\n\n\n\n
              print (Sortierliste)<\/code><\/pre>\n\n\n\n
              Steuerung<\/h2>\n\n\n\n
              def MeineFunktion():<\/code><\/pre>\n\n\n\n
              Schleifen \/ Wiederholungen<\/h3>\n\n\n\n
              For Next Schleife<\/h4>\n\n\n\n
              for Schleifenzaehler in range(1,7):\nprint('Ausgabe ' + str(Schleifenzaehler)) # So oft die Schleife durchlaufen wird, wird diese Ausgabe erzeugt\nif Schleifenzaehler > 5:\nbreak # Hier wird die Schleife unabh\u00e4ngig von der eigentlichen Schleifensteuerung unterbrochen<\/code><\/pre>\n\n\n\n
              Statt mit dem range Befehl eine Vorgabe von Zahlen zu durchlaufen k\u00f6nnte man auch die Werte einer definierten Liste durchlaufen:<\/p>\n\n\n\n
              Liste = ('Hund','Katze','Maus')\nfor Schleifenparameter in Liste:\nprint('Ausgabe ' + Schleifenparameter) # Schleifenparameter enth\u00e4lt den jeweiligen Listenwert und dieser wird mit ausgegeben.<\/code><\/pre>\n\n\n\n
              Verzweigungen<\/h3>\n\n\n\n
              If then else<\/h4>\n\n\n\n
              if 2 < 1:\nprint(' Diese Zeil wird nicht angezeigt, da 2 nicht kleiner als 1 ist')\nelif 1 > 2:\nprint(' Diese Zeile wird auch nicht angezeigt, da 1 auch nicht gr\u00f6\u00dfer als 2 ist')\nelif 0 > 2:\nprint(' Diese Zeile wird auch nicht angezeigt, da 0 auch nicht gr\u00f6\u00dfer als 2 ist')\nelse:\nprint(' Wenn keine andere Bedingung korrekt ist, wird das hier jetzt halt angezeigt')<\/code><\/pre>\n\n\n\n
              Fehlerbehandlung<\/h2>\n\n\n\n
              Fehler werden mit einem Try … Except Konzept behandelt<\/p>\n\n\n\n
              number = 1\ntry:\nprint('Zahl: ' + str(number))\n# wird ausgef\u00fchrt, da die Zahl vor Ausgabe in einen String umgewandelt wird\nPrint('Zahl: ' + str(number))\n# F\u00fchrt zu dem Namensfehler unten -> Gro\u00dfbuchstabe bei Print\nprint('Zahl: ' + 1) # f\u00fchrt zu dem Typfehler\nexcept TypeError:\n# except wird nur ausgef\u00fchrt, wenn nach try ein Fehler auftrat\nprint('Es ist ein Fehler wegen eines Variablentypen aufgetreten')\nexcept NameError:\n# except wird nur ausgef\u00fchrt, wenn nach try ein Fehler auftrat\nprint('Es ist ein Fehler wegen eines falschen Namens im Code aufgetreten')<\/code><\/pre>\n\n\n\n
              Mit dem Except Ausdruck k\u00f6nnen also verschiedene Fehlertypen abgefangen werden. Diese sollte man zuvor in der Shell ermitteln, indem man ohne try except die Fehlerausgabe anschaut.<\/p>\n\n\n\n
              >>> Print('Zahl: ' + str(number))\n# F\u00fchrt zu dem Namensfehler unten -> Gro\u00dfbuchstabe bei Print\nTraceback (most recent call last):\nFile \"\", line 1, in\nPrint('Zahl: ' + str(number))\nNameError: name 'Print' is not defined<\/code><\/pre>\n\n\n\n
              Dies war der Name Error<\/p>\n\n\n\n
              >>> print('Zahl: ' + 1)\n# f\u00fchrt zu dem Typfeheler\nTraceback (most recent call last):\nFile \"\", line 1, in\nprint('Zahl: ' + 1)\nTypeError: must be str, not int<\/code><\/pre>\n\n\n\n
              und dies der Type Error<\/p>\n\n\n\n
              h\u00e4ufig genutzte Befehle<\/h2>\n\n\n\n
              Funktionen<\/h2>\n\n\n\n
              Funktionen werden definiert<\/p>\n\n\n\n
              Im Anschlu\u00df werden die Befehle der Funktion einger\u00fcckt angegeben<\/p>\n\n\n\n
              def MeineFunktion():\n    print('Meine Funktion gibt einfach diesen Satz aus')<\/code><\/pre>\n\n\n\n
              Der Aufruf der Funktion erfolgt \u00fcber<\/p>\n\n\n\n
              MeineFunktion()<\/code><\/pre>\n\n\n\n
              Werte an Funktionen \u00fcbergeben<\/h4>\n\n\n\n
              def MeineFunktion(uebergebenerWert):\nprint ('Du hast folgendes an die Funktion \u00fcbergeben: ' + uebergebenerWert)\nMeineFunktion('Quatsch')<\/code><\/pre>\n\n\n\n
              In dieser Form ist der Parameter beim Aufruf der Funktion erforderlich. Weglassen des Parameters f\u00fchrt zu einer Fehlermeldung! Der Parameter ‚uebergebenerWert‘ ist nur innerhalb der Funktion als Variable ansprechbar und verschwindet mit verlassen der Funktion.<\/p>\n\n\n\n
              R\u00fcckgabewerte von Funktion<\/strong>en<\/strong><\/h4>\n\n\n\n
              def addiere5 (Ausgangswert):<\/p>\n\n\n\n
              return Ausgangswert + 5<\/p>\n\n\n\n
              print(addiere5 (10))<\/p>\n\n\n\n
              Hier wird im Rahmen des Print Statements der R\u00fcckgabewert der Funktion ‚addiere5‘ ausgegeben. An die Funktion wird der Wert 10 \u00fcbermittelt.<\/p>\n\n\n\n
              generieren von Zufallszahlen<\/h3>\n\n\n\n
              import random\nrandomNumber = random.randint(1, 20)<\/code><\/pre>\n\n\n\n
              Liefert eine zuf\u00e4llige Zahl zwischen 1 und 20<\/p>\n\n\n\n
              Ausgeben von Daten<\/h3>\n\n\n\n
              In Python integriert ist die print Funktion f\u00fcr solche Zwecke:<\/p>\n\n\n\n
              print ('Ein Text') # Gibt den Text aus und standardm\u00e4\u00dfig wird eine Zeilenschaltung am Ende durchgef\u00fchrt\nprint ('nach dem Text')\nprint ('Ein Text', end='') # Gibt den Text aus und es gibt nichts am Ende, also auch keine Zeilenschaltung!\nprint ('direkt nach dem Text')<\/code><\/pre>\n\n\n\n
              Daneben gibt es aber auch die M\u00f6glichkeit mit dem Modul pprint auf erweiterte Ausgabem\u00f6glichkeiten insbesondere f\u00fcr Dictionaries zuzugreifen!<\/p>\n\n\n\n
              import pprint\nMeinDictionary = {'Hammer': 'Nagel', 'S\u00e4ge': 'Brett','Schraubendreher':'Schraube'}\npprint.pprint (MeinDictionary) # sortiert die Ausgabe nach den Keys\nprint (MeinDictionary) # unsortierte Ausgabe\nTest = pprint.pformat (MeinDictionary) # Damit kann man die sortierte Ausgabe an eine Variable \u00fcbergeben!\nprint (Test)<\/code><\/pre>\n\n\n\n
              Bei der Ausgabe von Strings sollte man die Excape Character ber\u00fccksichtigen, die weiter oben beschrieben sind. Desweiteren gibt es die M\u00f6glichkeit, einen String als Raw Text auszugeben, bei dem Escape Character nicht ausgewertet und somit wie angegeben ausgegeben werden. Man stellt ein r vor den eigentlichen String bei print!<\/p>\n\n\n\n
              test = 'Dies ist Matze\\'s Test'\nprint ('Dies ist Matze\\'s Test')\nprint (r'Dies ist Matze\\'s Test')<\/code><\/pre>\n\n\n\n
              In diesem Zusammenhang sind auch einige Methoden interessant, mit denen man tabulare Ausgaben erzeugen kann:<\/p>\n\n\n\n
              meinDict = {'Eier': 10,'Mehl': 1000, 'Backpulver':1, 'Milch': 500}\nAnzahl = 0\nfor i,j in meinDict.items():\nprint (i.ljust(20,'.') + str(j).rjust(6))\nAnzahl += 1\nprint (('Anzahl Zutaten: ' + str(Anzahl)).center(26))<\/code><\/pre>\n\n\n\n
              G\u00fcltigkeitsbereich von Variablen<\/h2>\n\n\n\n
              Hier spricht man von global (Programmweit) und local (innerhalb von einer Funktion) scope. Aus dem globalen Scope kann nicht auf lokale Variablen zugegriffen werden. Im lokalen Scope kann man (sollte man aber nicht) auf globale Variablen zugreifen. Man kann nicht von einem lokalen Scope auf Variablen eines anderen lokalen Scopses zugreifen.<\/p>\n\n\n\n
              local scope<\/h3>\n\n\n\n
              Unter dem local scope versteht man Variablen innerhalb einer Funktion und die \u00fcbergebenen Parameter an die Funktion. Diese sind nur innerhalb der Funktion g\u00fcltig und mit Beendigung der Funktion wird der belegte Speicher dieser Werte wieder frei gegeben.<\/p>\n\n\n\n
              Das bedeutet auch, dass der Aufruf einer Funktion einen local scope erzeugt!<\/p>\n\n\n\n
              global scope<\/h3>\n\n\n\n
              Hier sind insbesondere die Variablen zu nennen, die global (also au\u00dferhalb von Funktionen) definiert werden.<\/p>\n\n\n\n
              Zugriff auf globale Variablen im local scope<\/h3>\n\n\n\n
              4 Regeln zum Erkennen des Scopes:<\/p>\n\n\n\n
                \n
              • Eine Variable, die au\u00dferhalb einer Funktion definiert wird, ist immer eine globale Variable<\/li>\n\n\n\n
              • Eine Variable in einer Funktion, die mit dem keyword ‚global‘ definiert wird ist eine globale Variable (Diese muss auch zuvor nicht im Hauptprogramm definiert worden sein)<\/li>\n\n\n\n
              • Wird einer global definierten Variable innerhalb einer Funktion ein Wert zugewiesen, ohne das vorher mit dem global keyword diese Variable als global definiert wurde, so wird eine lokale Variable erzeugt!<\/li>\n\n\n\n
              • Wird in einer Funktion lediglich auf den Inhalt einer global definierten Variable zugewiesen und kein Wert zugewiesen, so wird die globale Variable ausgelesen!<\/li>\n<\/ul>\n\n\n\n
                Beispiel:<\/p>\n\n\n\n
                def Testfunktion1():\n    global testglobal\n    testglobal = 'Dies ist eine Variable, die in einer Funktion global definiert wurde, ohne vorher im Hauptprogramm definiert worden zu sein'\n    print(globaleVariable) # Da nicht lokal definiert, wird der Inhalt der globalen Variable ausgegeben\ndef Testfunktion2():\n    globaleVariable = 'Quatsch' # Hier wird eine lokale Variable (sinnfrei) erzeugt\n    print(globaleVariable)\ndef Testfunktion3():\n    global globaleVariable # Es wird definiert, dass die globaleVariable in dieser Funktion referenziert wird\n    globaleVariable = 'Quatsch' # Hier wird die globale Variable tats\u00e4chlich ver\u00e4ndert\n    print(globaleVariable)\ndef Testfunktion4():\n# Diese Funktion liefert eine Fehlermeldung, da die 'globaleVariable' wegen eines Zuweisungsstatements lokal interpretiert wird\n# aber die erste Verwendung der lokalen Variable vor der ersten Zuweisung gegeben ist.\n    print(globaleVariable)\n    globaleVariable = 'Quatsch' # Hier wird die globale Variable tats\u00e4chlich ver\u00e4ndert\n    globaleVariable ='Dies ist der Inhalt der globalen Variable'\nTestfunktion1() # es wird die globaleVariable ausgegeben\n    print(testglobal) # Die globale Variable ist aber unver\u00e4ndert, da nur lokal \u00fcberschrieben wurde\nTestfunktion2() # es wird die globaleVariable lokal \u00fcberschrieben ausgegeben\n    print(globaleVariable) # Die globale Variable ist aber unver\u00e4ndert, da nur lokal \u00fcberschrieben wurde\nTestfunktion3() # es wird die globaleVariable global \u00fcberschrieben ausgegeben\nprint(globaleVariable) # Die globale Variable wurde innerhalb der letzten Funktion ver\u00e4ndert\nTestfunktion4() # es wird die globaleVariable global \u00fcberschrieben ausgegeben<\/code><\/pre>\n\n\n\n
                <\/p>\n","protected":false},"excerpt":{"rendered":"
                Python Konzepte Shebang Line Jedes Python Programm sollte eine Shebang Line haben, die vom Interpreter ausgewertet werden kann. Auf Windows mit Python 3 sollte diese Zeile wie folgt aussehen: Variablen Eine Variable wird im einfachsten Fall erzeugt, indem Werte zugewiesen werden. Operationen mit Variablen Operanden Statt einer Variablen per „Variable = Variable + 5“ den Wert 5 zu addieren kann man den Ausdruck mit „Variable += 5“ verwenden. Gilt auch…<\/p>\n","protected":false},"author":2,"featured_media":0,"parent":98,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":{"footnotes":""},"class_list":["post-533","page","type-page","status-publish","hentry"],"_links":{"self":[{"href":"https:\/\/www.kastens.net\/WPSub\/dokumentation\/index.php?rest_route=\/wp\/v2\/pages\/533","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.kastens.net\/WPSub\/dokumentation\/index.php?rest_route=\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/www.kastens.net\/WPSub\/dokumentation\/index.php?rest_route=\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/www.kastens.net\/WPSub\/dokumentation\/index.php?rest_route=\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/www.kastens.net\/WPSub\/dokumentation\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=533"}],"version-history":[{"count":9,"href":"https:\/\/www.kastens.net\/WPSub\/dokumentation\/index.php?rest_route=\/wp\/v2\/pages\/533\/revisions"}],"predecessor-version":[{"id":550,"href":"https:\/\/www.kastens.net\/WPSub\/dokumentation\/index.php?rest_route=\/wp\/v2\/pages\/533\/revisions\/550"}],"up":[{"embeddable":true,"href":"https:\/\/www.kastens.net\/WPSub\/dokumentation\/index.php?rest_route=\/wp\/v2\/pages\/98"}],"wp:attachment":[{"href":"https:\/\/www.kastens.net\/WPSub\/dokumentation\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=533"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}