32 essentielle Python-Einzeiler zum 32. Jahrestag von Python

Im Januar 1994 kündigte Guido van Rossum Python 1.0 der Welt über einen Usenet-Beitrag an und versprach eine Sprache mit einer "lesbaren Syntax", die Entwickler davor bewahren würde, "den Perl-Code zu entschlüsseln, den sie letzte Woche geschrieben haben."

Drei Jahrzehnte später ist Python zu einer der weltweit am häufigsten verwendeten Programmiersprachen geworden. Um den 32. Geburtstag von Python zu feiern, hier sind 32 praktische Python-Einzeiler, die zeigen, warum Pythons Einfachheit und Klarheit immer noch wichtig sind.

Hinweis: Einige Beispiele weichen die "Einzeiler"-Regel leicht zugunsten der Nützlichkeit auf. Das Ziel hier ist Klarheit, nicht Code-Golf.

1. Zwei Variablen tauschen

a, b = b, a

Keine temporäre Variable nötig. Pythons Tuple-Unpacking macht das wunderbar einfach.

Versuche es:

Führen Sie den folgenden Code von der Python-Konsole aus:

>>> a, b = 5, 10
>>> print(f"Before: a={a}, b={b}")
Before: a=5, b=10
>>> a, b = b, a
>>> print(f"After: a={a}, b={b}")
After: a=10, b=5

2. Einen String umkehren

reversed_string = original[::-1]

Die Slice-Notation mit einem Schritt von -1 liest sich wie Magie.

Versuche es:

>>> original = "Ostechnix"
>>> reversed_string = original[::-1]
>>> print(reversed_string)
xinhcetsO

3. Überprüfen, ob ein String ein Palindrom ist

is_palindrome = text == text[::-1]

Kombinieren Sie die Umkehrung von Zeichenfolgen mit dem Vergleich für die sofortige Palindromerkennung.

Versuche es:

>>> text = "racecar"
>>> is_palindrome = text == text[::-1]
>>> print(is_palindrome)
True
>>> text = "ostechnix"
>>> print(text == text[::-1])
False

4. Eine verschachtelte Liste abflachen

flat = [item for sublist in nested_list for item in sublist]

List-Comprehension macht das Abflachen elegant und lesbar.

Versuche es:

>>> nested_list = [[1, 2], [3, 4], [5, 6]]
>>> flat = [item for sublist in nested_list for item in sublist]
>>> print(flat)
[1, 2, 3, 4, 5, 6]

5. Einzigartige Elemente finden

unique = list(set(my_list))

In ein Set umwandeln und zurück. Pythons Mengenlehre in Aktion.

Versuche es:

>>> my_list = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
>>> unique = list(set(my_list))
>>> print(unique)
[1, 2, 3, 4]

6. Eine Datei in eine Liste einlesen

lines = open('file.txt').read().splitlines()

Eine Zeile, um von der Festplatte in den Speicher zu gehen (denk aber daran, with für Produktionscode zu verwenden!).

Versuche es:

>>> # First create a test file
>>> with open('test.txt', 'w') as f:
...     f.write("Line 1\nLine 2\nLine 3")
>>> lines = open('test.txt').read().splitlines()
>>> print(lines)
['Line 1', 'Line 2', 'Line 3']

7. Finde das häufigste Element

most_common = max(set(my_list), key=my_list.count)

Kluger Einsatz von max() mit einer benutzerdefinierten Schlüssel-Funktion. Es funktioniert gut für kleine Listen. Verwenden Sie Counter für größere Daten.

Versuche es:

>>> my_list = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
>>> most_common = max(set(my_list), key=my_list.count)
>>> print(most_common)
4

8. Eine Matrix transponieren

transposed = list(zip(*matrix))

Der *-Entpackungsoperator erledigt hier die schwere Arbeit.

Probier es aus:

>>> matrix = [[1, 2, 3], [4, 5, 6]]
>>> transposed = list(zip(*matrix))
>>> print(transposed)
[(1, 4), (2, 5), (3, 6)]
>>> # Convert tuples to lists if needed
>>> print([list(row) for row in transposed])
[[1, 4], [2, 5], [3, 6]]

9. Ein Wörterbuch aus zwei Listen erstellen

my_dict = dict(zip(keys, values))

