Python
Pandas Sorted

Pandas Sorted: Ein Leitfaden für effizientes Sortieren für Anfänger

MoeNagy Dev

Sortieren von Daten in Pandas

Bedeutung des Sortierens in der Datenanalyse

Sortieren ist eine grundlegende Operation in der Datenanalyse, die dazu dient, Daten auf sinnvolle Weise zu organisieren. Es erleichtert die Datenexploration und -verständnis und bereitet Daten für weitere Analysen und Visualisierungen vor. Durch das Sortieren von Daten lassen sich Muster, Trends und Ausreißer leichter erkennen und führt zu besseren Erkenntnissen und Entscheidungen.

Sortieren von einzeiligen Spalten

Das Sortieren einer einzeiligen Spalte in Pandas ist ein einfacher Vorgang. Sie können die Daten in aufsteigender oder absteigender Reihenfolge sortieren und dabei fehlende Werte behandeln.

Sortieren in aufsteigender Reihenfolge

import pandas as pd
 
# Erstellen einer Sample Series
s = pd.Series([3, 1, 4, 2, None])
 
# Sortieren der Series in aufsteigender Reihenfolge
sorted_s = s.sort_values()
print(sorted_s)

Output:

1    1.0
3    2.0
0    3.0
2    4.0
4    NaN
dtype: float64

Sortieren in absteigender Reihenfolge

# Sortieren der Series in absteigender Reihenfolge
sorted_s = s.sort_values(ascending=False)
print(sorted_s)

Output:

2    4.0
0    3.0
3    2.0
1    1.0
4    NaN
dtype: float64

Umgang mit fehlenden Werten beim Sortieren

Standardmäßig platziert Pandas die fehlenden Werte (NaN) am Ende der sortierten Series, unabhängig von der Sortierreihenfolge. Sie können die Position der fehlenden Werte mithilfe des Parameters na_position steuern.

# Platzieren der fehlenden Werte am Anfang der sortierten Series
sorted_s = s.sort_values(na_position='first')
print(sorted_s)

Output:

4    NaN
1    1.0
3    2.0
0    3.0
2    4.0
dtype: float64

Sortieren von mehrspaltigen DataFrames

Das Sortieren eines mehrspaltigen DataFrames umfasst das Festlegen der zu sortierenden Spalte(n) und die Steuerung der Sortierreihenfolge für jede Spalte.

Sortieren nach einer einzelnen Spalte

# Erstellen eines Sample DataFrames
df = pd.DataFrame({'A': [3, 1, 4, 2], 'B': [1, 2, 3, 4]})
 
# Sortieren des DataFrames nach der Spalte 'A'
sorted_df = df.sort_values(by='A')
print(sorted_df)

Output:

   A  B
1   1  2
3   2  4
0   3  1
2   4  3

Sortieren nach mehreren Spalten

# Sortieren des DataFrames nach den Spalten 'A' und 'B'
sorted_df = df.sort_values(by=['A', 'B'])
print(sorted_df)

Output:

   A  B
1   1  2
0   3  1
2   4  3
3   4  4

Steuern der Sortierreihenfolge für jede Spalte

# Sortieren des DataFrames nach 'A' in aufsteigender Reihenfolge und 'B' in absteigender Reihenfolge
sorted_df = df.sort_values(by=['A', 'B'], ascending=[True, False])
print(sorted_df)

Output:

   A  B
1   1  2
0   3  1
3   4  4
2   4  3

Sortieren mit benutzerdefinierten Key-Funktionen

Sie können benutzerdefinierte Key-Funktionen verwenden, um das Sortierverhalten in Pandas zu steuern. Dadurch können Sie komplexe Sortierlogik basierend auf Ihren spezifischen Anforderungen anwenden.

Verwendung von Lambda-Funktionen als Schlüssel

# Sortieren des DataFrames nach dem absoluten Wert der Spalte 'A'
sorted_df = df.sort_values(by='A', key=lambda x: x.abs())
print(sorted_df)

Output:

   A  B
1   1  2
3   2  4
0   3  1
2   4  3

Anwendung komplexer Sortierlogik mit benutzerdefinierten Funktionen

