序列项 0：预期的 str 实例，在 Python 中找到 X

作者

目录

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

  1. 序列项 0：预期的 str 实例，在 Python 中找到的 LIST
  2. 序列项 0：预期的 str 实例，找到 FLOAT
  3. 序列项 0：预期的 str 实例，未找到 NoneType
  4. 序列项 0：预期的 str 实例，已找到 INT
  5. 序列项 0：预期的 str 实例，已找到 TUPLE
  6. 序列项 0：预期的 str 实例，已找到 BYTES

序列项 0：预期的 str 实例，在 Python 中找到的列表

join()当我们使用包含一个或多个列表对象的可迭代对象调用方法时，会出现 Python“TypeError: sequence item 0: expected str instance, list found” 。

要解决该错误，请使用嵌套join()来连接每个列表的元素。

typeerror sequence item 0 expected str 实例列表找到

下面是错误如何发生的示例。

主程序
my_list = [['a', 'b'], ['c', 'd']]

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

如果可迭代对象中有任何非字符串值，该join方法将引发一个。TypeError

解决错误的一种方法是使用

带有嵌套join().

主程序
my_list = [['a', 'b'], ['c', 'd']]

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

print(result)  # 👉️ "abcd"

我们join()用每个嵌套列表调用该方法，然后连接字符串。

生成器表达式用于对每个元素执行某些操作或选择满足条件的元素子集。

如果您的嵌套列表可能包含非字符串值，您必须将每个值转换为字符串。

主程序
my_list = [[1, 2], ['c', 'd']]

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

print(result)  # 👉️ "12cd"

map ()函数将一个函数和一个可迭代对象作为参数，并使用可迭代对象的每个项目调用该函数。

如果你想将嵌套列表连接成一个字符串，你可以将每个列表传递给类str()。

主程序
my_list = [['a', 'b'], ['c', 'd']]

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

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

str.join方法将一个可迭代对象作为参数并返回一个字符串，该字符串是可迭代对象中字符串的串联。

TypeError请注意，如果可迭代对象中有任何非字符串值，该方法将引发 a 。

如果您的列表包含数字或其他类型，请在调用之前将所有值转换为字符串join()。

主程序
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"

调用该方法的字符串用作元素之间的分隔符。

主程序
my_list = ['a', 'b', 'c']

my_str = '-'.join(my_list)

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

如果您不需要分隔符而只想将可迭代的元素连接到一个字符串中，请join()在空字符串上调用该方法。

主程序
my_list = ['a', 'b', 'c']

my_str = ''.join(my_list)

print(my_str)  # 👉️ "abc"

目录

  1. 序列项 0：预期的 str 实例，找到 FLOAT
  2. 序列项 0：预期的 str 实例，未找到 NoneType
  3. 序列项 0：预期的 str 实例，已找到 INT
  4. 序列项 0：预期的 str 实例，已找到 TUPLE
  5. 序列项 0：预期的 str 实例，已找到 BYTES

序列项 0：预期的 str 实例，已找到 float

join()当我们使用包含一个或多个浮点数的可迭代对象调用方法时，会出现 Python“TypeError: sequence item 0: expected str instance, float found” 。

要解决该错误，请map()在调用之前使用该函数将 iterable 中的所有项目转换为字符串join。

typeerror sequence item 0 expected str 实例 float found

下面是错误如何发生的示例。

主程序
my_list = [1.1, 2.2, 'a', 'b']

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

如果可迭代对象中有任何非字符串值，该join方法将引发一个。TypeError

解决该错误的一种方法是使用该map()函数将可迭代对象中的所有值转换为字符串。

主程序
my_list = [1.1, 2.2, 'a', 'b']

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

print(result)  # 👉️ "1.12.2ab"

map ()函数将一个函数和一个可迭代对象作为参数，并使用可迭代对象的每个项目调用该函数。

在使用该方法之前，我们简单地调用了str()iterable 中每个项目的类，将它们转换为字符串join()。

另一种更明确的方法是使用生成器表达式。

主程序
my_list = [1.1, 2.2, 'a', 'b']

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

print(result)  # 👉️ "1.12.2ab"

生成器表达式和
列表理解用于对每个元素执行某些操作或选择满足条件的元素子集。

我们使用生成器表达式将每个项目传递给类，从而将其转换为字符串str()。

您还可以通过将表达式括在方括号中来使用列表理解。

主程序
my_list = [1.1, 2.2, 'a', 'b']

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

print(result)  # 👉️ "1.12.2ab"

str.join方法将一个可迭代对象作为参数并返回一个字符串，该字符串是可迭代对象中字符串的串联。

TypeError请注意，如果可迭代对象中有任何非字符串值，该方法将引发 a 。

