En Python, j'essaye de lancer une méthode dans une classe et j'obtiens une erreur:
Traceback (most recent call last):
File "C:\Users\domenico\Desktop\py\main.py", line 8, in <module>
fibo.f()
TypeError: unbound method f() must be called with fibo instance
as first argument (got nothing instead)
Code: (swineflu.py)
class fibo:
a=0
b=0
def f(self,a=0):
print fibo.b+a
b=a;
return self(a+1)
Script main.py
import swineflu
f = swineflu
fibo = f.fibo
fibo.f() #TypeError is thrown here
Que signifie cette erreur? Qu'est ce qui cause cette erreur?
OK, tout d’abord, il n’est pas nécessaire d’obtenir une référence au module sous un nom différent; vous avez déjà une référence (à partir de la import
) et vous pouvez simplement l'utiliser. Si vous voulez un nom différent, utilisez simplement import swineflu as f
.
Deuxièmement, vous obtenez une référence à la classe plutôt que d'instancier la classe.
Donc, cela devrait être:
import swineflu
fibo = swineflu.fibo() # get an instance of the class
fibo.f() # call the method f of the instance
Une méthode bound est une méthode attachée à une instance d'un objet. Une méthode non liée est, bien sûr, une méthode qui est non / attachée à une instance. L'erreur signifie généralement que vous appelez la méthode sur la classe plutôt que sur une instance, ce qui est exactement ce qui s'est passé dans ce cas car vous n'aviez pas instancié la classe.
>>> class C:
... def f(self):
... print "hi"
...
>>> C.f()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unbound method f() must be called with C instance as
first argument (got nothing instead)
Il échoue à cause de TypeError car vous n'avez pas d'abord instancié la classe. Vous avez le choix entre 1: soit rendre la méthode statique pour pouvoir l'exécuter de manière statique, soit 2: instancier votre classe afin que vous ayez une instance à récupérer. sur, pour exécuter la méthode.
On dirait que vous voulez exécuter la méthode de manière statique, procédez comme suit:
>>> class C:
... @staticmethod
... def f():
... print "hi"
...
>>> C.f()
hi
Ou, ce que vous vouliez probablement dire, c'est utiliser l'instance instanciée comme ceci:
>>> class C:
... def f(self):
... print "hi"
...
>>> c1 = C()
>>> c1.f()
hi
>>> C().f()
hi
Si cela vous déroute, posez les questions suivantes:
fibo = f.fibo
fait référence à la classe elle-même. Vous vouliez probablement que fibo = f.fibo()
(notez les parenthèses) fasse de une instance de la classe, après quoi fibo.f()
devrait réussir correctement.
f.fibo.f()
échoue car vous appelez essentiellement f(self, a=0)
sans fournir self
; self
est "lié" automatiquement lorsque vous avez une instance de la classe.
f
est une méthode (instance). Cependant, vous l'appelez via fibo.f
, où fibo
est l'objet de classe. Par conséquent, f
est non lié (non lié à une instance de classe).
Si vous avez fait
a = fibo()
a.f()
alors que f
est lié (à l'instance a
).
En Python 2 (la syntaxe 3 est différente):
Et si vous ne pouvez pas instancier votre classe Parent avant d'avoir besoin d'appeler l'une de ses méthodes?
Utilisez super(ChildClass, self).method()
pour accéder aux méthodes parent.
class ParentClass(object):
def method_to_call(self, arg_1):
print arg_1
class ChildClass(ParentClass):
def do_thing(self):
super(ChildClass, self).method_to_call('my arg')
import swineflu
x = swineflu.fibo() # create an object `x` of class `fibo`, an instance of the class
x.f() # call the method `f()`, bound to `x`.
Ici est un bon tutoriel pour se familiariser avec les classes en Python.
Essaye ça. Pour Python 2.7.12, nous devons définir un constructeur ou nous ajouter à chaque méthode, puis définir une instance d'une classe appelée object.
import cv2
class calculator:
# def __init__(self):
def multiply(self, a, b):
x= a*b
print(x)
def subtract(self, a,b):
x = a-b
print(x)
def add(self, a,b):
x = a+b
print(x)
def div(self, a,b):
x = a/b
print(x)
calc = calculator()
calc.multiply(2,3)
calc.add(2,3)
calc.div(10,5)
calc.subtract(2,3)
Différences entre les versions In python 2 et 3:
Si vous avez déjà une méthode par défaut dans une classe portant le même nom et que vous déclarez de nouveau sous le même nom, elle apparaîtra comme un appel à une méthode non liée de cette instance de classe lorsque vous voudriez l'instancier.
Si vous vouliez des méthodes de classe, mais que vous les déclariez comme méthodes d'instance.
Une méthode d'instance est une méthode utilisée pour créer une instance de la classe.
Un exemple serait
def user_group(self): #This is an instance method
return "instance method returning group"
Méthode d'étiquette de classe:
@classmethod
def user_group(groups): #This is an class-label method
return "class method returning group"
Dans python 2 et 3, la classe @classmethod diffère pour écrire .__ en python 3, elle est automatiquement désignée comme méthode de classe et n'a pas besoin d'écrire @classmethod Je pense que cela pourrait vous aider.