Python
Das Beherrschen von pandas.loc: Ein Leitfaden für Anfänger zur mühelosen Datenzugriff

Das Beherrschen von pandas.loc: Ein Leitfaden für Anfänger zur mühelosen Datenzugriff

MoeNagy Dev

Datenzugriff mit pandas.loc

Einführung in pandas.loc

pandas.loc ist eine leistungsstarke Methode zum Datenzugriff in der pandas-Bibliothek, einem weit verbreiteten Werkzeug zur Datenmanipulation und -analyse in Python. pandas.loc bietet eine flexible und intuitive Möglichkeit, Daten aus einem pandas DataFrame oder einer Series anhand von Indexierung auf der Basis von Bezeichnungen auszuwählen und darauf zuzugreifen.

Der Hauptzweck von pandas.loc besteht darin, es Ihnen zu ermöglichen, Daten anhand von Bezeichnungen auszuwählen, d.h. Sie können Zeilen, Spalten oder einzelne Elemente basierend auf ihren Zeilen- und Spaltenbezeichnungen anstatt ihrer ganzzahligen Position abrufen. Dies ist besonders nützlich, wenn Sie mit realen Datensätzen arbeiten, bei denen die Daten oft sinnvolle Zeilen- und Spaltenbezeichnungen haben.

pandas.loc ist eine von drei Hauptmethoden zum Datenzugriff in pandas, zusammen mit pandas.iloc (indexbasierter Zugriff) und pandas.ix (eine Mischung aus indexbasierter und bezeichnungsbasierter Indexierung). Das Verständnis der Unterschiede zwischen diesen Methoden ist entscheidend, um Ihre Daten effektiv zu navigieren und zu manipulieren.

Auswählen von Zeilen und Spalten

Auswahl von Zeilen anhand von Bezeichnungen

Um Zeilen anhand von Bezeichnungen auszuwählen, können Sie die folgende Syntax verwenden:

df.loc[Zeilenbezeichnungen]

Hierbei können Zeilenbezeichnungen eine einzelne Bezeichnung, eine Liste von Bezeichnungen, ein Bezeichnungsslice oder ein boolescher Array sein.

Beispiel:

import pandas as pd
 
# Erzeugen eines Beispieldatenrahmens
data = {'Name': ['Alice', 'Bob', 'Charlie', 'David'],
        'Alter': [25, 30, 35, 40],
        'Stadt': ['New York', 'London', 'Paris', 'Tokyo']}
df = pd.DataFrame(data)
 
# Auswahl von Zeilen anhand von Bezeichnungen
print(df.loc['Alice'])
print(df.loc[['Alice', 'Charlie']])
print(df.loc['Alice':'Charlie'])

Ausgabe:

Name      Alice
Alter        25
Stadt  New York
Name: Alice, dtype: object
       Name  Alter    Stadt
Alice  Alice     25  New York
Charlie  Charlie   35    Paris
       Name  Alter    Stadt
Alice  Alice     25  New York
Bob      Bob    30    London
Charlie  Charlie   35    Paris

Auswahl von Spalten anhand von Bezeichnungen

Um Spalten anhand von Bezeichnungen auszuwählen, können Sie die folgende Syntax verwenden:

df.loc[:, Spaltenbezeichnungen]

Hierbei können Spaltenbezeichnungen eine einzelne Bezeichnung, eine Liste von Bezeichnungen, ein Bezeichnungsslice oder ein boolescher Array sein.

Beispiel:

# Auswahl von Spalten anhand von Bezeichnungen
print(df.loc[:, 'Name'])
print(df.loc[:, ['Name', 'Alter']])
print(df.loc[:, 'Name':'Stadt'])

Ausgabe:

0    Alice
1      Bob
2  Charlie
3    David
Name: Name, dtype: object
       Name  Alter
0  Alice     25
1    Bob     30
2  Charlie   35
3   David    40
       Name  Alter    Stadt
0  Alice     25  New York
1    Bob     30    London
2  Charlie   35    Paris
3   David    40    Tokyo

Auswahl eines einzelnen Werts

Um einen einzelnen Wert auszuwählen, können Sie die folgende Syntax verwenden:

df.loc[Zeilenbezeichnung, Spaltenbezeichnung]

