webentwicklung-frage-antwort-db.com.de

Übergeben von Variablen, Erstellen von Instanzen, Selbst, Die Mechanik und Verwendung von Klassen: müssen erklärt werden

Ich habe den ganzen Tag darüber gesessen und bin schon ein bisschen müde, entschuldigen Sie bitte, dass ich mich kurz fasse.

Ich bin neu in Python.

Ich habe gerade ein Arbeitsprogramm umgeschrieben, in eine Reihe von Funktionen in einer Klasse und alles durcheinander gebracht. Ich weiß nicht, ob ich es bin, aber ich bin sehr überrascht, dass ich kein Tutorial für Anfänger zum Umgang mit Kursen im Web gefunden habe. Daher habe ich ein paar Fragen.

Zuerst Im Abschnitt __init__ Der Klasse habe ich eine Reihe von Variablen mit self.variable=something Deklariert.

Ist es richtig, dass ich in jeder Funktion der Klasse auf diese Variablen zugreifen/sie ändern kann, indem ich self.variable In dieser Funktion verwende? Mit anderen Worten, indem ich self.variable Deklariere, habe ich diese Variablen zu globalen Variablen im Geltungsbereich der Klasse gemacht, oder?

Wenn nicht, wie gehe ich mit mir selbst um?

Zweitens, wie übergebe ich Argumente korrekt an die Klasse? Ein Beispielcode wäre cool.

Drittens, wie rufe ich eine Funktion der Klasse außerhalb des Klassenbereichs auf? Ein Beispielcode wäre cool.

Fouthly, wie erstelle ich eine Instanz des class INITIALCLASS In einem anderen class OTHERCLASS Und übergebe Variablen von OTHERCLASS an INITIALCLASS? Ein Beispielcode wäre cool.

Ich möchte eine Funktion von OTHERCLASS mit Argumenten von INITIALCLASS aufrufen. Was ich bisher gemacht habe, ist.

class OTHERCLASS():
    def __init__(self,variable1,variable2,variable3):
        self.variable1=variable1
        self.variable2=variable2
        self.variable3=variable3
    def someotherfunction(self):
        something=somecode(using self.variable3)
        self.variable2.append(something)
        print self.variable2
    def somemorefunctions(self):
        self.variable2.append(variable1)

class INITIALCLASS():
    def __init__(self):
        self.variable1=value1
        self.variable2=[]
        self.variable3=''
        self.DoIt=OTHERCLASS(variable1,variable2,variable3)

    def somefunction(self):
        variable3=Somecode
        #tried this
        self.DoIt.someotherfunctions()
        #and this
        DoIt.someotherfunctions()

Ich verstand eindeutig nicht, wie man Variablen an Klassen übergibt oder wie man mit self umgeht, wann man es benutzt und wann nicht. Ich habe wahrscheinlich auch nicht verstanden, wie man eine Instanz einer Klasse richtig erstellt. Im Allgemeinen habe ich die Mechanik des Unterrichts nicht verstanden. Bitte helfen Sie mir und erklären Sie es mir, als hätte ich keine Ahnung (was ich anscheinend nicht tue). Oder zeigen Sie mir ein ausführliches Video oder ein lesbares Tutorial.

Alles, was ich im Web finde, sind supereinfache Beispiele, die mir nicht viel geholfen haben. Oder nur sehr kurze Definitionen von Klassen und Klassenmethoden usw.

Ich kann dir meinen Originalcode schicken, wenn ihr wollt, aber es ist ziemlich lang.

39
Baf
class Foo          (object):
    # ^class name  #^ inherits from object

    bar = "Bar" #Class attribute.

    def __init__(self):
        #        #^ The first variable is the class instance in methods.  
        #        #  This is called "self" by convention, but could be any name you want.
        #^ double underscore (dunder) methods are usually special.  This one 
        #  gets called immediately after a new instance is created.

        self.variable = "Foo" #instance attribute.
        print self.variable, self.bar  #<---self.bar references class attribute
        self.bar = " Bar is now Baz"   #<---self.bar is now an instance attribute
        print self.variable, self.bar  

    def method(self, arg1, arg2):
        #This method has arguments.  You would call it like this:  instance.method(1, 2)
        print "in method (args):", arg1, arg2
        print "in method (attributes):", self.variable, self.bar