zip() ist der Klebstoff, der Listen zusammenhält.

Versuche es:

>>> keys = ['a', 'b', 'c']
>>> values = [1, 2, 3]
>>> my_dict = dict(zip(keys, values))
>>> print(my_dict)
{'a': 1, 'b': 2, 'c': 3}

10. Duplikate entfernen und Reihenfolge beibehalten

unique_ordered = list(dict.fromkeys(my_list))

Wörterbücher behalten seit Python 3.7 die Einfügereihenfolge bei, ein Feature, das es wert ist, gefeiert zu werden!

Versuche es:

>>> my_list = [3, 1, 2, 1, 3, 4, 2, 5]
>>> unique_ordered = list(dict.fromkeys(my_list))
>>> print(unique_ordered)
[3, 1, 2, 4, 5]

11. Finde alle Indizes eines Elements

indices = [i for i, x in enumerate(my_list) if x == target]

In einer sauberen Zeile aufzählen und filtern.

Versuche es:

>>> my_list = [1, 2, 3, 2, 4, 2, 5]
>>> target = 2
>>> indices = [i for i, x in enumerate(my_list) if x == target]
>>> print(indices)
[1, 3, 5]

12. Überprüfen, ob eines/alle Elemente einer Bedingung entsprechen

has_even = any(x % 2 == 0 for x in numbers)
all_positive = all(x > 0 for x in numbers)

Die any()- und all()-Funktionen mit Generatorausdrücken sind unglaublich leistungsfähig.

Versuche es:

>>> numbers = [1, 2, 3, 4, 5]
>>> has_even = any(x % 2 == 0 for x in numbers)
>>> print(has_even)
True
>>> all_positive = all(x > 0 for x in numbers)
>>> print(all_positive)
True

13. Ein Wörterbuch nach Wert sortieren

sorted_dict = dict(sorted(my_dict.items(), key=lambda x: x[1]))

Lambda-Funktionen machen benutzerdefinierte Sortierungen zum Kinderspiel.

Versuche es:

>>> my_dict = {'a': 3, 'b': 1, 'c': 2}
>>> sorted_dict = dict(sorted(my_dict.items(), key=lambda x: x[1]))
>>> print(sorted_dict)
{'b': 1, 'c': 2, 'a': 3}

14. Zwei Wörterbücher zusammenführen

merged = {**dict1, **dict2}

Der Dictionary-Unpacking-Operator (Python 3.5+) ist prägnant und klar.

Versuche es:

>>> dict1 = {'a': 1, 'b': 2}
>>> dict2 = {'c': 3, 'd': 4}
>>> merged = {**dict1, **dict2}
>>> print(merged)
{'a': 1, 'b': 2, 'c': 3, 'd': 4}

15. Holen Sie die ersten N Elemente aus einem Iterator

first_n = list(itertools.islice(iterator, n))

itertools.islice() funktioniert bei jedem Iterator, ohne alles in den Speicher zu laden.

Versuche es:

>>> import itertools
>>> iterator = iter(range(100))
>>> first_n = list(itertools.islice(iterator, 5))
>>> print(first_n)
[0, 1, 2, 3, 4]

16. Erstelle eine Zähler-/Frequenzkarte

from collections import Counter; freq = Counter(my_list)

Die Counter-Klasse ist ein Schweizer Taschenmesser zur Häufigkeitszählung.

Versuche es:

>>> from collections import Counter
>>> my_list = ['a', 'b', 'a', 'c', 'b', 'a']
>>> freq = Counter(my_list)
>>> print(freq)
Counter({'a': 3, 'b': 2, 'c': 1})
>>> print(freq.most_common(2))
[('a', 3), ('b', 2)]

17. Elemente in Liste A finden, die nicht in Liste B sind

difference = list(set(list_a) - set(list_b))

Mengenoperationen machen dies intuitiv und schnell.

Versuche es:

>>> list_a = [1, 2, 3, 4, 5]
>>> list_b = [3, 4, 5, 6, 7]
>>> difference = list(set(list_a) - set(list_b))
>>> print(difference)
[1, 2]

18. Alle Permutationen einer Liste erhalten

from itertools import permutations; perms = list(permutations(my_list))

itertools übernimmt die kombinatorische Explosion für Sie.

Versuche es:

