Sequence item 0: expected str instance, X found in Python

# Table of Contents

# Sequence item 0: expected str instance, list found in Python

The Python "TypeError: sequence item 0: expected str instance, list found" occurs when we call the join() method with an iterable that contains one or more list objects.

To solve the error, use a nested join() to join the elements of each list.

typeerror sequence item 0 expected str instance list found

Here is an example of how the error occurs.

main.py

Copied!
my_list = [['a', 'b'], ['c', 'd']]

# ⛔️ TypeError: sequence item 0: expected str instance, list found
result = ''.join(my_list)

The join method raises a TypeError if there are any non-string values in the iterable.

One way to solve the error is to use a generator expression with a nested join().

main.py

Copied!
my_list = [['a', 'b'], ['c', 'd']]

result = ''.join(''.join(l) for l in my_list)

print(result)  # 👉️ "abcd"

using generator expression with nested join

We called the join() method with each nested list and then joined the strings.

Generator expressions are used to perform some operation for every element or select a subset of elements that meet a condition.

If your nested lists might contain non-string values, you'll have to convert each value to a string.

main.py

Copied!
my_list = [[1, 2], ['c', 'd']]

result = ''.join(''.join(map(str, l)) for l in my_list)

print(result)  # 👉️ "12cd"

The map() function takes a function and an iterable as arguments and calls the function with each item of the iterable.

If you want to join the nested lists into a string, you can pass each list to the str() class.

main.py

Copied!
my_list = [['a', 'b'], ['c', 'd']]

result = ''.join(str(l) for l in my_list)

print(result)  # 👉️ "['a', 'b']['c', 'd']"

The str.join() method takes an iterable as an argument and returns a string which is the concatenation of the strings in the iterable.

Note that the method raises a TypeError if there are any non-string values in the iterable.

If your list contains numbers or other types, convert all of the values to string before calling join().

main.py

Copied!
my_list = ['a', 'b', 1, 2]


all_strings = list(map(str, my_list))

print(all_strings) # 👉️ ['a', 'b', '1', '2']

result = ''.join(all_strings)

print(result)  # 👉️ "ab12"

The string the method is called on is used as the separator between elements.

main.py

Copied!
my_list = ['a', 'b', 'c']

my_str = '-'.join(my_list)

print(my_str)  # 👉️ "a-b-c"

If you don't need a separator and just want to join the iterable's elements into a string, call the join() method on an empty string.

main.py

Copied!
my_list = ['a', 'b', 'c']

my_str = ''.join(my_list)

print(my_str)  # 👉️ "abc"

# Table of Contents

# Sequence item 0: expected str instance, float found

The Python "TypeError: sequence item 0: expected str instance, float found" occurs when we call the join() method with an iterable that contains one or more floats.

To solve the error, use the map() function to convert all items in the iterable to strings before calling join.

typeerror sequence item 0 expected str instance float found

Here is an example of how the error occurs.

main.py

Copied!
my_list = [1.1, 2.2, 'a', 'b']

# ⛔️ TypeError: sequence item 0: expected str instance, float found
result = ''.join(my_list)

The join method raises a TypeError if there are any non-string values in the iterable.

One way to solve the error is to use the map() function to convert all values in the iterable to strings.

main.py

Copied!
my_list = [1.1, 2.2, 'a', 'b']

result = ''.join(map(str, my_list))

print(result)  # 👉️ "1.12.2ab"

The map() function takes a function and an iterable as arguments and calls the function with each item of the iterable.

We simply called the str() class with each item in the iterable to convert them to strings before using the join() method.

An alternative and more explicit approach is to use a generator expression.

main.py

Copied!
my_list = [1.1, 2.2, 'a', 'b']

result = ''.join(str(item) for item in my_list)

print(result)  # 👉️ "1.12.2ab"

Generator expressions and list comprehensions are used to perform some operation for every element or select a subset of elements that meet a condition.

We used a generator expression to convert each item to a string by passing it to the str() class.

You can also use a list comprehension by wrapping the expression in square brackets.

main.py

Copied!
my_list = [1.1, 2.2, 'a', 'b']

result = ''.join([str(item) for item in my_list])

print(result)  # 👉️ "1.12.2ab"

The str.join method takes an iterable as an argument and returns a string which is the concatenation of the strings in the iterable.

Note that the method raises a TypeError if there are any non-string values in the iterable.

The string the method is called on is used as the separator between elements.

main.py

Copied!
my_list = [1.1, 2.2, 'a', 'b']

result = '_'.join([str(item) for item in my_list])

print(result)  # 👉️ "1.1_2.2_a_b"

If you don't need a separator and just want to join the iterable's elements into a string, call the join() method on an empty string.

main.py

Copied!
my_list = [1.1, 2.2, 'a', 'b']

result = ''.join([str(item) for item in my_list])

print(result)  # 👉️ "1.12.2ab"

# Table of Contents

# Sequence item 0: expected str instance, NoneType found

The Python "TypeError: sequence item 0: expected str instance, NoneType found" occurs when we call the join() method with an iterable that contains one or more None values.

To solve the error, figure out where the None values come from or filter them out before calling join.

