Python Spickzettel

Wenn Sie alle paar Jahre Python schreiben, vergessen Sie leicht die Syntax. In diesem Fall können Sie diesen Spickzettel nutzen.

Inhaltsverzeichnis

• Hilfreiche Links
• Umgebung aufsetzen
• API Keys verwalten
• If __name__ = „__main__“
• Kommentare
• Escape Character
• Strings
• Strings mit Variablen verknüpfen
• Python Collections Überblick: List, Tuple, Set, Dictionary
• List
• Dictionary
• For Loop
• Funktionen
• Lambda Funktionen
• Dekoratoren für Funktionen
• Klassen
• Fehlerbehandlung mit try

Hilfreiche Links

• Python Webseite
• Python Tutorial

Umgebung aufsetzen

Python environment in VS Code – To create local environments in VS Code using virtual environments or Anaconda, you can follow these steps: open the Command Palette (Ctrl+Shift+P), search for the Python: Create Environment command, and select it.

Beim Anlegen kann man auch auswählen, ob alles aus requirements.txt installiert werden soll. Aber manchmal ist die virtuelle Umgebung noch nicht aktiv und dann ist das Chaos perfekt.

Daher zuerst sicherstellen, dass der venv Python Interpreter ausgewählt ist.Command Palette (Ctrl+Shift+P), search for the Python: Select Interpreter. Wird in der unteren rechten Ecke angezeigt.

Virtual Environment aktivieren:

.venv\Scripts\activate

On Windows, it may be required to enable this Activate.ps1 script by setting the execution policy for the user. You can do this by issuing the following PowerShell command:

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser

Nach der Aktivierung wird im Terminal grün (.venv) vorangestellt. Im Terminal der Ordners ausführen wo die Datei requirements.txt vorhanden ist, um die Pakete zu installieren.

pip install -r requirements.txt

Über Terminal → New Terminal kann man anschließend neue Packages installieren oder die über requirements.txt installierten upgraden. Sie werden in .venv /Lib/site-packages abgelegt.

pip install --upgrade streamlit

Eigene requirements.ext können bequem mit pipreqs erstellt werden. Zum Beispiel:

pipreqs C:/Users/denis/python_projekte/cooles_projekt/

Oder mit pip freeze.

pip freeze > requirements.txt

Google Colab – ermöglicht Ausführung von Jupyter-Notebooks in der Cloud. Es ist kostenlos und ermöglicht es Ihnen, Ihre Notebooks auf einer GPU oder TPU auszuführen.

Full setup for Python development with virtual environments

Working with Jupyter Notebooks in Visual Studio Code

API Keys verwalten – .env

Best Practices for API Key Safety – setx OPENAI_API_KEY "yourkeyhere" oder System > Erweiterte Systemeinstellungen > Umgebungsvariablen.

Alternativ in einer .env Datei im jeweiligen Projekt ablegen und zur Laufzeit in die Umgebugnsvariablen laden.

import os
from dotenv import load_dotenv

Private information is stored in .env in the following format. No spaces, no brackets.

OPENAI_API_KEY=your_api_key

Load .env into environment variables for API keys and passwords. In Debugging unter os -> environ -> _data

load_dotenv(override=True)

Display constants from .env

print(os.getenv('OPENAI_API_KEY'))
print(os.getenv('OPENAI_API_BASE'))
print(os.getenv('LANGCHAIN_API_KEY'))
print(os.getenv('LANGCHAIN_TRACING_V2'))
print(os.getenv('LANGCHAIN_ENDPOINT'))
print(os.getenv('LANGCHAIN_PROJECT'))

Prompt for key and store it as environment variable

import os
import getpass

if "OPENAI_API_KEY" not in os.environ:
    os.environ["OPENAI_API_KEY"] = getpass.getpass("Enter your OpenAI API key: ")

print(os.environ["OPENAI_API_KEY"])

Check if LangSmith Trace is on

from langsmith import utils
utils.tracing_is_enabled()

Run any LLM, Chat model, or Chain. Its trace will be sent to this project.

from langchain_openai import ChatOpenAI

llm = ChatOpenAI()
llm.invoke("Tell me a joke")

If __name__ == __main__

Verhindert versehentliche Ausführung beim Import.

import os
from dotenv import load_dotenv
# Weitere imports hier

def main():
    load_dotenv()


if __name__ == '__main__':
    main()

Kommentare

# Dies ist ein Kommentar
answer = 42  # Dies ist ein Inline-Kommentar

Mehrere Zeilen – in VS Code: Edit > Toogle Line Comment oder Strg + #

# Dies ist ein Kommentar
# über mehrere
# Zeilen

Blockkommentare gibt es in Python nicht. Mann könnte Docstringst nutzen. In VS Code: Edit > Toogle Block Comment oder Shift + Alt + A

Solange die Zeichenkette nicht einer Variablen zugewiesen ist, liest Python den Code, ignoriert ihn dann aber.

"""
Dies ist ein Kommentar
über mehrere 
Zeilen
"""

"""
Dieser Blocktext
wird vom Interpreter ignoriert,
da er nirgendwo zugewiesen wird.
"""

Docstring

def add_numbers(a, b):
    """
    Diese Funktion addiert zwei Zahlen.
    
    Parameter:
    a (int): Die erste Zahl.
    b (int): Die zweite Zahl.
    
    Rückgabe:
    int: Die Summe der beiden Zahlen.
    """
    return a + b