>>> from itertools import permutations
>>> my_list = [1, 2, 3]
>>> perms = list(permutations(my_list))
>>> print(perms)
[(1, 2, 3), (1, 3, 2), (2, 1, 3), (2, 3, 1), (3, 1, 2), (3, 2, 1)]

19. JSON schön formatieren

import json; print(json.dumps(data, indent=2))

Sofortige menschenlesbare JSON-Formatierung.

Versuche es:

>>> import json
>>> data = {'name': 'Python', 'age': 32, 'features': ['readable', 'powerful']}
>>> print(json.dumps(data, indent=2))
{
  "name": "Python",
  "age": 32,
  "features": [
    "readable",
    "powerful"
  ]
}

20. Fakultät berechnen

from math import factorial; result = factorial(n)

Oder wenn Sie es schick haben wollen: result=eval('*'.join(map(str, range(1, n+1))))

Versuche es:

>>> from math import factorial
>>> result = factorial(5)
>>> print(result)
120
>>> # The fancy way
>>> n = 5
>>> result = eval('*'.join(map(str, range(1, n+1))))
>>> print(result)
120

21. FizzBuzz in einer Zeile

['Fizz'*(i%3==0) + 'Buzz'*(i%5==0) or str(i) for i in range(1,101)]

Die klassische Interviewfrage gelöst mit Zeichenkettenmultiplikation und boolescher Logik.

Versuche es:

>>> fizzbuzz = ['Fizz'*(i%3==0) + 'Buzz'*(i%5==0) or str(i) for i in range(1,21)]
>>> print(fizzbuzz)
['1', '2', 'Fizz', '4', 'Buzz', 'Fizz', '7', '8', 'Fizz', 'Buzz', '11', 'Fizz', '13', '14', 'FizzBuzz', '16', '17', 'Fizz', '19', 'Buzz']

22. Finde die Schnittmenge mehrerer Listen

intersection = list(set.intersection(*map(set, list_of_lists)))

Mengentheorie trifft auf Entpacken für elegante Schnittmengen mehrerer Listen.

Versuche es:

>>> list_of_lists = [[1, 2, 3, 4], [2, 3, 4, 5], [3, 4, 5, 6]]
>>> intersection = list(set.intersection(*map(set, list_of_lists)))
>>> print(intersection)
[3, 4]

23. Einen String sicher in Titel-Schreibweise umwandeln

title = ' '.join(word.capitalize() for word in text.split())

Besser als .title(), weil es Apostrophe korrekt behandelt.

Versuche es:

>>> text = "python's awesome one-liners"
>>> title = ' '.join(word.capitalize() for word in text.split())
>>> print(title)
Python's Awesome One-liners
>>> # Compare with .title()
>>> print(text.title())
Python'S Awesome One-Liners

24. Erstelle einen Bereich mit Fließkommazahlen

float_range = [x * 0.1 for x in range(10, 100)]

List Comprehensions überwinden die Ganzzahllimitierung von range().

Versuche es:

>>> float_range = [x * 0.1 for x in range(10, 20)]
>>> print(float_range)
[1.0, 1.1, 1.2000000000000002, 1.3, 1.4000000000000001, 1.5, 1.6, 1.7000000000000002, 1.8, 1.9000000000000001]

25. Eine Datei aus dem Web herunterladen

import urllib.request; urllib.request.urlretrieve(url, 'filename.ext')

Dateien aus dem Internet in einer einzigen Zeile abrufen.

Versuche es:

>>> import urllib.request
>>> url = 'https://www.python.org/static/img/python-logo.png'
>>> urllib.request.urlretrieve(url, 'python-logo.png')
('python-logo.png', <http.client.HTTPMessage object at 0x...>)
>>> # File is now saved as 'python-logo.png'

26. Ein zufälliges Passwort generieren

import secrets, string; pwd = ''.join(secrets.choice(string.ascii_letters + string.digits) for _ in range(16))

Sichere zufällige Passwortgenerierung mit der Standardbibliothek.

Versuche es:

>>> import secrets, string
>>> pwd = ''.join(secrets.choice(string.ascii_letters + string.digits) for _ in range(16))
>>> print(pwd)
Kx9mP2nLq8WzBv3Y
>>> # Each run generates a cryptographically secure password
>>> pwd = ''.join(secrets.choice(string.ascii_letters + string.digits) for _ in range(16))
>>> print(pwd)
a7QnM5tR1wJzXp4G

