TypeError: methode() prend 1 de position argument, mais 2 ont été donnés

Si j'ai une classe ...

class MyClass:

    def method(arg):
        print(arg)

... que j'utilise pour créer un objet ...

my_object = MyClass()

... sur lequel j'appelle method("foo") comme si ...

>>> my_object.method("foo")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: method() takes exactly 1 positional argument (2 given)

... pourquoi Python me dire, je lui ai donné deux arguments, quand j'ai seulement donné un?

InformationsquelleAutor Zero Piraeus | 2014-05-29

280

En Python, c':
```
my_object.method("foo")
```
... est sucre syntaxique, qui l'interprète traduit derrière les scènes dans:
```
MyClass.method(my_object, "foo")
```
... qui, comme vous pouvez le voir, n'ont, en effet, deux arguments - c'est juste que le premier est implicite, du point de vue de l'appelant.

C'est parce que la plupart des méthodes de travail avec l'objet qu'ils sont appelés, si il doit y avoir un moyen pour que cet objet puisse être appelé à l'intérieur de la méthode. Par convention, ce premier argument est appelé self à l'intérieur de la définition de la méthode:
```
class MyNewClass:

    def method(self, arg):
        print(self)
        print(arg)
```
Si vous appelez method("foo") sur une instance de MyNewClass, il fonctionne comme prévu:
```
>>> my_new_object = MyNewClass()
>>> my_new_object.method("foo")
<__main__.MyNewClass object at 0x29045d0>
foo
```
Parfois (mais pas souvent), vous avez vraiment ne pas de soins sur l'objet que votre méthode est liée à, et dans ce cas, vous pouvez décorer la méthode avec le groupe builtin staticmethod() fonction de le dire:
```
class MyOtherClass:

    @staticmethod
    def method(arg):
        print(arg)
```
... dans ce cas, vous n'avez pas besoin d'ajouter un self argument de la définition de la méthode, et il fonctionne toujours:
```
>>> my_other_object = MyOtherClass()
>>> my_other_object.method("foo")
foo
```
- En bref: l'Ajout de self comme premier argument de la méthode résout le problème.
InformationsquelleAutor Zero Piraeus
12

Autre chose à considérer lors de ce type d'erreur est rencontrée:

J'ai été en cours d'exécution dans ce message d'erreur et a trouvé ce message utile. S'avère que dans mon cas, j'avais remplacé un init() où il a été l'objet de l'héritage.

Hérité exemple, c'est assez long, je vais donc passer à un autre plus simple exemple de ne pas utiliser l'héritage:
```
class MyBadInitClass:
    def ___init__(self, name):
        self.name = name

    def name_foo(self, arg):
        print(self)
        print(arg)
        print("My name is", self.name)


class MyNewClass:
    def new_foo(self, arg):
        print(self)
        print(arg)


my_new_object = MyNewClass()
my_new_object.new_foo("NewFoo")
my_bad_init_object = MyBadInitClass(name="Test Name")
my_bad_init_object.name_foo("name foo")
```
Résultat est:
```
<__main__.MyNewClass object at 0x033C48D0>
NewFoo
Traceback (most recent call last):
  File "C:/Users/Orange/PycharmProjects/Chapter9/bad_init_example.py", line 41, in <module>
    my_bad_init_object = MyBadInitClass(name="Test Name")
TypeError: object() takes no parameters
```
PyCharm n'a pas attraper cette faute de frappe. Ni Notepad++ (d'autres éditeurs/IDE peut).

Accordé, c'est un "ne prend pas de paramètres" TypeError, il n'est pas beaucoup différent de "a deux" lorsque attend, dans les termes de l'initialisation de l'objet en Python.

Sur le thème: Une surcharge de l'initialiseur sera utilisé si la syntaxe est correcte, mais si non il sera ignoré et le haut-utilisé à la place. L'objet ne s'attendent/gérer le présent et l'erreur est levée.

Dans le cas de la sytax erreur: La solution est simple, il suffit de modifier la coutume instruction init:
```
def __init__(self, name):
    self.name = name
```
- Il n'y a pas SyntaxError ici. Le code est syntaxiquement correcte, il a juste correctement définit une méthode nommée ___init__, dont personne n'est jamais à l'appel, au lieu de la méthode spéciale __init__. C'est pourquoi aucune erreur n'est détectée—car il n'existe pas de détecter.
InformationsquelleAutor Jonru2016

Il se produit lorsque vous ne spécifiez pas le pas de paramètres, la __init__() ou de toute autre méthode de recherche.

Par exemple:

class Dog:
    def __init__(self):
        print("IN INIT METHOD")

    def __unicode__(self,):
        print("IN UNICODE METHOD")

    def __str__(self):
        print("IN STR METHOD")

obj=Dog("JIMMY",1,2,3,"WOOF")

Lorsque vous exécutez le programme ci-dessus, il vous donne une erreur comme ça:

TypeError: __init__() prend 1 de position argument mais 6 ont été donnés

La façon dont nous pouvons nous débarrasser de cette chose?

Vient de passer les paramètres, ce qui __init__() méthode de recherche de

class Dog:
    def __init__(self, dogname, dob_d, dob_m, dob_y, dogSpeakText):
        self.name_of_dog = dogname
        self.date_of_birth = dob_d
        self.month_of_birth = dob_m
        self.year_of_birth = dob_y
        self.sound_it_make = dogSpeakText

    def __unicode__(self, ):
        print("IN UNICODE METHOD")

    def __str__(self):
        print("IN STR METHOD")


obj = Dog("JIMMY", 1, 2, 3, "WOOF")
print(id(obj))

InformationsquelleAutor Trinadh Koya

3

Dans des mots simples.

En Python, vous devez ajouter self argument comme premier argument à toutes les méthodes définies dans les classes:
```
class MyClass:
  def method(self, arg):
    print(arg)
```
Ensuite, vous pouvez utiliser votre méthode de travail selon votre intuition:
```
>>> my_object = MyClass()
>>> my_object.method("foo")
foo
```
Cela devrait résoudre votre problème 🙂

Pour une meilleure compréhension, vous pouvez également lire les réponses à cette question: Quel est le but de l'auto?
- Quel est le problème avec cette réponse? Pourquoi quelqu'un lui donner un point négatif? Après tout, c'est la réponse à la question et se distingue par sa simplicité par rapport à d'autres réponses, ce qui peut être important pour certaines personnes qui sont à la recherche d'une réponse. N'est-ce pas?
InformationsquelleAutor simhumileco
3

De nouveaux arrivants de Python, j'ai eu ce problème quand j'utilise le Python ** fonctionnalité dans un mauvais sens. Essayez d'appeler cette définition de quelque part:
```
def create_properties_frame(self, parent, **kwargs):
```
l'aide d'un appel sans une étoile double est à l'origine du problème:
```
self.create_properties_frame(frame, kw_gsp)
```
TypeError: create_properties_frame() prend 2 arguments de position, mais 3 ont été donnés

La solution est d'ajouter ** à l'argument:
```
self.create_properties_frame(frame, **kw_gsp)
```
- À venir à partir de JavaScript, je m'attends à être en mesure de passer à une liste ou un dictionnaire comme un argument. Mais il semble que ce n'est pas la façon Python fonctionne: vous avez à se déstructurent la liste avec * ou***, le dernier étant un disponible de la liste d'arguments.
InformationsquelleAutor Stanislav Pankevich
-2

Passer cls paramètre dans @classmethod pour résoudre ce problème.
```
@classmethod
def test(cls):
    return ''
```
InformationsquelleAutor Ruan Nawe

Vous devez vous connecter pour publier un commentaire.