Escape Character

Ein Escape-Zeichen in Python ist ein Backslash \, gefolgt von dem Zeichen, das Sie einfügen möchten.

txt = "We are the so-called \"Vikings\" from the north."
print(txt) 

Strings

Strings werden mit ‚ ‚ oder “ “ gekennzeichnet.

print("Hello world!")
print('Hello world!')

Quotes inside quotes

print("It's alright, it's ok")
print("He is called 'Deni'")
print('He is called "Deni"')

Ausgabe:

It's alright, it's ok
He is called 'Deni'
He is called "Deni"

Strings sind auch Arrays bzw. Listen. Python hat jedoch keinen Zeichendatentyp, ein einzelnes Zeichen ist einfach eine Zeichenkette mit der Länge 1. Eckige Klammern können verwendet werden, um auf Elemente der Zeichenkette zuzugreifen. Sie beginnen mit 0.

a = "Hello, world!"
print(a[0])
print(a[1])
print(a[2])

Ausgabe:

H
e
l

Da Zeichenketten Arrays sind, können wir mit einer for-Schleife durch die Zeichen in einer Zeichenkette gehen.

for x in "Denis":
  print(x)

Ausgabe:

D
e
n
i
s

Länge des Strings mit len() Funktion ausgeben.

a = "Denis"
print(len(a))
# Ausgabe: 5 

Um zu prüfen, ob eine bestimmte Phrase oder ein bestimmtes Zeichen in einer Zeichenkette vorhanden ist, können wir das Schlüsselwort in verwenden.

txt = "The best things in life are free!"
print("free" in txt)
# Ausgabe: True 

Ausgabe wenn „free“ im String

txt = "The best things in life are free!"
if "free" in txt:
  print("Yes, 'free' is present.")
# Ausgabe: Yes, 'free' is present.

Um zu prüfen, ob eine bestimmte Phrase oder ein bestimmtes Zeichen NICHT in einer Zeichenkette vorhanden ist, können wir das Schlüsselwort not in verwenden.

txt = "The best things in life are free!"
print("expensive" not in txt)
# Ausgabe: True

Mit if

txt = "The best things in life are free!"
if "expensive" not in txt:
  print("No, 'expensive' is NOT present.")
# Ausgabe: No, 'expensive' is NOT present.

Sie können einer Variablen eine mehrzeilige Zeichenkette zuweisen, indem Sie drei Anführungszeichen verwenden. Im Ergebnis werden die Zeilenumbrüche an der gleichen Stelle wie im Code eingefügt.

text = """Lorem ipsum dolor adipiscing consectetur amet,
ipsum elit Lorem sit ut tempor aliqua incididunt,
do et sed eiusmod dolore."""

print(text)

Zeilenenden werden automatisch in die Zeichenkette aufgenommen, aber es ist möglich, dies zu verhindern, indem ein \ am Ende der Zeile hinzugefügt wird. Im folgenden Beispiel wird der erste Zeilenumbruch nicht berücksichtigt:

text = """\
Lorem ipsum dolor adipiscing consectetur amet,
ipsum elit Lorem sit ut tempor aliqua incididunt,
do et sed eiusmod dolore.
"""

print(text)

Strings mit Variablen verknüpfen

Am einfachsten mit F-Strings.

first_name = "Denis"
last_name = "Reis"
full_name = f"{first_name} {last_name}"
message = f"Hello, {full_name.upper()}!" # In Großbuchstaben
print(full_name)
print(message)

Ausgabe:

Denis Reis
Hello, DENIS REIS!

Python Collections Überblick

4 Arten – Data Structures in Python:

• List is a collection which is ordered and changeable. Allows duplicate members.
• Tuple is a collection which is ordered and unchangeable. Allows duplicate members.
• Set is a collection which is unordered, unchangeable, and unindexed. No duplicate members.
• Dictionary is a collection which is ordered and changeable. No duplicate members.

Type	Ordered	Changeable	Duplicates
List ["apple", "banana", "cherry"]	Yes	Yes	Yes
Tuple ("apple", "banana", "cherry")	Yes	No	Yes
Set {"apple", "banana", "cherry"}	No	No	No
Dictionary thisdict = { "fruit": "apple", "color": "red", "price": 2 }	Yes	Yes	No

List

Speichert mehrere Elemente in einer einzigen Variable.

friends = ["Kevin", "Karen", "Jim"]
print(friends)
# Ausgabe: ['Kevin', 'Karen', 'Jim']

Kann mehrere Datentypen in einer Liste speichern.

friends = ["Kevin", 2, True]

Listen erlauben Duplikate.

friends = ["Kevin", "Karen", "Jim", "Kevin"]
print(friends)
# Ausgabe: ['Kevin', 'Karen', 'Jim', 'Kevin']

Ausgabe über Index. Fängt mit 0 an. 0, 1, 2, 3…

friends = ["Kevin", "Karen", "Jim"]
print(friends[0])
# Ausgabe: Kevin

friends = ["Kevin", "Karen", "Jim"]
print(friends[2])
# Ausgabe: Jim

Kann auch von hinten Anfangen. Mit -1 – erste von hinten.

friends = ["Kevin", "Karen", "Jim"]
print(friends[-1])
# Ausgabe: Jim

