List indices must be integers or slices not str python ошибка

◈ Overview

Aim: How to fix – TypeError: list indices must be integers or slices, not str in Python?

Example: Take a look at the following code which generates the error mentioned above.

Output:

Traceback (most recent call last):
File “D:/PycharmProjects/pythonProject1/error.py”, line 3, in
print(‘Second Subject: ‘, list1[index])
TypeError: list indices must be integers or slices, not str

Reason:

We encountered the TypeError because we tried to access the index of the list using a string which is not possible!

Before proceeding further let’s have a quick look at the solution to the above error.

Solution:

You should use an integer to access an element using its index.

But this brings us to a number of questions. Let’s have a look at them one by one.

◈ What Is TypeError in Python?

A TypeError is generally raised when a certain operation is applied to an object of an incorrect type.

Example:

Output:

TypeError: can only concatenate str (not “int”) to str

In the above code, we tried to add a string object and an integer object using the + operator. This is not allowed; hence we encountered a TypeError.

There can be numerous reasons that lead to the occurrence of TypeError. Some of these reasons are:

• Trying to perform an unsupported operation between two types of objects.
• Trying to call a non-callable caller.
• Trying to iterate over a non-iterative identifier.

Python raises TypeError: List Indices Must Be Integers Or Slices, Not 'Str' whenever you try to access a value or an index of a list using a string.

Let us have a look at another complex example where you might encounter this kind of TypeError.

◈ Example: Trying To Access A Value Of A List of Dictionaries Using A String

Problem: Given a list of dictionaries; Each dictionary within the list contains the name of an athlete and the sports he is associated with. You have to help the user with the sports when the user enters the athletes name.

Your Code:

Output:

Traceback (most recent call last):
File “D:/PycharmProjects/pythonProject1/TypeError part2.py”, line 25, in
if search.lower() in athletes[‘Name’].lower():
TypeError: list indices must be integers or slices, not str

Explanation: The above error occurred because you tried to access Name using the key. The entire data-structure in this example is a list that contains dictionaries and you cannot access the value within a particular dictionary of the list using it’s key.

✨ Solution 1: Accessing Index Using range() + len()

To avoid TypeError: list indices must be integers or slices, not str in the above example you must first access the dictionary using it’s index within the list that contains the search value and then access the value using its key.

Output:

Explanation:

• Instead of directly iterating over the list, you should iterate through each dictionary one by one within the list using the len() and range() methods.
• You can access a particular value from a particular dictionary dictionary using the following syntax:
  • list_name[index_of_dictionary]['Key_within_dictionary']
  • example:- athletes[n]['name']

✨ Solution 2: Accessing Index Using enumerate()

You can access the index of a dictionary within the list using Python’s built-in enumerate method as shown below.

Output:

✨ Solution 3: Python One-Liner

Though this might not be the simplest of solutions or even the most Python way of resolving the issue but it deserves to be mentioned because it’s a great trick to derive your solution in a single line of code.

Solutions:

◈ A Simple Example

In case you were intimidated by the above example, here’s another example for you that should make things crystal clear.

Problem: You have a list containing names, and you have to print each name with its index.

Your Code:

Output:

✨ Solution:

In the above code the variable i represents an item inside the list and not an index. Therefore, when you try to use it as an index within the for loop it leads to a TypeError: list indices must be integers or slices, not str.

To avoid this error, you can either use the enumerate() function or the len() method along with the range() method as shown in the solution below.

Output:

Conclusion

We have come to the end of this comprehensive guide to resolve TypeError: List Indices Must Be Integers Or Slices, Not 'Str'. I hope this article helped clear all your doubts regarding TypeError: list indices must be integers or slices, not str and you can resolve them with ease in the future.

Please stay tuned and subscribe for more exciting articles. Happy learning! 📚

If you are accessing the elements of a list in Python, you need to access it using its index position or slices. However, if you try to access a list value using a string instead of integer to access a specific index Python will raise TypeError: list indices must be integers or slices, not str exception.

We can resolve the error by converting the string to an integer or if it is dictionary we can access the value using the format list_name[index_of_dictionary]['key_within_dictionary']

In this tutorial, we will learn what “list indices must be integers or slices, not str” error means and how to resolve this TypeError in your program with examples.

Lists are always indexed using a valid index number, or we can use slicing to get the elements of the list. Below is an example of indexing a list.

# Example 1: of list indexing
my_list = [1, 2, 3, 4, 5, 6, 7, 8]
print(my_list[5])

# Example 2: of list slicing
fruits = ["Apple", "Orange", "Lemon", "Grapes"]
print("Last 2 fruits is", fruits[2:4])

Output

6
Last 2 fruits is ['Lemon', 'Grapes']

