Erkunden der Namensverzerrung in Python: Was es ist und wie es funktioniert

Python ist für seine Einfachheit und Lesbarkeit bekannt, aber wenn es um objektorientierte Programmierung (OOP) geht, gibt es einige weniger diskutierte Mechanismen, die für das Schreiben von robustem Code von entscheidender Bedeutung sind. Ein solcher Mechanismus ist die Namensverfälschung. In diesem Artikel erfahren Sie, was Namensverzerrung ist, warum Python sie verwendet und wie sie dazu beitragen kann, Namenskollisionen in komplexen Klassenhierarchien zu verhindern.

Was ist Namensmangling?

Python ermöglicht das Überschreiben von Methoden in Klassen durch Unterklassen. Dies kann jedoch manchmal zu Namenskonflikten führen, wenn eine Unterklasse unbeabsichtigt Attribute oder Methoden der übergeordneten Klasse überschreibt. Namensverzerrung ist ein Mechanismus, den Python verwendet, um diese Konflikte zu vermeiden, insbesondere für Attribute, die privat sein sollen.

Namensmangling in Python ist eine Funktion, bei der der Interpreter die Namen privater Klasseneigenschaften ändert, um das Risiko zu minimieren, dass versehentlich auf sie zugegriffen und sie überschrieben werden. Dies bietet ein gewisses Maß an Datenschutz für Klassenattribute, wird jedoch nicht strikt durchgesetzt. Es handelt sich jedoch nicht um eine strikte Durchsetzung.

Technische Definition

In Python wird jeder Bezeichner mit zwei führenden Unterstrichen (__) und nicht mehr als einem abschließenden Unterstrich einer Namensverfälschung unterzogen. Der Interpreter transformiert den Namen, indem er ihm den Klassennamen voranstellt.

Warum verwendet Python Namensmangling?

Um Namenskonflikte zu vermeiden, insbesondere in der Situation, in der die Unterklassen möglicherweise eigene Variablen haben, die möglicherweise die Variablen in der übergeordneten Klasse überschreiben, implementiert Python die Namensverzerrung. Namensverfälschung behebt dieses Problem.

from datetime import datetime, timedelta
from time import time, sleep

class Machine:
    def __init__(self, id):
        self.id = id
        self._started = time()

    def uptime(self):
        return time() - self._started

class PetrolMachine(Machine):
    def __init__(self, id):
        super().__init__(id)
        self._started = datetime.now()

    def cost(self):
        duration = datetime.now() - self._started
        return duration/timedelta(seconds=60) *0.02

worked = PetrolMachine('12345')
sleep(0.123)
print(f"uptime : {worked.uptime():.2f}")

In diesem Beispiel speichert die Machine-Klasse eine ID und zeichnet die Startzeit mit der Funktion time() von Python auf. Wenn Sie die Betriebszeit anfordern, wird die Differenz zwischen der aktuellen Zeit und der Startzeit berechnet, die als Gleitkommazahl gespeichert wird. Die Unterklasse PetrolMachine hingegen speichert die Startzeit mit datetime.now(). Wenn wir versuchen, die Betriebszeit zu berechnen, gibt das Programm einen Fehler aus, da es erwartet, dass start_time eine Gleitkommazahl ist, es sich jedoch jetzt um ein Datetime-Objekt handelt. Dieser Namenskonflikt kann auftreten, wenn Attribute der Unterklasse unbeabsichtigt die Attribute der übergeordneten Klasse überschreiben. Das Verfälschen von Namen hilft, dieses Problem zu vermeiden.

Wie funktioniert Namensverfälschung?

Wie hilft die Namensverfälschung bei der Lösung dieses Problems? Wenn einem Klassenattribut zwei Unterstriche vorangestellt werden, ändert Python intern den Namen so, dass er den Klassennamen als Präfix enthält. So können Sie die Machine-Klasse ändern, um Namenskonflikte durch Namensverzerrung zu vermeiden:

