Python String 转 Int：完整指南

在 Python 编程中，处理不同数据类型之间的转换是一项基本且常见的任务。其中，将字符串（String）转换为整数（Integer）是开发者经常遇到的操作。例如，当你从用户那里获取输入（通常是字符串），或者从文件、网络接收数据时，如果这些数据代表的是数字，你就需要将它们转换为整数才能进行数学计算或逻辑判断。

Python 提供了内置且高效的方式来完成这项转换，但了解其工作原理、潜在问题以及如何优雅地处理这些问题，对于编写健壮可靠的代码至关重要。

本文将作为一份完整的指南，带你深入了解 Python 中如何进行字符串到整数的转换，包括基本方法、高级用法、可能遇到的错误、错误处理策略以及一些最佳实践。

为什么需要 String 转 Int？

在我们深入技术细节之前，先来理解为什么会频繁地遇到这种需求：

用户输入: Python 的 input() 函数总是返回一个字符串。如果你需要用户输入一个数字进行计算，就必须将其转换为整数。
python user_age_str = input("请输入您的年龄: ") # user_age_str 现在是一个字符串，例如 "25" # 如果你想计算 user_age_str + 1，会因为类型错误而失败
文件读取: 从文本文件中读取的数据行通常是字符串。如果文件中包含数字数据，你需要将其转换为整数。
python # 假设文件 lines.txt 中每行是一个数字 # with open('lines.txt', 'r') as f: # for line in f: # number_str = line.strip() # 去除换行符和空白 # # number_str 是字符串，需要转成整数
网络通信/API响应: 从网页抓取的数据、API 返回的 JSON/XML 数据等，其中的数字字段可能被表示为字符串。
数据解析: 解析 CSV、日志文件或其他特定格式的数据时，其中的数值部分需要转换为整数。
数据库交互: 从数据库读取的数据，有时需要根据其在应用中的用途进行类型转换。

总之，任何时候当你从外部源获取数据，并且该数据在逻辑上应被视为整数时，都需要进行字符串到整数的转换。

基本方法：使用内置的 `int()` 函数

Python 提供了内置的 int() 函数，它是进行字符串到整数转换的主要工具。int() 函数的功能非常强大，不仅可以处理简单的十进制字符串，还可以处理其他进制的字符串，并且能处理字符串中的空白和正负号。

int() 函数的基本语法如下：

python int(x, base=10)

x: 需要转换的对象。它可以是一个字符串（string）、一个数字（number），或者任何定义了 __int__() 或 __trunc__() 方法的对象。在本文中，我们主要关注 x 是字符串的情况。
base: 可选参数，表示字符串 x 所基于的进制。默认值是 10，表示十进制。如果提供了 base 参数，x 必须是字符串或 Bytes 对象。

简单的十进制转换

最常见的情况是将一个表示十进制整数的字符串转换为整数。

“`python

示例 1: 基本正整数

str_num1 = “123”
int_num1 = int(str_num1)
print(f”‘{str_num1}’ 转换为整数是: {int_num1}, 类型是: {type(int_num1)}”)

输出: ‘123’ 转换为整数是: 123, 类型是:

示例 2: 负整数

str_num2 = “-456″
int_num2 = int(str_num2)
print(f”‘{str_num2}’ 转换为整数是: {int_num2}, 类型是: {type(int_num2)}”)

输出: ‘-456’ 转换为整数是: -456, 类型是:

示例 3: 包含正号的整数

str_num3 = “+789″
int_num3 = int(str_num3)
print(f”‘{str_num3}’ 转换为整数是: {int_num3}, 类型是: {type(int_num3)}”)

输出: ‘+789’ 转换为整数是: 789, 类型是:

示例 4: 包含前导和尾随空白的字符串

str_num4 = ” 100 ”
int_num4 = int(str_num4)
print(f”‘{str_num4}’ 转换为整数是: {int_num4}, 类型是: {type(int_num4)}”)

输出: ‘ 100 ‘ 转换为整数是: 100, 类型是:

示例 5: 包含空白和符号

str_num5 = ” -200 ”
int_num5 = int(str_num5)
print(f”‘{str_num5}’ 转换为整数是: {int_num5}, 类型是: {type(int_num5)}”)

输出: ‘ -200 ‘ 转换为整数是: -200, 类型是:

“`

