Skip to main content

How to Resolve Python Error "TypeError: descriptor 'append' for 'list' objects doesn't apply to a '...' object"

The TypeError: descriptor 'append' for 'list' objects doesn't apply to a '...' object (where '...' is often str, int, or another type) is a somewhat confusing error message in Python. It fundamentally occurs when you try to call an instance method, like .append(), directly on the class (list) itself, instead of on an instance of that class (an actual list object).

This guide explains the difference between classes and instances in this context and shows the correct way to use the append method.

Understanding the Error: Class vs. Instance Methods​

  • Class (list): This is the blueprint or type definition for lists. You can access class-level attributes or methods through it, but instance methods aren't typically called this way.
  • Instance (my_list = []): This is an actual object created from the class blueprint. It holds specific data (the elements of the list).
  • Instance Method (.append()): Methods like append, pop, sort, extend, etc., are designed to operate on a specific instance of a list. They implicitly receive the instance itself as their first argument (conventionally named self).

The error message "descriptor 'append' for 'list' objects doesn't apply to a 'str' object" arises because when you incorrectly call list.append('some_value'), Python tries to pass 'some_value' as the first argument (self) to the append method. Since append expects self to be a list instance, but it receives a string (or integer, etc.), a TypeError occurs because the method (descriptor) doesn't apply to the type provided as self.

The Cause: Calling append on the list Class​

The error happens when you use the syntax list.append(...) instead of my_actual_list.append(...).

# Error Scenario
try:
    # ⛔️ TypeError: descriptor 'append' for 'list' objects doesn't apply to a 'str' object
    # Calling append directly on the list *class*
    list.append("an item")
except TypeError as e:
    print(e)

try:
    # ⛔️ TypeError: descriptor 'append' for 'list' objects doesn't apply to a 'int' object
    list.append(123)
except TypeError as e:
    print(e)

You need an actual list object to append to.

The Solution: Call append on a List Instance​

You must first create an instance of a list and then call the .append() method on that specific instance.

Creating a List Instance ([] or list())​

There are two common ways to create an empty list instance:

  • List Literal [] (Recommended): This is the most common and generally preferred syntax. 
    my_list = []
    print(f"Created list using []: {my_list}, Type: {type(my_list)}")
  • list() Constructor: Calling the class constructor also creates an empty list. 
    another_list = list()
    print(f"Created list using list(): {another_list}, Type: {type(another_list)}")

Calling .append() Correctly​

Once you have a list instance, call .append() on that instance.

# ✅ Create a list instance first (using preferred literal)
shopping_list = []

# ✅ Call append() on the instance
shopping_list.append("apples")
shopping_list.append("bananas")
shopping_list.append("bread")

print(f"Shopping list: {shopping_list}")
# Output: Shopping list: ['apples', 'bananas', 'bread']

Example with list() constructor

number_list = list()
number_list.append(10)
number_list.append(20)
print(f"Number list: {number_list}")
# Output: Number list: [10, 20]

Understanding list.append() Behavior​

It's important to know how append works:

Modifies In-Place​

.append(item) adds item to the end of the existing list it's called on. It modifies the original list directly.

Returns None (Common Pitfall)​

.append() does not return the modified list or the added item; it always returns None. A common mistake is assigning the result of append to a variable, expecting the list.

my_list = ['a']

# Incorrect: Assigning the result of append()
result = my_list.append('b') # my_list becomes ['a', 'b']

print(f"Result of append: {result}")    # Output: None
print(f"Original list: {my_list}")      # Output: ['a', 'b']
note

Call append for its side effect (modifying the list), don't rely on its return value.

warning

Do not do this because it makes my_list = None:

my_list = []
my_list = my_list.append('c')

Alternative for Adding Multiple Items: list.extend()​

If you want to add all items from another iterable (like another list or tuple) to your list, use .extend() instead of .append(). .extend() also modifies the list in-place and returns None.

primary_colors = ["red", "yellow"]
secondary_colors = ["green", "orange", "purple"]

# ✅ Use extend() to add all items from secondary_colors
primary_colors.extend(secondary_colors)

print(f"Extended list: {primary_colors}")
# Output: Extended list: ['red', 'yellow', 'green', 'orange', 'purple']

Calling primary_colors.append(secondary_colors) would add the entire secondary_colors list as a single nested element.

Debugging the Error (type())​

When you encounter the "descriptor 'append'..." error:

  1. Look at the line where .append() is being called.
  2. Examine the object before the dot (.).
  3. If it's the literal word list, you know you're calling on the class.
  4. If it's a variable, print its type: print(type(variable_name)). If it's not <class 'list'>, there might be another issue (like accidental reassignment). However, this specific TypeError almost always points to calling on the class list itself.

Conclusion​

The TypeError: descriptor 'append' for 'list' objects doesn't apply to a '...' object occurs when you incorrectly attempt to call the .append() method (or other instance methods) directly on the list class type instead of on an actual list object (an instance).

The solution is fundamental:

  1. Create a list instance first (e.g., my_list = [] or my_list = list()).
  2. Call the .append() method on that specific instance: my_list.append(element).

Remember that append modifies the list in-place and returns None. Use extend to add multiple items from another iterable.

Table of Contents