Wat is een “methode” in Python?

Kan iemand me alsjeblieft in heel eenvoudige bewoordingen uitleggen wat een “methode” is in Python?

Het punt is dat in veel Python-tutorials voor beginners dit woord zo wordt gebruikt alsof de beginner al wist wat een methode is in de context van Python. Hoewel ik natuurlijk bekend ben met de algemene betekenis van dit woord, heb ik geen idee wat deze term in Python betekent. Dus leg me alsjeblieft uit waar de “Pythoniaanse” methode over gaat.

Een aantal zeer eenvoudige voorbeeldcode zou zeer op prijs worden gesteld, aangezien een afbeelding meer zegt dan duizend woorden.


Antwoord 1, autoriteit 100%

Het is een functie die lid is van een klasse:

class C:
    def my_method(self):
        print("I am a C")
c = C()
c.my_method()  # Prints("I am a C")

Zo simpel is het!

(Er zijn ook een aantal alternatieve methoden, waarmee je de relatie tussen de klasse en de functie kunt bepalen. Maar ik vermoed uit je vraag dat je daar niet naar vraagt, maar alleen de basis.)


Antwoord 2, autoriteit 48%

Een methode is een functie die een klasse-instantie als eerste parameter neemt. Methoden zijn leden van klassen.

class C:
    def method(self, possibly, other, arguments):
        pass # do something here

Omdat je wilde weten wat het specifiek betekent in Python, kan men onderscheid maken tussen gebonden en ongebonden methoden. In Python zijn alle functies (en dus ook methoden) objecten die kunnen worden doorgegeven en waarmee kan worden “gespeeld”. Het verschil tussen ongebonden en gebonden methoden is dus:

1) Gebonden methoden

# Create an instance of C and call method()
instance = C()
print instance.method # prints '<bound method C.method of <__main__.C instance at 0x00FC50F8>>'
instance.method(1, 2, 3) # normal method call
f = instance.method
f(1, 2, 3) # method call without using the variable 'instance' explicitly

Gebonden methoden zijn methoden die bij instanties van een klasse horen. In dit voorbeeld is instance.methodgebonden aan de instantie met de naam instance. Telkens wanneer die gebonden methode wordt aangeroepen, wordt de instantie automatisch als eerste parameter doorgegeven – die volgens afspraak selfwordt genoemd.

2) Niet-gebonden methoden

print C.method # prints '<unbound method C.method>'
instance = C()
C.method(instance, 1, 2, 3) # this call is the same as...
f = C.method
f(instance, 1, 2, 3) # ..this one...
instance.method(1, 2, 3) # and the same as calling the bound method as you would usually do

Als je C.methodopent (de methode binnen een klasse in plaats van binnen een instantie), krijg je een ongebonden methode. Als je het wilt aanroepen, moet je de instantie als eerste parameter doorgeven omdat de methode nietaan een instantie is gebonden.

Als je dat verschil kent, kun je functies/methoden als objecten gebruiken, zoals het doorgeven van methoden. Als voorbeeld van een use-case, stel je een API voor waarmee je een callback-functie kunt definiëren, maar je wilt een methode als callback-functie bieden. Geen probleem, geef gewoon self.myCallbackMethoddoor als de callback en het wordt automatisch aangeroepen met de instantie als eerste argument. Dit zou niet mogelijk zijn in statische talen zoals C++ (of alleen met bedrog).

Ik hoop dat je het begrijpt 😉 Ik denk dat dit alles is wat je moet weten over de basisprincipes van methoden. Je zou ook meer kunnen lezen over de classmethoden staticmethoddecorateurs, maar dat is een ander onderwerp.


Antwoord 3, autoriteit 30%

In Python is een methodeeen functie die beschikbaar is voor een bepaald object vanwege het type object.