typeerror sequence item 0 expected str instance nonetype found

Here is an example of how the error occurs.

main.py

Copied!
my_list = [None, None, 'a', 'b']

# ⛔️ TypeError: sequence item 0: expected str instance, NoneType found
result = ''.join(my_list)

The join method raises a TypeError if there are any non-string values in the iterable.

The best way to solve the error is to figure out where the None values in the iterable came from and correct the assignment.

The most common sources of None values are:

Having a function that doesn't return anything (returns None implicitly).
Explicitly setting a variable to None.
Assigning a variable to the result of calling a built-in function that doesn't return anything.
Having a function that only returns a value if a certain condition is met.

If you want to filter out the None values from the iterable, use the filter() function.

main.py

Copied!
my_list = [None, None, 'a', 'b']

result = ''.join(filter(lambda x: x if x is not None else '', my_list))

print(result)  # 👉️ 'ab'

If your iterable contains other values that are not of type string, make sure to pass them to the str() class to convert them to strings before passing them to join().

main.py

Copied!
my_list = [None, None, 'a', 'b']

result = ''.join(filter(lambda x: str(x) if x is not None else '', my_list))

print(result)  # 👉️ 'ab'

The filter() function takes a function and an iterable as arguments and constructs an iterator from the elements of the iterable for which the function returns a truthy value.

If you pass None for the function argument, all falsy elements of the iterable are removed.

The str.join() method takes an iterable as an argument and returns a string which is the concatenation of the strings in the iterable.

Note that the method raises a TypeError if there are any non-string values in the iterable.

If your list contains numbers or other types, convert all of the values to string before calling join().

main.py

Copied!
my_list = ['a', 'b', 1, 2]


all_strings = list(map(str, my_list))

print(all_strings) # 👉️ ['a', 'b', '1', '2']

result = ''.join(all_strings)

print(result)  # 👉️ "ab12"

The string the method is called on is used as the separator between elements.

main.py

Copied!
my_list = ['a', 'b', 'c']

my_str = '-'.join(my_list)

print(my_str)  # 👉️ "a-b-c"

If you don't need a separator and just want to join the iterable's elements into a string, call the join() method on an empty string.

main.py

Copied!
my_list = ['a', 'b', 'c']

my_str = ''.join(my_list)

print(my_str)  # 👉️ "abc"

# Table of Contents

# TypeError: sequence item 0: expected str instance, int found

The Python "TypeError: sequence item 0: expected str instance, int found" occurs when we call the join() method with an iterable that contains one or more integers.

To solve the error, use the map() function to convert all items in the iterable to strings before calling join.

typeerror sequence item 0 expected str instance int found

Here is an example of how the error occurs.

main.py

Copied!
my_list = [1, 2, 'a', 'b']

# ⛔️ TypeError: sequence item 0: expected str instance, int found
result = ''.join(my_list)

The join method raises a TypeError if there are any non-string values in the iterable.

One way to solve the error is to use the map() function to convert all values in the iterable to strings.

main.py

Copied!
my_list = [1, 2, 'a', 'b']

result = ''.join(map(str, my_list))

print(result)  # 👉️ '12ab'

The map() function takes a function and an iterable as arguments and calls the function with each item of the iterable.

We simply called the str() class with each item in the iterable to convert them to strings before using the join() method.

An alternative and more explicit approach is to use a generator expression.

main.py

Copied!
my_list = [1, 2, 'a', 'b']

result = ''.join(str(item) for item in my_list)

print(result)  # 👉️ '12ab'

Generator expressions and list comprehensions are used to perform some operation for every element or select a subset of elements that meet a condition.

We used a generator expression to convert each item to a string by passing it to the str() class.

You can also use a list comprehension by wrapping the expression in square brackets.

main.py

Copied!
my_list = [1, 2, 'a', 'b']

result = ''.join([str(item) for item in my_list])

print(result)  # 👉️ '12ab'

The str.join method takes an iterable as an argument and returns a string which is the concatenation of the strings in the iterable.

Note that the method raises a TypeError if there are any non-string values in the iterable.

The string the method is called on is used as the separator between elements.

main.py

Copied!
my_list = [1, 2, 'a', 'b']

result = '_'.join(map(str, my_list))

print(result)  # 👉️ '1_2_a_b'

If you don't need a separator and just want to join the iterable's elements into a string, call the join() method on an empty string.

main.py

Copied!
my_list = [1, 2, 'a', 'b']

result = ''.join(map(str, my_list))

print(result)  # 👉️ '12ab'

# Table of Contents

# Sequence item 0: expected str instance, tuple found (Python)

The Python "TypeError: sequence item 0: expected str instance, tuple found" occurs when we call the join() method with an iterable that contains one or more tuples.

To solve the error, use a nested join() to join the elements of each tuple.

typeerror sequence item 0 expected str instance tuple found

Here is an example of how the error occurs.

main.py

Copied!
my_list = [('a', 'b'), ('c', 'd'), ('e', 'f')]

# ⛔️ TypeError: sequence item 0: expected str instance, tuple found
result = ''.join(my_list)

The join method raises a TypeError if there are any non-string values in the iterable.