Beispiel:

# Auswahl eines einzelnen Werts
print(df.loc['Alice', 'Alter'])

Ausgabe:

25

Auswahl mehrerer Zeilen und Spalten

Sie können mehrere Zeilen und Spalten gleichzeitig auswählen, indem Sie eine Liste oder einen Slice von Bezeichnungen übergeben.

Beispiel:

# Auswahl mehrerer Zeilen und Spalten
print(df.loc[['Alice', 'Charlie'], ['Name', 'Stadt']])

Ausgabe:

       Name         Stadt
0     Alice  New York
2  Charlie      Paris

Bedingte Auswahl

Filtern von Zeilen basierend auf Bedingungen

Sie können die Indexierung mit booleschen Werten verwenden, um Zeilen basierend auf einer oder mehreren Bedingungen zu filtern.

Beispiel:

# Filtern von Zeilen basierend auf Bedingungen
print(df.loc[df['Alter'] > 30])

Ausgabe:

    Name     Alter   Stadt
2  Charlie     35     Paris
3    David     40    Tokyo

Kombinieren mehrerer Bedingungen

Sie können mehrere Bedingungen mithilfe von booleschen Operatoren wie & (und) und | (oder) kombinieren.

Beispiel:

# Kombinieren mehrerer Bedingungen
print(df.loc[(df['Alter'] > 30) & (df['Stadt'] != 'New York')])

Ausgabe:

    Name     Alter   Stadt
2  Charlie     35     Paris
3    David     40    Tokyo

Gleichzeitige Auswahl von Zeilen und Spalten

Sie können Zeilen und Spalten gleichzeitig mit pandas.loc auswählen.

Beispiel:

# Gleichzeitige Auswahl von Zeilen und Spalten
print(df.loc[df['Alter'] > 30, ['Name', 'Stadt']])

Ausgabe:

    Name     Stadt
2  Charlie     Paris
3    David     Tokyo

Umgang mit fehlenden Daten

Umgang mit fehlenden Werten in pandas.loc

pandas.loc behandelt fehlende Werte in der gleichen Weise wie andere pandas Methoden zum Datenzugriff. Wenn eine Zeile oder Spalte einen fehlenden Wert enthält, wird er in der Auswahl enthalten sein.

Beispiel:

# Erzeugen eines Datenrahmens mit fehlenden Werten
data = {'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
        'Alter': [25, 30, None, 40, 35],
        'Stadt': ['New York', 'London', 'Paris', None, 'Tokyo']}
df = pd.DataFrame(data)
 
# Auswahl von Zeilen und Spalten mit fehlenden Werten
print(df.loc[:, ['Alter', 'Stadt']])

Ausgabe:

     Alter   Stadt
0   25.0  New York
1   30.0    London
2   NaN      Paris
3   40.0       NaN
4   35.0     Tokyo

Ersetzen von fehlenden Werten

Sie können pandas.loc verwenden, um fehlende Werte in Ihrem DataFrame zu ersetzen.

Beispiel:

# Ersetzen von fehlenden Werten durch einen spezifischen Wert
df.loc[:, 'Alter'] = df['Alter'].fillna(0)
df.loc[:, 'Stadt'] = df['Stadt'].fillna('Unbekannt')
print(df)

Ausgabe:

    Name     Alter    Stadt
0  Alice      25  New York
1    Bob       30    London
2  Charlie    0      Paris
3    David     40    Unbekannt
4    Eve       35    Tokyo

Interpolieren von fehlenden Daten

Sie können auch pandas.loc verwenden, um fehlende Werte basierend auf den Werten in anderen Zeilen zu interpolieren.

Beispiel:

# Interpolieren von fehlenden Werten
df['Alter'] = df['Alter'].interpolate()
print(df.loc[:, 'Alter'])

Ausgabe:

0    25.0
1    30.0
2    35.0
### Fortgeschrittenes Indizieren

#### Verwendung von booleschen Arrays zur Auswahl

Sie können boolesche Arrays verwenden, um Zeilen und Spalten basierend auf einer bestimmten Bedingung auszuwählen.