Als u bijvoorbeeld my_list = [1, 2, 3]maakt, kan de methode appendworden toegepast op my_listomdat het een Python-lijst: my_list.append(4). Alle lijsten hebben een append-methode, simpelweg omdat het lijsten zijn.

Als een ander voorbeeld, als u my_string = 'some lowercase text'maakt, kan de uppermethode worden toegepast op my_stringsimpelweg omdat het een Python-string: my_string.upper().

Lijsten hebben geen methode upperen strings hebben geen methode append. Waarom? Omdat methoden alleen bestaan voor een bepaald object als ze expliciet zijn gedefinieerd voor dat type object, en de ontwikkelaars van Python (tot nu toe) hebben besloten dat die specifieke methoden niet nodig zijn voor die specifieke objecten.

Om een methode aan te roepen, is het formaat object_name.method_name(), en eventuele argumenten voor de methode worden tussen haakjes vermeld. De methode werkt impliciet op het object dat een naam krijgt, en daarom hebben sommige methoden geen opgegeven argumenten omdat het object zelfhet enige noodzakelijke argument is. my_string.upper()heeft bijvoorbeeld geen vermelde argumenten omdat het enige vereiste argument het object zelf is, my_string.

Een veelvoorkomend punt van verwarring betreft het volgende:

import math
math.sqrt(81)

Is sqrteen methode van het mathobject? Nee.Zo roept u de functie sqrtaan vanuit de module math. Het gebruikte formaat is module_name.function_name(), in plaats van object_name.method_name(). Over het algemeen is de enige manier om onderscheid te maken tussen de twee formaten (visueel) door in de rest van de code te kijken en te kijken of het deel voor de punt(math, my_list, my_string) is gedefinieerd als een object of een module.


Antwoord 4, autoriteit 4%

Sorry, maar – naar mijn mening – heeft RichieHindle volkomen gelijk als hij zegt dat die methode…

Het is een functie die lid is van een klasse.

Hier is het voorbeeld van een functie die lid wordt van de klasse. Sindsdien gedraagt het zich als een methode van de klasse. Laten we beginnen met de klasse emptyen de normale functie met één argument:

>>> class C:
...     pass
...
>>> def func(self):
...     print 'func called'
...
>>> func('whatever')
func called

Nu voegen we een lid toe aan de klasse C, wat de verwijzing is naar de functie. Daarna kunnen we de instantie van de klasse maken en zijn methode aanroepen alsof deze in de klasse is gedefinieerd:

>>> C.func = func
>>> o = C()
>>> o.func()
func called

We kunnen ook de alternatieve manier gebruiken om de methode aan te roepen:

>>> C.func(o)
func called

De o.funcmanifesteert zich zelfs op dezelfde manier als de klassemethode:

>>> o.func
<bound method C.func of <__main__.C instance at 0x000000000229ACC8>>

en we kunnen de omgekeerde aanpak proberen. Laten we een klasse definiëren en zijn methode stelen als een functie:

>>> class A:
...     def func(self):
...         print 'aaa'
...
>>> a = A()
>>> a.func
<bound method A.func of <__main__.A instance at 0x000000000229AD08>>
>>> a.func()
aaa

Tot nu toe ziet het er hetzelfde uit. Nu de functie stelen:

>>> afunc = A.func
>>> afunc(a)
aaa    

De waarheid is dat de methode niet accepteert ‘wat’ ook ‘argument is:

>>> afunc('whatever')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unbound method func() must be called with A instance as first 
  argument (got str instance instead)

IMHO, dit is niet het argument tegen -methode is een functie die lid is van een klasse .

later gevonden de antwoord van Alex Martelli die in principe hetzelfde zegt. Sorry als je het durende duplicatie beschouwt 🙂


Antwoord 5

http://docs.python.org/2/tutorial/ Classes.html # Method-objecten

Meestal wordt een methode geredde meteen nadat het is gebonden:

x.f()

