Blockbereich in Python

Wenn Sie in anderen Sprachen codieren, erstellen Sie manchmal einen Blockbereich wie folgt:

statement
...
statement
{
    statement
    ...
    statement
}
statement
...
statement

Ein (von vielen) Zweck besteht darin, die Lesbarkeit des Codes zu verbessern: zu zeigen, dass bestimmte Anweisungen eine logische Einheit bilden oder dass bestimmte lokale Variablen nur in diesem Block verwendet werden.

Gibt es eine idiomatische Möglichkeit, dasselbe in Python zu tun?

Nein, es gibt keine Sprachunterstützung zum Erstellen eines Blockbereichs.

Die folgenden Konstrukte erstellen einen Bereich:

• Modul
• Klasse
• Funktion (inkl. Lambda)
• Generatorausdruck
• Verständnis (diktieren, setzen, auflisten (in Python 3.x))

Die idiomatische Methode in Python besteht darin, Ihre Funktionen kurz zu halten. Wenn Sie glauben, dass Sie dies benötigen, überarbeiten Sie Ihren Code! :) :)

Python erstellt einen neuen Bereich für jedes Modul, jede Klasse, Funktion, jeden Generatorausdruck, jedes Diktatverständnis, jedes Mengenverständnis und in Python 3.x auch für jedes Listenverständnis. Abgesehen von diesen gibt es innerhalb von Funktionen keine verschachtelten Bereiche.

Sie können etwas Ähnliches wie einen C ++ - Blockbereich in Python tun, indem Sie eine Funktion in Ihrer Funktion deklarieren und sie dann sofort aufrufen. Beispielsweise:

def my_func():
    shared_variable = calculate_thing()

    def do_first_thing():
        ... = shared_variable
    do_first_thing()

    def do_second_thing():
        foo(shared_variable)
        ...
    do_second_thing()

Wenn Sie sich nicht sicher sind, warum Sie dies tun möchten, kann Sie dieses Video überzeugen.

Das Grundprinzip besteht darin, alles so eng wie möglich do_first_thing()zu erfassen, ohne dass "Müll" (zusätzliche Typen / Funktionen) in einen größeren Bereich als unbedingt erforderlich eingeführt wird. Nichts anderes möchte die Methode beispielsweise verwenden, damit sie nicht außerhalb des Bereichs liegt Funktion aufrufen.

Ich bin damit einverstanden, dass es keinen Blockumfang gibt. Aber eine Stelle in Python 3 lässt es so aussehen, als hätte es einen Blockbereich.

Was ist passiert, was diesen Blick gab? Dies funktionierte in Python 2 ordnungsgemäß, aber um die variable Leckage in Python 3 zu stoppen, haben sie diesen Trick ausgeführt, und diese Änderung lässt es so aussehen, als hätte es hier einen Blockbereich.

Lassen Sie mich erklären.

Wenn wir Variablen mit demselben Namen in denselben Bereich einführen, sollte gemäß der Idee des Bereichs der Wert geändert werden.

Dies ist, was in Python 2 passiert

>>> x = 'OLD'
>>> sample = [x for x in 'NEW']
>>> x
'W'

Obwohl in Python 3 die gleichnamige Variable eingeführt wird, wird sie nicht überschrieben. Das Listenverständnis verhält sich aus irgendeinem Grund wie eine Sandbox und scheint darin einen neuen Bereich zu erstellen.

>>> x = 'OLD'
>>> sample = [x for x in 'NEW']
>>> x
'OLD'

und diese Antwort widerspricht der Aussage von answerer @ Thomas. Das einzige Mittel zum Erstellen eines Bereichs sind Funktionen, Klassen oder Module, da dies wie ein anderer Ort zum Erstellen eines neuen Bereichs aussieht.

Module (und Pakete) sind eine großartige pythonische Möglichkeit, Ihr Programm in separate Namespaces zu unterteilen, was ein implizites Ziel dieser Frage zu sein scheint. Als ich die Grundlagen von Python lernte, war ich frustriert über das Fehlen einer Block-Scope-Funktion. Sobald ich jedoch die Python-Module verstanden hatte, konnte ich meine vorherigen Ziele eleganter verwirklichen, ohne dass ein Blockumfang erforderlich war.

