Typeerror object of type nonetype has no len ошибка

This error occurs when you pass a None value to a len() function call. NoneType objects are returned by functions that do not return anything and do not have a length.

You can solve the error by only passing iterable objects to the len() function. Also, ensure that you do not assign the output from a function that works in-place like sort() to the variable name for an iterable object, as this will override the original object with a None value

In this tutorial, we will explore the causes of this error with code examples, and you will learn how to solve the error in your code.

TypeError: object of type ‘NoneType’ has no len()

We raise a Python TypeError when attempting to perform an illegal operation for a specific type. In this case, the type is NoneType.

The part ‘has no len()‘ tells us the map object does not have a length, and therefore len() is an illegal operation for the NoneType object.

Retrieving the length of an object is only suitable for iterable objects, like a list or a tuple.

The len() method implicitly calls the dunder method __len__() which returns a positive integer representing the length of the object on which it is called. All iterable objects have __len__ as an attribute. Let’s check if __len__ is in the list of attributes for an NoneType object and a list object using the built-in dir() method.

def hello_world():
    print('Hello World')

print(type(hello_world())
print('__len__' in dir(hello_world())

Hello World
<class 'NoneType'>
Hello World
False

We can see that __len__ is not present in the attributes of the NoneType object.

lst = ["football", "rugby", "tennis"]

print(type(lst))

print('__len__' in dir(lst))

<class 'list'>
True

We can see that __len__ is present in the attributes of the list object.

Example #1: Reassigning a List with a Built-in Function

Let’s write a program that sorts a list of dictionaries of fundamental particles. We will sort the list in ascending order of the particle mass. The list will look as follows:

particles = [
    
{"name":"electron", "mass": 0.511},
    {"name":"muon", "mass": 105.66},
    {"name":"tau", "mass": 1776.86},
    {"name":"charm", "mass":1200},
    {"name":"strange", "mass":120}
 ]

Each dictionary contains two keys and values, and one key corresponds to the particle’s name, and the other corresponds to the mass of the particle in MeV. The next step involves using the sort() method to sort the list of particles by their masses.

def particle_sort(p):
     
    return p["mass"]
sorted_particles = particles.sort(key=particle_sort)

The particle_sort function returns the value of “mass” in each dictionary. We use the mass values as the key to sorting the list of dictionaries using the sort() method. Let’s try and print the contents of the original particles list with a for loop:

for p in particles:

    print("{} has a mass of {} MeV".format(p["name"], p["mass"]))

electron has a mass of 0.511 MeV

muon has a mass of 105.66 MeV

strange has a mass of 120 MeV

charm has a mass of 1200 MeV

tau has a mass of 1776.86 MeV

Let’s see what happens when we try to print the length of sorted_particles:

print("There are {} particles in the list".format(len(sorted_particles)))

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-57-9b5c6f8e88b6> in <module>
----> 1 print("There are {} particles in the list".format(len(sorted_particles)))
TypeError: object of type 'NoneType' has no len()

Let’s try and print sorted_particles

print(sorted_particles)

None

Solution

To solve this error, we do not assign the result of the sort() method to sorted_particles. If we assign the sort result, it will change the list in place; it will not create a new list. Let’s see what happens if we remove the declaration of sorted_particles and use particles, and then print the ordered list.

particles.sort(key=particle_sort)
print("There are {} particles in the list".format(len(particles)))
for p in particles:
    print("{} has a mass of {} MeV.".format(p["name"],p["mass"]))

There are 5 particles in the list
electron has a mass of 0.511 MeV.
muon has a mass of 105.66 MeV.
strange has a mass of 120 MeV.
charm has a mass of 1200 MeV.
tau has a mass of 1776.86 MeV.

The code now works. We see that the program prints out the number of particles in the list and the order of the particles by ascending mass in MeV.

Example #2: Not Including a Return Statement

We can put the sorting steps in the previous example in its function. We can use the same particle list and sorting function as follows:

particles = [
 {"name":"electron", "mass": 0.511},
 {"name":"muon", "mass": 105.66},
 {"name":"tau", "mass": 1776.86},
 {"name":"charm", "mass":1200},
 {"name":"strange", "mass":120}
]
def particle_sort(p):
    return p["mass"]

The next step involves writing a function that sorts the list using the “mass” as the sorting key.

def sort_particles_list(particles):
    particles.sort(key=particle_sort)

Then we can define a function that prints out the number of particles in the list and the ordered particles by ascending mass:

def show_particles(sorted_particles):
    print("There are {} particles in the list.".format(len(sorted_particles)))
    for p in sorted_particles:
    
        print("{} has a mass of {} MeV.".format(p["name"],p["mass"]))

Our program needs to call the sort_particles_list() function and the show_particles() function.

sorted_particles = sort_particles_list(particles)
show_particles(sorted_particles)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-64-65566998d04a> in <module>
----> 1 show_particles(sorted_particles)
<ipython-input-62-6730bb50a05a> in show_particles(sorted_particles)
      1 def show_particles(sorted_particles):
----> 2     print("There are {} particles in the list.".format(len(sorted_particles)))
      3     for p in sorted_particles:
      4         print("{} has a mass of {} MeV.".format(p["name"],p["mass"]))
      5 
TypeError: object of type 'NoneType' has no len()

The error occurs because we did not include a return statement in the sort_particles_list() function. We assign the sort_particles_list() output to the variable sorted_particles, then pass the variable to show_particles() to get the information inside the list.

Solution

We need to add a return statement to the sort_particles_list() function to solve the error.

def sort_particles_list(particles):
    particles.sort(key=particle_sort)
    return particles
sorted_particles = sort_particles_list(particles)
show_particles(sorted_particles)

There are 5 particles in the list.
electron has a mass of 0.511 MeV.
muon has a mass of 105.66 MeV.
strange has a mass of 120 MeV.
charm has a mass of 1200 MeV.
tau has a mass of 1776.86 MeV.

Summary

Congratulations on reading to the end of this tutorial!

For further reading on the len() method, go to the article: How to Find the Length of a List in Python.

For further reading on the has no len() TypeErrors, go to the article:

How to Solve Python TypeError: object of type ‘function’ has no len()

To learn more about Python for data science and machine learning, go to the online courses page on Python, which provides the best, easy-to-use online courses.

The len() method only works on iterable objects such as strings, lists, and dictionaries. This is because iterable objects contain sequences of values. If you try to use the len() method on a None value, you’ll encounter the error “TypeError: object of type ‘NoneType’ has no len()”.

In this guide, we talk about what this error means and how it works. We walk through two examples of this error in action so you can figure out how to solve it in your code.

TypeError: object of type ‘NoneType’ has no len()

NoneType refers to the None data type. You cannot use methods that would work on iterable objects, such as len(), on a None value. This is because None does not contain a collection of values. The length of None cannot be calculated because None has no child values.

This error is common in two cases:

• Where you forget that built-in functions change a list in-place
• Where you forget a return statement in a function

Let’s take a look at each of these causes in depth.

Cause #1: Built-In Functions Change Lists In-Place

We’re going to build a program that sorts a list of dictionaries containing information about students at a school. We’ll sort this list in ascending order of a student’s grade on their last test.

To start, define a list of dictionaries that contains information about students and their most recent test score:

students = [
	{"name": "Peter", "score": 76 },
	{"name": "Richard", "score": 63 },
{"name": "Erin", "score": 64 },
{"name": "Miley", "score": 89 }
]

Each dictionary contains two keys and values. One corresponds with the name of a student and the other corresponds with the score a student earned on their last test. Next, use the sort() method to sort our list of students:

def score_sort(s):
	return s["score"]



sorted_students = students.sort(key=score_sort)

We have declared a function called “score_sort” which returns the value of “score” in each dictionary. We then use this to order the items in our list of dictionaries using the sort() method.

Next, we print out the length of our list:

print("There are {} students in the list.".format(len(sorted_students)))

We print out the new list of dictionaries to the console using a for loop:

for s in sorted_students:
	print("{} earned a score of {} on their last test.".format(s["name"], s["score"]))

This code prints out a message informing us of how many marks a student earned on their last test for each student in the “sorted_students” list. Let’s run our code:

Traceback (most recent call last):
  File "main.py", line 13, in <module>
	print("There are {} students in the list.".format(len(sorted_students)))
TypeError: object of type 'NoneType' has no len()

Our code returns an error.

To solve this problem, we need to remove the code where we assign the result of the sort() method to “sorted_students”. This is because the sort() method changes a list in place. It does not create a new list.

Remove the declaration of the “sorted_students” list and use “students” in the rest of our program:

students.sort(key=score_sort)

print("There are {} students in the list.".format(len(students)))

for s in students:
	print("{} earned a score of {} on their last test.".format(s["name"], s["score"]))

Run our code and see what happens:

There are 4 students in the list.
Richard earned a score of 63 on their last test.
Erin earned a score of 64 on their last test.
Peter earned a score of 76 on their last test.
Miley earned a score of 89 on their last test.

Our code executes successfully. First, our code tells us how many students are in our list. Our code then prints out information about each student and how many marks they earned on their last test. This information is printed out in ascending order of a student’s grade.

Cause #2: Forgetting a Return Statement

We’re going to make our code more modular. To do this, we move our sorting method into its own function. We’ll also define a function that prints out information about what score each student earned on their test.

Start by defining our list of students and our sorting helper function. We’ll borrow this code from earlier in the tutorial.

students = [
	{"name": "Peter", "score": 76 },
	{"name": "Richard", "score": 63 },
{"name": "Erin", "score": 64 },
{"name": "Miley", "score": 89 }
]

def score_sort(s):
	return s["score"]

Next, write a function that sorts our list:

def sort_list(students):
	students.sort(key=score_sort)

Finally, we define a function that displays information about each students’ performance:

def show_students(new_students):
	print("There are {} students in the list.".format(len(students)))
	for s in new_students:
			 print("{} earned a score of {} on their last test.".format(s["name"], s["score"]))

Before we run our code, we have to call our functions:

new_students = sort_list(students)
show_students(new_students)

Our program will first sort our list using the sort_list() function. Then, our program will print out information about each student to the console. This is handled in the show_students() function.

Let’s run our code:

Traceback (most recent call last):
  File "main.py", line 21, in <module>
	show_students(new_students)
  File "main.py", line 15, in show_students
	print("There are {} students in the list.".format(len(new_students)))
TypeError: object of type 'NoneType' has no len()

Our code returns an error. This error has occured because we have forgotten to include a “return” statement in our “sort_list” function.

When we call our sort_list() function, we assign its response to the variable “new_students”. That variable is passed into our show_students() function that displays information about each student. To solve this error, we must add a return statement to the sort_list() function:

def sort_list(students):
	students.sort(key=score_sort)
	return students

Run our code:

There are 4 students in the list.
Richard earned a score of 63 on their last test.
Erin earned a score of 64 on their last test.
Peter earned a score of 76 on their last test.
Miley earned a score of 89 on their last test.

Our code returns the response we expected.

Conclusion

The “TypeError: object of type ‘NoneType’ has no len()” error is caused when you try to use the len() method on an object whose value is None.

To solve this error, make sure that you are not assigning the responses of any built-in list methods, like sort(), to a variable. If this does not solve the error, make sure your program has all the “return” statements it needs to function successfully.

Now you’re ready to solve this problem like a Python professional!

None object in Python has a data type which is referred to as “NoneType”. The None value is not equal to “0” it is equal to None/Null because it has a specific memory size in Python. The len() function in Python is utilized to get the length of any input variable other than None. If None is passed inside the len() function, it will return a “TypeError ”. To resolve this error, various functions are used in  Python.

This write-up will provide various reasons and solutions for “TypeError: object of type NoneType has no len()” in Python. The following aspects will be discussed in this guide:

• Reason 1: Assigning None Value to len() Function
• Solution 1: Change the None Value
• Solution 2: Using an if-else Statement
• Reason 2: Function Returns None
• Solution: Use return Statement
• Reason 3: Function returns None if Condition Not Satisfied
• Solution: Initialize Empty List Inside the Function
• Reason 4: sort() Method Return None
• Solution: Find Length of the Original List Instead of the Sort List

So, let’s get started!

Reason 1: Assigning None Value to len() Function

One of the prominent reasons that invokes the “object of type NoneType has no len()” error is when the “None” value is assigned to the len() function in Python. An example snippet that shows the stated error is given below:

students = [
	{"name": "Peter", "score": 76 },
	{"name": "Richard", "score": 63 },
{"name": "Erin", "score": 64 },
{"name": "Miley", "score": 89 }
]

def score_sort(s):
	return s["score"]



sorted_students = students.sort(key=score_sort)

print("There are {} students in the list.".format(len(sorted_students)))

for s in sorted_students:
	print("{} earned a score of {} on their last test.".format(s["name"], s["score"]))

Traceback (most recent call last):
  File "main.py", line 13, in <module>
	print("There are {} students in the list.".format(len(sorted_students)))
TypeError: object of type 'NoneType' has no len()

students.sort(key=score_sort)

print("There are {} students in the list.".format(len(students)))

for s in students:
	print("{} earned a score of {} on their last test.".format(s["name"], s["score"]))

There are 4 students in the list.
Richard earned a score of 63 on their last test.
Erin earned a score of 64 on their last test.
Peter earned a score of 76 on their last test.
Miley earned a score of 89 on their last test.

students = [
	{"name": "Peter", "score": 76 },
	{"name": "Richard", "score": 63 },
{"name": "Erin", "score": 64 },
{"name": "Miley", "score": 89 }
]

def score_sort(s):
	return s["score"]

def sort_list(students):
	students.sort(key=score_sort)

def show_students(new_students):
	print("There are {} students in the list.".format(len(students)))
	for s in new_students:
			 print("{} earned a score of {} on their last test.".format(s["name"], s["score"]))

new_students = sort_list(students)
show_students(new_students)

Traceback (most recent call last):
  File "main.py", line 21, in <module>
	show_students(new_students)
  File "main.py", line 15, in show_students
	print("There are {} students in the list.".format(len(new_students)))
TypeError: object of type 'NoneType' has no len()

def sort_list(students):
	students.sort(key=score_sort)
	return students

«Career Karma entered my life when I needed it most and quickly helped me match with a bootcamp. Two months after graduating, I found my dream job that aligned with my values and goals in life!»

Venus, Software Engineer at Rockbot

There are 4 students in the list.
Richard earned a score of 63 on their last test.
Erin earned a score of 64 on their last test.
Peter earned a score of 76 on their last test.
Miley earned a score of 89 on their last test.