调用该方法的字符串用作元素之间的分隔符。

主程序
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"

如果您不需要分隔符而只想将可迭代的元素连接到一个字符串中，请join()在空字符串上调用该方法。

主程序
my_list = [1.1, 2.2, 'a', 'b']

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

print(result)  # 👉️ "1.12.2ab"

目录

  1. 序列项 0：预期的 str 实例，未找到 NoneType
  2. 序列项 0：预期的 str 实例，已找到 INT
  3. 序列项 0：预期的 str 实例，已找到 TUPLE
  4. 序列项 0：预期的 str 实例，已找到 BYTES

序列项 0：预期的 str 实例，未找到 NoneType

join()当我们使用包含一个或多个值的可迭代对象调用方法时，会出现 Python“TypeError: sequence item 0: expected str instance, NoneType found” None。

要解决错误，请找出None值的来源或在调用之前将其过滤掉join。

typeerror sequence item 0 预期的 str 实例 nonetype 找到

下面是错误如何发生的示例。

主程序
my_list = [None, None, 'a', 'b']

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

如果可迭代对象中有任何非字符串值，该join方法将引发一个。TypeError

解决错误的最好方法是找出None 可迭代对象中的值来自何处并更正分配。

最常见的None价值来源是：

  1. 有一个不返回任何东西的函数（None隐式返回）。
  2. 明确地将变量设置为None.
  3. 将变量分配给调用不返回任何内容的内置函数的结果。
  4. 具有仅在满足特定条件时才返回值的函数。

如果要从可None迭代对象中过滤掉值，请使用该
filter()函数。

主程序
my_list = [None, None, 'a', 'b']

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

print(result)  # 👉️ 'ab'

如果您的 iterable 包含其他非字符串类型的值，请确保将它们传递给类str()以将它们转换为字符串，然后再将它们传递给
join().

主程序
my_list = [None, None, 'a', 'b']

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

print(result)  # 👉️ 'ab'

filter函数接受一个函数和一个可迭代对象作为参数，并从可迭代对象的元素构造一个迭代器，函数返回一个真值。

如果您传递None函数参数，则 iterable 的所有虚假元素都将被删除。

str.join方法将一个可迭代对象作为参数并返回一个字符串，该字符串是可迭代对象中字符串的串联。

TypeError请注意，如果可迭代对象中有任何非字符串值，该方法将引发 a 。

如果您的列表包含数字或其他类型，请在调用之前将所有值转换为字符串join()。

主程序
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"

调用该方法的字符串用作元素之间的分隔符。

主程序
my_list = ['a', 'b', 'c']

my_str = '-'.join(my_list)

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

如果您不需要分隔符而只想将可迭代的元素连接到一个字符串中，请join()在空字符串上调用该方法。

主程序
my_list = ['a', 'b', 'c']

my_str = ''.join(my_list)

print(my_str)  # 👉️ "abc"

目录

  1. 序列项 0：预期的 str 实例，已找到 INT
  2. 序列项 0：预期的 str 实例，已找到 TUPLE
  3. 序列项 0：预期的 str 实例，已找到 BYTES

类型错误：序列项 0：预期的 str 实例，找到了 int

join()当我们使用包含一个或多个整数的可迭代对象调用方法时，会出现 Python“TypeError: sequence item 0: expected str instance, int found” 。

要解决该错误，请map()在调用之前使用该函数将 iterable 中的所有项目转换为字符串join。

typeerror 序列项 0 预期的 str 实例 int 找到

下面是错误如何发生的示例。

主程序
my_list = [1, 2, 'a', 'b']

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

如果可迭代对象中有任何非字符串值，该join方法将引发一个。TypeError

解决该错误的一种方法是使用该map()函数将可迭代对象中的所有值转换为字符串。

主程序
my_list = [1, 2, 'a', 'b']

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

print(result)  # 👉️ '12ab'

map ()函数将一个函数和一个可迭代对象作为参数，并使用可迭代对象的每个项目调用该函数。

在使用该方法之前，我们简单地调用了str()iterable 中每个项目的类，将它们转换为字符串join()。

另一种更明确的方法是使用生成器表达式。

主程序
my_list = [1, 2, 'a', 'b']

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

print(result)  # 👉️ '12ab'

生成器表达式和列表理解用于对每个元素执行某些操作或选择满足条件的元素子集。

我们使用生成器表达式将每个项目传递给类，从而将其转换为字符串str()。

您还可以通过将表达式括在方括号中来使用列表理解。

主程序
my_list = [1, 2, 'a', 'b']

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

print(result)  # 👉️ '12ab'

str.join方法将一个可迭代对象作为参数并返回一个字符串，该字符串是可迭代对象中字符串的串联。

