Python
Das .loc in Python meistern: Ein Leitfaden für Anfänger

Das .loc in Python meistern: Ein Leitfaden für Anfänger

MoeNagy Dev

Das .loc Accessor verstehen

Was ist der .loc Accessor?

Der .loc Accessor in Pandas ist ein leistungsstolles Werkzeug zum Auswählen und Zugreifen auf Daten in einem DataFrame oder einer Series anhand von Zeilen- und Spaltenbezeichnungen. Er ermöglicht es Ihnen, Daten auszuwählen, indem Sie explizit die Zeilen- und Spaltenbezeichnungen angeben, anstatt numerische Indizes wie beim .iloc Accessor zu verwenden.

Zugriff auf Daten mit Zeilen- und Spaltenbezeichnungen

Um auf Daten mit dem .loc Accessor zuzugreifen, müssen Sie die Zeilen- und Spaltenbezeichnungen als Argumente angeben. Hier ist ein grundlegendes Beispiel:

import pandas as pd
 
# Erstellen Sie ein Beispiel DataFrame
df = pd.DataFrame({'A': [1, 2, 3, 4, 5],
                   'B': [10, 20, 30, 40, 50]},
                  index=['Zeile1', 'Zeile2', 'Zeile3', 'Zeile4', 'Zeile5'])
 
# Zugriff auf ein einzelnes Element
print(df.loc['Zeile2', 'B'])  # Output: 20
 
# Zugriff auf eine Zeile
print(df.loc['Zeile3'])
# Output:
# A    3
# B   30
# Name: Zeile3, dtype: int64
 
# Zugriff auf eine Spalte
print(df.loc[:, 'A'])
# Output:
# Zeile1    1
# Zeile2    2
# Zeile3    3
# Zeile4    4
# Zeile5    5
# Name: A, dtype: int64

Im obigen Beispiel erstellen wir ein Beispiel DataFrame mit den Zeilenbezeichnungen 'Zeile1' bis 'Zeile5' und den Spaltenbezeichnungen 'A' und 'B'. Anschließend zeigen wir, wie man den .loc Accessor verwendet, um ein einzelnes Element, eine ganze Zeile und eine ganze Spalte auszuwählen.

Auswahl einzelner Elemente, Zeilen und Spalten

Der .loc Accessor ermöglicht es Ihnen, einzelne Elemente, Zeilen und Spalten auszuwählen, indem Sie die entsprechenden Bezeichnungen angeben. Hier sind einige Beispiele:

# Auswahl eines einzelnen Elements
print(df.loc['Zeile2', 'B'])  # Output: 20
 
# Auswahl einer Zeile
print(df.loc['Zeile3'])
# Output:
# A    3
# B   30
# Name: Zeile3, dtype: int64
 
# Auswahl einer Spalte
print(df.loc[:, 'A'])
# Output:
# Zeile1    1
# Zeile2    2
# Zeile3    3
# Zeile4    4
# Zeile5    5
# Name: A, dtype: int64

Auswahl mehrerer Zeilen und Spalten

Sie können den .loc Accessor auch verwenden, um mehrere Zeilen und Spalten auszuwählen, indem Sie eine Liste oder einen Bereich von Bezeichnungen angeben:

# Auswahl mehrerer Zeilen
print(df.loc[['Zeile2', 'Zeile4']])
#         A   B
# Zeile2  2  20
# Zeile4  4  40
 
# Auswahl mehrerer Spalten
print(df.loc[:, ['A', 'B']])
#         A   B
# Zeile1  1  10
# Zeile2  2  20
# Zeile3  3  30
# Zeile4  4  40
# Zeile5  5  50
 
# Auswahl eines Bereichs von Zeilen
print(df.loc['Zeile2':'Zeile4'])
#         A   B
# Zeile2  2  20
# Zeile3  3  30
# Zeile4  4  40

In den obigen Beispielen zeigen wir, wie man mit Listen oder Bereichen von Bezeichnungen mehrere Zeilen und Spalten auswählt.

Bedingte Auswahl mit .loc

Filtern von Zeilen und Spalten basierend auf Bedingungen

Der .loc Accessor kann auch verwendet werden, um Zeilen und Spalten basierend auf bestimmten Bedingungen zu filtern. Dies ist besonders nützlich, wenn Sie Daten auswählen müssen, die bestimmte Kriterien erfüllen.

