Wie vermeide ich explizites 'Selbst' in Python?

Ich habe Python gelernt, indem ich einige Pygame-Tutorials befolgt habe .

Darin fand ich eine umfassende Verwendung des Schlüsselworts self , und da ich hauptsächlich aus Java stamme, vergesse ich immer wieder, self einzugeben . Zum Beispiel self.rect.centerxwürde ich anstelle von tippen rect.centerx, weil rect für mich bereits eine Mitgliedsvariable der Klasse ist.

Die Java parallel kann ich denke , für diese Situation mit allen Verweisen auf Membervariablen Präfix wird mit dieser .

Habe ich es nicht geschafft, alle Mitgliedsvariablen mit dem Präfix self zu versehen , oder gibt es eine Möglichkeit, sie zu deklarieren, die es mir ermöglicht, dies zu vermeiden?

Auch wenn das, was ich vorschlage, nicht pythonisch ist , würde ich gerne wissen, ob es möglich ist.

Ich habe mir diese verwandten SO-Fragen angesehen, aber sie beantworten nicht ganz, wonach ich suche:

• Python - warum "Selbst" in einer Klasse verwenden?
• Warum muss das Argument "self" explizit in einer Python-Methode enthalten sein?

Python erfordert die Angabe von self. Das Ergebnis ist, dass es keine Verwirrung darüber gibt, was ein Mitglied ist und was nicht, auch ohne dass die vollständige Klassendefinition sichtbar ist. Dies führt zu nützlichen Eigenschaften wie: Sie können keine Mitglieder hinzufügen, die versehentlich Nichtmitglieder beschatten und dadurch den Code beschädigen.

Ein extremes Beispiel: Sie können eine Klasse schreiben, ohne zu wissen, welche Basisklassen sie haben könnte, und immer wissen, ob Sie auf ein Mitglied zugreifen oder nicht:

class A(some_function()):
  def f(self):
    self.member = 42
    self.method()

Das ist das Ganze Code! (some_function gibt den als Basis verwendeten Typ zurück.)

Eine andere, bei der die Methoden einer Klasse dynamisch zusammengesetzt sind:

class B(object):
  pass

print B()
# <__main__.B object at 0xb7e4082c>

def B_init(self):
  self.answer = 42
def B_str(self):
  return "<The answer is %s.>" % self.answer
# notice these functions require no knowledge of the actual class
# how hard are they to read and realize that "members" are used?

B.__init__ = B_init
B.__str__ = B_str

print B()
# <The answer is 42.>

Denken Sie daran, dass diese beiden Beispiele extrem sind und Sie sie nicht jeden Tag sehen werden. Ich schlage auch nicht vor, dass Sie häufig Code wie diesen schreiben sollten, aber sie zeigen deutlich, dass Aspekte des Selbst explizit erforderlich sind.

Frühere Antworten sind im Grunde alle Varianten von "Sie können nicht" oder "Sie sollten nicht". Obwohl ich dem letzteren Gefühl zustimme, ist die Frage technisch immer noch unbeantwortet.

Darüber hinaus gibt es legitime Gründe, warum jemand etwas tun möchte, das der eigentlichen Frage entspricht. Eine Sache, auf die ich manchmal stoße, sind lange mathematische Gleichungen, bei denen die Verwendung langer Namen die Gleichung nicht wiedererkennbar macht. Hier sind einige Möglichkeiten, wie Sie dies in einem Beispiel aus der Dose tun können:

import numpy as np
class MyFunkyGaussian() :
    def __init__(self, A, x0, w, s, y0) :
        self.A = float(A)
        self.x0 = x0
        self.w = w
        self.y0 = y0
        self.s = s

    # The correct way, but subjectively less readable to some (like me) 
    def calc1(self, x) :
        return (self.A/(self.w*np.sqrt(np.pi))/(1+self.s*self.w**2/2)
                * np.exp( -(x-self.x0)**2/self.w**2)
                * (1+self.s*(x-self.x0)**2) + self.y0 )

    # The correct way if you really don't want to use 'self' in the calculations
    def calc2(self, x) :
        # Explicity copy variables
        A, x0, w, y0, s = self.A, self.x0, self.w, self.y0, self.s
        sqrt, exp, pi = np.sqrt, np.exp, np.pi
        return ( A/( w*sqrt(pi) )/(1+s*w**2/2)
                * exp( -(x-x0)**2/w**2 )
                * (1+s*(x-x0)**2) + y0 )

    # Probably a bad idea...
    def calc3(self, x) :
        # Automatically copy every class vairable
        for k in self.__dict__ : exec(k+'= self.'+k)
        sqrt, exp, pi = np.sqrt, np.exp, np.pi
        return ( A/( w*sqrt(pi) )/(1+s*w**2/2)
                * exp( -(x-x0)**2/w**2 )
                * (1+s*(x-x0)**2) + y0 )

g = MyFunkyGaussian(2.0, 1.5, 3.0, 5.0, 0.0)
print(g.calc1(0.5))
print(g.calc2(0.5))
print(g.calc3(0.5))

Das dritte Beispiel - dh Verwenden for k in self.__dict__ : exec(k+'= self.'+k)ist im Grunde das, wonach die Frage tatsächlich fragt, aber lassen Sie mich klarstellen, dass ich es im Allgemeinen nicht für eine gute Idee halte.

Weitere Informationen und Möglichkeiten zum Durchlaufen von Klassenvariablen oder sogar Funktionen finden Sie in den Antworten und in der Diskussion zu dieser Frage . In diesem Blog-Beitrag erfahren Sie, wie Sie Variablen dynamisch benennen können und warum dies normalerweise keine gute Idee ist .

