How to Resolve Python "AttributeError: 'int' object has no attribute '...'"

The AttributeError: 'int' object has no attribute '...' (where ... is a method or property name like append, split, lower, etc.) is a frequent error in Python. It signals a fundamental type mismatch: you are trying to use a feature (an attribute or method) that belongs to a different data type (like a list, string, or custom object) on a variable that currently holds an integer (int).

This guide explains why this happens and how to fix it, covering common examples like append, split, and encode.

Understanding the Error: Type Mismatch

Python is dynamically typed, meaning a variable's type can change during program execution. However, operations you perform on a variable must be valid for its current type.

An AttributeError occurs when you try to access an attribute (a variable associated with an object) or call a method (a function associated with an object) that doesn't exist for that object's type.

Integers (int) in Python have specific attributes and methods (mostly related to numerical operations), but they do not have methods like append() (which belongs to lists) or split() (which belongs to strings).

Common Cause: Incorrect Variable Assignment

The most frequent reason for this error is that a variable you expect to hold a certain type (e.g., a list or str) has been accidentally reassigned to hold an int somewhere earlier in your code.

# Example: Expected a list, got an int
my_data = [10, 20, 30]
print(f"Initially: {my_data}, type: {type(my_data)}")
# Output: Initially: [10, 20, 30], type: <class 'list'>

# ... some code later ...

# ⚠️ Accidental reassignment!
my_data = len(my_data) # len() returns an integer (3 in this case)
print(f"After reassignment: {my_data}, type: {type(my_data)}")
# Output: After reassignment: 3, type: <class 'int'>

try:
    # ⛔️ AttributeError: 'int' object has no attribute 'append'
    my_data.append(40)
except AttributeError as e:
    print(e)

Another common cause is assigning the return value of a function that you thought returned one type (like a string) but actually returned an integer.

Debugging: Identifying the Type Mismatch

When you encounter this error, the first step is to confirm the type of the variable right before the line causing the error.

variable_causing_error = 123 # Example value

# ✅ Print the type just before the error line
print(f"Type of variable_causing_error: {type(variable_causing_error)}")
# Output: Type of variable_causing_error: <class 'int'>

try:
    # This line would cause the error, e.g.:
    variable_causing_error.some_method()
except AttributeError as e:
    print(f"Error: {e}")

Once you confirm it's an int, trace back through your code (or use a debugger) to find where that variable was assigned the integer value instead of the expected type.

General Solution: Fix Assignment or Convert Type