# Filtern von Zeilen basierend auf einer Bedingung
print(df.loc[df['A'] > 3])
#         A   B
# Zeile4  4  40
# Zeile5  5  50
 
# Filtern von Spalten basierend auf einer Bedingung
print(df.loc[:, df.columns.str.startswith('A')])
#         A
# Zeile1  1
# Zeile2  2
# Zeile3  3
# Zeile4  4
# Zeile5  5

Im ersten Beispiel filtern wir das DataFrame, um nur Zeilen einzuschließen, bei denen der Wert in Spalte 'A' größer als 3 ist. Im zweiten Beispiel filtern wir das DataFrame, um nur Spalten einzuschließen, deren Namen mit 'A' beginnen.

Kombinieren mehrerer Bedingungen mit Booleschen Operatoren

Sie können auch mehrere Bedingungen mithilfe von Booleschen Operatoren wie & (und) und | (oder) kombinieren, um komplexere Filter zu erstellen.

# Kombinieren mehrerer Bedingungen mit Booleschen Operatoren
print(df.loc[(df['A'] > 2) & (df['B'] < 40)])
#         A   B
# Zeile3  3  30

In diesem Beispiel wählen wir die Zeilen aus, in denen der Wert in Spalte 'A' größer als 2 und der Wert in Spalte 'B' kleiner als 40 ist.

Auswahl von Zeilen und Spalten basierend auf komplexen Bedingungen

Der .loc Accessor ermöglicht es Ihnen, komplexe Bedingungen zu erstellen, indem Sie mehrere Filter kombinieren und Boolesche Operatoren verwenden. Dies kann besonders nützlich sein, wenn Sie fortgeschrittenere Daten auswählen und extrahieren müssen.

# Auswahl von Zeilen und Spalten basierend auf komplexen Bedingungen
print(df.loc[(df['A'] > 2) & (df['B'] < 40), ['A', 'B']])
#         A   B
# Zeile3  3  30

In diesem Beispiel wählen wir die Zeilen aus, in denen der Wert in Spalte 'A' größer als 2 und der Wert in Spalte 'B' kleiner als 40 ist, und wir geben nur die Spalten 'A' und 'B' zurück.

Ändern von Daten mit .loc

Zuweisen von Werten zu bestimmten Elementen

Der .loc Accessor kann auch verwendet werden, um Werte zu bestimmten Elementen in einem DataFrame oder einer Series zuzuweisen.

# Zuweisen eines Werts zu einem bestimmten Element
df.loc['Zeile2', 'B'] = 25
print(df)
#         A    B
# Zeile1  1   10
# Zeile2  2   25
# Zeile3  3   30
# Zeile4  4   40
# Zeile5  5   50

In diesem Beispiel verwenden wir den .loc Accessor, um den Wert 25 dem Element in Zeile 'Zeile2' und Spalte 'B' zuzuweisen.

Aktualisieren mehrerer Zeilen und Spalten

Sie können den .loc Accessor auch verwenden, um gleichzeitig mehrere Zeilen und Spalten zu aktualisieren.

# Aktualisieren mehrerer Zeilen und Spalten
df.loc[['Zeile2', 'Zeile4'], ['A', 'B']] = [[12, 125], [42, 420]]
print(df)
#         A    B
# Zeile1   1   10
# Zeile2  12  125
# Zeile3   3   30
# Zeile4  42  420
# Zeile5   5   50

In diesem Beispiel verwenden wir den .loc Accessor, um die Werte in den Spalten 'A' und 'B' für die Zeilen 'Zeile2' und 'Zeile4' zu aktualisieren.

Umgang mit fehlenden Daten mit .loc

Der .loc Accessor kann auch verwendet werden, um fehlende Daten in einem DataFrame oder einer Series zu verarbeiten.

# Erstellen eines DataFrame mit fehlenden Daten
df = pd.DataFrame({'A': [1, 2, None, 4, 5],
                   'B': [10, 20, 30, None, 50]},
                  index=['Zeile1', 'Zeile2', 'Zeile3', 'Zeile4', 'Zeile5'])
 
# Fehlende Werte mit .loc füllen
df.loc[:, 'A'] = df['A'].fillna(0)
Bitte geben Sie die deutsche Übersetzung für diese Markdown-Datei an. Wenn es einen Frontmatter gibt, stellen Sie sicher, dass Sie das Sprachparameter auch auf de übersetzen. Für den Code darf nur der Kommentar übersetzt werden, nicht der Code selbst. Der Inhalt der Beispiel-Aufforderung darf nicht übersetzt werden. Hier ist die Datei:
 