a = Foo() # this calls __init__ (indirectly), output:
                 # Foo bar
                 # Foo  Bar is now Baz
print a.variable # Foo
a.variable = "bar"
a.method(1, 2) # output:
               # in method (args): 1 2
               # in method (attributes): bar  Bar is now Baz
Foo.method(a, 1, 2) #<--- Same as a.method(1, 2).  This makes it a little more explicit what the argument "self" actually is.

class Bar(object):
    def __init__(self, arg):
        self.arg = arg
        self.Foo = Foo()

b = Bar(a)
b.arg.variable = "something"
print a.variable # something
print b.Foo.variable # Foo
76
mgilson

Hier ist ein einfaches Beispiel für die Verwendung von Klassen: Angenommen, Sie sind ein Finanzinstitut. Sie möchten, dass die Konten Ihrer Kunden von einem Computer verwaltet werden. Sie müssen diese Konten also modellieren. Hier kommen die Klassen ins Spiel. Das Arbeiten mit Klassen wird als objektorientierte Programmierung bezeichnet. Mit Klassen modellieren Sie reale Objekte in Ihrem Computer. Was brauchen wir also, um ein einfaches Bankkonto zu modellieren? Wir brauchen eine Variable, die das Guthaben speichert, und eine, die den Namen des Kunden speichert. Darüber hinaus einige Methoden zum Ein- und Ausgleichen des Gleichgewichts. Das könnte so aussehen:

class bankaccount():
    def __init__(self, name, money):
        self.name = name
        self.money = money

    def earn_money(self, amount):
        self.money += amount

    def withdraw_money(self, amount):
        self.money -= amount

    def show_balance(self):
        print self.money

Nun haben Sie ein abstraktes Modell eines einfachen Kontos und seines Mechanismus. Die def __init__(self, name, money) ist der Konstruktor der Klassen. Es baut das Objekt im Speicher auf. Wenn Sie jetzt ein neues Konto eröffnen möchten, müssen Sie eine Instanz Ihrer Klasse erstellen. Dazu müssen Sie den Konstruktor aufrufen und die erforderlichen Parameter übergeben. In Python wird ein Konstruktor nach dem Namen der Klasse aufgerufen:

spidermans_account = bankaccount("SpiderMan", 1000)

Wenn Spiderman M.J. einen neuen Ring kaufen will, muss er etwas Geld abheben. Er würde die withdraw -Methode für sein Konto aufrufen:

spidermans_account.withdraw_money(100)

Wenn er den Kontostand sehen will, ruft er:

spidermans_account.show_balance()

Das Ganze bei Klassen ist das Modellieren von Objekten, ihren Attributen und Mechanismen. Um ein Objekt zu erstellen, instanziieren Sie es wie im Beispiel. Werte werden mit Get- und Setter-Methoden wie `earn_money () ´ an Klassen übergeben. Diese Methoden greifen auf Ihre Objektvariablen zu. Wenn Ihre Klasse ein anderes Objekt speichern soll, müssen Sie im Konstruktor eine Variable für dieses Objekt definieren.

27
MaxPowers

Der springende Punkt einer Klasse ist, dass Sie eine Instanz erstellen und diese Instanz einen Datensatz kapselt. Es ist also falsch zu sagen, dass Ihre Variablen im Geltungsbereich der Klasse global sind: Sagen Sie stattdessen, dass eine Instanz Attribute enthält und diese Instanz in jedem Code auf ihre eigenen Attribute verweisen kann (über self.whatever). Ebenso kann jeder andere Code einer Instanz diese Instanz verwenden, um auf die Attribute der Instanz zuzugreifen - dh instance.whatever.

3
Daniel Roseman