类型错误：只能将元组（不是“X”）连接到元组

作者

目录

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

  1. 类型错误：只能将元组（不是“int”）连接到元组
  2. 类型错误：只能将元组（不是“str”）连接到元组
  3. 类型错误：只能将元组（不是“列表”）连接到元组

类型错误：只能将元组（不是“int”）连接到元组

当我们尝试连接元组和整数时，会出现 Python“TypeError: can only concatenate tuple (not “int”) to tuple”。

要解决此错误，请确保在尝试对两个整数求和时没有任何悬垂的逗号，否则声明 2 个元组。

typeerror 只能连接 tuple 而不是 int 到 tuple

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

主程序
my_tuple = 1, 2, 3

my_int = 4

# ⛔️ TypeError: can only concatenate tuple (not "int") to tuple
result = my_tuple + my_int

尝试将加法 (+) 运算符与元组和整数一起使用会导致错误。

使用浮点数时也会发生该错误。

主程序
my_tuple = 1.1, 2.2

my_float = 3.3

# ⛔️ TypeError: can only concatenate tuple (not "float") to tuple
result = my_tuple + my_float

我们尝试使用
加法 (+) 运算符连接导致错误的元组和整数。

左侧和右侧的值需要是兼容的类型。

连接两个元组

如果您打算连接两个元组，请声明一个元组而不是一个 int。

主程序
my_tuple = 1, 2, 3

my_other_tuple = (4,)

result = my_tuple + my_other_tuple

print(result)  # 👉️ (1, 2, 3, 4)

当您对两个元组使用加法 (+) 运算符时，元组的元素会组合成一个新元组。

如果您打算添加 2 个整数，请确保您没有任何悬空的逗号，因为您可能会错误地声明一个元组。
主程序
my_tuple = 4, # 👈️ comma makes it a tuple

print(type(my_tuple)) # 👉️ <class 'tuple'>

在整数声明元组之后有一个尾随逗号。

您可以删除结尾的逗号以声明一个整数。

主程序
int_1 = 4
int_2 = 6

result = int_1 + int_2
print(result) # 👉️ 10

如果您打算在同一行声明两个整数，
请使用 unpacking。

主程序
int_1, int_2 = 4, 10

print(int_1)  # 👉️ 4
print(int_2)  # 👉️ 10

请注意，等号左边的值必须与等号右边的值一样多。

元组在 Python 中是如何构造的

元组有多种构造方式：

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

访问索引处的元组元素

如果您打算访问元组中特定索引处的元素，请使用方括号。

主程序
my_tuple = 1, 2, 3

my_int = 10

result = my_tuple[0] + my_int

print(result)  # 👉️ 11

我们访问了元组中的第一个元素并将其添加到一个整数中。

注意加法运算符两边的值
都是整数，所以这是允许的。

Python 索引是从零开始的，因此元组中的第一项的索引为，最后一项的索引为or 。 0-1 len(my_tuple) - 1

检查变量的类型

如果不确定变量存储的类型，请使用内置type()类。

主程序
my_tuple = (1, 2, 3)
print(type(my_tuple))  # 👉️ <class 'tuple'>
print(isinstance(my_tuple, tuple))  # 👉️ True

my_int = 10
print(type(my_int))  # 👉️ <class 'int'>
print(isinstance(my_int, int))  # 👉️ True

类型
类
返回对象的类型。

如果传入的对象是传入类的实例或子类，则isinstance函数返回
。True

  1. 类型错误：只能将元组（不是“str”）连接到元组
  2. 类型错误：只能将元组（不是“列表”）连接到元组

类型错误：只能将元组（不是“str”）连接到元组

当我们尝试连接元组和字符串时，会出现 Python“TypeError: can only concatenate tuple (not “str”) to tuple”。

要解决该错误，请确保值是 2 个元组或 2 个字符串，然后再连接它们。

typeerror 只能连接列表而不是 nonetype 到列表

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

主程序
my_tuple = ('apple', 'banana')

my_str = 'kiwi'

# ⛔️ TypeError: can only concatenate tuple (not "str") to tuple
result = my_tuple + my_str

我们尝试使用加法 (+) 运算符连接导致错误的元组和字符串。

左侧和右侧的值需要是兼容的类型。

连接两个元组

如果您打算连接两个元组，请声明一个元组而不是字符串。