27. Zeitmessung der Codeausführung (Schnellüberprüfung)

import time; start = time.time(); your_function(); elapsed = time.time() - start

Schnelle und grobe Leistungsbewertung (für ernsthaftes Benchmarking timeit verwenden).

Versuche es:

>>> import time
>>> start = time.time()
>>> sum(range(1000000))  # Some operation to time
499999500000
>>> elapsed = time.time() - start
>>> print(f"Execution time: {elapsed:.6f} seconds")
Execution time: 15.000495 seconds

28. Finde alle Vorkommen mit Regex

import re; matches = re.findall(pattern, text)

Reguläre Ausdrücke machen die Mustererkennung mühelos.

Versuche es:

>>> import re
>>> text = "Python 1.0, Python 2.0, Python 3.0"
>>> pattern = r'Python \d+\.\d+'
>>> matches = re.findall(pattern, text)
>>> print(matches)
['Python 1.0', 'Python 2.0', 'Python 3.0']

29. Erstelle einen einfachen HTTP-Server

python -m http.server 8000

Okay, das ist technisch gesehen ein Kommandozeilen-One-Liner, aber er ist zu nützlich, um ihn nicht einzuschließen!

Versuche es:

# Run this in your terminal
$ python -m http.server 8000
Serving HTTP on 0.0.0.0 port 8000 (http://0.0.0.0:8000/) ...

# Then visit http://localhost:8000 in your browser
# Perfect for quickly sharing files or testing web pages locally

30. Verkettete Vergleichsoperatoren

is_valid = 0 <= value <= 100

Python ermöglicht es dir, Mathematik so zu schreiben, wie du darüber denkst.

Versuche es:

>>> value = 50
>>> is_valid = 0 <= value <= 100
>>> print(is_valid)
True
>>> value = 150
>>> print(0 <= value <= 100)
False
>>> # You can chain any comparison operators
>>> x = 5
>>> print(1 < x < 10)
True

31. Das kartesische Produkt von Listen erhalten

from itertools import product; pairs = list(product(list1, list2))

Erzeuge alle Kombinationen ohne verschachtelte Schleifen.

Versuche es:

>>> from itertools import product
>>> list1 = ['A', 'B']
>>> list2 = [1, 2]
>>> pairs = list(product(list1, list2))
>>> print(pairs)
[('A', 1), ('A', 2), ('B', 1), ('B', 2)]
>>> # Works with any number of lists
>>> print(list(product(['X', 'Y'], [1, 2], ['a', 'b'])))
[('X', 1, 'a'), ('X', 1, 'b'), ('X', 2, 'a'), ('X', 2, 'b'), ('Y', 1, 'a'), ('Y', 1, 'b'), ('Y', 2, 'a'), ('Y', 2, 'b')]

32. Erstellen Sie einen schnellen Lambda-Server (Ja, wirklich!)

from flask import Flask; app = Flask(__name__); app.route('/')(lambda: 'Hello!')

Nicht für die Produktion empfohlen, zeigt aber die Einfachheit von Flask!

Probier es aus:

>>> from flask import Flask
>>> app = Flask(__name__)
>>> @app.route('/')
... def hello():
...     return 'Hello, Python is 32!'
>>> # Then run: app.run()
# Visit http://localhost:5000 to see your message

# Note: You'll need Flask installed: pip install flask

Der Geist des Pythons

Diese Einzeiler drehen sich nicht darum, schlau zu sein. Sie spiegeln die langjährigen Werte von Python wider:

• Lesbarkeit über Tricks
• Explizites Verhalten
• Starke Standardbibliotheken
• Code, der sich selbst erklärt

Als Guido 1994 Python 1.0 ankündigte, versprach er eine lesbare Sprache. Dreiunddreißig Jahre später hält Python dieses Versprechen immer noch.

Herzlichen Glückwunsch zum 32. Jubiläum, Python!

Was ist dein Lieblings-Python-Einzeiler? Bitte teile ihn unten in den Kommentaren!

Weiterführende Literatur:

• Originale Python 1.0 Ankündigung im Usenet
• Der Zen von Python
• Offizielle Python-Dokumentation