friends = ["Kevin", "Karen", "Jim"]
print(friends[-2])
# Ausgabe: Karen

Teile der Liste ausgeben. Ab Index 0 (erste Position) bis Ende. Also dasselbe wie gesamte Liste ausgeben.

friends = ["Kevin", "Karen", "Jim"]
print(friends[0:])
# Ausgabe: ['Kevin', 'Karen', 'Jim']

Ab Index 1 (ab der zweiten Position) bis Ende.

friends = ["Kevin", "Karen", "Jim"]
print(friends[1:])
# Ausgabe: ['Karen', 'Jim']

Index 1 bis 3 (3 nicht eingeschlossen).

friends = ["Kevin", "Karen", "Jim", "Oscar", "Tobias"]
print(friends[1:3])
# Ausgabe: ['Karen', 'Jim']

Von hinten bis Anfang.

friends = ["Kevin", "Karen", "Jim", "Oscar", "Tobias"]
print(friends[:5])
# Ausgabe:9 ['Kevin', 'Karen', 'Jim', 'Oscar', 'Tobias']

Mit -1. Letzte wird nicht inkludiert.

friends = ["Kevin", "Karen", "Jim", "Oscar", "Tobias"]
print(friends[:-1])
# Ausgabe: ['Kevin', 'Karen', 'Jim', 'Oscar']

Index -1 bis -3, nicht inkludiert.

friends = ["Kevin", "Karen", "Jim", "Oscar", "Tobias"]
print(friends[-3:-1])
# Ausgabe: ['Jim', 'Oscar']

Listenelement ändern. Element mit der Indexposition 1 anpassen.

friends = ["Kevin", "Karen", "Jim", "Oscar", "Tobias"]
friends[1] = "Denis"
print(friends)
# Ausgabe: ['Kevin', 'Denis', 'Jim', 'Oscar', 'Tobias']

Länge der Liste ausgeben.

friends = ["Kevin", "Karen", "Jim"]
print(len(friends))
# Ausgabe: 3

Liste kann über den list() Konstruktor erstellt werden.

friends = list(("Kevin", "Karen", "Jim")) # note the double round-brackets
print(type(friends))
print(friends)
# Ausgabe: <class 'list'>
# Ausgabe: ['Kevin', 'Karen', 'Jim']

Listen zusammenführen.

lucky_numbers = [4, 8, 15, 16,23, 42]
friends = ["Kevin", "Karen", "Jim", "Oscar", "Tobias"]

friends.extend(lucky_numbers)
print(friends)
# Ausgabe: ['Kevin', 'Karen', 'Jim', 'Oscar', 'Tobias', 4, 8, 15, 16, 23, 42]

Element zur Liste hinzufügen. Wir am Ende der Liste hinzugefügt.

friends = ["Kevin", "Karen", "Jim", "Oscar", "Tobias"]

friends.append("Denis")
print(friends)
# Ausgabe: ['Kevin', 'Karen', 'Jim', 'Oscar', 'Tobias', 'Denis']

An einer bestimmten Position (Index) einfügen. Wird in dieser Indexposition (Index staret mit 0) eingefügt. Alle anderen Elemente werden nach rechts geschoben.

friends = ["Kevin", "Karen", "Jim", "Oscar", "Tobias"]

friends.insert(1, "Denis")
print(friends)
# Ausgabe: ['Kevin', 'Denis', 'Karen', 'Jim', 'Oscar', 'Tobias']

Element entfernen.

friends = ["Kevin", "Karen", "Jim", "Oscar", "Tobias"]

friends.remove("Jim")
print(friends)
# Ausgabe: ['Kevin', 'Karen', 'Oscar', 'Tobias']

Entfernt jedoch nur den ersten Eintrag für „Jim“

friends = ["Kevin", "Karen", "Jim", "Oscar", "Tobias", "Jim"]
print(friends)
# Ausgabe: ['Kevin', 'Karen', 'Jim', 'Oscar', 'Tobias', 'Jim']

friends.remove("Jim")
print(friends)
# Ausgabe: ['Kevin', 'Karen', 'Oscar', 'Tobias', 'Jim']

Um alle Einträge für „Jim“ zu entfernen, gibt es mehrere Methoden.

1. List comprehension. Create a new list with all names excpet „Jim“.

friends = ["Kevin", "Karen", "Jim", "Oscar", "Tobias", "Jim"]
friends = [name for name in friends if name != "Jim"]
print(friends)
# Ausgabe: ['Kevin', 'Karen', 'Oscar', 'Tobias']

2. Neue Liste mit filter() Lambda Funktion anlegen.

friends = ["Kevin", "Karen", "Jim", "Oscar", "Tobias", "Jim"]
friends = list(filter(lambda name: name != "Jim", friends))
print(friends)

3. Loop mit remove(). Mach das nicht, nutze einfach List comprehension.

friends = ["Kevin", "Karen", "Jim", "Oscar", "Tobias", "Jim"]
while "Jim" in friends:
    friends.remove("Jim")
print(friends)

Liste leeren.

friends = ["Kevin", "Karen", "Jim", "Oscar", "Tobias"]
friends.clear()
print(friends)
# Ausgabe: []

Letzen Eintrag entfernen mit pop().

friends = ["Kevin", "Karen", "Jim", "Oscar", "Tobias"]
friends.pop()
print(friends)
# Ausgabe: ['Kevin', 'Karen', 'Jim', 'Oscar']

