# Einführung
Warum verwenden Sie Python? Für viele Leute läuft es auf „einfach so“ hinaus, aber das sollte eigentlich nicht der Fall sein. Python ist eine leistungsstarke Allzweck-Programmiersprache mit einer einfachen Syntax, die durch die pythonischen Ansätze zur Verwaltung von Logik und Daten hervorgehoben wird und sich zufällig als die bevorzugte Sprache für Datenwissenschaft, maschinelles Lernen und KI erwiesen hat genau aus diesen Gründen. Es ist einfach, Python zu erlernen, aber Sie können viele Jahre damit verbringen, Ihre Fähigkeiten zu verbessern und die Kernmechanismen der Sprache zu beherrschen, um vom Anfänger zum Profi zu werden, der in der Lage ist, effiziente, wartbare Systeme zu schreiben.
Vor diesem Hintergrund werden wir heute fünf grundlegende Konzepte untersuchen, die jeder Python-Entwickler in seinem Toolkit haben sollte.
# 1. Hear Sie Verständnis- und Generatorausdrücke auf
Python ist für seine Lesbarkeit bekannt. Verständnis auflisten ermöglichen es Ihnen, umständliche Schleifen durch eine einzige Codezeile zu ersetzen. Der eigentliche Vorteil besteht hier jedoch darin, zu wissen, wann man a verwenden sollte Generatorausdruck stattdessen um Speicherplatz zu sparen.
// Der klobige Weg (For-Schleife)
Beginnen wir mit der ineffizienten, nicht-pythonischen „klobigen“ Vorgehensweise:
numbers = vary(1000000)
squared_list = ()
for n in numbers:
if n % 2 == 0:
squared_list.append(n ** 2)// Der pythonische Weg (Listenverständnis)
Schauen wir uns nun die Pythonic-Methode zur Lösung derselben Aufgabe an:
# Concise and quicker execution
squared_list = (n ** 2 for n in numbers if n % 2 == 0)
# The "Should-Know" Twist: Generator Expressions
# For those who solely have to iterate as soon as and do not want the entire checklist in reminiscence:
squared_gen = (n ** 2 for n in numbers if n % 2 == 0)Ausgabe:
Record dimension: 4,167,352 bytes
Generator dimension: 200 bytesAus diesem Grund ist dies wichtig, abgesehen davon, dass die Leute Ihnen sagen: „So wird es in Python gemacht“: Das Verständnis von Hear ist schneller als .append(). Generatorausdrücke (unter Verwendung von Klammern) sind „faul“ – sie erzeugen Elemente einzeln, sodass Sie riesige Datensätze verarbeiten können, ohne den Speicher Ihres Programs zu erschöpfen.
Sehen wir uns an, wie der Generator Aufruf für Aufruf mithilfe eines Generatorausdrucks verwendet wird:
numbers = vary(1000000)
squared_gen = (n ** 2 for n in numbers if n % 2 == 0)
# Values are computed solely when requested, not
print(subsequent(squared_gen))
print(subsequent(squared_gen))
print(subsequent(squared_gen))Ausgabe:
# 2. Dekorateure
Dekorateure sind eine Möglichkeit, das Verhalten einer Funktion oder Klasse zu ändern, ohne den Quellcode dauerhaft zu ändern. Betrachten Sie sie als Wrapper für andere Funktionen.
// Der klobige Weg
Wenn Sie protokollieren möchten, wie lange die Ausführung verschiedener Funktionen gedauert hat, können Sie jeder einzelnen Funktion manuell Timing-Code hinzufügen.
import time
def process_data():
begin = time.time()
# ... operate logic ...
finish = time.time()
print(f"process_data took {finish - begin:.4f}s")
def train_model():
begin = time.time()
# ... operate logic ...
finish = time.time()
print(f"train_model took {finish - begin:.4f}s")
def generate_report():
begin = time.time()
# ... operate logic ...
finish = time.time()
print(f"generate_report took {finish - begin:.4f}s")Beachten Sie, dass die Wiederholung das Drawback offensichtlich macht: Die gleichen vier Zeilen werden in jeder Funktion dupliziert. Sehen wir uns an, wie eine Dekoratorfunktion dieses Drawback beheben kann.
// Der pythonische Weg
Hier ist ein eher pythonischer Ansatz für diese Aufgabe.
import time
from functools import wraps
def timer_decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
begin = time.time()
consequence = func(*args, **kwargs)
finish = time.time()
print(f"{func.__name__} took {finish - begin:.4f}s")
return consequence
return wrapper
@timer_decorator
def heavy_computation():
return sum(vary(10**7))
heavy_computation()Ausgabe:
heavy_computation took 0.0941sSehen Sie, wie die timer_decorator() „umhüllt“ das heavy_computation() Funktion, und wenn die letztere aufgerufen wird, wird sie von der ersteren subsumiert und erfährt deren Vorteile.
Dekorateure fördern das „Wiederhole dich nicht (DRY)-Prinzip. Sie sind für die Protokollierung, Authentifizierung und Zwischenspeicherung in Produktionsumgebungen unerlässlich.
# 3. Kontextmanager (with Aussagen)
Die Verwaltung von Ressourcen wie Dateien, Datenbankverbindungen oder Netzwerk-Sockets ist eine häufige Fehlerquelle. Wenn Sie vergessen, eine Datei zu schließen, verlieren Sie Speicher oder sperren die Datei für andere Prozesse.
// Der klobige Weg
Hier öffnen wir eine Datei, verwenden sie und erzwingen ein Schließen, wenn sie nicht mehr benötigt wird.
f = open("knowledge.txt", "w")
strive:
f.write("Hi there World")
lastly:
# Straightforward to overlook!
f.shut()// Der pythonische Weg
Eine with-Anweisung würde uns bei dem oben Gesagten helfen.
# File is mechanically closed right here, even when an error happens
with open("knowledge.txt", "w") as f:
f.write("Hi there World")Es ist nicht nur prägnanter, die Logik ist auch einfacher und leichter zu befolgen – und Sie bekommen auch das, was man leicht vergisst shut() kostenlos, da „Aufbau“ und „Abbau“ zuverlässig erfolgen. Im Hinblick auf Datenaufgaben ist dies nützlich, wenn Sie eine Verbindung zu SQL-Datenbanken herstellen oder große Eingabe-/Ausgabe-(IO)-Aufgaben bearbeiten.
# 4. Beherrschen *args Und **kwargs
Manchmal weiß man nicht, wie viele Argumente an eine Funktion übergeben werden. Python handhabt dies elegant mithilfe von „Packing“-Operatoren. Selbst als Anfänger, der sie vielleicht noch nicht eingesetzt hat, haben Sie diese „Verpackungs“-Operatoren zweifellos schon einmal gesehen.
// Das pythonische Beispiel
Hier ist die pythonische Vorgehensweise:
*args(Nicht-Schlüsselwort-Argumente): Ein „Packungs“-Operator, der Extras sammelt Positionsargumente in ein Tupel. Dies wird verwendet, wenn Sie nicht wissen, wie viele Elemente an eine Funktion übergeben werden.**kwargs(Schlüsselwortargumente): Ein „Packungs“-Operator, der Extras sammelt benannte Argumente in ein Wörterbuch. Dies wird für optionale Einstellungen oder benannte Parameter verwendet.
def make_profile(identify, *tags, **metadata):
# identify is the named argument
print(f"Consumer: {identify}")
# tags is a tuple
print(f"Tags: {tags}")
# metadata is a dictionary
print(f"Particulars: {metadata}")
make_profile("Alice", "DataScientist", "Pythonist", location="NY", seniority="Senior")Ausgabe:
Consumer: Alice
Tags: ('DataScientist', 'Pythonist')
Particulars: {'location': 'NY', 'seniority': 'Senior'}Dies ist das Geheimnis hinter flexiblen Bibliotheken wie Scikit-Study oder Matplotlib. Es ermöglicht Ihnen, eine beliebige Anzahl von Konfigurationseinstellungen an eine Funktion zu übergeben, wodurch Ihr Code unglaublich flexibel an sich ändernde Anforderungen angepasst werden kann.
# 5. Dunder-Methoden (magische Methoden)
„Dunder“ steht für doppelter Unterstrich (z.B __init__). Offiziell spezielle Methoden (aber häufiger als magische Methoden bezeichnet) ermöglichen diese Methoden Ihren benutzerdefinierten Objekten, das integrierte Python-Verhalten zu emulieren.
// Der pythonische Weg
Sehen wir uns an, wie man mit magischen Methoden automatisches Verhalten zu unseren Klassen hinzufügt.
class Dataset:
def __init__(self, knowledge):
self.knowledge = knowledge
def __len__(self):
return len(self.knowledge)
def __str__(self):
return f"Dataset with {len(self.knowledge)} objects"
# Create a dataset occasion
my_data = Dataset((1, 2, 3))
# Calls __len__
print(len(my_data))
# Calss __str__
print(my_data)Ausgabe:
Durch die Verwendung des integrierten __len__ Und __str__ dunders, unsere benutzerdefinierte Klasse erhält einige nützliche Funktionen kostenlos.
Dunder-Methoden sind das Rückgrat des Python-Objektprotokolls. Durch die Implementierung von Methoden wie __getitem__ oder __call__können Sie dafür sorgen, dass sich Ihre Klassen wie Hear, Wörterbücher oder sogar Funktionen verhalten, was zu viel intuitiveren APIs führt.
# Zusammenfassung
Die Beherrschung dieser fünf Konzepte markiert den Übergang vom Schreiben von Skripten zum Erstellen von Software program. Durch die Verwendung von Listenverständnissen für Geschwindigkeit, Dekoratoren für saubere Logik, Kontextmanagern für Sicherheit, *args/**kwargs Für Flexibilität und Dunder-Methoden für Objektleistung legen Sie die Grundlage, auf der Sie weitere Python-Kenntnisse aufbauen können.
Matthew Mayo (@mattmayo13) hat einen Grasp-Abschluss in Informatik und ein Diplom in Knowledge Mining. Als geschäftsführender Herausgeber von KDnuggets & Statistikund Mitherausgeber bei Beherrschung des maschinellen LernensZiel von Matthew ist es, komplexe datenwissenschaftliche Konzepte zugänglich zu machen. Zu seinen beruflichen Interessen zählen die Verarbeitung natürlicher Sprache, Sprachmodelle, Algorithmen für maschinelles Lernen und die Erforschung neuer KI. Seine Mission ist es, das Wissen in der Datenwissenschaftsgemeinschaft zu demokratisieren. Matthew programmiert seit seinem sechsten Lebensjahr.