The first example is we use an integer as an index to get the specific element of a list.

In the second example, we use a Python slicing technique by defining a start point and end-point to retrieve the sublist from the main list.

Now that we know how to access the elements of the list, there are several scenarios where developers tend to make mistakes, and we get a TypeError. Let us take a look at each scenario with examples.

Scenario 1: Reading string input from a user

It’s the most common scenario where we do not convert the input data into a valid type in Menu-driven programs, leading to TypeError. Let us take an example to reproduce this issue.

Consider an ATM menu-driven example where the user wants to perform certain operations by providing the input to the program.

menu = ["Deposit Cash", "Withdraw Case", "Check Balance", "Exit"]
choice = input(
    'Choose what would you like to perform (Valid inputs 0, 1, 2, 3)')
print(menu[choice])

Output

Choose what would you like to perform (Valid inputs 0, 1, 2, 3)2
Traceback (most recent call last):
  File "C:PersonalIJSCodemain.py", line 13, in <module>
    print(menu[choice])
TypeError: list indices must be integers or slices, not str

When the user inputs any number from 0 to 3, we get TypeError: list indices must be integers or slices, not str, because we are not converting the input variable “choice” into an integer, and the list is indexed using a string.

We can resolve the TypeError by converting the user input to an integer, and we can do this by wrapping the int() method to the input, as shown below.

menu = ["Deposit Cash", "Withdraw Case", "Check Balance", "Exit"]
choice = int(input(
    'Choose what would you like to perform (Valid inputs 0, 1, 2, 3) - ' ))
print(menu[choice])

Output

Choose what would you like to perform (Valid inputs 0, 1, 2, 3) - 2
Check Balance

Scenario 2: Trying to access Dictionaries list elements using a string

Another reason we get TypeError while accessing the list elements is if we treat the lists as dictionaries. 

In the below example, we have a list of dictionaries, and each list contains the actor and name of a movie.

actors = [
    {
        'name': "Will Smith",
        'movie': "Pursuit of Happiness"
    },

    {
        'name': "Brad Pitt",
        'movie': "Ocean's 11"
    },
    {
        'name': "Tom Hanks",
        'movie': "Terminal"
    },
    {
        'name': "Leonardo DiCaprio",
        'movie': "Titanic"
    },
    {
        'name': "Robert Downey Jr",
        'movie': "Iron Man"
    },
]

actor_name = input('Enter the actor name to find a movie -   ')
for i in range(len(actors)):
    if actor_name.lower() in actors['name'].lower():
        print('Actor Name: ', actors['name'])
        print('Movie: ', actors['movie'])
        break
else:
    print('Please choose a valid actor')

Output

Enter the actor name to find a movie -   Brad Pitt
Traceback (most recent call last):
  File "C:PersonalIJSCodeprogram.py", line 27, in <module>
    if actor_name.lower() in actors['name'].lower():
TypeError: list indices must be integers or slices, not str

We need to display the movie name when the user inputs the actor name.

When we run the program, we get TypeError: list indices must be integers or slices, not str because we are directly accessing the dictionary items using the key, but the dictionary is present inside a list. 

If we have to access the particular value from the dictionary, it can be done using the following syntax.

list_name[index_of_dictionary]['key_within_dictionary']

We can resolve this issue by properly iterating the dictionaries inside the list using range() and len() methods and accessing the dictionary value using a proper index and key, as shown below.

actors = [
    {
        'name': "Will Smith",
        'movie': "Pursuit of Happiness"
    },

    {
        'name': "Brad Pitt",
        'movie': "Ocean's 11"
    },
    {
        'name': "Tom Hanks",
        'movie': "Terminal"
    },
    {
        'name': "Leonardo DiCaprio",
        'movie': "Titanic"
    },
    {
        'name': "Robert Downey Jr",
        'movie': "Iron Man"
    },
]

actor_name = input('Enter the actor name to find a movie -   ')
for i in range(len(actors)):
    if actor_name.lower() in actors[i]['name'].lower():
        print('Actor Name: ', actors[i]['name'])
        print('Movie: ', actors[i]['movie'])
        break
else:
    print('Please choose a valid actor')

Output

Enter the actor name to find a movie -   Brad Pitt
Actor Name:  Brad Pitt
Movie:  Ocean's 11

Conclusion

The TypeError: list indices must be integers or slices, not str occurs when we try to index the list elements using string. The list elements can be accessed using the index number (valid integer), and if it is a dictionary inside a list, we can access using the syntax list_name[index_of_dictionary]['key_within_dictionary']

List indexing is a valuable tool for you as a Python developer. You can extract specific values or ranges of values using indices or slices. You may encounter the TypeError telling you that the index of the list must be integers or slices but not strings. In this part of Python Solutions, we will discuss what causes this error and solve it with several example scenarios.