One way to solve the error is to use a generator expression with a nested join().

main.py

Copied!
my_list = [('a', 'b'), ('c', 'd'), ('e', 'f')]

result = ''.join(''.join(tup) for tup in my_list)

print(result)  # 👉️ 'abcdef'

We called the join() method with each tuple in the list and then joined the strings.

Generator expressions are used to perform some operation for every element or select a subset of elements that meet a condition.

If your tuple might contain non-string values, you'll have to convert each value to a string.

main.py

Copied!
my_list = [(1, 2), 'c', 'd', 'e', 'f']

result = ''.join(''.join(map(str, tup)) for tup in my_list)

print(result)  # 👉️ '12cdef'

The map() function takes a function and an iterable as arguments and calls the function with each item of the iterable.

If you want to join the tuples into a string, you can pass each tuple to the str() class.

main.py

Copied!
my_list = [('a', 'b'), ('c', 'd'), ('e', 'f')]

result = ''.join(str(tup) for tup in my_list)

print(result)  # 👉️ "('a', 'b')('c', 'd')('e', 'f')"

In case you declared a tuple by mistake, tuples are constructed in multiple ways:

Using a pair of parentheses () creates an empty tuple
Using a trailing comma - a, or (a,)
Separating items with commas - a, b or (a, b)
Using the tuple() constructor

The str.join() method takes an iterable as an argument and returns a string which is the concatenation of the strings in the iterable.

Note that the method raises a TypeError if there are any non-string values in the iterable.

If your list contains numbers or other types, convert all of the values to string before calling join().

main.py

Copied!
my_list = ['a', 'b', 1, 2]


all_strings = list(map(str, my_list))

print(all_strings) # 👉️ ['a', 'b', '1', '2']

result = ''.join(all_strings)

print(result)  # 👉️ "ab12"

The string the method is called on is used as the separator between elements.

main.py

Copied!
my_list = ['a', 'b', 'c']

my_str = '-'.join(my_list)

print(my_str)  # 👉️ "a-b-c"

If you don't need a separator and just want to join the iterable's elements into a string, call the join() method on an empty string.

main.py

Copied!
my_list = ['a', 'b', 'c']

my_str = ''.join(my_list)

print(my_str)  # 👉️ "abc"

# Sequence item 0: expected str instance, bytes found (Python)

The Python "TypeError: sequence item 0: expected str instance, bytes found" occurs when we call the join() method with an iterable that contains one or more bytes objects.

To solve the error, prefix the string separator with b, e.g. result = b''.join(my_list).

typeerror sequence item 0 expected str instance bytes found

Here is an example of how the error occurs.

main.py

Copied!
my_list = [b'a', b'b', b'c']

# ⛔️ TypeError: sequence item 0: expected str instance, bytes found
result = ''.join(my_list)

The issue is that we are trying to use a string separator to join a list containing bytes objects.

One way to solve the error is to prefix the string separator with a b to turn it into a bytes object.

main.py

Copied!
my_list = [b'a', b'b', b'c']

# 👇️ using b'' prefix
result = b''.join(my_list)
print(result)  # 👉️ b'abc'

# 👇️ optionally decode bytes to str
my_str = result.decode('utf-8')
print(my_str)  # 👉️ 'abc'

After joining the bytes objects, you can optionally use the decode() method to get a string.

The bytes.decode() method returns a string decoded from the given bytes. The default encoding is utf-8.

If your list contains both bytes objects and strings, use the map() function to decode each bytes object.

main.py

Copied!
my_list = [b'a', 'b', b'c', 'd']

result = ''.join(map(lambda item: item if isinstance(
    item, str) else item.decode('utf-8'), my_list))

print(result)  # 👉️ 'abcd'

The map() function takes a function and an iterable as arguments and calls the function with each item of the iterable.

On each iteration, we check if the value is a string and if it is we return it, otherwise, we decode the value and return the result.

The str.join() method takes an iterable as an argument and returns a string which is the concatenation of the strings in the iterable.

Note that the method raises a TypeError if there are any non-string values in the iterable.

The string the method is called on is used as the separator between elements.

main.py

Copied!
my_list = [1, 2, 'a', 'b']

result = '_'.join(map(str, my_list))

print(result)  # 👉️ '1_2_a_b'

If you don't need a separator and just want to join the iterable's elements into a string, call the join() method on an empty string.

main.py

Copied!
my_list = [1, 2, 'a', 'b']

result = ''.join(map(str, my_list))

print(result)  # 👉️ '12ab'

I wrote a book in which I share everything I know about how to become a better, more efficient programmer.

You can use the search field on my Home Page to filter through all of my articles.

Sequence item 0: expected str instance, X found in Python

# Table of Contents

# Sequence item 0: expected str instance, list found in Python

# Table of Contents

# Sequence item 0: expected str instance, float found

# Table of Contents

# Sequence item 0: expected str instance, NoneType found

# Table of Contents

# TypeError: sequence item 0: expected str instance, int found

# Table of Contents

# Sequence item 0: expected str instance, tuple found (Python)

# Sequence item 0: expected str instance, bytes found (Python)

Borislav Hadzhiev