TypeError请注意，如果可迭代对象中有任何非字符串值，该方法将引发 a 。

调用该方法的字符串用作元素之间的分隔符。

主程序
my_list = [1, 2, 'a', 'b']

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

print(result)  # 👉️ '1_2_a_b'

如果您不需要分隔符而只想将可迭代的元素连接到一个字符串中，请join()在空字符串上调用该方法。

主程序
my_list = [1, 2, 'a', 'b']

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

print(result)  # 👉️ '12ab'

目录

  1. 序列项 0：预期的 str 实例，已找到 TUPLE
  2. 序列项 0：预期的 str 实例，已找到 BYTES

序列项 0：预期的 str 实例，找到的元组 (Python)

join()当我们使用包含一个或多个元组的可迭代对象调用方法时，会出现 Python“TypeError: sequence item 0: expected str instance, tuple found” 。

要解决该错误，请使用嵌套join()来连接每个元组的元素。

typeerror sequence item 0 expected str 实例元组找到

下面是错误如何发生的示例。

主程序
my_list = [('a', 'b'), ('c', 'd'), ('e', 'f')]

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

如果可迭代对象中有任何非字符串值，该join方法将引发一个。TypeError

解决错误的一种方法是使用带有嵌套
join().

主程序
my_list = [('a', 'b'), ('c', 'd'), ('e', 'f')]

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

print(result)  # 👉️ 'abcdef'

我们join()用列表中的每个元组调用该方法，然后连接字符串。

生成器表达式用于对每个元素执行某些操作或选择满足条件的元素子集。

如果您的元组可能包含非字符串值，则必须将每个值转换为字符串。

主程序
my_list = [(1, 2), 'c', 'd', 'e', 'f']

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

print(result)  # 👉️ '12cdef'

map ()函数将一个函数和一个可迭代对象作为参数，并使用可迭代对象的每个项目调用该函数。

如果你想将元组连接成一个字符串，你可以将每个元组传递给类
str()。

主程序
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')"

万一你错误地声明了一个元组，元组有多种构造方式：

  • 使用一对括号()创建一个空元组
  • 使用尾随逗号 –a,或(a,)
  • 用逗号分隔项目 –a, b或(a, b)
  • 使用tuple()构造函数

str.join方法将一个可迭代对象作为参数并返回一个字符串，该字符串是可迭代对象中字符串的串联。

TypeError请注意，如果可迭代对象中有任何非字符串值，该方法将引发 a 。

如果您的列表包含数字或其他类型，请在调用之前将所有值转换为字符串join()。

主程序
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"

调用该方法的字符串用作元素之间的分隔符。

主程序
my_list = ['a', 'b', 'c']

my_str = '-'.join(my_list)

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

如果您不需要分隔符而只想将可迭代的元素连接到一个字符串中，请join()在空字符串上调用该方法。

主程序
my_list = ['a', 'b', 'c']

my_str = ''.join(my_list)

print(my_str)  # 👉️ "abc"

序列项 0：预期的 str 实例，找到的字节数 (Python)

join()当我们使用包含一个或多个字节对象的可迭代对象调用方法时，会出现 Python“TypeError: sequence item 0: expected str instance, bytes found” 。

要解决该错误，请在字符串分隔符前加上b，例如
result = b''.join(my_list)。

typeerror 序列项 0 预期的 str 实例字节找到

下面是错误如何发生的示例。

主程序
my_list = [b'a', b'b', b'c']

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

问题是我们正在尝试使用字符串分隔符来加入包含字节对象的列表。

解决该错误的一种方法是在字符串分隔符前加上 ab以将其转换为字节对象。

主程序
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'

加入字节对象后，您可以选择使用该decode()方法获取字符串。

bytes.decode方法返回从给定字节解码的字符串。默认编码为utf-8.

如果您的列表同时包含字节对象和字符串，请使用该map()函数解码每个字节对象。

主程序
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'

map ()函数将一个函数和一个可迭代对象作为参数，并使用可迭代对象的每个项目调用该函数。

在每次迭代中，我们检查该值是否是一个字符串，如果是我们返回它，否则我们解码该值并返回结果。

str.join方法将一个可迭代对象作为参数并返回一个字符串，该字符串是可迭代对象中字符串的串联。

TypeError请注意，如果可迭代对象中有任何非字符串值，该方法将引发 a 。

调用该方法的字符串用作元素之间的分隔符。

主程序
my_list = [1, 2, 'a', 'b']

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

print(result)  # 👉️ '1_2_a_b'

如果您不需要分隔符而只想将可迭代的元素连接到一个字符串中，请join()在空字符串上调用该方法。

主程序
my_list = [1, 2, 'a', 'b']

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

print(result)  # 👉️ '12ab'