"TypeError: method() takes 1 positional argument but 2 were given" but I only passed one


If I have a class …

class MyClass:

    def method(arg):

… which I use to create an object …

my_object = MyClass()

… on which I call method("foo") like so …

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

… why does Python tell me I gave it two arguments, when I only gave one?

Asked By: Zero Piraeus



In Python, this:


… is syntactic sugar, which the interpreter translates behind the scenes into:

MyClass.method(my_object, "foo")

… which, as you can see, does indeed have two arguments – it’s just that the first one is implicit, from the point of view of the caller.

This is because most methods do some work with the object they’re called on, so there needs to be some way for that object to be referred to inside the method. By convention, this first argument is called self inside the method definition:

class MyNewClass:

    def method(self, arg):

If you call method("foo") on an instance of MyNewClass, it works as expected:

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

Occasionally (but not often), you really don’t care about the object that your method is bound to, and in that circumstance, you can decorate the method with the builtin staticmethod() function to say so:

class MyOtherClass:

    def method(arg):

… in which case you don’t need to add a self argument to the method definition, and it still works:

>>> my_other_object = MyOtherClass()
>>> my_other_object.method("foo")
Answered By: Zero Piraeus

Something else to consider when this type of error is encountered:

I was running into this error message and found this post helpful. Turns out in my case I had overridden an __init__() where there was object inheritance.

The inherited example is rather long, so I’ll skip to a more simple example that doesn’t use inheritance:

class MyBadInitClass:
    def ___init__(self, name):
        self.name = name

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

class MyNewClass:
    def new_foo(self, arg):

my_new_object = MyNewClass()
my_bad_init_object = MyBadInitClass(name="Test Name")
my_bad_init_object.name_foo("name foo")

Result is:

<__main__.MyNewClass object at 0x033C48D0>
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 didn’t catch this typo. Nor did Notepad++ (other editors/IDE’s might).

Granted, this is a “takes no parameters” TypeError, it isn’t much different than “got two” when expecting one, in terms of object initialization in Python.

Addressing the topic: An overloading initializer will be used if syntactically correct, but if not it will be ignored and the built-in used instead. The object won’t expect/handle this and the error is thrown.

In the case of the sytax error: The fix is simple, just edit the custom init statement:

def __init__(self, name):
    self.name = name
Answered By: Jonru

It occurs when you don’t specify the no of parameters the __init__() or any other method looking for.

For example:

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

When you run the above programme, it gives you an error like that:

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

How we can get rid of this thing?

Just pass the parameters, what __init__() method looking for

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")
Answered By: Trinadh Koya

In simple words

In Python you should add self as the first parameter to all defined methods in classes:

class MyClass:
  def method(self, arg):

Then you can use your method according to your intuition:

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

For a better understanding, you can also read the answers to this question: What is the purpose of self?

Answered By: simhumileco

This issue can also be caused by failing to pass keyword arguments to a function properly.

For example, given a method defined like:

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

a call like this:

self.create_properties_frame(frame, kw_gsp)

will cause TypeError: create_properties_frame() takes 2 positional arguments but 3 were given, because the kw_gsp dictionary is treated as a positional argument instead of being unpacked into separate keyword arguments.

The solution is to add ** to the argument:

self.create_properties_frame(frame, **kw_gsp)
Answered By: Stanislav Pankevich

You should actually create a class:

class accum:
    def __init__(self):
        self.acc = 0
    def accumulator(self, var2add, end):
        if not end:
        return self.acc
Answered By: Coddy

In my case, I forgot to add the ()

I was calling the method like this

obj = className.myMethod

But it should be is like this

obj = className.myMethod()
Answered By: Gabriel Arghire

As mentioned in other answers – when you use an instance method you need to pass self as the first argument – this is the source of the error.

With addition to that,it is important to understand that only instance methods take self as the first argument in order to refer to the instance.

In case the method is Static you don’t pass self, but a cls argument instead (or class_).

Please see an example below.

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
   def change_country(cls, new_country):
       cls.country = new_country

Some tests just to make things more clear:

# 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

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

I get this error when I’m sleep-deprived, and create a class using def instead of class:

def MyClass():
    def __init__(self, x):
        self.x = x

a = MyClass(3)
-> TypeError: MyClass() takes 0 positional arguments but 1 was given
Answered By: Simon Alford

If you want to call method without creating object, you can change method to static method.

class MyClass:

    def method(arg):

MyClass.method("i am a static method")
Answered By: Manikandan Raju

If you experience this with Django then this is what it implies:

  1. add an object to the function, Django will understand the rest, example
def display_genre(self, obj):
        return ', '.join(genre.name for genre in obj.genre.all())}

Answered By: King Chudi

You may also get the same error message if a function takes one positional argument and any additional variables as keyword arguments. To resolve the issue, pass the additional variables as keywords arguments.

An example that triggers the error:

def func(value, **kwargs):

func(1, 2)   # <--- TypeError: func() takes 1 positional argument but 2 were given

func(1, b=2) # <--- OK

Another more practical example: django’s authenticate() method can be used to verify credentials such as username and password but it takes them as keyword arguments (docs, source code), so the following scenario comes up:

from django.contrib.auth import authenticate
authenticate(username, password)                    # <--- TypeError
authenticate(username=username, password=password)  # <--- OK
Answered By: cottontail