从上面的示例可以看出，int() 函数能够正确地处理：
* 由数字 ‘0’ 到 ‘9’ 组成的字符串。
* 字符串前可以选择性地加上 ‘+’ 或 ‘-‘ 号。
* 字符串前和后可以有任意数量的空白字符（空格、制表符、换行符等），int() 会自动忽略它们。

处理其他进制的字符串

int() 函数的第二个参数 base 允许我们将表示其他进制（如二进制、八进制、十六进制）的字符串转换为十进制整数。base 参数的取值范围是 0 和 2 到 36。

base = 2 (二进制)
字符串应只包含 ‘0’ 和 ‘1’。
“`python
str_binary = “10110” # 二进制的 10110
int_binary = int(str_binary, 2)
print(f”‘{str_binary}’ (二进制) 转换为十进制是: {int_binary}”)
# 输出: ‘10110’ (二进制) 转换为十进制是: 22

也可以包含前缀 ‘0b’ 或 ‘0B’

str_binary_prefix = “0b10110″
int_binary_prefix = int(str_binary_prefix, 2)
print(f”‘{str_binary_prefix}’ (二进制) 转换为十进制是: {int_binary_prefix}”)

输出: ‘0b10110’ (二进制) 转换为十进制是: 22

“`
base = 8 (八进制)
字符串应只包含 ‘0’ 到 ‘7’。
“`python
str_octal = “34” # 八进制的 34
int_octal = int(str_octal, 8)
print(f”‘{str_octal}’ (八进制) 转换为十进制是: {int_octal}”)
# 输出: ’34’ (八进制) 转换为十进制是: 28

也可以包含前缀 ‘0o’ 或 ‘0O’

str_octal_prefix = “0o34″
int_octal_prefix = int(str_octal_prefix, 8)
print(f”‘{str_octal_prefix}’ (八进制) 转换为十进制是: {int_octal_prefix}”)

输出: ‘0o34’ (八进制) 转换为十进制是: 28

“`
base = 16 (十六进制)
字符串应包含 ‘0’ 到 ‘9’ 和 ‘a’ 到 ‘f’ (大小写均可)。
“`python
str_hex = “1a” # 十六进制的 1a
int_hex = int(str_hex, 16)
print(f”‘{str_hex}’ (十六进制) 转换为十进制是: {int_hex}”)
# 输出: ‘1a’ (十六进制) 转换为十进制是: 26

str_hex_upper = “Ff” # 十六进制的 Ff
int_hex_upper = int(str_hex_upper, 16)
print(f”‘{str_hex_upper}’ (十六进制) 转换为十进制是: {int_hex_upper}”)

输出: ‘Ff’ (十六进制) 转换为十进制是: 255

也可以包含前缀 ‘0x’ 或 ‘0X’

str_hex_prefix = “0xff”
int_hex_prefix = int(str_hex_prefix, 16)
print(f”‘{str_hex_prefix}’ (十六进制) 转换为十进制是: {int_hex_prefix}”)

输出: ‘0xff’ (十六进制) 转换为十进制是: 255

“`
base = 0 (自动识别)
如果 base 是 0，并且字符串有前缀（如 ‘0b’, ‘0o’, ‘0x’），int() 函数将根据前缀自动判断进制。如果字符串没有前缀，则默认为十进制（等同于 base=10）。
python print(int("101", 0)) # 没有前缀，默认为 10 进制 -> 101 print(int("0b101", 0)) # 有 '0b' 前缀，识别为 2 进制 -> 5 print(int("0o101", 0)) # 有 '0o' 前缀，识别为 8 进制 -> 65 print(int("0x101", 0)) # 有 '0x' 前缀，识别为 16 进制 -> 257
需要注意的是，当 base 不为 0 时，字符串中不能包含这些前缀。例如，int("0b101", 2) 会引发 ValueError，因为 ‘0b’ 在 base=2 的上下文中是非法字符。
其他进制 (base 3 到 36)
对于 base 大于 10 的情况，int() 函数会使用字母 ‘a’ 到 ‘z’ 来表示大于 9 的数字。例如，在 base 16 中，’a’ 代表 10，’b’ 代表 11，以此类推，直到 ‘f’ 代表 15。对于 base 36，’a’ 代表 10，’b’ 代表 11，…，’z’ 代表 35。
python # base = 36 str_base36 = "az" # base 36 的 az # a 代表 10, z 代表 35 # 计算方式: 10 * 36^1 + 35 * 36^0 = 360 + 35 = 395 int_base36 = int(str_base36, 36) print(f"'{str_base36}' (base 36) 转换为十进制是: {int_base36}") # 输出: 'az' (base 36) 转换为十进制是: 395