Index eines bestimmten Eintrag ausgeben. Index fängt mit 0 an.

friends = ["Kevin", "Karen", "Jim", "Oscar", "Tobias"]

print(friends.index("Jim"))
# Ausgabe: 2

Wenn ein Eintrag nicht in der Liste ist, wird ein ValueError ausgegeben.

friends = ["Kevin", "Karen", "Jim", "Oscar", "Tobias"]

print(friends.index("Denis"))
# Ausgabe: ValueError: 'Denis' is not in list

Doppelte Einträge zählen.

friends = ["Kevin", "Karen", "Jim", "Jim", "Tobias"]

print(friends.count("Jim"))
# Ausgabe: 2

Liste sortieren.

friends = ["Kevin", "Karen", "Jim", "Oscar", "Tobias", "Denis"]
friends.sort()
print(friends)
# Ausgabe: ['Denis', 'Jim', 'Karen', 'Kevin', 'Oscar', 'Tobias']

Reihenfolge umkehren.

friends = ["Kevin", "Karen", "Jim", "Oscar", "Tobias"]
friends.reverse()
print(friends)
# Ausgabe: ['Tobias', 'Oscar', 'Jim', 'Karen', 'Kevin']

Liste kopieren

friends = ["Kevin", "Karen", "Jim", "Oscar", "Tobias"]
personen = friends.copy()
print(personen)
# Ausgabe: ['Kevin', 'Karen', 'Jim', 'Oscar', 'Tobias']

Dictionary

Speichert Informationen in einer Reihe von Schlüssel-Wert-Paaren. key:value

Ähnlich wie JSON in JavaScript. Ein Dictionary ist eine Sammlung, die geordnet sowie veränderbar ist und keine Duplikate zulässt.

Man kann es sich wie ein Wörterbuch (engl. Dictionary) vorstellen. Links ist Key / Schlüssel, Rechts ist der Wert. In unserem Beispiel ist der deutsche Eintrag „Januar“ Schlüssel und des englische Pendant „January“ der Wert

monate =	{
  "Januar": "January",
  "Februar": "February",
  "März": "March",
  "April": "April"
}
print(monate) 
# Ausgabe: {'Januar': 'January', 'Februar': 'February', 'März': 'March', 'April': 'April'}

Duplikate sind nicht erlaubt. Da der erster Eintrag Key/Schlüssel ist. Key is unique. Doppelter Eintrag überschreibt den vorherigen Eintrag.

monate =	{
  "Januar": "January",
  "Februar": "February",
  "März": "March",
  "April": "April",
  "Januar": "Jan",
}
print(monate) 
# Ausgabe: {'Januar': 'Jan', 'Februar': 'February', 'März': 'March', 'April': 'April'}

Kann verschiedene Datentypen speichern

thisdict =	{
  "brand": "Ford", #string
  "electric": False, #boolean
  "year": 1964, #int
  "colors": ["red", "white", "blue"] #list
} 

dict() Konstruktor kann genutzt werden, um Dictionaries zu erstellen.

person = dict(name = "Denis", age = 42, country = "Schweiz")
print(person)
# Ausgabe: {'name': 'Denis', 'age': 42, 'country': 'Schweiz'}

Den Wert über Schlüssel auslesen

monthConversions = {
    "Jan" : "January",
    "Feb" : "February",
    "Mar" : "March",
    "Apr" : "April",
    "May" : "May",
    "Jun" : "June",
    "Jul" : "July",
    "Aug" : "August",
    "Sep" : "September",
    "Oct" : "October",
    "Nov" : "November",
    "Dec" : "December"
 }

print(monthConversions["Nov"]) 
# Ausgabe: November

Mit get() Methode

print(monthConversions.get("Dec"))
# Ausgabe: December

get() mit Default / Standard Wert

print(monthConversions.get("X", "Not a valid key"))
# Ausgabe: Not a valid key

JSON-Objekte haben das gleiche Format wie Python-Dictionaries. Wenn Ihr JSON-Code nicht in einer Datei, sondern in einem Python-Dictionary steht, können Sie ihn direkt in einen Pandas DataFrame laden.

data = {
  "Duration":{
    "0":60,
    "1":60,
    "2":60,
    "3":45,
    "4":45,
    "5":60
  },
  "Pulse":{
    "0":110,
    "1":117,
    "2":103,
    "3":109,
    "4":117,
    "5":102
  },
  "Maxpulse":{
    "0":130,
    "1":145,
    "2":135,
    "3":175,
    "4":148,
    "5":127
  },
  "Calories":{
    "0":409,
    "1":479,
    "2":340,
    "3":282,
    "4":406,
    "5":300
  }
}

import pandas as pd
df = pd.DataFrame(data)
print(df) 

Ausgabe:

   Duration  Pulse  Maxpulse  Calories
0        60    110       130       409
1        60    117       145       479
2        60    103       135       340
3        45    109       175       282
4        45    117       148       406
5        60    102       127       300

For Loop

Iteration über eine Collection. Syntax: for <Variable> in <Collection>: <do something>

In Python sind Strings auch Arrays und man kann über sie loopen. Zum Beispiel, jeden Buchstaben in „Hello world“ ausdrucken:

for variable in "Hello world":
    print(variable)

Die Variable nach for kann beliebig benannt werden.

