“TypeError: method () toma 1 argumento posicional pero se dieron 2” pero solo pasé uno

Si tengo una clase…

class MyClass:

    def method(arg):
        print(arg)

… que uso para crear un objeto …

my_object = MyClass()

… en el que llamo method("foo") al igual que …

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

… ¿por qué Python me dice que le di dos argumentos, cuando solo le di uno?

En Python, esto:

my_object.method("foo")

… es azúcar sintácticaque la intérprete traduce tras bambalinas en:

MyClass.method(my_object, "foo")

… que, como puede ver, de hecho tiene dos argumentos: es solo que el primero está implícito, desde el punto de vista de la persona que llama.

Esto se debe a que la mayoría de los métodos funcionan con el objeto al que se llaman, por lo que debe haber alguna forma de hacer referencia a ese objeto dentro del método. Por convención, este primer argumento se llama self dentro de la definición del método:

class MyNewClass:

    def method(self, arg):
        print(self)
        print(arg)

si llamas method("foo") en una instancia de MyNewClassfunciona como se esperaba:

>>> my_new_object = MyNewClass()
>>> my_new_object.method("foo")
<__main__.MyNewClass object at 0x29045d0>
foo

De vez en cuando (pero no a menudo), realmente no preocuparse por el objeto al que está vinculado su método, y en esa circunstancia, puede Decorar el método con el incorporado staticmethod() función para decirlo:

class MyOtherClass:

    @staticmethod
    def method(arg):
        print(arg)

… en cuyo caso no es necesario agregar un self argumento a la definición del método, y todavía funciona:

>>> my_other_object = MyOtherClass()
>>> my_other_object.method("foo")
foo

En palabras simples

En Python debes agregar self como primer parámetro para todos los métodos definidos en las clases:

class MyClass:
  def method(self, arg):
    print(arg)

Entonces puedes usar tu método de acuerdo a tu intuición:

>>> my_object = MyClass()
>>> my_object.method("foo")
foo

Para una mejor comprensión, también puede leer las respuestas a esta pregunta: ¿Cuál es el propósito de uno mismo?

Algo más a considerar cuando se encuentra este tipo de error:

Me encontré con este mensaje de error y encontré útil esta publicación. Resulta que en mi caso había anulado un __init__() donde había herencia de objetos.

El ejemplo heredado es bastante largo, así que pasaré a un ejemplo más simple que no usa la herencia:

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")

El resultado es:

<__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 no detectó este error tipográfico. Notepad++ tampoco (otros editores/IDE podrían).

Por supuesto, este es un TypeError “no toma parámetros”, no es muy diferente de “obtuve dos” cuando esperaba uno, en términos de inicialización de objetos en Python.

Abordar el tema: se usará un inicializador de sobrecarga si es sintácticamente correcto, pero si no, se ignorará y se usará el integrado en su lugar. El objeto no espera/maneja esto y se lanza el error.

En el caso del error de sytax: la solución es simple, simplemente edite la declaración de inicio personalizada:

def __init__(self, name):
    self.name = name

Este problema también puede deberse a que no se pasan correctamente los argumentos de palabras clave a una función.

Por ejemplo, dado un método definido como:

def create_properties_frame(self, parent, **kwargs):

una llamada como esta:

self.create_properties_frame(frame, kw_gsp)

causará TypeError: create_properties_frame() takes 2 positional arguments but 3 were givenporque el kw_gsp el diccionario se trata como un argumento posicional en lugar de descomprimirse en argumentos de palabras clave separados.

La solución es agregar ** al argumento:

self.create_properties_frame(frame, **kw_gsp)

Como se menciona en otras respuestas, cuando usa un método de instancia, debe pasar self como primer argumento: esta es la fuente del error.

Además de eso, es importante entender que solo los métodos de instancia toman self como primer argumento para referirse a la instancia.

En caso de que el método sea Estático tu no pasas selfpero un cls argumento en su lugar (o class_).

Por favor, vea un ejemplo a continuación.

class City:

   country = "USA" # This is a class level attribute which will be shared across all instances  (and not created PER instance)

   def __init__(self, name, location, population):
       self.name       = name
       self.location   = location
       self.population = population
 
   # This is an instance method which takes self as the first argument to refer to the instance 
   def print_population(self, some_nice_sentence_prefix):
       print(some_nice_sentence_prefix +" In " +self.name + " lives " +self.population + " people!")

   # This is a static (class) method which is marked with the @classmethod attribute
   # All class methods must take a class argument as first param. The convention is to name is "cls" but class_ is also ok
   @classmethod
   def change_country(cls, new_country):
       cls.country = new_country

Algunas pruebas solo para dejar las cosas más claras:

# Populate objects
city1 = City("New York",    "East", "18,804,000")
city2 = City("Los Angeles", "West", "10,118,800")

#1) Use the instance method: No need to pass "self" - it is passed as the city1 instance
city1.print_population("Did You Know?") # Prints: Did You Know? In New York lives 18,804,000 people!

#2.A) Use the static method in the object
city2.change_country("Canada")

#2.B) Will be reflected in all objects
print("city1.country=",city1.country) # Prints Canada
print("city2.country=",city2.country) # Prints Canada

Ocurre cuando no especificas el número de parámetros que __init__() o cualquier otro método buscando.

Por ejemplo:

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")

Cuando ejecuta el programa anterior, le da un error como ese:

TypeError: __init__() takes 1 positional argument but 6 were given

¿Cómo podemos deshacernos de esta cosa?

Solo pasa los parametros, que __init__() método buscando

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))

Si desea llamar al método sin crear un objeto, puede cambiar el método a un método estático.

class MyClass:

    @staticmethod
    def method(arg):
        print(arg)

MyClass.method("i am a static method")