Beispiel:
```python
# Verwendung von booleschen Arrays zur Auswahl
bool_mask = (df['Alter'] > 30) & (df['Stadt'] != 'New York')
print(df.loc[bool_mask, ['Name', 'Alter', 'Stadt']])

Ausgabe:

       Name  Alter        Stadt
2   Charlie 35.0      Paris
3     David 40.0     Unknown
4       Eve 35.0     Tokyo

Auswahl basierend auf der Positionsnummer

Während pandas.loc hauptsächlich für indexbasiertes Indizieren verwendet wird, können Sie es auch mit pandas.iloc kombinieren, um indexbasiertes Indizieren zu verwenden.

Beispiel:

# Kombination von indexbasiertem und indexbasiertem Indizieren
print(df.loc[0, 'Name'])
print(df.loc[1:3, 'Name':'Stadt'])

Ausgabe:

Alice
   Name  Alter        Stadt
1   Bob   30    London
2  Charlie 35.0      Paris
3   David 40.0     Unknown

Kombination mehrerer Indizierungstechniken

Sie können verschiedene Indizierungstechniken wie indexbasierte, indexbasierte und boolesche Indizierung kombinieren, um komplexe Auswahlen zu erstellen.

Beispiel:

# Kombination mehrerer Indizierungstechniken
print(df.loc[bool_mask, df.columns[::2]])

Ausgabe:

       Name        Stadt
2   Charlie      Paris
3     David     Unknown
4       Eve     Tokyo

Datenänderung

Zuweisen von Werten zu Zeilen und Spalten

Sie können pandas.loc verwenden, um Werte für bestimmte Zeilen und Spalten in Ihrem DataFrame zuzuweisen.

Beispiel:

# Werte für Zeilen und Spalten zuweisen
df.loc['Alice', 'Alter'] = 26
df.loc[:, 'Stadt'] = 'San Francisco'
print(df)

Ausgabe:

       Name  Alter           Stadt
0     Alice   26  San Francisco
1       Bob   30  San Francisco
2   Charlie   35  San Francisco
3     David   40  San Francisco
4       Eve   35  San Francisco

Aktualisierung vorhandener Daten

Sie können auch pandas.loc verwenden, um vorhandene Daten in Ihrem DataFrame zu aktualisieren.

Beispiel:

# Aktualisieren vorhandener Daten
df.loc[df['Name'] == 'Bob', 'Alter'] = 31
print(df)

Ausgabe:

       Name  Alter           Stadt
0     Alice   26  San Francisco
1       Bob   31  San Francisco
2   Charlie   35  San Francisco
3     David   40  San Francisco
4       Eve   35  San Francisco

Hinzufügen neuer Daten

Während pandas.loc hauptsächlich zur Datenauswahl verwendet wird, können Sie es auch verwenden, um neue Zeilen zu Ihrem DataFrame hinzuzufügen.

Beispiel:

# Hinzufügen neuer Daten
new_row = pd.Series({'Name': 'Frank', 'Alter': 28, 'Stadt': 'Los Angeles'})
df.loc[len(df)] = new_row
print(df)

Ausgabe:

       Name  Alter           Stadt
0     Alice   26  San Francisco
1       Bob   31  San Francisco
2   Charlie   35  San Francisco
3     David   40  San Francisco
4       Eve   35  San Francisco
5      Frank   28  Los Angeles

Arbeiten mit MultiIndex

Auswählen von Daten aus einem DataFrame mit MultiIndex

Wenn Sie mit einem DataFrame arbeiten, das einen MultiIndex hat, können Sie pandas.loc verwenden, um Daten basierend auf dem hierarchischen Index auszuwählen.

Beispiel:

# Erstellen eines DataFrame mit MultiIndex
index = pd.MultiIndex.from_tuples([('A', 'X'), ('A', 'Y'), ('B', 'X'), ('B', 'Y')],
                                 names=['Gruppe', 'Untergruppe'])
df = pd.DataFrame({'Wert': [10, 20, 30, 40]}, index=index)
 
# Auswählen von Daten aus einem DataFrame mit MultiIndex
print(df.loc[('A', 'Y')])
print(df.loc[('B', :)])

Ausgabe:

Wert    20
Name: ('A', 'Y'), dtype: int64
           Wert
Gruppe Untergruppe  
B     X        30
      Y        40

Bedingte Auswahl mit MultiIndex

Sie können pandas.loc auch verwenden, um bedingte Auswahl in einem DataFrame mit MultiIndex durchzuführen.

Beispiel:

# Bedingte Auswahl mit MultiIndex
print(df.loc[('A', 'X'), 'Wert'])
print(df.loc[df['Wert'] > 25])

Ausgabe:

10
           Wert
Gruppe Untergruppe  
B     X        30
      Y        40

Ändern von Daten in einem DataFrame mit MultiIndex

pandas.loc kann auch verwendet werden, um Daten in einem DataFrame mit MultiIndex zu ändern.

Beispiel:

# Ändern von Daten in einem DataFrame mit MultiIndex
df.loc[('B', 'Y'), 'Wert'] = 45
print(df)

Ausgabe:

                Wert
Gruppe Untergruppe       
A      X           10
       Y           20
B      X           30
       Y           45

Optimierung der Leistung

Obwohl pandas.loc ein leistungsfähiges Werkzeug ist, ist es wichtig, seine Leistungsmerkmale zu verstehen und seine Verwendung zu optimieren.

Verständnis der Leistungsmerkmale von pandas.loc

pandas.loc ist in der Regel schneller als pandas.iloc für indexbasiertes Indizieren, da es direkt auf die Daten nach dem Labelzugriff zugreifen kann. Für große Datensätze oder komplexe Operationen kann pandas.loc jedoch immer noch langsamer sein als andere Methoden wie boolesches Indizieren oder

Hier ist die zweite Hälfte eines über 2000 Wörter langen Python-Tutorials basierend auf der bereitgestellten Gliederung:

Arbeiten mit Dateien

Das Arbeiten mit Dateien ist ein wesentlicher Bestandteil vieler Programmieraufgaben. Python bietet eine einfache und unkomplizierte Möglichkeit, mit Dateien auf Ihrem System zu interagieren.

Öffnen und Schließen von Dateien

Um eine Datei zu öffnen, können Sie die integrierte Funktion open() verwenden. Die open() Funktion hat zwei Argumente: den Dateipfad und den Modus, in dem Sie die Datei öffnen möchten.

datei = open('beispiel.txt', 'r')

Der Modus kann einer der folgenden sein:

  • 'r': Lese-Modus (Standard)
  • 'w': Schreib-Modus (überschreibt vorhandenen Inhalt)
  • 'a': Anfüge-Modus (fügt Inhalt am Ende der Datei hinzu)
  • 'x': Exklusiver Erstellungsmodus (erstellt eine neue Datei, schlägt fehl, wenn die Datei bereits existiert)

Nachdem Sie mit der Datei fertig sind, ist es wichtig, sie mit der Methode close() zu schließen:

datei.close()

Lesen und Schreiben von Dateien

Sobald Sie ein Dateiobjekt haben, können Sie aus der Datei lesen oder in die Datei schreiben mithilfe verschiedener Methoden:

# Lesen der gesamten Datei
datei = open('beispiel.txt', 'r')
inhalt = datei.read()
print(inhalt)
datei.close()
 
# Zeilenweise lesen
datei = open('beispiel.txt', 'r')
for zeile in datei:
    print(zeile.strip())
datei.close()
 
# Schreiben in eine Datei
datei = open('beispiel.txt', 'w')

file.write('Dies ist eine neue Zeile.\n') file.write('Dies ist eine weitere Zeile.') file.close()


### Kontext-Manager (`with`-Anweisung)

Um den Vorgang des Öffnens und Schließens von Dateien zu vereinfachen, können Sie die `with`-Anweisung verwenden, die als Kontext-Manager fungiert. Dadurch wird sichergestellt, dass die Datei ordnungsgemäß geschlossen wird, auch wenn eine Ausnahme auftritt.

```python
with open('beispiel.txt', 'r') as datei:
    inhalt = datei.read()
    print(inhalt)

