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
• Klassen

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/

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)

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

Klassen

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}")