• Primary Solution: Fix the Assignment: The best approach is usually to find the incorrect assignment and fix it so the variable holds the correct type (e.g., list, string) when the method is called.
• Secondary Solution: Type Conversion: If the logic requires you to work with the number but use a method from another type, you might explicitly convert the int just before calling the method. This is common when needing string methods on numbers.

  number = 12345
  
  # ✅ Convert int to string to use a string method
  if str(number).startswith('123'):
      print("Number starts with '123'")
  # Output: Number starts with '123'
  However, this only works if the operation makes sense after conversion (e.g., you can't meaningfully append to a converted number).

Specific Examples and Solutions

AttributeError: 'int' object has no attribute 'append' (List Method)

This error means you called .append() on an integer. append() is exclusively a list method used to add items to the end of a list.

• Error Cause: The variable is an int, not a list.

  my_list = [1, 2]
  # ...
  my_list = 5 # ⚠️ Incorrect assignment
  # ...
  try:
      # ⛔️ AttributeError: 'int' object has no attribute 'append'
      my_list.append(3)
  except AttributeError as e:
      print(e)
  
  # Another common mistake: appending to an integer *element* of a list
  number_list = [10, 20, 30]
  try:
      # ⛔️ number_list[0] is 10 (an int), ints don't have .append()
      number_list[0].append(5)
  except AttributeError as e:
      print(e) # Output: 'int' object has no attribute 'append'
• Solution: Ensure the variable is a list when .append() is called. Fix any incorrect assignments or logic errors.

  my_list = [1, 2]
  # ... (Ensure my_list remains a list) ...
  # ✅ Correct: append to the list itself
  my_list.append(3)
  print(my_list) # Output: [1, 2, 3]
  
  number_list = [10, 20, 30]
  # ✅ Correct: append to the list itself, not an element
  number_list.append(5)
  print(number_list) # Output: [10, 20, 30, 5]

AttributeError: 'int' object has no attribute 'split' (String Method)

This error occurs when you call .split() on an integer. split() is a str method used to break a string into a list of substrings.

• Error Cause: The variable is an int, not a str.

  user_input = "item1,item2"
  # ...
  user_input = 100 # ⚠️ Incorrect assignment (e.g., from a function return)
  # ...
  try:
      # ⛔️ AttributeError: 'int' object has no attribute 'split'
      items = user_input.split(',')
      print(items)
  except AttributeError as e:
      print(e)
• Solution: Ensure the variable holds a str before calling .split(). Fix incorrect assignments or convert the int to str if appropriate.

  user_input = "item1,item2"
  # ... (Ensure user_input remains a string) ...
  # ✅ Correct: split the string
  items = user_input.split(',')
  print(items) # Output: ['item1', 'item2']
  
  # ✅ Workaround: Convert int to string if needed before split
  number_as_int = 12345
  number_as_str = str(number_as_int)
  parts = number_as_str.split('3') # Splitting the string representation
  print(parts) # Output: ['12', '45']

AttributeError: 'int' object has no attribute 'encode' (String Method)

This error happens when you call .encode() on an integer. encode() is a str method used to convert a string into a bytes object using a specified encoding (like UTF-8).

• Error Cause: The variable is an int, not a str.

  message = "Data"
  # ...
  message = 404 # ⚠️ Incorrect assignment
  # ...
  try:
      # ⛔️ AttributeError: 'int' object has no attribute 'encode'
      encoded_message = message.encode('utf-8')
      print(encoded_message)
  except AttributeError as e:
      print(e)
• Solution: Ensure the variable is a str. Fix assignments or convert the int to str before encoding if you intend to encode the number's string representation.

  message = "Data"
  # ... (Ensure message remains a string) ...
  # ✅ Correct: encode the string
  encoded_message = message.encode('utf-8')
  print(encoded_message) # Output: b'Data'
  
  # ✅ Convert int to string first if you need bytes representation of the number string
  status_code = 404
  encoded_status = str(status_code).encode('utf-8')
  print(encoded_status) # Output: b'404'

Other Common Methods (e.g., isdigit, startswith, lower)

The same principle applies to any method specific to strings (isdigit, startswith, endswith, lower, upper, strip, etc.) or other types. If you call them on an int, you'll get the AttributeError.

• Error Cause: Calling a string-specific method on an int.

  value = 123
  try:
      # ⛔️ AttributeError: 'int' object has no attribute 'isdigit'
      is_digit = value.isdigit()
  except AttributeError as e:
      print(e)
• Solution: Convert to str before calling the method, or ensure the variable holds a str in the first place.

  value = 123
  # ✅ Convert to string first
  is_digit = str(value).isdigit()
  print(is_digit) # Output: True

Using hasattr() for Defensive Programming

While fixing the root cause is best, you can sometimes use the built-in hasattr() function to check if an object has a specific attribute/method before attempting to access it. This can prevent the error but might hide the underlying logic flaw.

variable = 123 # Could be an int or something else

if hasattr(variable, 'append'):
    # This block only runs if variable has an 'append' method (i.e., likely a list)
    variable.append(4)
    print("Appended successfully")
elif hasattr(variable, 'lower'):
    # This block only runs if variable has a 'lower' method (i.e., likely a string)
    print(f"String in lower case: {variable.lower()}")
else:
    # Handle the case where the variable is neither (or doesn't have the checked methods)
    print(f"Variable is of type {type(variable)} and doesn't have expected methods.")
    # Output: Variable is of type <class 'int'> and doesn't have expected methods.

Using dir() to Inspect Available Attributes

To see exactly which attributes and methods are available for an object (like an integer), you can use the dir() function. This is useful for debugging and understanding what operations are valid.

number = 10

# Print attributes/methods available for an integer
print(dir(number))

Output includes things like (notice the absence of 'append', 'split', 'encode', etc.):

['__abs__', '__add__', ..., 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']

Conclusion

The AttributeError: 'int' object has no attribute '...' in Python is a clear sign that you're trying to perform an operation on an integer that isn't valid for its type.

The most reliable solution is to:

1. Use print(type(variable)) to confirm the type just before the error occurs.
2. Trace back and fix the code where the variable was incorrectly assigned an integer value.
3. Alternatively, if logically necessary, explicitly convert the integer to the required type (e.g., str()) immediately before calling the method.

By understanding the type requirements of different methods, you can effectively debug and prevent these common errors.