Als Motivation und um die Menschen in die richtige Richtung zu weisen, halte ich es für nützlich, explizite Beispiele für einige der Scoping-Konstrukte von Python zu geben. Zuerst erkläre ich meinen fehlgeschlagenen Versuch, Python-Klassen zum Implementieren des Blockbereichs zu verwenden. Als nächstes erkläre ich, wie ich mit Python-Modulen etwas Nützlicheres erreicht habe. Am Ende skizziere ich eine praktische Anwendung von Paketen zum Laden und Filtern von Daten.

Blockbereich mit Klassen versuchen

Für einige Momente dachte ich, ich hätte den Blockumfang erreicht, indem ich Code in eine Klassendeklaration gesteckt habe:

x = 5
class BlockScopeAttempt:
    x = 10
    print(x) # Output: 10
print(x) # Output: 5

Leider bricht dies zusammen, wenn eine Funktion definiert wird:

x = 5 
class BlockScopeAttempt: 
    x = 10
    print(x) # Output: 10
    def printx2(): 
        print(x) 
    printx2() # Output: 5!!!

Dies liegt daran, dass innerhalb einer Klasse definierte Funktionen einen globalen Bereich verwenden. Der einfachste (wenn auch nicht der einzige) Weg, dies zu beheben, besteht darin, die Klasse explizit anzugeben:

x = 5 
class BlockScopeAttempt: 
    x = 10
    print(x) # Output: 10
    def printx2(): 
        print(BlockScopeAttempt.x)  # Added class name
    printx2() # Output: 10

Dies ist nicht so elegant, da man Funktionen unterschiedlich schreiben muss, je nachdem, ob sie in einer Klasse enthalten sind oder nicht.

Bessere Ergebnisse mit Python-Modulen

Module sind statischen Klassen sehr ähnlich, aber Module sind meiner Erfahrung nach viel sauberer. Um dasselbe mit Modulen zu tun, erstelle ich eine my_module.pyim aktuellen Arbeitsverzeichnis aufgerufene Datei mit folgendem Inhalt:

x = 10
print(x) # (A)

def printx():
    global x
    print(x) # (B)

Dann mache ich es in meiner Hauptdatei oder in einer interaktiven Sitzung (z. B. Jupyter)

x = 5
import my_module # Output: 10 from (A)
my_module.printx() # Output: 10 from (B)
print(x) # Output: 5

Zur Erklärung definiert jede Python-Datei ein Modul mit einem eigenen globalen Namespace. Durch das Importieren eines Moduls können Sie mit der .Syntax auf die Variablen in diesem Namespace zugreifen .

Wenn Sie in einer interaktiven Sitzung mit Modulen arbeiten, können Sie diese beiden Zeilen zu Beginn ausführen

%load_ext autoreload
%autoreload 2

und Module werden automatisch neu geladen, wenn die entsprechenden Dateien geändert werden.

Pakete zum Laden und Filtern von Daten

Die Idee der Pakete ist eine leichte Erweiterung des Modulkonzepts. Ein Paket ist ein Verzeichnis mit einer (möglicherweise leeren) __init__.pyDatei, die beim Import ausgeführt wird. Auf Module / Pakete in diesem Verzeichnis kann mit der .Syntax zugegriffen werden .

Für die Datenanalyse muss ich häufig eine große Datendatei lesen und dann interaktiv verschiedene Filter anwenden. Das Lesen einer Datei dauert einige Minuten, daher möchte ich es nur einmal tun. Basierend auf dem, was ich in der Schule über objektorientiertes Programmieren gelernt habe, war ich der Meinung, dass man den Code zum Filtern und Laden als Methoden in einer Klasse schreiben sollte. Ein Hauptnachteil dieses Ansatzes besteht darin, dass sich die Definition meiner Klasse ändert, wenn ich meine Filter neu definiere, sodass ich die gesamte Klasse einschließlich der Daten neu laden muss.

Heutzutage definiere ich mit Python ein Paket namens, my_datadas Submodule mit dem Namen loadund enthält filter. Innerhalb von filter.pykann ich einen relativen Import durchführen:

from .load import raw_data

Wenn ich ändere filter.py, autoreloadwerden die Änderungen erkannt. Es wird nicht neu geladen load.py, daher muss ich meine Daten nicht neu laden. Auf diese Weise kann ich meinen Filtercode in einem Jupyter-Notizbuch prototypisieren, als Funktion umschließen und dann direkt aus meinem Notizbuch ausschneiden und einfügen filter.py. Das herauszufinden hat meinen Workflow revolutioniert und mich von einem Skeptiker zu einem Gläubigen des „Zen of Python“ gemacht.