`int()` 函数处理非字符串类型

虽然本文主要讨论字符串到整数的转换，但了解 int() 函数也能处理其他类型是有益的：

数字类型: 如果 x 已经是整数或浮点数，int() 函数会将其转换为整数。对于浮点数，它会简单地截断小数部分（丢弃，而不是四舍五入）。
python print(int(123)) # 整数转整数 -> 123 print(int(123.99)) # 浮点数转整数 (截断) -> 123 print(int(-123.99)) # 负浮点数转整数 (截断) -> -123
实现 __int__() 或 __trunc__() 方法的对象: 某些自定义对象可以通过实现这些特殊方法来定义如何被转换为整数。

潜在的错误和异常

在使用 int() 函数进行字符串转换时，可能会遇到几种错误。理解这些错误的原因对于编写健壮的代码至关重要。

`ValueError`

这是最常见的错误。当字符串的内容无法被解释为给定进制下的有效整数时，会引发 ValueError。常见的原因包括：

包含非数字字符: 字符串中除了可选的正负号和前导/尾随空白外，包含其他非数字字符。
“`python
try:
int(“abc”)
except ValueError as e:
print(f”错误: {e}”) # 输出: 错误: invalid literal for int() with base 10: ‘abc’

try:
int(“123a”)
except ValueError as e:
print(f”错误: {e}”) # 输出: 错误: invalid literal for int() with base 10: ‘123a’

try:
int(“123 456″) # 中间有空格
except ValueError as e:
print(f”错误: {e}”) # 输出: 错误: invalid literal for int() with base 10: ‘123 456’
“`
字符串为空或只包含空白: 空字符串或只包含前导/尾随空白的字符串无法转换为整数。
“`python
try:
int(“”)
except ValueError as e:
print(f”错误: {e}”) # 输出: 错误: invalid literal for int() with base 10: ”

try:
int(” “)
except ValueError as e:
print(f”错误: {e}”) # 输出: 错误: invalid literal for int() with base 10: ‘ ‘
“`
字符串表示浮点数: int() 函数不能直接将表示浮点数的字符串（如 “123.45”）转换为整数。你需要先将其转换为浮点数，然后再转换为整数。
python try: int("123.45") except ValueError as e: print(f"错误: {e}") # 输出: 错误: invalid literal for int() with base 10: '123.45'
字符串包含的数字超出了指定进制的有效范围: 当指定 base 参数时，字符串中的字符必须是该进制允许的数字。
“`python
try:
int(“1012″, 2) # 二进制字符串不能包含 ‘2’
except ValueError as e:
print(f”错误: {e}”) # 输出: 错误: invalid literal for int() with base 2: ‘1012’

try:
int(“89″, 8) # 八进制字符串不能包含 ‘8’ 或 ‘9’
except ValueError as e:
print(f”错误: {e}”) # 输出: 错误: invalid literal for int() with base 8: ’89’

try:
int(“G”, 16) # 十六进制字符串不能包含 ‘G’ (或 g)
except ValueError as e:
print(f”错误: {e}”) # 输出: 错误: invalid literal for int() with base 16: ‘G’
“`
指定了非零的 base 参数，但字符串包含前缀（如 ‘0b’, ‘0o’, ‘0x’）: 如果 base 不为 0，字符串必须严格匹配该进制的数字表示，不能包含前缀。
python try: int("0b101", 2) # base=2 时不能有 '0b' 前缀 except ValueError as e: print(f"错误: {e}") # 输出: 错误: invalid literal for int() with base 2: '0b101'

`TypeError`

当传递给 int() 函数的参数 x 不是一个字符串、数字或定义了 __int__() / __trunc__() 方法的对象时，会引发 TypeError。

“`python
try:
int([1, 2, 3]) # 列表不是可转换为整数的类型
except TypeError as e:
print(f”错误: {e}”) # 输出: 错误: int() argument must be a string, a bytes-like object or a number, not ‘list’

try:
int(None) # None 不是可转换为整数的类型
except TypeError as e:
print(f”错误: {e}”) # 输出: 错误: int() argument must be a string, a bytes-like object or a number, not ‘NoneType’
“`