def custom_sort_key(x):
    # Sortieren nach dem Quadrat des Werts in der Spalte 'A'
    # und dann nach dem Wert in der Spalte 'B'
    return (x['A'] ** 2, x['B'])
 
sorted_df = df.sort_values(by=['A', 'B'], key=custom_sort_key)
print(sorted_df)

Output:

   A  B
1   1  2
0   3  1
2   4  3
3   4  4

Beibehaltung des ursprünglichen Index während des Sortierens

Standardmäßig ändert Pandas den Index der sortierten Daten. Wenn Sie den ursprünglichen Index beibehalten möchten, können Sie den Parameter ignore_index verwenden oder nach dem Sortieren den Index zurücksetzen.

Beibehaltung des ursprünglichen Index

# Sortieren des DataFrames und Beibehaltung des ursprünglichen Index
sorted_df = df.sort_values(by='A', ignore_index=False)
print(sorted_df)

Output:

   A  B
0   1  2
1   3  1
2   4  3
3   2  4

Zurücksetzen des Index nach dem Sortieren

# Sortieren des DataFrames und Zurücksetzen des Index
sorted_df = df.sort_values(by='A').reset_index(drop=True)
print(sorted_df)

Output:

   A  B
0   1  2
1   2  4
2   3  1
3   4  3

Sortieren von Teildaten

Manchmal müssen Sie nur eine Teilmenge von Zeilen oder Spalten in einem DataFrame sortieren. Pandas bietet Flexibilität, um mit solchen Szenarien umzugehen.

Sortieren einer Teilmenge von Zeilen oder Spalten

# Erstellen eines Sample DataFrames
df = pd.DataFrame({'A': [3, 1, 4, 2], 'B': [1, 2, 3, 4], 'C': [10, 20, 30, 40]})
 
# Sortieren Sie nur die Zeilen, in denen die Spalte 'A' größer als 2 ist
sorted_df = df[df['A'] > 2].sort_values(by='A')
print(sorted_df)

Output:

   A  B   C
0   3  1  10
2   4  3  30

Umgang mit fehlenden Werten in Teildaten

# Erstellen eines DataFrame mit fehlenden Werten
df = pd.DataFrame({'A': [3, 1, None, 2], 'B': [1, 2, 3, 4]})
 
# Sortieren Sie nur die Zeilen mit nicht fehlenden Werten in der Spalte 'A'
sorted_df = df.loc[df['A'].notna()].sort_values(by='A')
print(sorted_df)

Output:

     A  B
1    1  2
3    2  4
0    3  1

Sortieren kategorischer Daten

Pandas bietet eine spezielle Behandlung für das Sortieren kategorischer Daten, mit der Sie die Reihenfolge der Kategorien während des Sortierprozesses steuern können.

Sortieren von Kategorien basierend auf ihrer Reihenfolge

import pandas as pd
 
# Erstellen einer kategorischen Serie
s = pd.Series([1, 2, 3, 1], dtype='category')
s = s.cat.reorder_categories([3, 1, 2])
 
# Sortieren der kategorischen Serie
sorted_s = s.sort_values()
print(sorted_s)

Output:

0    1
3    1
1    2
2    3
dtype: category
Categories (3, int64): [3, 1, 2]

Anpassen der Kategoriereihenfolge für das Sortieren

# Erstellen eines DataFrames mit kategorischen Spalten
df = pd.DataFrame({'A': [1, 2, 3, 1], 'B': ['a', 'b', 'c', 'a']})
Please provide the German translation for this markdown file. If there is a frontmatter, make sure you translate language parameter to the matching de as well. For the code, do not translate code, only translate comments. Do not translate the content of sample prompt. Here is the file: df['B'] = df['B'].astype('category')
df['B'] = df['B'].cat.reorder_categories(['c', 'b', 'a'])
 
# Sort the DataFrame by column 'B'
sorted_df = df.sort_values(by='B')
print(sorted_df)

Output:

   A  B
2  3  c
1  2  b
0  1  a
3  1  a

Sorting Datetime and Timedelta Data

Pandas bietet eine effiziente Bearbeitung von Datums-, Zeit- und Dauerdaten. Dies ist besonders nützlich bei der Arbeit mit Zeitreihendaten.

Sortieren von datums- und zeitbasierten Daten

import pandas as pd
 