string = "Hello world"
for letter in string:
    print(letter)

Ausgabe:

H
e
l
l
o
 
w
o
r
l
d

Loop over list:

friends = ["Kevin", "Karen", "Jim"]
for friend in friends:
    print(friend.upper()) #In Großbuchstaben ausgeben

Ausgabe:

KEVIN
KAREN
JIM

range kann genutzt werden, um Iterationen über den Index auszuführen.

friends = ["Kevin", "Karen", "Jim"]
for index in range(len(friends)):
    print(friends[index].lower()) #In Kleinbuchstaben ausgeben
    #gibt friends[0], dann friends[1] usw. aus.

Ausgabe:

kevin
karen
jim

Bei Iterationen über eine Sequenz können der Positionsindex und der entsprechende Wert mit der Funktion enumerate() aufgerufen werden.

for index, friend in enumerate(friends):
    print(index, friend)

Ausgabe:

0 Kevin
1 Karen
2 Jim

Bei Iterationen über Dictionaries können der Schlüssel und der entsprechende Wert mit der items() Methode aufgerufen werden.

monate = {
    "Januar": "January",
    "Februar": "February", 
    "März": "March",
    "April": "April"
}

for german, english in monate.items():
    print(f"{german}: {english}")

Ausgabe:

Januar: January
Februar: February
März: March
April: April

Funktionen

Funktionen ermöglichen es, eine bestimmte Aufgabe mehrfach auszuführen. Funktionen stellen einen wiederverwendbaren Codeblock dar, der eine Folge von Anweisungen zusammenfasst, um eine bestimmte Aufgabe zu erfüllen.

def say_hi():
    print("Hi")

say_hi() #output: Hi

Mit Parameter:

def say_hi(name):
    print(f"Hi {name}")

say_hi("Denis") #output: Hi Denis

Mit mehreren Parametern:

def say_hi(vorname, nachname):
    print(f"Hi {vorname} {nachname}!")

say_hi("Denis", "Reis") #output: Hi Denis Reis!

Mit Ausgabe zur Weiterverarbeitung:

def say_hi(vorname, nachname):
    greeting = f"Hi {vorname} {nachname}!"
    return greeting

greetings = say_hi("Denis", "Reis")
print(greetings)

Ein anderes Beispiel:

def cube(num):
    return num*num*num

print(cube(3))

def cube(num):
    return num*num*num

result=cube(4)
print(result)

Hier ist ein Beispiel für eine Python-Funktion, die zwei Zahlen aus Benutzereingaben multipliziert.

def multiply_numbers():
    # Get input from the user
    num1 = float(input("Enter the first number: "))
    num2 = float(input("Enter the second number: "))
    
    # Multiply the numbers
    result = num1 * num2
    
    # Print the result
    print(f"The result of multiplying {num1} and {num2} is {result}")
    
# Call the function
multiply_numbers()

Hier ist ein Beispiel, bei dem der Benutzer die Eingaben als Argumente an die Funktion übergeben kann, anstatt innerhalb der Funktion aufgefordert zu werden.

def multiply_numbers(num1, num2):
    # Multiply the numbers
    result = num1 * num2
    
    # Print the result
    print(f"The result of multiplying {num1} and {num2} is {result}")

# User-provided inputs
number1 = float(input("Enter the first number: "))
number2 = float(input("Enter the second number: "))

# Call the function with user inputs
multiply_numbers(number1, number2)

def multiply_numbers(num1, num2):
    # Multiply the numbers
    result = num1 * num2
    
    # Print the result
    print(f"The result of multiplying {num1} and {num2} is {result}")

# User-provided inputs
number1 = 2
number2 = 3

# Call the function with user inputs
multiply_numbers(number1, number2)

Gibt das Ergebnis der Funktion zur Weiterverarbeitung aus

def multiply_numbers(num1, num2):
    # Multiply the numbers
    result = num1 * num2
    return result

# User-provided inputs
number1 = 2
number2 = 3

# Call the function with user inputs and store the result in a variable
result = multiply_numbers(number1, number2)

# Print the result
print(f"The result of multiplying {number1} and {number2} is {result}")

def multiply_numbers(num1, num2):
    # Multiply the numbers
    result = num1 * num2
    return result

# User-provided inputs
number1 = 2
number2 = 3

# Call the function with user inputs and store the result in a variable
number3 = multiply_numbers(number1, number2)

# Print the result
print(f"The result of multiplying {number1} and {number2} is {number3}")

Wegen Lesbarkeit würde ich folgendes nicht empfehlen.

def multiply_numbers(num1, num2):
    # Multiply the numbers
    result = num1 * num2
    return result

# User-provided inputs
number1 = 2
number2 = 3

# Print the result
print(f"The result of multiplying {number1} and {number2} is {multiply_numbers(number1, number2)}")

Funktion zur Extraktion von Inhalten zwischen XML Tags.

import re

def extract_tag_content(text, tag_name):
    """
    Extract content between specified XML/HTML-style tags.
    
    Args:
        text (str): The input text containing tagged content
        tag_name (str): Name of the tag to extract content from
    
    Returns:
        str or None: Content between tags if found, None otherwise
    """
    # Create pattern using the provided tag name
    pattern = f'<{tag_name}>(.*?)</{tag_name}>'
    
    # Search for the pattern in the text
    match = re.search(pattern, text, re.DOTALL)
    
    # Return the matched text if found, otherwise return None
    return match.group(1).strip() if match else None