UPDATE: Es scheint keine Möglichkeit zu geben, lokale Elemente in einer Funktion in Python3 dynamisch zu aktualisieren oder zu ändern, sodass calc3 und ähnliche Varianten nicht mehr möglich sind. Die einzige Python3-kompatible Lösung, an die ich jetzt denken kann, ist die Verwendung von globals:

def calc4(self, x) :
        # Automatically copy every class variable in globals
        globals().update(self.__dict__)
        sqrt, exp, pi = np.sqrt, np.exp, np.pi
        return ( A/( w*sqrt(pi) )/(1+s*w**2/2)
                * exp( -(x-x0)**2/w**2 )
                * (1+s*(x-x0)**2) + y0 )

Was wiederum im Allgemeinen eine schreckliche Praxis wäre.

Eigentlich selfist es kein Schlüsselwort, sondern nur der Name, der üblicherweise dem ersten Parameter von Instanzmethoden in Python gegeben wird. Und dieser erste Parameter kann nicht übersprungen werden, da dies der einzige Mechanismus ist, mit dem eine Methode weiß, auf welche Instanz Ihrer Klasse sie aufgerufen wird.

Sie können beispielsweise einen beliebigen Namen verwenden

class test(object):
    def function(this, variable):
        this.variable = variable

oder auch

class test(object):
    def function(s, variable):
        s.variable = variable

Sie müssen jedoch keinen Namen für den Bereich verwenden.

Ich empfehle Ihnen nicht, etwas anderes als sich selbst zu verwenden, es sei denn, Sie haben einen überzeugenden Grund, da dies für erfahrene Pythonisten fremd wäre.

Ja, Sie müssen immer angeben self , da explizit nach der Python-Philosophie besser als implizit ist.

Sie werden auch feststellen, dass sich die Art und Weise, wie Sie in Python programmieren, stark von der Art und Weise unterscheidet, wie Sie in Java programmieren. Daher nimmt die Verwendung von selftendenziell ab, da Sie nicht alles innerhalb des Objekts projizieren. Vielmehr nutzen Sie Funktionen auf Modulebene, die besser getestet werden können.

Apropos. Ich hasste es zuerst, jetzt hasse ich das Gegenteil. Gleiches gilt für die eingedrückte Durchflussregelung.

Das "Selbst" ist der herkömmliche Platzhalter der aktuellen Objektinstanz einer Klasse. Es wird verwendet, wenn Sie auf die Eigenschaft, das Feld oder die Methode des Objekts innerhalb einer Klasse verweisen möchten, als würden Sie auf "sich selbst" verweisen. Aber um es kürzer zu machen, hat jemand im Python-Programmierbereich angefangen, "self" zu verwenden, andere Bereiche verwenden "this", aber sie machen es als Schlüsselwort, das nicht ersetzt werden kann. Ich habe eher "its" verwendet, um die Lesbarkeit des Codes zu verbessern. Es ist eines der guten Dinge in Python - Sie haben die Freiheit, Ihren eigenen Platzhalter für die Instanz des Objekts zu wählen, außer "Selbst". Beispiel für sich selbst:

class UserAccount():    
    def __init__(self, user_type, username, password):
        self.user_type = user_type
        self.username = username            
        self.password = encrypt(password)        

    def get_password(self):
        return decrypt(self.password)

    def set_password(self, password):
        self.password = encrypt(password)

Jetzt ersetzen wir 'Selbst' durch 'Sein':

class UserAccount():    
    def __init__(its, user_type, username, password):
        its.user_type = user_type
        its.username = username            
        its.password = encrypt(password)        

    def get_password(its):
        return decrypt(its.password)

    def set_password(its, password):
        its.password = encrypt(password)

was ist jetzt besser lesbar?

self ist Teil der Python-Syntax für den Zugriff auf Mitglieder von Objekten. Ich fürchte, Sie bleiben dabei

Tatsächlich können Sie das Rezept "Implizites Selbst" aus der Präsentation von Armin Ronacher "5 Jahre schlechte Ideen" (google it) verwenden.

Es ist ein sehr cleveres Rezept, wie fast alles von Armin Ronacher, aber ich finde diese Idee nicht sehr ansprechend. Ich denke, ich würde es vorziehen, dies explizit zu tun in C # / Java.

Aktualisieren. Link zum "Rezept für schlechte Ideen": https://speakerdeck.com/mitsuhiko/5-years-of-bad-ideas?slide=58

Ja, Selbst ist langweilig. Aber ist es besser?

class Test:

    def __init__(_):
        _.test = 'test'

    def run(_):
        print _.test

Von: Self Hell - Stateful Funktionen.

... ein hybrider Ansatz funktioniert am besten. Alle Ihre Klassenmethoden, die tatsächlich Berechnungen durchführen, sollten in Abschlüsse verschoben werden, und Erweiterungen zum Bereinigen der Syntax sollten in Klassen beibehalten werden. Füllen Sie die Verschlüsse in Klassen und behandeln Sie die Klasse wie einen Namespace. Die Verschlüsse sind im Wesentlichen statische Funktionen und erfordern daher kein Selbst *, auch nicht in der Klasse ...

Ich denke, dass es einfacher und lesbarer wäre, wenn es eine Anweisung "Mitglied" gäbe, genauso wie es "global" gibt, damit Sie dem Interpreter mitteilen können, welche Objekte Mitglieder der Klasse sind.