Arbeiten mit Modulen und Paketen

Das modulare Design von Python ermöglicht es Ihnen, Ihren Code in wiederverwendbare Komponenten namens Module zu organisieren. Module können in Ihren Python-Skripten importiert und verwendet werden.

Importieren von Modulen

Um ein Modul in Ihrem Python-Skript zu verwenden, können Sie die import-Anweisung verwenden. Sie können das gesamte Modul oder bestimmte Funktionen oder Variablen aus dem Modul importieren.

# Importieren des gesamten Moduls
import math
ergebnis = math.sqrt(16)
print(ergebnis)  # Ausgabe: 4.0
 
# Importieren bestimmter Funktionen
from math import sqrt, pi
ergebnis = sqrt(16)
print(ergebnis)  # Ausgabe: 4.0
print(pi)  # Ausgabe: 3.141592653589793
 
# Importieren mit einem Alias
import math as m
ergebnis = m.sqrt(16)
print(ergebnis)  # Ausgabe: 4.0

Erstellen von Modulen

Sie können Ihre eigenen Module erstellen, indem Sie Ihren Python-Code in eine .py-Datei platzieren. Der Dateiname wird zum Modulnamen und Sie können das Modul dann in anderen Teilen Ihres Codes importieren und verwenden.

# my_module.py
def begrüßen(name):
    print(f"Hallo, {name}!")
 