主程序
my_tuple = ('apple', 'banana')

my_other_tuple = ('kiwi',)

result = my_tuple + my_other_tuple

print(result)  # 👉️ ('apple', 'banana', 'kiwi')

如果您打算连接 2 个字符串，请确保这两个变量存储一个字符串。

当您声明一个带有尾随逗号的变量时，您就声明了一个元组。

主程序
my_tuple = 'apple', # 👈️ note the trailing comma

print(my_tuple) # 👉️ ('apple',)
print(type(my_tuple)) # 👉️ <class 'tuple'>

如果您打算声明一个字符串，请删除尾随的逗号。

如果您打算在同一行中声明两个字符串，请使用解包。

主程序
str_1, str_2 = ('one', 'two')

print(str_1) # 👉️ one
print(str_2) # 👉️ two

在 Python 中如何创建元组

元组有多种构造方式：

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

访问元组中的特定元素。

如果您打算访问元组中特定索引处的元素，请使用方括号。

主程序
my_tuple = ('apple', 'banana')

my_str = ' is a fruit'

result = my_tuple[0] + my_str

print(result)  # 👉️ "apple is a fruit"

我们将元组中的第一个元素连接成一个字符串。请注意，加法 (+) 运算符两边的值都是字符串，因此这是允许的。

Python 索引是从零开始的，因此元组中的第一项的索引为0，最后一项的索引为-1or len(my_tuple) - 1。

打印元组的内容

如果要打印元组的内容，请使用
格式化字符串文字。

主程序
my_tuple = ('apple', 'banana')

my_str = 'are fruits'

result = f'{my_tuple} {my_str}'

print(result)  # 👉️ "('apple', 'banana') are fruits"
格式化字符串文字 (f-strings) 让我们通过在字符串前加上f.

确保将表达式括在大括号 – 中{expression}。

检查变量的类型

如果不确定变量存储的类型，请使用内置type()类。

主程序
my_tuple = ('apple', 'banana')
print(type(my_tuple))  # 👉️ <class 'tuple'>
print(isinstance(my_tuple, tuple))  # 👉️ True

my_str = 'are fruits'
print(type(my_str))  # 👉️ <class 'str'>
print(isinstance(my_str, str))  # 👉️ True

类型
类
返回对象的类型。

如果传入的对象是传入类的实例或子类，则isinstance函数返回
。True

类型错误：只能将元组（不是“列表”）连接到元组

当我们尝试连接元组和列表时，会出现 Python“TypeError: can only concatenate tuple (not “list”) to tuple”。

要解决该错误，请确保这两个值在连接它们之前是列表类型或元组类型。

typeerror 只能连接元组而不是列表到元组

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

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

# ⛔️ TypeError: can only concatenate tuple (not "list") to tuple
result = my_tuple + my_list

我们尝试使用加法 (+) 运算符连接导致错误的元组和列表。

左侧和右侧的值需要是兼容的类型。

将列表转换为元组以连接两个元组

如果您打算连接两个元组，请声明一个元组而不是列表，或者将列表转换为元组。

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

result = my_tuple + tuple(my_list)

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

元组类接受一个可迭代对象并返回一个tuple对象。

我们将列表转换为元组并将两个元组连接起来。

将元组转换为列表以连接两个列表

相反，您可以将元组转换为列表并将两个列表连接起来。

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

result = list(my_tuple) + my_list

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

列表类接受一个可迭代对象并返回一个列表对象。

在 Python 中如何创建元组

如果您错误地声明了元组，则元组将按以下方式构造：

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

如果您打算将元组附加到列表，请使用该append()方法。

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

my_list.append(my_tuple)
print(my_list)  # 👉️ [('a', 'b'), ('c', 'd')]

list.append ()方法将一个项目添加到列表的末尾。

该方法在改变原始列表时返回。None

检查变量存储的类型

如果不确定变量存储的类型，请使用内置type()类。

主程序
my_tuple = ('a', 'b')
print(type(my_tuple))  # 👉️ <class 'tuple'>
print(isinstance(my_tuple, tuple))  # 👉️ True

my_list = ['c', 'd']
print(type(my_list))  # 👉️ <class 'list'>
print(isinstance(my_list, list))  # 👉️ True

类型
类
返回对象的类型。

如果传入的对象是传入类的实例或子类，则isinstance函数返回
。True