```python
df.loc[:, 'B'] = df['B'].fillna(0)
print(df)
#        A   B
# Zeile1  1  10
# Zeile2  2  20
# Zeile3  0  30
# Zeile4  4   0
# Zeile5  5  50

In diesem Beispiel erstellen wir ein DataFrame mit fehlenden Werten in den Spalten 'A' und 'B'. Wir verwenden dann den .loc-Zugriff, um die fehlenden Werte für beide Spalten mit 0 zu füllen.

Fortgeschrittene Techniken mit .loc

Verketten von .loc mit anderen Pandas-Operationen

Der .loc-Zugriff kann mit anderen Pandas-Operationen verknüpft werden, um komplexere Datenauswahl- und Manipulations-Workflows zu erstellen.

# Verketten von .loc mit anderen Pandas-Operationen
gefilterter_df = df.loc[(df['A'] > 2) & (df['B'] < 40), ['A', 'B']]
gefilterter_df['C'] = gefilterter_df['A'] + gefilterter_df['B']
print(gefilterter_df)
#        A   B   C
# Zeile3  3  30  33

In diesem Beispiel verwenden wir zunächst den .loc-Zugriff, um das DataFrame basierend auf einer Bedingung zu filtern, und erstellen dann eine neue Spalte 'C', die die Summe der Spalten 'A' und 'B' für die gefilterten Zeilen ist.

Umgang mit hierarchischen (mehrebenigen) Indizes

Der .loc-Zugriff kann auch verwendet werden, um mit DataFrames oder Series zu arbeiten, die hierarchische (mehrebenige) Indizes haben.

# Erstellen eines DataFrames mit mehrstufigem Index
df = pd.DataFrame({'A': [1, 2, 3, 4, 5],
                   'B': [10, 20, 30, 40, 50]},
                  index=pd.MultiIndex.from_tuples([('Gruppe1', 'Zeile1'), ('Gruppe1', 'Zeile2'),
                                                  ('Gruppe2', 'Zeile1'), ('Gruppe2', 'Zeile2'),
                                                  ('Gruppe2', 'Zeile3')],
                                                 names=['Gruppe', 'Zeile']))
 
# Datenzugriff mit .loc und mehrstufigen Indizes
print(df.loc[('Gruppe2', 'Zeile1'), 'A'])  # Ausgabe: 3
print(df.loc[('Gruppe1', slice(None)), 'B'])
# Ausgabe:
# ('Gruppe1', 'Zeile1')    10
# ('Gruppe1', 'Zeile2')    20
# Name: B, dtype: int64

In diesem Beispiel erstellen wir ein DataFrame mit einem mehrstufigen Index und zeigen dann, wie der .loc-Zugriff verwendet werden kann, um Daten basierend auf dem hierarchischen Index auszuwählen.

Kombinieren von .loc mit anderen Pandas-Zugriffsmethoden (z. B. .at, .iat)

Der .loc-Zugriff kann mit anderen Pandas-Zugriffsmethoden, wie z. B. .at und .iat, kombiniert werden, um einen präzisen und effizienten Datenzugriff zu ermöglichen.

# Kombinieren von .loc mit .at und .iat
print(df.at[('Gruppe2', 'Zeile1'), 'A'])  # Ausgabe: 3
print(df.iat[2, 0])  # Ausgabe: 3

In diesem Beispiel verwenden wir den .at-Zugriff, um ein einzelnes Element basierend auf den Zeilen- und Spaltenbezeichnungen auszuwählen, und den .iat-Zugriff, um ein einzelnes Element basierend auf den Zeilen- und Spaltenpositionen auszuwählen.

Leistungserwägungen mit .loc

Verständnis der Effizienz von .loc

Der .loc-Zugriff ist in der Regel effizienter als die Verwendung von booleschem Indexing oder indexbasiertem Indexing (.iloc) für große Datensätze, da er unnötige Berechnungen und Datenkopien vermeidet.

# Vergleich von .loc, .iloc und booleschem Indexing
import pandas as pd
import numpy as np
 
# Erstellen eines großen DataFrames
df = pd.DataFrame(np.random.rand(1000000, 5), columns=['A', 'B', 'C', 'D', 'E'])
 
# Zeitvergleich
%timeit df.loc[df['A'] > 0.5, ['B', 'C']]
%timeit df.iloc[df['A'] > 0.5, [1, 2]]
%timeit df[(df['A'] > 0.5) & (df['B'] < 0.7)]

In diesem Beispiel erstellen wir ein großes DataFrame und vergleichen die Leistung der Verwendung von .loc, .iloc und booleschem Indexing, um eine Teilmenge von Zeilen und Spalten auszuwählen. Der .loc-Zugriff ist in der Regel die effizienteste Methode der drei.

Vergleich von .loc mit anderen Auswahlmethoden (z. B. .iloc, booleschem Indexing)

Obwohl der .loc-Zugriff in der Regel effizient ist, kann es in einigen Fällen sinnvoller sein, andere Auswahlmethoden wie .iloc oder boolesches Indexing zu verwenden, abhängig von Ihrem konkreten Anwendungsfall und der Datenstruktur.

# Vergleich von .loc, .iloc und booleschem Indexing
# Wann man jede Methode verwendet
# .loc: Wenn Sie beschriftete Daten haben und basierend auf den Labels auswählen möchten
# .iloc: Wenn Sie numerische Indizes haben und basierend auf der Position auswählen möchten
# Boolesches Indexing: Wenn Sie Daten anhand komplexer Bedingungen filtern möchten

Es ist wichtig, die Trade-offs zu verstehen und die geeignete Auswahlmethode für Ihre spezifischen Anforderungen zu wählen.

Listen und Tupel

Listen und Tupel sind beides Sequenztypen in Python, aber sie haben einige wichtige Unterschiede. Listen sind veränderlich, dh Sie können ihre Elemente ändern, während Tupel unveränderlich sind, dh ihre Elemente können nicht geändert werden.

Listen

Listen werden mit eckigen Klammern [] definiert. Hier ist ein Beispiel:

fruits = ['apple', 'banana', 'cherry']

Sie können auf einzelne Elemente einer Liste über ihren Index zugreifen, der bei 0 beginnt:

print(fruits[0])  # Ausgabe: 'apple'
print(fruits[1])  # Ausgabe: 'banana'

Sie können auch Elemente in einer Liste ändern:

fruits[1] = 'orange'
print(fruits)  # Ausgabe: ['apple', 'orange', 'cherry']

Listen haben viele nützliche Methoden wie append(), insert(), remove() und pop(). Hier ist ein Beispiel:

fruits.append('grape')
fruits.insert(1, 'pear')
fruits.remove('orange')
last_fruit = fruits.pop()
print(fruits)  # Ausgabe: ['apple', 'pear', 'cherry']
print(last_fruit)  # Ausgabe: 'grape'

Tupel

Tupel werden mit Klammern () definiert. Hier ist ein Beispiel:

point = (3, 4)

Sie können auf einzelne Elemente eines Tupels über ihren Index zugreifen, ganz wie bei Listen:

print(point[0])  # Ausgabe: 3
print(point[1])  # Ausgabe: 4

Sie können jedoch die Elemente eines Tupels nicht ändern:

point[0] = 5  # TypeError: 'tuple' object does not support item assignment

Tupel werden oft verwendet, um unveränderliche Daten wie Koordinaten oder Schlüssel-Wert-Paare darzustellen.

Wörterbücher

Wörterbücher sind eine weitere wichtige Datenstruktur in Python. Sie werden verwendet, um Schlüssel-Wert-Paare zu speichern, wobei die Schlüssel eindeutig sind und die Werte beliebige Datentypen haben können.

Wörterbücher werden mit geschwungenen Klammern {} definiert und Schlüssel-Wert-Paare werden durch Doppelpunkte : getrennt.

person = {
    'name': 'John Doe',
    'age': 35,
    'occupation': 'Software Engineer'
}

Listen und Tupel

Listen und Tupel sind sequentielle Datentypen zur Aufbewahrung von Sammlungen von Daten.

Eine Liste ist veränderbar (mutable), während ein Tupel unveränderbar (immutable) ist.

Hier ist ein Beispiel für eine Liste:

fruits = ['apple', 'banana', 'cherry']
print(fruits)  # Ausgabe: ['apple', 'banana', 'cherry']

Hier ist ein Beispiel für ein Tupel:

colors = ('red', 'green', 'blue')
print(colors)  # Ausgabe: ('red', 'green', 'blue')

Listen und Tupel können Elemente hinzufügen, entfernen und modifizieren.

fruits.append('orange')
print(fruits)  # Ausgabe: ['apple', 'banana', 'cherry', 'orange']
 
fruits.remove('banana')
print(fruits)  # Ausgabe: ['apple', 'cherry', 'orange']
 
colors[1] = 'yellow'  # Fehler: Tupel ist unveränderbar

Listen und Tupel können mit Indizes zugegriffen werden:

print(fruits[0])  # Ausgabe: 'apple'
print(colors[2])  # Ausgabe: 'blue'

Listen und Tupel sind nützliche Datentypen für die Speicherung und Manipulation von Sammlungen von Daten in Python.

Wörterbücher

Wörterbücher sind Datenstrukturen zur Speicherung von Key-Value-Paaren.

Hier ist ein Beispiel für ein Wörterbuch:

person = {'name': 'John Doe', 'age': 35, 'occupation': 'Software Engineer'}
print(person)  # Ausgabe: {'name': 'John Doe', 'age': 35, 'occupation': 'Software Engineer'}

Sie können auf die Werte in einem Wörterbuch über ihre Schlüssel zugreifen:

print(person['name'])  # Ausgabe: 'John Doe'
print(person['age'])   # Ausgabe: 35

Sie können auch Key-Value-Paare in einem Wörterbuch hinzufügen, ändern und entfernen:

person['email'] = 'john.doe@example.com'
person['age'] = 36
del person['occupation']
print(person)  # Ausgabe: {'name': 'John Doe', 'age': 36, 'email': 'john.doe@example.com'}

Wörterbücher haben viele nützliche Methoden wie keys(), values() und items(), mit denen Sie mit den Schlüsseln und Werten im Wörterbuch arbeiten können.

print(list(person.keys()))   # Ausgabe: ['name', 'age', 'email']
print(list(person.values())) # Ausgabe: ['John Doe', 36, 'john.doe@example.com']
print(list(person.items()))  # Ausgabe: [('name', 'John Doe'), ('age', 36), ('email', 'john.doe@example.com')]

Wörterbücher sind sehr vielseitig und können verwendet werden, um komplexe Datenstrukturen wie verschachtelte Wörterbücher oder Listen von Wörterbüchern zu speichern.

Bedingte Anweisungen

Bedingte Anweisungen in Python ermöglichen es Ihnen, verschiedene Codeblöcke basierend auf bestimmten Bedingungen auszuführen.

Die häufigste bedingte Anweisung ist die if-elif-else Anweisung:

x = 10
if x > 0:
    print("x is positive")
elif x < 0:
    print("x is negative")
else:
    print("x is zero")

Sie können auch die and, or und not Operatoren verwenden, um mehrere Bedingungen zu kombinieren:

age = 25
if age >= 18 and age < 65:
    print("You are an adult")
else:
    print("You are not an adult")

Eine weitere nützliche bedingte Anweisung ist der Ternary Operator, der es Ihnen ermöglicht, eine einfache if-else Anweisung in einer einzigen Zeile zu schreiben:

is_student = True
status = "Student" if is_student else "Not a student"
print(status)  # Ausgabe: "Student"

Bedingte Anweisungen sind unerlässlich, um komplexe Logik in Ihren Python-Programmen zu erstellen.

Schleifen

Schleifen in Python ermöglichen es Ihnen, einen Codeblock wiederholt auszuführen, bis eine bestimmte Bedingung erfüllt ist.

Die häufigste Schleife ist die for-Schleife, die verwendet wird, um über eine Sequenz (wie eine Liste, ein Tupel oder einen String) zu iterieren:

fruits = ['apple', 'banana', 'cherry']
for fruit in fruits:
    print(fruit)

Sie können auch die range()-Funktion verwenden, um eine Sequenz von Zahlen zu erzeugen, über die Sie iterieren können:

for i in range(5):
    print(i)  # Ausgabe: 0, 1, 2, 3, 4

Die while-Schleife wird verwendet, wenn Sie die Anzahl der Iterationen im Voraus nicht kennen und die Schleife fortgesetzt werden soll, bis eine bestimmte Bedingung erfüllt ist:

count = 0
while count < 3:
    print("Hello")
    count += 1

Sie können die break- und continue-Anweisungen verwenden, um den Ablauf einer Schleife zu steuern:

for i in range(10):
    if i % 2 == 0:
        continue  # Gerade Zahlen überspringen
    if i > 7:
        break     # Schleife stoppen, wenn i größer als 7 ist
    print(i)      # Ausgabe: 1, 3, 5, 7

Schleifen sind unerlässlich, um wiederkehrende Aufgaben zu automatisieren und große Datenmengen in Ihren Python-Programmen zu verarbeiten.

Funktionen

Funktionen in Python sind Blöcke von wiederverwendbarem Code, die eine bestimmte Aufgabe ausführen. Sie ermöglichen es Ihnen, Ihren Code zu organisieren und ihn modularer und wartbarer zu machen.

Sie definieren eine Funktion mit dem Schlüsselwort def, gefolgt vom Funktionsnamen und einer Reihe von Klammern. Der Funktionskörper ist eingerückt und kann beliebigen gültigen Python-Code enthalten.

def greet(name):
    print(f"Hallo, {name}!")
 
greet("Alice")  # Ausgabe: "Hallo, Alice!"

Funktionen können auch Argumente entgegennehmen und Werte zurückgeben:

def add_numbers(a, b):
    return a + b
 
result = add_numbers(3, 4)
print(result)  # Ausgabe: 7

Sie können auch Standardwerte für Funktionsargumente festlegen:

def greet(name, message="Hallo"):
    print(f"{message}, {name}!")
 
greet("Bob")       # Ausgabe: "Hallo, Bob!"
greet("Charlie", "Hi")  # Ausgabe: "Hi, Charlie!"

Funktionen können auch mit einer variablen Anzahl von Argumenten definiert werden, indem sie die *args und **kwargs Syntax verwenden:

def print_numbers(*args):
    for arg in args:
        print(arg)
 
print_numbers(1, 2, 3)   # Ausgabe: 1, 2, 3
print_numbers(4, 5, 6, 7, 8)  # Ausgabe: 4, 5, 6, 7, 8

Funktionen sind eine grundlegende Bausteine der Python-Programmierung und sind unerlässlich für die Erstellung modularer, wiederverwendbarer und wartbarer Code.

Module und Pakete

In Python werden Module und Pakete verwendet, um Code zu organisieren und zu verteilen.

Ein Modul ist eine einzelne Python-Datei, die Definitionen und Anweisungen enthält. Sie können ein Modul mit dem Schlüsselwort import importieren:

import math
print(math.pi)  # Ausgabe: 3.141592653589793

Sie können auch bestimmte Funktionen oder Variablen aus einem Modul importieren:

from math import sqrt
print(sqrt(16))  # Ausgabe: 4.0

Pakete sind Sammlungen von verwandten Modulen. Sie sind in einer hierarchischen Verzeichnisstruktur organisiert, wobei jedes Verzeichnis eine __init__.py-Datei enthält.

Hier ist ein Beispiel, wie man ein Paket verwendet:

import my_package.my_module
my_package.my_module.my_function()

Sie können auch das Schlüsselwort from verwenden, um bestimmte Elemente aus einem Paket zu importieren:

from my_package.my_module import my_function
my_function()

Module und Pakete sind unerlässlich für die Organisation und Verteilung von Python-Code, da sie es Ihnen ermöglichen, wiederverwendbaren und wartbaren Code zu erstellen, der mit anderen geteilt werden kann.

Fazit

In diesem Tutorial haben Sie die folgenden wichtigen Konzepte in Python kennengelernt:

  • Listen und Tupel: Sequenztypen zur Speicherung von Sammlungen von Daten
  • Wörterbücher: Datenstrukturen zur Speicherung von Key-Value-Paaren
  • Bedingte Anweisungen: Ausführung von Code basierend auf Bedingungen
  • Schleifen: Wiederholung von Codeblöcken
  • Funktionen: Wiederverwendbare Codeblöcke zur Ausführung bestimmter Aufgaben
  • Module und Pakete: Organisation und Verteilung von Python-Code
Diese Konzepte sind grundlegend für das Programmieren mit Python und dienen als solide Grundlage für den Aufbau komplexerer Anwendungen. Denken Sie daran, diese Konzepte zu üben und zu experimentieren, um Ihr Verständnis zu vertiefen und ein besserer Python-Programmierer zu werden.

[![MoeNagy Dev](https://raw.githubusercontent.com/lynn-mikami/Images/main/moenagy-dev.png)](/)