错误处理策略

在实际编程中，从不可信赖的源（如用户输入、文件、网络）获取的字符串很可能无法直接转换为整数。因此，必须对转换过程中可能出现的错误进行处理，以防止程序崩溃。最推荐和 Pythonic 的方法是使用 try...except 语句。

使用 `try...except` 块

try...except 块允许你“尝试”执行一段可能出错的代码，如果发生特定的错误（异常），则执行相应的错误处理代码。

“`python
def safe_string_to_int(s, base=10):
“””
安全地将字符串转换为整数，如果转换失败则返回 None。

Args:
    s: 要转换的字符串。
    base: 可选参数，字符串的进制 (默认为 10)。

Returns:
    转换后的整数，如果转换失败则返回 None。
"""
try:
    # 尝试将字符串 s 转换为指定进制的整数
    integer_value = int(s, base)
    return integer_value
except ValueError:
    # 如果 s 无法被解释为指定进制的整数，捕获 ValueError
    print(f"无法将 '{s}' 转换为 base {base} 的整数。值错误。")
    return None
except TypeError:
    # 如果 s 的类型不正确 (不是字符串或数字)，捕获 TypeError
    print(f"无法将 '{s}' 转换为整数。类型错误。输入类型为 {type(s)}。")
    return None
# 可以选择捕获更广泛的 Exception 或不捕获 TypeError，取决于具体需求
# except Exception as e:
#     print(f"转换 '{s}' 时发生未知错误: {e}")
#     return None

示例使用

input_str1 = “12345”
result1 = safe_string_to_int(input_str1)
print(f”转换 ‘{input_str1}’: {result1}”)

input_str2 = “abc”
result2 = safe_string_to_int(input_str2)
print(f”转换 ‘{input_str2}’: {result2}”)

input_str3 = “123.45”
result3 = safe_string_to_int(input_str3)
print(f”转换 ‘{input_str3}’: {result3}”)

input_str4 = “”
result4 = safe_string_to_int(input_str4)
print(f”转换 ‘{input_str4}’: {result4}”)

input_str5 = “10110”
result5 = safe_string_to_int(input_str5, 2)
print(f”转换 ‘{input_str5}’ (base 2): {result5}”)

input_str6 = “1012”
result6 = safe_string_to_int(input_str6, 2) # 非法二进制字符串
print(f”转换 ‘{input_str6}’ (base 2): {result6}”)

input_str7 = [1, 2] # 非法类型
result7 = safe_string_to_int(input_str7)
print(f”转换 ‘{input_str7}’: {result7}”)

“`

try...except 方法是 Python 中处理这类转换错误的推荐方式，因为它遵循了 “Easier to Ask for Forgiveness than Permission” (EAFP) 的原则。也就是说，与其提前检查所有可能的无效情况（这可能复杂且容易遗漏），不如直接尝试执行操作，如果失败了再进行处理。

使用 `str.isdigit()` 和 `str.isnumeric()` (不推荐用于精确验证)

有时开发者会考虑使用字符串的内置方法如 isdigit() 或 isnumeric() 来检查一个字符串是否可以转换为整数。

str.isdigit(): 如果字符串中的所有字符都是十进制数字（’0′ 到 ‘9’），并且至少有一个字符，则返回 True。
str.isnumeric(): 如果字符串中的所有字符都是数字字符（包括 Unicode 数字，如 ②, ¾, 罗马数字等），并且至少有一个字符，则返回 True。

“`python
print(“123”.isdigit()) # True
print(“-123”.isdigit()) # False (因为 ‘-‘ 不是数字)
print(“+123”.isdigit()) # False (因为 ‘+’ 不是数字)
print(“123.45”.isdigit()) # False (因为 ‘.’ 不是数字)
print(“”.isdigit()) # False (空字符串)
print(” “.isdigit()) # False (空格不是数字)

print(“123”.isnumeric()) # True
print(“-123”.isnumeric()) # False (因为 ‘-‘ 不是数字)
print(“+123”.isnumeric()) # False (因为 ‘+’ 不是数字)
print(“123.45”.isnumeric()) # False (因为 ‘.’ 不是数字)
print(“②”.isnumeric()) # True (Unicode 数字)
print(“壹”.isnumeric()) # True (中文数字)
print(“½”.isnumeric()) # True (分数数字)
“`

为什么不推荐使用 isdigit() 或 isnumeric() 进行转换前的验证？