# Verwendung des Moduls
import my_module
my_module.begrüßen("Alice")  # Ausgabe: Hallo, Alice!

Pakete

Pakete sind eine Möglichkeit, Ihre Module zu organisieren und zu strukturieren. Ein Paket ist eine Sammlung von Modulen und ermöglicht es Ihnen, verwandte Module zusammenzufassen.

Um ein Paket zu erstellen, müssen Sie ein Verzeichnis erstellen und Ihre Moduldateien darin platzieren. Zusätzlich müssen Sie eine spezielle Datei namens __init__.py in das Paketverzeichnis aufnehmen.

my_package/
    __init__.py
    modul1.py
    modul2.py

Sie können dann Module aus dem Paket mit dem Punkt-Notation importieren:

import my_package.module1
my_package.module1.funktion_aus_modul1()
 
from my_package import module2
module2.funktion_aus_modul2()

Arbeiten mit Ausnahmen

Ausnahmen sind eine Möglichkeit, unerwartete oder fehleranfällige Situationen in Ihrem Code zu behandeln. Python verfügt über einen integrierten Mechanismus zur Behandlung von Ausnahmen, der es Ihnen ermöglicht, diese Situationen vorherzusehen und elegant zu behandeln.

Ausnahmen auslösen

Sie können eine Ausnahme mit derraise-Anweisung auslösen. Dies ist nützlich, wenn Sie signalisieren möchten, dass eine bestimmte Bedingung aufgetreten ist.

raise ValueError("Ungültiger Eingabewert")

Ausnahmen behandeln

Sie können den try-except-Block verwenden, um Ausnahmen in Ihrem Code zu behandeln. Wenn eine Ausnahme im try-Block auftritt, wird der entsprechende except-Block ausgeführt.

try:
    ergebnis = 10 / 0
except ZeroDivisionError:
    print("Fehler: Division durch Null")

Sie können auch mehrere Ausnahmen im selben except-Block behandeln:

try:
    ergebnis = int("abc")
except (ValueError, TypeError):
    print("Fehler: Ungültige Eingabe")

Benutzerdefinierte Ausnahmen

Sie können Ihre eigenen benutzerdefinierten Ausnahmen erstellen, indem Sie neue Ausnahme-Klassen definieren, die von der integrierten Klasse Exception oder einer ihrer Unterklasse erben.

class BenutzerdefinierteAusnahme(Exception):
    pass
 
raise BenutzerdefinierteAusnahme("Dies ist eine benutzerdefinierte Ausnahme")

Die finally-Klausel

Die finally-Klausel wird verwendet, um sicherzustellen, dass ein Codeblock ausgeführt wird, unabhängig davon, ob eine Ausnahme ausgelöst wurde oder nicht. Dies wird oft zum Aufräumen von Ressourcen wie dem Schließen von Dateien oder Verbindungen verwendet.

try:
    datei = open("beispiel.txt", "r")
    inhalt = datei.read()
    print(inhalt)
except FileNotFoundError:
    print("Fehler: Datei nicht gefunden")
finally:
    datei.close()

Arbeiten mit objektorientierter Programmierung (OOP)