Why Does This Error Occur?

Each element in a list object in Python has a distinct position called an index. The indices of a list are always integers. If you declare a variable and use it as an index value of a list element, it does not have an integer value but a string value, resulting in the raising of the TypeError.

In general, TypeError in Python occurs when you try to perform an illegal operation for a specific data type.

You may also encounter the similar error “TypeError: list indices must be integers, not tuple“, which occurs when you try to index or slice a list using a tuple value.

Let’s look at an example of a list of particle names and use indices to return a specific particle name:

particle_list = ['gluon', 'photon', 'muon', 'electron', 'Z-boson']

value = particle_list[2]

print(value)

muon

You can also use slices, which define an integer combination: start-point, end-point, and step-size, which will return a sub-list of the original list. See the slice operation performed on the particle list:

sub_list_1 = particle_list[3:5]

print(sub_list_1)

['electron', 'Z-boson']

sub_list_2 = particle_list[1:5:2]

print(sub_list_2)

['photon', 'electron']

In the second example, the third integer is the step size. If you do not specify the step size, it will be set to the default value of 1.

Iterating Over a List

When trying to iterate through the items of a list, it is easy to make the mistake of indexing a list using the list values, strings instead of integers or slices. If you try iterating over the list of particles using the particle names as indices, you will raise the TypeError

particle_list = ['gluon', 'photon', 'muon', 'electron', 'Z-boson']

for particle in particle_list:
    if particle_list[particle] == 'electron':
        print('Electron is in the list!')

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
      1 for particle in particle_list:
      2     if particle_list[particle] == 'electron':
      3         print('Electron is in the list!')
      4 

TypeError: list indices must be integers or slices, not str

Here, the error is raised because we are using string values as indices for the list. In this case, we do not need to index the list as the list values exist in the particle variable within the for statement.

Solution

particle_list = ['gluon', 'photon', 'muon', 'electron', 'Z-boson']

for particle in particle_list:
    if particle == 'electron':
        print('Electron is in the list!')

Electron is in the list!

We can use the if in statement to check if an item exists in a list as discussed in the Python: Check if String Contains a Substring. For example:

particle_list = ['gluon', 'photon', 'muon', 'electron', 'Z-boson']

if 'electron' in particle_list:
    print('Electron is in the list!')

Electron is in the list!

Incorrect Use of List as a Dictionary

We can treat the list of particle names to include their masses and store the values as a list of JSON objects. Each object will hold the particle name and mass. We can access the particle mass using indexing. In this example, we take the electron, muon and Z-boson:

 particles_masses = [
 {
"Name": "electron",
"Mass": 0.511
},
 {
"Name": "muon",
"Mass": 105.7
},
{
"Name": "Z-boson",
"Mass": 912000
}
]

if particles_masses["Name"] == 'muon':
    print(f'Mass of Muon is: {particles_masses["Mass"]} MeV')

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
      1 if particles_masses["Name"] == 'muon':
      2     print(f'Mass of Muon is: {particles_masses["Mass"]} MeV')
      3 

TypeError: list indices must be integers or slices, not str

We see the error arise because we are trying to access the dictionary using the “Name” key, but the dictionary is actually inside a list. You must first access the dictionary using its index within the list.

Solution 1: Using range() + len()

When accessing elements in a list, we need to use an integer or a slice. Once we index the list, we can use the “Name” key to get the specific element we want from the dictionary.

for i in range(len(particles_masses)):
    if particles_masses[i]["Name"] == 'muon':
        print(f'Mass of Muon is: {particles_masses["Mass"]} MeV')

Mass of Muon is: 105.7 MeV

The change made uses integer type I to index the list of particles and retrieve the particle dictionary. With access to the dictionary type, we can then use the “Name” and “Mass” keys to get the values for the particles present.

Solution 2: Using enumerate()

You can access the index of a dictionary within the list using Python’s built-in enumerate method as shown below:

for n, name in enumerate(particles_masses):

    if particles_masses[n]["Name"] == 'muon':

        print(f'Mass of Muon is: {particles_masses[n]["Mass"]} MeV')

Mass of Muon is: 105.7 MeV

Solution 3: Using Python One-Liner

A more complicated solution for accessing a dictionary is to use the search() function and list-comprehension

search = input("Enter particle name you want to explore:  ")

print(next((item for item in particles_masses if search.lower() in item ["Name"].lower()), 'Particle not found!'))

Enter particle name you want to explore:  muon

{'Name': 'muon', 'Mass': 105.7}

Not Converting Strings

You may want to design a script that takes the input to select an element from a list. The TypeError can arise if we are trying to access the list with a “string” input. See the example below:

particles_to_choose = ["electron", "muon", "Z-boson"]