Wir können den Fehler beheben, indem wir Namensmangling auf das __started-Attribut in der Machine-Klasse anwenden, wie unten gezeigt:

from datetime import datetime, timedelta
from time import time, sleep

class Machine:
    def __init__(self, id):
        self.id = id
        self.__started = time()

    def uptime(self):
        return time() - self.__started  

class PetrolMachine(Machine):
    def __init__(self, id):
        super().__init__(id)
        self._started = datetime.now()

    def cost(self):
        duration = datetime.now() - self._started
        return duration/timedelta(seconds=60) *0.02


worked = PetrolMachine('12345')
sleep(0.123)
print(f"uptime : {worked.uptime():.2f}")

Eine einfache Möglichkeit, Namensverstümmelung auszudrücken, wird unten gezeigt. Ich habe eine Klasse ClassA, die eine private_Variable hat, deren Name verstümmelt ist.

class MyClass:
    def __init__(self):
        self.__private_var = "I am private"

    def get_private_var(self):
        return self.__private_var

my_object = MyClass()
print(my_object.get_private_var())  # This works
print(my_object.__private_var)

Der zweite print() löst einen AttributeError aus, da der Name der Variablen __private_var geändert wurde. Intern hat Python den Namen in _MyClass__private_var geändert, was den Zugriff von außerhalb der Klasse erschwert.

Zugriff auf den verstümmelten Namen

Während Pythons Namensverfälschung dazu dient, versehentlichen Zugriff zu verhindern, erzwingt es keine strikte Privatsphäre. Sie können weiterhin auf das Mangled-Attribut zugreifen, indem Sie den vollständigen Mangled-Namen verwenden, allerdings wird davon abgeraten. So funktioniert es: my_object._MyClass__private_var

print(my_object._MyClass__private_var)

Wann verstümmelt Python Namen?

Ich werde es anhand eines einfachen Beispiels erklären

class MyClass:
    def __init__(self):
        self._protected_var = "I'm protected"
        self.__private_var__ = "I'm not mangled"

In Python gibt ein führender einzelner Unterstrich (z. B. _protected_var) an, dass das Attribut „geschützt“ ist und nicht direkt von außerhalb der Klasse aufgerufen werden sollte. Python erzwingt dies jedoch nicht. Im Gegensatz dazu werden Namen mit zwei führenden Unterstrichen (z. B. __private_var) entstellt, um ein versehentliches Überschreiben zu verhindern. Wichtig ist, dass Namen mit doppelten Unterstrichen auf beiden Seiten (z. B. __special__) nicht entstellt werden und für spezielle Anwendungsfälle wie magische Methoden reserviert sind.

Faedah dan Had

Faedah

• Membantu menghalang penentangan atribut kelas secara tidak sengaja dalam subkelas
• Menyediakan mekanisme yang ringan untuk privasi tanpa terlalu menyekat.

Had

• Ia tidak benar-benar peribadi—pemaju lain masih boleh mengakses nama yang rosak jika mereka tahu caranya.
• Boleh menjadikan nyahpepijat dan membaca kod lebih kompleks jika digunakan secara berlebihan.

_ Walaupun terdapat batasan ini, pemecahan nama kekal sebagai alat yang berguna dalam kit alat OOP Python. Walaupun ia bukan penguatkuasaan privasi yang ketat, ia membantu mengelakkan konflik penamaan dan mengatasi atribut yang tidak disengajakan. Memahami pemecahan nama akan membolehkan anda menulis kod yang lebih mantap dan boleh diselenggara, terutamanya apabila bekerja dengan hierarki kelas yang kompleks. Cuba dalam projek anda, dan kongsi pengalaman atau soalan anda dalam ulasan di bawah!_

Das obige ist der detaillierte Inhalt vonErkunden der Namensverzerrung in Python: Was es ist und wie es funktioniert. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!