它们不处理负号和正号: "-123" 和 "+123" 是有效的整数字符串，但 isdigit() 和 isnumeric() 都返回 False。
它们不处理空白: int() 会忽略前导和尾随空白，但这些方法不会。" 123 ".isdigit() 是 False。
isnumeric() 处理的字符比 int() 默认接受的范围广: int("②") 会引发 ValueError，但 "②".isnumeric() 返回 True。这意味着即使 isnumeric() 返回 True，int() 转换仍然可能失败（除非指定了能处理这些字符的基数，但通常不是这样）。
冗余和非 Pythonic: 即使 isdigit() 返回 True（处理了正负号和空白的情况），你仍然需要调用 int()，而 int() 在字符串无效时 本身就会 抛出 ValueError。先检查再转换（LBYL – Look Before You Leap）在这种情况下不如直接尝试转换并处理错误（EAFP）高效和简洁。

结论: 字符检查方法如 isdigit() 和 isnumeric() 更适用于检查字符串是否 完全由 特定类型的数字字符组成，而不是用于验证一个字符串是否可以成功通过 int() 函数转换。对于验证转换，强烈推荐使用 try...except ValueError。

处理特殊情况

字符串表示浮点数 (`"123.45"`)

如前所述，int("123.45") 会导致 ValueError。如果你的字符串可能代表一个浮点数，并且你想将其转换为整数，你需要先将其转换为浮点数，然后再转换为整数。

“`python
str_float = “123.45”
try:
# 先转浮点数，再转整数
int_from_float_str = int(float(str_float))
print(f”将浮点数字符串 ‘{str_float}’ 转换为整数: {int_from_float_str}”)
# 输出: 将浮点数字符串 ‘123.45’ 转换为整数: 123
except ValueError:
print(f”字符串 ‘{str_float}’ 无法转换为浮点数或整数。”)
except TypeError:
print(f”输入 ‘{str_float}’ 类型错误。”)

str_float_neg = “-67.89″
try:
int_from_float_str_neg = int(float(str_float_neg))
print(f”将浮点数字符串 ‘{str_float_neg}’ 转换为整数: {int_from_float_str_neg}”)
# 输出: 将浮点数字符串 ‘-67.89’ 转换为整数: -67
except ValueError:
print(f”字符串 ‘{str_float_neg}’ 无法转换为浮点数或整数。”)
except TypeError:
print(f”输入 ‘{str_float_neg}’ 类型错误。”)

如果字符串不是合法的浮点数表示，float() 也会抛出 ValueError

str_invalid_float = “123.45.67”
try:
int_from_invalid_float_str = int(float(str_invalid_float))
print(f”将浮点数字符串 ‘{str_invalid_float}’ 转换为整数: {int_from_invalid_float_str}”)
except ValueError as e:
print(f”字符串 ‘{str_invalid_float}’ 无法转换为浮点数或整数。错误: {e}”)
# 输出: 字符串 ‘123.45.67’ 无法转换为浮点数或整数。错误: could not convert string to float: ‘123.45.67’

“`

重要提示: int(float_value) 会简单地截断小数部分。如果你需要四舍五入到最接近的整数，应该结合 round() 函数：

python str_float_round = "123.67" try: int_rounded = int(round(float(str_float_round))) print(f"将浮点数字符串 '{str_float_round}' 四舍五入转换为整数: {int_rounded}") # 输出: 将浮点数字符串 '123.67' 四舍五入转换为整数: 124 except ValueError: print(f"字符串 '{str_float_round}' 无法转换为浮点数或整数。") except TypeError: print(f"输入 '{str_float_round}' 类型错误。")

处理非常大的数字（任意精度整数）

Python 3 的整数类型支持任意精度，这意味着它可以处理理论上无限大的整数，只受限于系统的内存。int() 函数可以正确地将表示非常大整数的字符串转换为 Python 的任意精度整数。

python large_number_str = "1234567890123456789012345678901234567890" try: large_int = int(large_number_str) print(f"成功转换非常大的整数字符串: {large_int}") print(f"转换后的大整数类型: {type(large_int)}") # 输出: 成功转换非常大的整数字符串: 1234567890123456789012345678901234567890 # 输出: 转换后的大整数类型: <class 'int'> except ValueError as e: print(f"转换大整数字符串失败: {e}")
这使得 Python 在处理涉及大数计算的场景时非常方便，你无需担心整数溢出问题（除非你是在与某些有固定大小整数限制的外部库或系统交互）。