# Example usage
text = """<action_title>
Operational Excellence Drives Stability Amid Claims Challenges
</action_title>"""

# Extract content using different tag names
title = extract_tag_content(text, "action_title")
print(title)  # Output: Operational Excellence Drives Stability Amid Claims Challenges

# Another example with different tags
sample_text = """<summary>
This is a summary of the document
</summary>
<body>
This is the main content
</body>"""

summary = extract_tag_content(sample_text, "summary")
body = extract_tag_content(sample_text, "body")

print(summary)  # Output: This is a summary of the document
print(body)    # Output: This is the main content

Funktionen können Standardwerte für Argumente haben. Diese werden verwendet, wenn kein Wert übergeben wird.

def greet(name="Welt"):
    return f"Hallo, {name}!"

print(greet())           # Hallo, Welt!
print(greet("Denis"))     # Hallo, Denis!

Funktionen mit variablen Argumenten (*args und **kwargs).

*args sammelt beliebig viele nicht-benannte Argumente als Tupel.

**kwargs sammelt beliebig viele benannte Argumente als Dictionary

def add_numbers(*args):
    return sum(args)

print(add_numbers(1, 2, 3))  # 6

def print_details(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_details(name="Denis", age=42)  
# name: Denis
# age: 42

Lambda-Funktionen

Kurznotation für einfache Funktionen, die oft als Argumente an andere Funktionen übergeben werden.

# Normale Funktion
def square(x):
    return x ** 2

# Lambda-Funktion
square_lambda = lambda x: x ** 2

print(square(4))          # 16
print(square_lambda(4))   # 16

# Verwendung in Funktionen wie `map`
numbers = [1, 2, 3, 4]
squared = list(map(lambda x: x ** 2, numbers))
print(squared)  # [1, 4, 9, 16]

Die Funktion map() wird verwendet, um eine bestimmte Funktion auf jedes Element einer iterierbaren Datei (z. B. eine Liste oder ein Tupel) anzuwenden, und gibt ein map-Objekt zurück (das ein Iterator ist). In dem Beispiel wird es zusätzlich mit list() in eine Liste umgewandelt.

Dekoratoren für Funktionen

Dekoratoren sind Funktionen, die andere Funktionen erweitern oder verändern. Sie werden mit @ vor der Funktion angegeben. So haben wir die folgende Funktion, die den Benutzer begrüßt.

user = "Denis"

def say_hi(name):
    return f"Hi {name}"

print(say_hi(user)) # Output: Hi Denis

Diese kann mit einer Uppercase Funktion erweitert werden, ohne die bestehende Funktion zu verändern.

# Define decorator for uppercase conversion
def capitalize_output(func):
    def wrapper(name):
        result = func(name)  # Call the original function
        if isinstance(result, str):  # Check if the function returns a string
            return result.upper()  # Convert the string to uppercase
        return result  # Return the result as is if not a string
    return wrapper

# Apply the decorator to say_hi
@capitalize_output
def say_hi(name):
    return f"Hi {name}"

user = "Denis"
print(say_hi(user)) # Output : HI DENIS

Ein anderes Beispiel mit Debugging Dekorator. Dieser kann durch das auskommentieren #@debug ausgeschaltet werden.

# Debugging Dekorator
def debug(func):
    def wrapper(*args, **kwargs):
        print(f"Funktion {func.__name__} wird mit {args} und {kwargs} aufgerufen")
        result = func(*args, **kwargs)
        print(f"Ergebnis: {result}")
        return result
    return wrapper

@debug
def add(a, b):
    return a + b

add(3, 5)
# Funktion add wird mit (3, 5) und {} aufgerufen
# Ergebnis: 8

Klassen

Eine Klasse ist eine Blaupause für Objekte. Ein Objekt ist eine Instanz einer Klasse. Attribute sind Eigenschaften eines Objekts. Methoden sind Funktionen innerhalb einer Klasse.

Vererbung ermöglicht, von einer bestehenden Klasse zu erben und deren Funktionen zu erweitern. Polymorphismus – Verschiedene Objekte können die gleiche Methode unterschiedlich implementieren.

Grundstruktur einer Klasse:

class Fahrzeug:
    def __init__(self, marke, modell):
        self.marke = marke  # Attribut
        self.modell = modell

    def beschreibung(self):  # Methode
        return f"{self.marke} {self.modell}"
    
    def fahren(self):  # Methode
        return f"{self.marke} {self.modell} macht Wroom, WROOM"

# Objekt erstellen
auto = Fahrzeug("VW", "Polo")
print(auto.beschreibung())  # VW Polo
print(auto.fahren())  # VW Polo macht Wroom, WROOM

# Noch ein Objekt erstellen
auto2 = Fahrzeug("Tesla", "Model S")
print(auto2.beschreibung())  # Tesla Model S
print(auto2.fahren())  # Tesla Model S macht Wroom, WROOM

Die oben beschriebene Mulitplikation Funktion als Klasse

class Multiplier:
    def __init__(self, num1, num2):
        # Initialize with two numbers
        self.num1 = num1
        self.num2 = num2

    def multiply(self):
        # Multiply the numbers and return the result
        return self.num1 * self.num2

# User-provided inputs
number1 = 2
number2 = 3

# Create an instance of the class
multiplier = Multiplier(number1, number2)

# Call the multiply method and store the result in a variable
number3 = multiplier.multiply()

# Print the result
print(f"The result of multiplying {number1} and {number2} is {number3}")

System zur Verwaltung von Hotelzimmerbuchungen

class Zimmer:
    def __init__(self, nummer, betten, preis):
        self.nummer = nummer
        self.betten = betten
        self.preis = preis
        self.verfuegbar = True  # Standard: Verfügbar

    def buchen(self):
        if self.verfuegbar:
            self.verfuegbar = False
            print(f"Zimmer {self.nummer} wurde erfolgreich gebucht.")
        else:
            print(f"Zimmer {self.nummer} ist bereits belegt.")

    def freigeben(self):
        self.verfuegbar = True
        print(f"Zimmer {self.nummer} ist jetzt wieder verfügbar.")

    def beschreibung(self):
        status = "verfügbar" if self.verfuegbar else "belegt"
        return f"Zimmer {self.nummer}: {self.betten} Betten, {self.preis} €/Nacht, Status: {status}"

# Hauptprogramm
if __name__ == "__main__":
    # Zimmer erstellen
    zimmer1 = Zimmer(101, 2, 80)
    zimmer2 = Zimmer(102, 3, 120)

    # Beschreibung der Zimmer
    print(zimmer1.beschreibung()) # Output: Zimmer 101: 2 Betten, 80 €/Nacht, Status: verfügbar
    print(zimmer2.beschreibung()) # Output: Zimmer 102: 3 Betten, 120 €/Nacht, Status: verfügbar

    # Zimmer buchen
    zimmer1.buchen() # Output: Zimmer 101 wurde erfolgreich gebucht.
    print(zimmer1.beschreibung()) # Output: Zimmer 101: 2 Betten, 80 €/Nacht, Status: belegt

    # Belegtes Zimmer erneut buchen
    zimmer1.buchen() # Output: Zimmer 101 ist bereits belegt.

    # Zimmer freigeben
    zimmer1.freigeben() # Output: Zimmer 101 ist jetzt wieder verfügbar.
    print(zimmer1.beschreibung()) # Output: Zimmer 101: 2 Betten, 80 €/Nacht, Status: verfügbar

Vererbung ermöglicht es, eine neue Klasse von einer bestehenden Klasse abzuleiten. Die abgeleitete Klasse erbt alle Eigenschaften und Methoden der Basisklasse und kann sie erweitern oder überschreiben.

class Fahrzeug:
    def __init__(self, marke, modell):
        self.marke = marke
        self.modell = modell

    def beschreibung(self):
        return f"{self.marke} {self.modell}"

# Unterklasse erbt von Fahrzeug
class Elektrofahrzeug(Fahrzeug):
    def __init__(self, marke, modell, batterie_kapazitaet):
        super().__init__(marke, modell)  # Konstruktor der Basisklasse aufrufen
        self.batterie_kapazitaet = batterie_kapazitaet

    def beschreibung(self):  # Überschreiben der Methode
        return f"{super().beschreibung()} mit {self.batterie_kapazitaet} kWh Batterie"

# Objekte erstellen
auto1 = Fahrzeug("BMW", "X5")
auto2 = Elektrofahrzeug("Tesla", "Model 3", 75)

print(auto1.beschreibung())  # BMW X5
print(auto2.beschreibung())  # Tesla Model 3 mit 75 kWh Batterie

class Fahrzeug:
    def __init__(self, marke, modell):
        self.marke = marke  # Attribut
        self.modell = modell

    def beschreibung(self):  # Methode
        return f"{self.marke} {self.modell}"
    
    def fahren(self):  # Methode
        return f"{self.marke} {self.modell} macht Wroom, WROOM"
    
# Unterklasse erbt von Fahrzeug
class Elektrofahrzeug(Fahrzeug):
    def __init__(self, marke, modell, batterie_kapazitaet):
        super().__init__(marke, modell)  # Konstruktor der Basisklasse aufrufen
        self.batterie_kapazitaet = batterie_kapazitaet

    def beschreibung(self):  # Überschreiben der Methode
        return f"{super().beschreibung()} mit {self.batterie_kapazitaet} kWh Batterie"
    
    def fahren(self):  # Methode
        return f"{self.marke} {self.modell} macht Woosh"

# Objekt erstellen
auto_vw_polo = Fahrzeug("VW", "Polo")
print(auto_vw_polo.beschreibung())  # VW Polo
print(auto_vw_polo.fahren())  # VW Polo macht Wroom, WROOM

# Noch ein Objekt erstellen
auto_tesla_s = Elektrofahrzeug("Tesla", "Model 3", 75)
print(auto_tesla_s.beschreibung())  # Tesla Model 3 mit 75 kWh Batterie
print(auto_tesla_s.fahren())  # TTesla Model 3 macht Woosh

Kapselung schützt die Daten einer Klasse, indem Attribute als privat markiert werden. Dies erfolgt durch Doppelte Unterstriche (__).

class Konto:
    def __init__(self, inhaber, startguthaben):
        self.__inhaber = inhaber  # Privates Attribut
        self.__guthaben = startguthaben

    def einzahlen(self, betrag):
        if betrag > 0:
            self.__guthaben += betrag
            print(f"{betrag} € eingezahlt. Neues Guthaben: {self.__guthaben} €")
        else:
            print("Einzahlungsbetrag muss positiv sein.")

    def abheben(self, betrag):
        if 0 < betrag <= self.__guthaben:
            self.__guthaben -= betrag
            print(f"{betrag} € abgehoben. Neues Guthaben: {self.__guthaben} €")
        else:
            print("Unzureichendes Guthaben oder ungültiger Betrag.")

    def get_guthaben(self):  # Getter
        return self.__guthaben

# Objekt erstellen
konto = Konto("Anna", 500)
konto.einzahlen(200)
konto.abheben(100)
print(f"Aktuelles Guthaben: {konto.get_guthaben()} €")

Kann auf private Attribute nicht von außerhalb zugreifen. Folgendes geht nicht:

print(konto.__guthaben)
print(konto.__inhaber)

Allerdings sind „private“ Attribute in Python nicht wirklich privat. Denn ich kann folgendes machen:

print(konto._Konto__inhaber)
print(konto._Konto__guthaben)

Polymorphismus ermöglicht es, dass unterschiedliche Klassen die gleiche Methode mit spezifischem Verhalten implementieren. Verschiedene Klassen haben Methoden mit demselben Namen, aber unterschiedlicher Implementierung.

class Fahrzeug:
    def __init__(self, marke, modell):
        self.marke = marke  # Attribut
        self.modell = modell

    def beschreibung(self):  # Methode
        return f"{self.marke} {self.modell}"
    
    def fahren(self):  # Methode
        raise NotImplementedError("Diese Methode muss in der Unterklasse überschrieben werden")
    
class Vw(Fahrzeug):
    def fahren(self):
        return "Wroom"

class Tesla(Fahrzeug):
    def fahren(self):
        return "Woosh"
    
vw = Vw("VW", "Polo")
tesla = Tesla("Tesla", "Model 3")

print(vw.beschreibung())  # VW Polo
print(vw.fahren())  # Wroom

print(tesla.beschreibung())  # Tesla Model
print(tesla.fahren())  # Woosh

In diesem Beispiel erstellen wir ein Buchungssystem für verschiedene Fahrzeugtypen. Es kombiniert Vererbung, Kapselung und Polymorphismus.

Vererbung: Eine Basisklasse Fahrzeug wird erstellt, von der spezialisierte Klassen wie Auto und Motorrad erben.
Kapselung: Attribute wie __preis sind privat und nur über Getter und Setter zugänglich.
Polymorphismus: Jede Klasse implementiert ihre eigene Methode beschreibung.

class Fahrzeug:
    def __init__(self, marke, modell, preis):
        self.marke = marke
        self.modell = modell
        self.__preis = preis  # Privates Attribut

    def get_preis(self):  # Getter für Preis
        return self.__preis

    def set_preis(self, neuer_preis):  # Setter für Preis
        if neuer_preis > 0:
            self.__preis = neuer_preis
        else:
            print("Der Preis muss positiv sein.")

    def beschreibung(self):  # Polymorphe Methode
        return f"{self.marke} {self.modell} - Preis: {self.__preis} €"

# Vererbte Klassen
class Auto(Fahrzeug):
    def __init__(self, marke, modell, preis, sitzplaetze):
        super().__init__(marke, modell, preis)
        self.sitzplaetze = sitzplaetze

    def beschreibung(self):  # Überschreibt die Methode
        return f"Auto: {super().beschreibung()}, Sitzplätze: {self.sitzplaetze}"

class Motorrad(Fahrzeug):
    def __init__(self, marke, modell, preis, hubraum):
        super().__init__(marke, modell, preis)
        self.hubraum = hubraum

    def beschreibung(self):  # Überschreibt die Methode
        return f"Motorrad: {super().beschreibung()}, Hubraum: {self.hubraum}cc"

# Hauptprogramm
if __name__ == "__main__":
    # Objekte erstellen
    auto = Auto("Tesla", "Model S", 80000, 5)
    motorrad = Motorrad("Yamaha", "MT-07", 7500, 689)

    # Beschreibung der Fahrzeuge
    print(auto.beschreibung())   # Auto: Tesla Model S - Preis: 80000 €, Sitzplätze: 5
    print(motorrad.beschreibung())  # Motorrad: Yamaha MT-07 - Preis: 7500 €, Hubraum: 689cc

    # Preis anpassen (Kapselung)
    auto.set_preis(85000)
    print(f"Neuer Preis des Autos: {auto.get_preis()} €")  # Neuer Preis des Autos: 85000 €

    # Polymorphismus in Aktion
    def fahrzeug_beschreiben(fahrzeug):
        print(fahrzeug.beschreibung())

    fahrzeug_beschreiben(auto)       # Auto: Tesla Model S - Preis: 85000 €, Sitzplätze: 5
    fahrzeug_beschreiben(motorrad)   # Motorrad: Yamaha MT-07 - Preis: 7500 €, Hubraum: 689cc

Fehlerbehandlung mit try

Fehlerbehandlung mit try except finally.

try:
    zahl = int(input("Gib eine Zahl ein: "))
    ergebnis = 10 / zahl
    print(f"Ergebnis: {ergebnis}")
except ValueError:
    print("Bitte gib eine gültige Zahl ein.")
except ZeroDivisionError:
    print("Division durch Null ist nicht erlaubt.")
finally:
    print("Das Programm wurde beendet.")