chosen = input('What particle do you want to study? (0, 1, or 2)?')

print(particles_to_choose[chosen])

What particle do you want to study? (0, 1, or 2)?1

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
1 print(particles_to_choose[chosen])

TypeError: list indices must be integers or slices, not str

The error arises because the index returned by the input() function’s default, which is “string”. To solve this, we need to convert the input chosen to an integer type. We can do this by using the int() function:

particles_to_choose = ["electron", "muon", "Z-boson"]

chosen = int(input('What particle do you want to study? (0, 1, or 2)?'))

print(particles_to_choose[chosen])

What particle do you want to study? (0, 1, or 2)?1

muon

Summary

This TypeError occurs when you try to index a list using anything other than integer values or slices. You can convert your values to integer type using the int() function. You can use the “if… in” statement to extract values from a list of strings. If you are trying to iterate over a dictionary within a list, you have to index the list using either range() + len(), enumerate() or next().

If you are encountering other TypeError issues in your code, I provide a solution for another common TypeError in the article titled: “Python TypeError: can only concatenate str (not “int”) to str Solution“.

Thanks for reading to the end of this article. Stay tuned for more of the Python Solutions series, covering common problems data scientists and developers encounter coding in Python. If you want to explore educational resources for Python in data science and machine learning, go to the Online Courses Python page for the best online courses and resources. Have fun and happy researching!

String indices must be integers or slices, not strings? What does this error mean? It’s a TypeError, which tells us that we are trying to perform an operation on a value whose type is not compatible with the operation. What’s the solution?

In this guide, we’re going to answer all of those questions. We’ll discuss what causes this error in Python and why it is raised. We’ll walk through an example scenario to help you figure out how to solve it. Without further ado, let’s begin!

The Problem: typeerror: list indices must be integers or slices, not str

Houston, we have a TypeError:

typeerror: list indices must be integers or slices, not str

This error is raised when you try to access a value inside a list using a string value.

Items in lists are indexed using numbers. Consider the following list:

To access values in this string, we can use index slicing. This is when you call a string followed by an index value to retrieve the character at that position:

example_string = "String"

print(example_string[0])

This code returns: S. Our code retrieves the character at the index position 0 in our list.

If you try to access a list using a letter, like “S”, an error will occur.

An Example Scenario

The error “typeerror: list indices must be integers or slices, not str” is commonly raised when you try to access an item in a list of JSON objects as if it were a list.

Consider the following code snippet:

students = [
	{
		"name": "Lisa Simpson",	
		"age": 8
	},
	{
		"name": "Janey Powell",
		"age": 9
	},
	{
		"name": "Ralph Wiggum",
		"age": 8
	}
]

to_find = input("Enter the name of the student whose age you want to find: ")

for s in students:
	if students["name"] == to_find:
		print("The age of {} is {}.".format(students["name"], students["age"]))

This code snippet finds the age of a particular student in a class. First, we have declared a list of students. This list stores each student as a JSON object.

Next, we ask the user to enter the name of the student whose age they want to find. Our program then iterates over each student in the list using a for loop to find the student whose name matches the one we have specified.

If that particular name is found, the age of the student is printed to the console. Otherwise, nothing happens.

Let’s try to run our code:

Traceback (most recent call last):
  File "main.py", line 19, in <module>
	if students["name"] == to_find:
TypeError: list indices must be integers or slices, not str

Oh no. It’s a TypeError!

The Solution

You can solve the error “typeerror: list indices must be integers or slices, not str” by making sure that you access items in a list using index numbers, not strings.

The problem in our code is that we’re trying to access “name” in our list of students:

This corresponds with no value because our list contains multiple JSON objects. To solve this problem, we’re going to use a range() statement to iterate over our list of students. Then, we’ll access each student by their index number:

for s in range(len(students)):
	if students[s]["name"] == to_find:
		print("The age of {} is {}.".format(students[s]["name"], students[s]["age"]))

To start, we have used a range statement. This will allow us to iterate over every student in our list. We’ve replaced every instance of “students[“key_name”]” with “students[s][“key_name”]”. This allows us to access each value in the list.

Let’s run our code and see what happens:

Enter the name of the student whose age you want to find: Lisa Simpson
The age of Lisa Simpson is 9.

Our code has successfully found the age of Lisa Simpson.

We access each value in the “students” list using its index number instead of a string. Problem solved!

Conclusion

The error “typeerror: list indices must be integers or slices, not str” is raised when you try to access a list using string values instead of an integer. To solve this problem, make sure that you access a list using an index number.

A common scenario where this error is raised is when you iterate over a list and compare objects in the list. To solve this error, we used a range() statement so that we could access each value in “students” individually.

Now you’re ready to solve this error like a Python expert!