空白字符的处理细节

int() 函数在转换字符串时，会忽略前导（Leading）和尾随（Trailing）的空白字符。这里的“空白字符”不仅仅指空格，还包括制表符（\t）、换行符（\n）、回车符（\r）以及其他 Unicode 空白字符。

“`python
print(int(” \t\n123\r “)) # 各种空白字符

输出: 123

但字符串中间的空白是导致 ValueError 的原因

try:
int(“1 2 3″)
except ValueError as e:
print(f”错误: {e}”) # 输出: 错误: invalid literal for int() with base 10: ‘1 2 3’
“`

最佳实践

优先使用 try...except: 当从外部或不可信赖的源获取可能无法转换为整数的字符串时，使用 try...except ValueError 是最健壮和 Pythonic 的方法。它直接处理了 int() 函数可能报告的所有转换相关的错误。
明确指定 base: 如果你知道字符串代表的不是十进制数（例如，读取配置文件中的十六进制颜色码），总是在 int() 函数中明确指定 base 参数。这使得代码更清晰，避免了依赖于字符串前缀（如 ‘0x’）的隐式行为（尽管 base=0 可以处理这种情况，但明确指定通常更易读）。
处理浮点数字符串: 如果字符串可能代表浮点数，并且需要转换为整数，先使用 float() 再使用 int()。根据需求决定是直接截断 (int(float(s))) 还是四舍五入 (int(round(float(s))))。同样，这步也应该放在 try...except 块中，因为 float() 也可能引发 ValueError。
避免使用 isdigit()/isnumeric() 进行转换前验证: 它们的行为与 int() 不完全一致，可能导致误判或需要额外的逻辑来处理符号和空白。直接依赖 int() 的异常处理更简洁有效。
清晰的错误信息: 在 except 块中，提供清晰的错误信息或记录日志，说明哪个字符串转换失败以及原因（例如，通过打印异常对象 e）。这有助于调试。
定义一个辅助函数: 对于频繁进行的字符串到整数的转换（尤其是在需要错误处理的地方），可以像前面示例那样定义一个小的辅助函数（如 safe_string_to_int），封装 try...except 逻辑，提高代码的可读性和复用性。

总结

将 Python 字符串转换为整数是日常编程中的一项基础技能。核心工具是内置的 int() 函数。它功能强大，可以处理十进制、其他进制的字符串，并能忽略前导和尾随空白以及处理正负号。

然而，转换并非总是成功的。无效的字符串会引发 ValueError，不兼容的类型会引发 TypeError。为了编写健壮的代码，必须使用 try...except 语句来优雅地处理这些潜在的错误，而不是使用 isdigit() 或 isnumeric() 进行前置检查。

理解如何处理表示浮点数的字符串（先转 float 再转 int）以及 Python 对任意精度整数的支持，能帮助你应对更复杂的场景。

掌握了 int() 函数的使用、异常处理机制以及相应的最佳实践，你就能自信高效地在 Python 中进行字符串到整数的转换。

希望这篇完整指南对你有所帮助！

Python String 转 Int：完整指南

为什么需要 String 转 Int？

基本方法：使用内置的 int() 函数

简单的十进制转换

示例 1: 基本正整数

输出: ‘123’ 转换为整数是: 123, 类型是:

示例 2: 负整数

输出: ‘-456’ 转换为整数是: -456, 类型是:

示例 3: 包含正号的整数

输出: ‘+789’ 转换为整数是: 789, 类型是:

示例 4: 包含前导和尾随空白的字符串

输出: ‘ 100 ‘ 转换为整数是: 100, 类型是:

示例 5: 包含空白和符号

输出: ‘ -200 ‘ 转换为整数是: -200, 类型是:

处理其他进制的字符串

也可以包含前缀 ‘0b’ 或 ‘0B’

输出: ‘0b10110’ (二进制) 转换为十进制是: 22

也可以包含前缀 ‘0o’ 或 ‘0O’

输出: ‘0o34’ (八进制) 转换为十进制是: 28

输出: ‘Ff’ (十六进制) 转换为十进制是: 255

也可以包含前缀 ‘0x’ 或 ‘0X’

输出: ‘0xff’ (十六进制) 转换为十进制是: 255

int() 函数处理非字符串类型