# Erstellen Sie ein DataFrame mit Datumsangaben
df = pd.DataFrame({'A': [1, 2, 3, 4], 'B': pd.to_datetime(['2023-04-01', '2023-03-15', '2023-04-15', '2023-03-01'])})
 
# Sortieren Sie das DataFrame nach der Spalte 'B' mit dem Datums- und Zeitwert
sorted_df = df.sort_values(by='B')
print(sorted_df)

Ausgabe:

   A         B
3  4 2023-03-01
1  2 2023-03-15
0  1 2023-04-01
2  3 2023-04-15

Umgang Mit Zeitbezogenen Sortierszenarien

# Erstellen Sie ein DataFrame mit Dauerdaten
df = pd.DataFrame({'A': [1, 2, 3, 4], 'B': pd.to_timedelta(['1 days', '2 hours', '3 minutes', '4 seconds'])})
 
# Sortieren Sie das DataFrame nach der Dauerspalte 'B'
sorted_df = df.sort_values(by='B')
print(sorted_df)

Ausgabe:

   A           B
3  4 0 days 00:00:04
1  2 0 days 00:02:00
2  3 0 days 00:03:00
0  1 1 days 00:00:00

Effizientes Sortieren mit großen Datenmengen

Bei der Arbeit mit großen Datenmengen ist es wichtig, die optimierten Sortieralgorithmen von Pandas zu nutzen und Speicher- und Leistungsauswirkungen zu berücksichtigen.

Nutzung der optimierten Sortieralgorithmen von Pandas

# Sortieren Sie ein großes DataFrame mit dem optimierten Sortieralgorithmus von Pandas
large_df = pd.DataFrame({'A': np.random.randint(0, 1000000, size=1000000), 'B': np.random.randint(0, 1000000, size=1000000)})
sorted_df = large_df.sort_values(by='A')

Überlegungen zur Speicher- und Leistungsoptimierung

Beim Sortieren großer Datenmengen sollten Sie folgende Punkte beachten:

  • Speicherbedarf: Das Sortieren kann speicherintensiv sein, insbesondere für große DataFrames. Überwachen Sie den Speicherverbrauch und verwenden Sie gegebenenfalls die Parameter chunksize oder sort_in_place, um den Speicherverbrauch zu optimieren.
  • Leistung: Die Sortieralgorithmen von Pandas sind im Allgemeinen effizient, aber bei extrem großen Datensätzen müssen Sie möglicherweise alternative Sortiermethoden oder Bibliotheken wie Dask oder Vaex verwenden, die für die Verarbeitung großer Datenmengen konzipiert sind.

Kombinieren von Sortierung mit anderen Pandas-Operationen

Sortierung wird häufig in Verbindung mit anderen Pandas-Operationen wie Gruppierung, Filterung und Aggregierung verwendet, um Daten für weitere Analysen vorzubereiten.

Sortieren vor der Gruppierung, Filterung oder Aggregierung

# Erstellen Sie ein Beispiel DataFrame
df = pd.DataFrame({'A': [1, 2, 3, 1, 2], 'B': [10, 20, 30, 40, 50]})
 
# Sortieren Sie das DataFrame vor der Gruppierung und Aggregierung
sorted_df = df.sort_values(by='A')
grouped = sorted_df.groupby('A')['B'].mean()
print(grouped)

Ausgabe:

A
1    25.0
2    35.0
3    30.0
Name: B, dtype: float64

Integration der Sortierung in Daten-Transformations-Pipelines

# Erstellen Sie ein Beispiel DataFrame
df = pd.DataFrame({'A': [3, 1, 4, 2], 'B': [1, 2, 3, 4]})
 
# Kombinieren Sie die Sortierung mit anderen Pandas-Operationen
transformed_df = (
    df
    .sort_values(by='A')
    .groupby('A')['B']
    .sum()
    .reset_index()
)
print(transformed_df)

Ausgabe:

   A   B
0  1   2
1  2   4
2  3   1
3  4   3

Variablen und Datentypen

Strings