Python ist eine Multi-Paradigma-Sprache, das bedeutet, sie unterstützt sowohl prozedurale als auch objektorientierte Programmierungsstile (OOP). OOP ist eine leistungsstarke Möglichkeit, Ihren Code zu organisieren und zu strukturieren.

Klassen und Objekte

In OOP definieren Sie Klassen als Baupläne zur Erstellung von Objekten. Objekte sind Instanzen dieser Klassen und haben ihre eigenen Attribute und Methoden.

class Auto:
    def __init__(self, marke, modell):
        self.marke = marke
        self.modell = modell
 
    def starten(self):
        print(f"Starte {self.marke} {self.modell}.")
 
# Objekte erstellen
mein_auto = Auto("Toyota", "Corolla")
mein_auto.starten()  # Ausgabe: Starte Toyota Corolla.

Vererbung

Vererbung ist eine Möglichkeit, neue Klassen auf der Grundlage vorhandener Klassen zu erstellen. Die neue Klasse (die "Kind"-Klasse) erbt die Attribute und Methoden der vorhandenen Klasse (der "Eltern"-Klasse).

class Elektroauto(Auto):
    def __init__(self, marke, modell, batteriekapazität):
        super().__init__(marke, modell)
        self.batteriekapazität = batteriekapazität
 
    def aufladen(self):
        print(f"Lade {self.marke} {self.modell} mit einer {self.batteriekapazität} kWh-Batterie auf.")
 
# Objekt der Kindklasse erstellen
mein_elektroauto = Elektroauto("Tesla", "Model S", 100)
mein_elektroauto.starten()  # Geerbt von der Elternklasse
mein_elektroauto.aufladen()  # In der Kindklasse definiert

Polymorphismus

Polymorphismus ermöglicht es, Objekte unterschiedlicher Klassen als Objekte einer gemeinsamen Oberklasse zu behandeln. Dies wird oft durch Methodenüberschreibung erreicht.

class Motorrad:
    def starten(self):
        print("Starte das Motorrad.")
 
class Fahrrad:
    def starten(self):
        print("Beginne mit dem Treten des Fahrrads.")
 
# Polymorphie in Aktion
fahrzeuge = [Motorrad(), Fahrrad()]
for fahrzeug in fahrzeuge:
    fahrzeug.starten()

Kapselung

Kapselung ist die Idee, Daten und Methoden in einer einzigen Einheit (der Klasse) zu bündeln und die internen Implementierungsdetails vor der Außenwelt zu verbergen. Dies wird durch Zugriffsmodifizierer wie public, private und protected erreicht.

class Bankkonto:
class BankAccount:
    def __init__(self, owner, balance):
        self.__owner = owner  # Privates Attribut
        self.__balance = balance  # Privates Attribut

    def deposit(self, amount):
        self.__balance += amount

    def withdraw(self, amount):
        if amount <= self.__balance:
            self.__balance -= amount
        else:
            print("Unzureichendes Guthaben.")

    def get_balance(self):
        return self.__balance

# Die BankAccount-Klasse verwenden
account = BankAccount("Alice", 1000)
account.deposit(500)
print(account.get_balance())  # Ausgabe: 1500
account.__balance = 0  # Dies funktioniert aufgrund der Kapselung nicht

Fazit

In diesem umfassenden Python-Tutorial haben wir eine Vielzahl von Themen behandelt, angefangen beim Arbeiten mit Dateien und Modulen bis hin zu den Grundlagen der objektorientierten Programmierung. Zu diesem Zeitpunkt sollten Sie ein solides Verständnis dieser Schlüsselkonzepte haben und auf dem besten Weg sein, ein kompetenter Python-Programmierer zu werden.

Denken Sie daran, dass der beste Weg, Ihre Python-Kenntnisse zu verbessern, darin besteht, zu üben, zu experimentieren und weiter zu lernen. Erforschen Sie fortgeschrittenere Themen, arbeiten Sie an eigenen Projekten und tauschen Sie sich mit der lebendigen Python-Community aus. Mit Hingabe und Ausdauer werden Sie in der Lage sein, die Leistungsfähigkeit von Python zu nutzen, um komplexe Probleme zu lösen und erstaunliche Anwendungen zu erstellen.

Viel Spaß beim Codieren!

MoeNagy Dev