In het MyClass-voorbeeld zal dit de string ‘hallo wereld’ retourneren.
Het is echter niet nodig om meteen een methode aan te roepen: x.f is a
method-object en kan worden opgeslagen en op een later tijdstip worden aangeroepen. Voor
voorbeeld:

xf = x.f
while True:
    print xf()

zal hello world blijven afdrukken tot het einde der tijden.

Wat gebeurt er precies als een methode wordt aangeroepen? Het is je misschien opgevallen
dat x.f() werd aangeroepen zonder een argument hierboven, hoewel de
functiedefinitie voor f() specificeerde een argument. wat is er gebeurd met
het betoog? Python werpt toch een uitzondering op wanneer een functie die
vereist dat een argument wordt aangeroepen zonder enige — zelfs als het argument
wordt niet echt gebruikt…

Eigenlijk heb je het antwoord misschien al geraden: het bijzondere aan
methoden is dat het object wordt doorgegeven als het eerste argument van de
functie. In ons voorbeeld is de aanroep x.f() exact gelijk aan
MijnKlasse.f(x). Over het algemeen is het aanroepen van een methode met een lijst van n argumenten
is gelijk aan het aanroepen van de corresponderende functie met een argument
lijst die is gemaakt door het object van de methode in te voegen vóór de eerste
argument.

Als je nog steeds niet begrijpt hoe methoden werken, kijk dan eens naar de
uitvoering kan wellicht duidelijkheid verschaffen. Wanneer een instantiekenmerk
waarnaar wordt verwezen dat geen gegevensattribuut is, wordt de klasse ervan doorzocht. Indien
de naam geeft een geldig klasseattribuut aan dat een functieobject is, a
methode-object wordt gemaakt door (verwijzingen naar) het instantie-object in te pakken
en het functieobject dat zojuist samen in een abstract object is gevonden:
dit is het methode-object. Wanneer het methode-object wordt aangeroepen met een
argumentenlijst, een nieuwe argumentenlijst wordt geconstrueerd op basis van de instantie
object en de argumentenlijst, en het functieobject wordt aangeroepen met
deze nieuwe lijst met argumenten.


Antwoord 6

Als je denkt dat een object vergelijkbaar is met een zelfstandig naamwoord, dan is een methode vergelijkbaar met een werkwoord. Gebruik een methode direct na een object (d.w.z. een tekenreeks of een lijst) om de actie van een methode erop toe te passen.


Antwoord 7

Om methoden te begrijpen, moet u eerst denken in termen van objectgeoriënteerd programmeren:
Laten we een auto als klas nemen. Alle auto’s hebben dingen gemeen en dingen die ze uniek maken, alle auto’s hebben bijvoorbeeld 4 wielen, deuren, een stuur… 5.6s
Verder staat de auto momenteel bij mij thuis, de deuren zijn op slot, de kofferbak is leeg… Dat zijn allemaal eigenschappen van het exemplaar van my_toyota. your_honda is misschien onderweg, koffer vol boodschappen …

Er zijn echter dingen die u met de auto kunt doen. Je kunt ermee rijden, je kunt de deur openen, je kunt hem laden. Die dingen die je met een auto kunt doen, zijn methoden van de auto en ze veranderen de eigenschappen van het specifieke exemplaar.

als pseudo-code zou je doen:

my_toyota.drive(shop)

om de locatie van mijn huis naar de winkel te wijzigen of

my_toyota.load([milk, butter, bread]

Hierdoor is de koffer nu beladen met [melk, boter, brood].

Een dergelijke methode is dus praktisch een functie die als onderdeel van het object fungeert:

class Car(vehicle)
    n_wheels = 4
    load(self, stuff):
    '''this is a method, to load stuff into the trunk of the car'''
        self.open_trunk
        self.trunk.append(stuff)
        self.close_trunk

de code zou dan zijn:

my_toyota = Car(red)
my_shopping = [milk, butter, bread]
my_toyota.load(my_shopping)

Other episodes