Strings in Python sind eine Sequenz von Zeichen. Sie können mit einfachen Anführungszeichen ', doppelten Anführungszeichen " oder dreifachen Anführungszeichen ''' oder """ definiert werden. Hier ist ein Beispiel:

my_string = "Hallo, Welt!"
print(my_string)  # Ausgabe: Hallo, Welt!

Sie können einzelne Zeichen in einem String über den Index abrufen, und Sie können auch Strings schneiden, um eine Teilmenge der Zeichen zu erhalten.

my_string = "Python ist fantastisch!"
print(my_string[0])  # Ausgabe: P
print(my_string[7:13])  # Ausgabe: ist fan

Zahlen

Python unterstützt drei Hauptnumerische Datentypen: int (ganze Zahlen), float (Fließkommazahlen) und complex (komplexe Zahlen). Hier ist ein Beispiel:

x = 42  # Ganze Zahl
y = 3.14  # Fließkommazahl
z = 2 + 3j  # Komplexe Zahl
 
print(x)  # Ausgabe: 42
print(y)  # Ausgabe: 3.14
print(z)  # Ausgabe: (2+3j)

Booleans

Booleans sind ein spezieller Datentyp in Python, der einen von zwei Werten haben kann: True oder False. Sie werden häufig in bedingten Anweisungen und logischen Operationen verwendet.

ist_sonnig = True
es_regnet = False
 
print(ist_sonnig)  # Ausgabe: True
print(es_regnet)  # Ausgabe: False

Listen

Listen in Python sind geordnete Sammlungen von Elementen. Sie können Elemente verschiedener Datentypen enthalten, einschließlich anderer Listen. Hier ist ein Beispiel:

meine_liste = [1, 2.5, "drei", True]
print(meine_liste)  # Ausgabe: [1, 2.5, 'drei', True]
print(meine_liste[2])  # Ausgabe: 'drei'

Sie können auch verschiedene Operationen auf Listen ausführen, wie z. B. Slicing, Hinzufügen und Entfernen von Elementen.

fruechte = ["Apfel", "Banane", "Kirsche"]
fruechte.append("Orange")
print(fruechte)  # Ausgabe: ['Apfel', 'Banane', 'Kirsche', 'Orange']
del fruechte[1]
print(fruechte)  # Ausgabe: ['Apfel', 'Kirsche', 'Orange']

Tupel

Tupel sind ähnlich wie Listen, aber sie sind unveränderlich, dh ihre Elemente können nach der Erstellung nicht geändert werden. Tupel werden mit Klammern () definiert.

mein_tupel = (1, 2.5, "drei")
print(mein_tupel)  # Ausgabe: (1, 2.5, 'drei')
mein_tupel[0] = 4  # TypeError: 'tuple' object does not support item assignment

Dictionaries

Dictionaries in Python sind ungeordnete Sammlungen von Schlüssel-Wert-Paaren. Sie werden mit geschweiften Klammern {} definiert und jedes Schlüssel-Wert-Paar wird durch einen Doppelpunkt : getrennt.

person = {
    "name": "John Doe",
    "alter": 35,
    "stadt": "New York"
}
print(person)  # Ausgabe: {'name': 'John Doe', 'alter': 35, 'stadt': 'New York'}
print(person["alter"])  # Ausgabe: 35

Operatoren und Ausdrücke

Arithmetische Operatoren

Python unterstützt die folgenden arithmetischen Operatoren: + (Addition), - (Subtraktion), * (Multiplikation), / (Division), // (ganzzahlige Division), % (Modulo) und ** (Exponentialfunktion).

x = 10
y = 3
print(x + y)  # Ausgabe: 13
print(x - y)  # Ausgabe: 7
print(x * y)  # Ausgabe: 30
print(x / y)  # Ausgabe: 3.3333333333333335
print(x // y)  # Ausgabe: 3
print(x % y)  # Ausgabe: 1
print(x ** y)  # Ausgabe: 1000

Vergleichsoperatoren

Python unterstützt die folgenden Vergleichsoperatoren: < (kleiner als), > (größer als), <= (kleiner oder gleich), >= (größer oder gleich), == (gleich) und != (ungleich).

x = 10
y = 20
print(x < y)  # Ausgabe: True
print(x > y)  # Ausgabe: False
print(x <= 10)  # Ausgabe: True
print(x >= y)  # Ausgabe: False
print(x == 10)  # Ausgabe: True
print(x != y)  # Ausgabe: True

Logische Operatoren

Python unterstützt die folgenden logischen Operatoren: and (und), or (oder) und not (nicht).

x = 10
y = 20
print(x < 15 and y > 15)  # Ausgabe: True
print(x < 5 or y > 15)  # Ausgabe: True
print(not(x < 5))  # Ausgabe: True

Bitweise Operatoren

Python unterstützt auch bitweise Operatoren, die Operationen auf den einzelnen Bits von Zahlen durchführen. Hierzu gehören & (und), | (oder), ^ (xor), ~ (nicht), << (Linksverschiebung) und >> (Rechtsverschiebung).

x = 0b1010  # 10 in binärer Darstellung
y = 0b1100  # 12 in binärer Darstellung
print(x & y)  # Ausgabe: 8 (0b1000)
print(x | y)  # Ausgabe: 14 (0b1110)
print(x ^ y)  # Ausgabe: 6 (0b0110)
print(~x)  # Ausgabe: -11 (0b11111111111111111111111111110101)
print(x << 1)  # Ausgabe: 20 (0b10100)
print(y >> 1)  # Ausgabe: 6 (0b110)

Kontrollstrukturen

Bedingte Anweisungen

Die if-elif-else-Anweisung wird verwendet, um verschiedene Codeblöcke basierend auf bestimmten Bedingungen auszuführen.

x = 10
if x > 0:
    print("x ist positiv")
elif x < 0:
    print("x ist negativ")
else:
    print("x ist null")

Schleifen

Python hat zwei Haupt-Schleifenkonstrukte: for-Schleifen und while-Schleifen.

# For-Schleife
fruits = ["Apfel", "Banane", "Kirsche"]
for fruit in fruits:
    print(fruit)
 
# While-Schleife
count = 0
while count < 5:
    print(count)
    count += 1

Abbrechen und Fortsetzen

Die break-Anweisung wird verwendet, um eine Schleife vorzeitig zu beenden, während die continue-Anweisung verwendet wird, um die aktuelle Iteration zu überspringen und zur nächsten überzugehen.

# Beispiel für Abbrechen
for i in range(10):
    if i == 5:
        break
    print(i)
 
# Beispiel für Fortsetzen
for i in range(10):
    if i % 2 == 0:
        continue
    print(i)

Funktionen

Funktionen in Python werden mit dem Schlüsselwort def definiert. Sie können Parameter entgegennehmen und Werte zurückgeben.

def greet(name):
    print(f"Hallo, {name}!")
 
begrüßen("Alice")  # Ausgabe: Hallo, Alice!
 
def add_numbers(a, b):
    return a + b
 
ergebnis = add_numbers(5, 3)
print(ergebnis)  # Ausgabe: 8

Funktionen können auch Standardparameterwerte und Argumente variabler Länge haben.

def print_info(name, age=30):
    print(f"{name} ist {age} Jahre alt.")
 
print_info("John")  # Ausgabe: John ist 30 Jahre alt.
print_info("Jane", 25)  # Ausgabe: Jane ist 25 Jahre alt.
 
def sum_numbers(*args):
    summe = 0
    for num in args:
        summe += num
    return summe
 
print(sum_numbers(1, 2, 3))  # Ausgabe: 6
print(sum_numbers(4, 5, 6, 7, 8))  # Ausgabe: 30

Module und Pakete

Die Python-Standardbibliothek bietet eine Vielzahl von integrierten Modulen, die Sie in Ihren Programmen verwenden können. Sie können auch eigene Module und Pakete erstellen, um Ihren Code zu organisieren.

import math
print(math.pi)  # Ausgabe: 3.141592653589793
 
from math import sqrt
print(sqrt(16))  # Ausgabe: 4.0
 
import mein_modul
mein_modul.meine_funktion()

Fazit

In diesem Tutorial haben Sie die grundlegenden Konzepte von Python kennen gelernt, einschließlich Variablen, Datentypen, Operatoren, Kontrollstrukturen, Funktionen und Modulen. Mit diesem Wissen können Sie jetzt eigene Python-Anwendungen erstellen und in der Zukunft fortgeschrittene Themen erkunden. Denken Sie daran, dass der beste Weg, Ihre Python-Kenntnisse zu verbessern, regelmäßiges Üben und kontinuierliches Lernen ist.

MoeNagy Dev