在 Python 编程的世界里，变量和数据类型是构建程序大厦的基石。它们看似简单，却蕴含着无尽的奥秘和强大的功能。今天，就让我们一起深入探索 Python 中变量与数据类型的奇妙世界。

常量和表达式：数学世界的 Python 映射

在 Python 中，常量是指在程序运行过程中值不会发生改变的量。虽然 Python 不像其他一些语言那样有专门的常量声明语法，但我们通常约定使用全大写字母来表示常量，例如PI = 3.14159。这就好比我们在数学中定义圆周率，无论在程序的哪个部分使用，PI的值都固定为3.14159。

表达式则是由常量、变量、运算符和函数调用等组成的式子，它会根据运算符的优先级进行计算并返回一个结果。以2 + 3 * 4这个简单的算术表达式为例，根据数学运算规则，乘法的优先级高于加法。所以，Python 会先计算3 * 4，结果为12，然后再将2与12相加，最终得到14。在复杂的科学计算中，可能会遇到像(2.5 + 3.7) * (4.2 - 1.8) / 2这样的表达式。首先，计算括号内的内容，2.5 + 3.7 = 6.2，4.2 - 1.8 = 2.4。然后，进行乘法运算6.2 * 2.4 = 14.88，最后进行除法运算14.88 / 2 = 7.44。这些常量和表达式是我们在 Python 中进行数学运算和逻辑处理的基础工具。

一，变量和类型：程序中的灵动舞者

变量

1. 变量的定义

在 Python 中，变量是存储数据的容器。你可以把变量看作是一个标签，它指向内存中存储的数据。变量不需要事先声明类型，在赋值时会自动确定类型。

示例代码：

# 定义一个整数变量
num = 10
# 定义一个字符串变量
name = "Alice"

2. 变量的命名规则

• 变量名只能包含字母、数字和下划线。
• 变量名不能以数字开头。
• 变量名区分大小写。
• 变量名不能使用 Python 的关键字（如if、else、for等）。

# 合法的变量名
age = 20
student_name = "Bob"

# 不合法的变量名
# 以数字开头
# 123num = 10  

# 使用关键字
# if = 5  

3. 变量的赋值

在 Python 中，使用等号（=）来给变量赋值。可以一次给多个变量赋值，也可以交换两个变量的值。

示例代码：

# 一次给多个变量赋值
a, b, c = 1, 2, 3
print(a, b, c)

# 交换两个变量的值
x = 10
y = 20
x, y = y, x
print(x, y)

# 整数转浮点数
num_int = 10
num_float = float(num_int)
print(num_float)  # 10.0

# 浮点数转整数
num_float = 3.14
num_int = int(num_float)
print(num_int)  # 3

# 整数转字符串
num_int = 20
str_num = str(num_int)
print(str_num)  # '20'

变量的类型：丰富多彩的数据容器

数值类型

1. int（整数类型）

• 描述：用于表示整数，可正可负，没有小数部分。在 Python 3 里，int 类型能表示任意大小的整数，不受位数限制，这使得处理大数值时非常方便。
• 使用场景：常用于计数、索引、表示数量等，例如循环中的计数器、列表的索引等。
• 示例：

  a = 10
  b = -20
  c = 12345678901234567890  # 可以表示极大的整数

  2. float（浮点数类型）

• 描述：用于表示带有小数部分的数字，遵循 IEEE 754 标准。浮点数在内存中的存储存在一定的精度问题，这是由于二进制无法精确表示某些十进制小数。
• 使用场景：在需要处理小数的场景中使用，如科学计算、金融计算（但在金融领域需注意精度问题）等。
• 示例：

  x = 3.14
  y = -0.5

  3. complex（复数类型）

• 描述：由实部和虚部组成，虚部以 j 或 J 结尾。在数学和科学计算中，复数常用于处理交流电、信号处理等领域。
• 使用场景：在涉及复数运算的科学和工程计算中使用。
• 示例：

  z = 2 + 3j
  w = -1 - 0.5j

  4. bool（布尔类型）

• 描述：只有两个值，即 True 和 False，常用于条件判断和逻辑运算。
• 使用场景：在 if 语句、while 循环等条件控制结构中使用，用于决定程序的执行流程。
• 示例：

  is_valid = True
  has_error = False

  序列类型

  1. str（字符串类型）

• 描述：由零个或多个字符组成的不可变序列，用于表示文本数据。可以使用单引号（'）、双引号（"）或三引号（''' 或 """）来定义。三引号可以用于定义多行字符串。
• 使用场景：用于存储和处理文本信息，如用户输入、文件内容、网页文本等。
• 示例：

  single_quote_str = 'Hello'
  double_quote_str = "World"
  multi_line_str = '''This is a 
  multi - line string.'''

  2. list（列表类型）

• 描述：可变的有序序列，可包含任意类型的元素，使用方括号定义。列表支持元素的添加、删除、修改等操作。
• 使用场景：当需要存储多个元素，并且这些元素的数量和内容可能会动态变化时使用，如存储用户输入的一组数据、存储一组对象等。
• 示例：

  my_list = [1, 'apple', True]

  3. tuple（元组类型）

• 描述：有序集合，元素不能修改，使用圆括号定义。元组在创建后，其元素的数量和值都不能改变。
• 使用场景：当需要存储一组不可变的数据时使用，如函数返回多个值时可以使用元组，或者作为字典的键（因为键必须是不可变的）。
• 示例：

  my_tuple = (1, 2, 'hello')

  集合类型

  1. set（集合类型）

• 描述：无序、元素唯一的集合，使用花括号或 set() 函数来创建。集合中的元素必须是不可变类型（如数字、字符串、元组等），因为集合会对元素进行哈希操作以实现快速查找和去重。
• 使用场景：用于去重、判断元素是否存在、进行集合运算（如并集、交集、差集等）。
• 示例：

  my_set = {1, 2, 3, 3}  # 自动去重，实际为 {1, 2, 3}

  2. frozenset（冻结集合类型）

• 描述：无序、元素唯一且不可变的集合，使用 frozenset() 函数创建。一旦创建，不能对其进行添加、删除元素等修改操作。
• 使用场景：可以作为字典的键，或者在需要不可变集合的场景中使用。
• 示例：

  frozen = frozenset([1, 2, 3])

  映射类型

  dict（字典类型）

• 描述：由键值对组成，键必须唯一，使用花括号定义。字典是无序的（Python 3.7 及以后版本保证插入顺序），键必须是不可变类型（如数字、字符串、元组等），值可以是任意类型。
• 使用场景：用于存储具有关联关系的数据，如存储用户信息（姓名 - 年龄、姓名 - 地址等）、配置信息等。
• 示例：

  my_dict = {'name': 'Alice', 'age': 20}

  二进制类型

  1. bytes（不可变字节序列）

• 描述：用于存储二进制数据，是不可变的。字节对象中的每个元素是一个 0 到 255 之间的整数。
• 使用场景：在处理文件、网络数据等二进制数据时使用，如读取二进制文件、发送网络请求等。
• 示例：

  b = b'hello'

  2. bytearray（可变字节序列）

• 描述：与 bytes 类似，但它是可变的，可以对其中的元素进行修改。
• 使用场景：当需要对二进制数据进行修改时使用，如在处理二进制文件时进行数据的替换、插入等操作。
• 示例：

  ba = bytearray(b'hello')
  ba[0] = 72  # 将第一个字符替换为 'H'

  3. memoryview（内存视图）

• 描述：用于访问其他二进制对象的内存，提供了一种无需复制数据就可以操作二进制数据的方式，提高了内存使用效率。
• 使用场景：在处理大型二进制数据时，避免数据的复制，提高性能，如在 NumPy 数组操作中可能会用到。
• 示例：

  data = bytearray(b'abc')
  mv = memoryview(data)

  特殊类型

  NoneType

• 描述：只有一个值 None，通常用于表示空值或未定义的值。在函数没有显式返回值时，默认返回 None。
• 使用场景：用于初始化变量，表示变量还没有被赋予有意义的值，或者作为函数的默认返回值。
• 示例：

  result = None

  其他内置类型

  1. range

• 描述：表示不可变的整数序列，通常用于循环。可以指定起始值、结束值和步长。
• 使用场景：在 for 循环中生成一系列整数，控制循环的次数。
• 示例：

  for i in range(0, 5):
      print(i)

  2. slice

• 描述：用于指定切片操作的对象，可以通过 slice(start, stop, step) 来创建。切片操作可以用于序列类型（如列表、字符串、元组等）。
• 使用场景：当需要对序列进行切片操作，并且切片的参数需要复用或动态生成时使用。
• 示例：

  my_list = [1, 2, 3, 4, 5]
  s = slice(1, 3)
  print(my_list[s])

  3. ellipsis

• 描述：由 ... 表示，主要用于 NumPy 等库中多维数组切片，在 Python 内置中较少使用。它可以用来表示省略的维度。
• 使用场景：在处理多维数组时，简化切片操作，特别是当数组维度较多时。
• 示例：

  import numpy as np
  arr = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
  print(arr[..., 0])

动态类型特性

a = 10
print(type(a))
a = 'hello'
print(type(a))

C++/Java 这样的语言则不允许这样的操作 . 一个变量定义后类型就是固定的了 . 这种特性则称为 " 静态类型 ".

二，操作符深度剖析

1.算术运算符

加法（+）

• 功能：用于两个数值相加，得出它们的总和；若操作数为列表等序列类型，可实现拼接操作。

• 注意事项：当不同类型数据相加时，可能会引发类型错误，例如数字与字符串直接相加（除字符串与数字用+拼接的特定情况）。

• 示例：

数值相加：result = 3 + 5，result的值为8。

列表拼接：list1 = [1, 2]; list2 = [3, 4]

new_list = list1 + list2，new_list的值为[1, 2, 3, 4]。

减法（-）

• 功能：从第一个数值中减去第二个数值，得到差值。

• 注意事项：确保操作数类型为数值型，否则会报错。

• 示例：

result = 7 - 3，result的值为4。

乘法（*）

• 功能：实现两个数值相乘，得到乘积；若一个操作数为字符串，另一个为整数，则将字符串重复指定次数。

• 注意事项：同样要保证操作数类型匹配，不能用非数值或非字符串与整数进行不恰当的乘法操作。

• 示例：

数值相乘：result = 4 * 6，result的值为24。

字符串重复：new_string = "Hello" * 3，new_string的值为"HelloHelloHello"。

除法（/）

• 功能：将第一个数值除以第二个数值，返回一个浮点数结果。

• 注意事项：除数不能为零，否则会触发ZeroDivisionError异常。

• 示例：

result = 10 / 3，result的值为3.3333333333333335。

整除（//）

• 功能：执行除法运算并返回商的整数部分，舍去小数部分。

• 注意事项：除数不能为零，且结果为整数类型。

• 示例：

result = 10 // 3，result的值为3。

取模（%）

• 功能：返回两个数值相除后的余数。

• 注意事项：除数不能为零，常用于判断一个数能否被另一个数整除等场景。

• 示例：

result = 10 % 3，result的值为1。

幂运算（**）

• 功能：将第一个数值作为底数，第二个数值作为指数，计算幂次方。

• 注意事项：操作数需为数值类型，且指数为负数时，结果为底数的倒数的正数次幂。

• 示例：

result = 2 ** 3，result的值为8。

2.比较运算符

等于（==）

• 功能：判断两个操作数的值是否相等，返回布尔值True或False。

• 注意事项：比较时会考虑数据类型，不同类型数据比较可能得出不符合预期的结果，例如"5" == 5为False。

• 示例：

result1 = 5 == 5，result1为True；result2 = 5 == 3，result2为False。

不等于（!=）

• 功能：判断两个操作数的值是否不相等，返回布尔值True或False。

• 注意事项：同样要注意数据类型对比较结果的影响。

• 示例：

result1 = 5 != 3，result1为True；result2 = 5 != 5，result2为False。

大于（>）

• 功能：判断第一个操作数是否大于第二个操作数，返回布尔值True或False。

• 注意事项：操作数应为可比较类型，例如数值类型或相同类型的序列等。

• 示例：

result1 = 7 > 5，result1为True；result2 = 5 > 7，result2为False。

小于（<）

• 功能：判断第一个操作数是否小于第二个操作数，返回布尔值True或False。

• 注意事项：与大于运算符类似，需注意操作数类型。

• 示例：

result1 = 3 < 5，result1为True；result2 = 5 < 3，result2为False。

大于等于（>=）

• 功能：判断第一个操作数是否大于或等于第二个操作数，返回布尔值True或False。

• 注意事项：操作数类型需兼容比较。

• 示例：

result1 = 5 >= 5，result1为True；result2 = 3 >= 5，result2为False。

小于等于（<=）

• 功能：判断第一个操作数是否小于或等于第二个操作数，返回布尔值True或False。

• 注意事项：注意操作数类型匹配。

• 示例：

result1 = 5 <= 5，result1为True；result2 = 7 <= 5，result2为False。

3.逻辑运算符

与（and）

• 功能：当两个操作数都为True时，返回True；否则返回False，常用于组合多个条件判断。

• 注意事项：操作数应为布尔类型或可转换为布尔类型的数据，例如数值类型中，0 被视为False，非 0 视为True；空字符串、空列表等空数据结构视为False，非空视为True。

• 示例：

result1 = (5 > 3) and (2 < 4)，result1为True。

result2 = (5 > 3) and (2 > 4)，result2为False。

或（or）

• 功能：只要两个操作数中有一个为True，就返回True；只有当两个操作数都为False时，才返回False。

• 注意事项：与and运算符类似，操作数需为布尔类型或可转换为布尔类型。

• 示例：

result1 = (5 > 3) or (2 > 4)，result1为True。

result2 = (2 > 4) or (1 > 3)，result2为False。

非（not）

• 功能：对操作数的布尔值进行取反，True变为False，False变为True。

• 注意事项：操作数需为可转换为布尔类型的数据。

• 示例：

result1 = not (5 > 3)，result1为False。

result2 = not (2 > 4)，result2为True。

4.赋值运算符

简单赋值（=）

• 功能：将右侧的值赋给左侧的变量，创建或更新变量的值。

• 注意事项：变量名需符合 Python 命名规则，且左侧必须是合法变量名。

• 示例：

x = 5，此时变量x的值为5。

加法赋值（+=）

• 功能：将变量自身与右侧的值相加，并将结果重新赋给该变量，是x = x + value的简写形式。

• 注意事项：变量需先定义，且操作数类型需兼容加法运算。

• 示例：

x = 3; x += 2，执行后x的值变为5。

减法赋值（-=）

• 功能：从变量自身减去右侧的值，并将结果重新赋给该变量，即x = x - value的简写。

• 注意事项：变量需先存在，操作数类型要满足减法运算要求。

• 示例：

x = 5; x -= 2，执行后x的值变为3。

乘法赋值（*=）

• 功能：将变量自身与右侧的值相乘，并将结果重新赋给该变量，等同于x = x * value。

• 注意事项：变量需已定义，操作数类型支持乘法运算。

• 示例：

x = 3; x *= 2，执行后x的值变为6。

除法赋值（/=）

• 功能：将变量自身除以右侧的值，并将结果（浮点数）重新赋给该变量，即x = x / value。

• 注意事项：变量需先定义，除数不能为零，且结果为浮点数类型。

• 示例：

x = 6; x /= 2，执行后x的值变为3.0。

整除赋值（//=）

• 功能：将变量自身进行整除运算（除以右侧的值并取整数部分），并将结果重新赋给该变量，即x = x // value。

• 注意事项：变量需已存在，除数不能为零，结果为整数类型。

• 示例：

x = 7; x //= 2，执行后x的值变为3。

取模赋值（%=）

• 功能：将变量自身与右侧的值进行取模运算，并将结果重新赋给该变量，即x = x % value。

• 注意事项：变量需先定义，除数不能为零。

• 示例：

x = 7; x %= 2，执行后x的值变为1。

幂赋值（**=）

• 功能：将变量自身作为底数，右侧的值作为指数进行幂运算，并将结果重新赋给该变量，即x = x ** value。

• 注意事项：变量需先定义，操作数类型需为数值型。

• 示例：

x = 2; x **= 3，执行后x的值变为8。

5.位运算符

按位与（&）

• 功能：对两个操作数的每个二进制位进行与运算，只有当两个对应位都为 1 时，结果位才为 1，否则为 0。

• 注意事项：操作数需为整数类型，常用于对二进制数据进行特定位操作。

• 示例：

a = 5（二进制101）；b = 3（二进制011）。

result = a & b，result的值为1（二进制001）。

按位或（|）

• 功能：对两个操作数的每个二进制位进行或运算，只要两个对应位中有一个为 1，结果位就为 1，否则为 0。

• 注意事项：操作数应为整数类型。

• 示例：

a = 5（二进制101）；b = 3（二进制011）。

result = a | b，result的值为7（二进制111）。

按位异或（^）

• 功能：对两个操作数的每个二进制位进行异或运算，当两个对应位不同时，结果位为 1，相同时为 0。

• 注意事项：操作数需为整数类型。

• 示例：

a = 5（二进制101）；b = 3（二进制011）。

result = a ^ b，result的值为6（二进制110）。

按位取反（~）

• 功能：对操作数的每个二进制位进行取反操作，0 变 1，1 变 0。在有符号整数系统中，取反结果需考虑符号位。

• 注意事项：操作数为整数类型，取反结果的解读与整数的存储方式相关。

• 示例：

a = 5（二进制00000101）。

result = ~a，result的值为-6（二进制11111010，在有符号整数系统中）。

左移（<<）

• 功能：将操作数的二进制位向左移动指定的位数，右侧空出的位用 0 填充，相当于对原数乘以 2 的移动位数次方。

• 注意事项：操作数为整数类型，移动位数不能为负数。

• 示例：

a = 5（二进制101）。

result = a << 2，result的值为20（二进制10100）。

右移（>>）

• 功能：将操作数的二进制位向右移动指定的位数，左侧空出的位根据原数的符号位进行填充（正数用 0，负数用 1），相当于对原数除以 2 的移动位数次方并向下取整。

• 注意事项：操作数为整数类型，移动位数不能为负数。

• 示例：

a = 5（二进制101）。

result = a >> 1，result的值为2（二进制010）。

6.成员运算符

in

• 功能：判断一个值是否存在于某个序列（如列表、元组、字符串等）中，如果存在则返回True，否则返回False。

• 注意事项：第一个操作数为要查找的值，第二个操作数为序列类型数据。

• 示例：

result1 = 3 in [1, 2, 3]，result1为True。

result2 = 4 in "Hello"，result2为False。

not in

• 功能：判断一个值是否不存在于某个序列中，如果不存在则返回True，否则返回False。

• 注意事项：操作数类型要求与in运算符一致。

• 示例：

result1 = 4 not in [1, 2, 3]，result1为True。

result2 = 'l' not in "Hello"，result2为False。

7.身份运算符

is

• 功能：判断两个对象是否为同一对象，即它们在内存中是否具有相同的地址，返回布尔值True或False。

• 注意事项：比较的是对象的身份，而不仅仅是值相等，例如两个值相同但独立创建的列表，用is比较为False。

• 示例：

a = [1, 2, 3]

b = a

result = a is b，result为True。

is not

• 功能：判断两个对象是否不是同一对象，即它们在内存中的地址不同，返回布尔值True或False。

• 注意事项：与is运算符相反，关注对象地址的差异。

• 示例：

a = [1, 2, 3]

b = [1, 2, 3]

result = a is not b，result为True，因为a和b虽然值相同，但为不同的列表对象。

三，注释规范指南

在 Python 中，注释是代码中用于解释代码功能、用途、实现思路等信息的文本内容，它不会被 Python 解释器执行。合理使用注释能够提高代码的可读性和可维护性，方便开发者自己以及其他人员理解代码。Python 支持两种类型的注释：单行注释和多行注释。

单行注释

• 语法：以井号（#）开头，从 # 开始到行尾的所有内容都会被视为注释。
• 示例：

  # 这是一个单行注释，用于计算两个数的和
  a = 5
  b = 3
  result = a + b  # 计算 a 和 b 的和并存储在 result 变量中
  print(result)

• 使用场景
  • 解释代码功能：在代码行上方或旁边添加注释，说明这行代码或代码块的功能。例如，在一个复杂的数学计算或函数调用前，用注释简要说明其目的。
  • 临时禁用代码：当你想要暂时不执行某行代码，但又不想删除它时，可以在该行代码前添加 # 将其注释掉。

# num = 10  # 暂时禁用这行代码

多行注释

1. 使用多个单行注释

• 语法：在需要注释的每一行前面都加上 #。
• 示例：

  # 以下代码用于创建一个简单的列表
  # 并对列表中的元素进行求和操作
  my_list = [1, 2, 3, 4, 5]
  total = sum(my_list)
  print(total)

• 使用场景：当需要注释的内容较多，但逻辑上是逐行说明时，使用多个单行注释较为合适。

2. 使用三引号字符串

• 语法：使用三单引号（'''）或三双引号（"""）将需要注释的内容括起来。
• 示例：

  '''
  这个函数用于计算两个数的乘积
  参数:
      a: 第一个数
      b: 第二个数
  返回值:
      两个数的乘积
  '''
  def multiply(a, b):
      return a * b
  
  """
  这里也可以使用三双引号进行多行注释
  下面调用 multiply 函数进行测试
  """
  result = multiply(3, 4)
  print(result)

• 使用场景
  • 函数和类的文档字符串：在函数或类的定义下方，使用三引号字符串作为文档字符串（docstring），用于描述函数或类的功能、参数、返回值等信息。可以通过 __doc__ 属性访问这些文档字符串。

    def add(a, b):
        """
        计算两个数的和
        :param a: 第一个数
        :param b: 第二个数
        :return: 两个数的和
        """
        return a + b
    
    print(add.__doc__)  # 输出函数的文档字符串

  • 大段注释内容：当需要注释一大段文本时，使用三引号字符串更方便，无需在每行前面都添加 #。

注释的最佳实践

• 适度注释：注释应该简洁明了，避免过多无用的注释。如果代码本身已经很清晰，就不需要额外的注释。
• 保持更新：当代码发生变化时，要及时更新相应的注释，确保注释与代码的实际功能一致。
• 使用规范格式：对于函数和类的文档字符串，建议遵循一定的规范格式，如 reStructuredText 或 Google 风格，方便生成文档。例如，Google 风格的文档字符串示例如下：

  def calculate_average(numbers):
      """计算列表中数字的平均值。
  
      Args:
          numbers (list): 包含数字的列表。
  
      Returns:
          float: 列表中数字的平均值。
      """
      if not numbers:
          return 0
      return sum(numbers) / len(numbers)

  通过合理使用注释，可以让你的 Python 代码更易于理解和维护。

四，输入和输出全解析

输出

1. print() 函数

print() 是 Python 中最常用的输出函数，用于将指定的对象打印到标准输出（通常是控制台）。

基本用法

可以直接将要输出的内容作为参数传递给 print() 函数

print("Hello, World!")  # 输出字符串
print(123)  # 输出整数
print(3.14)  # 输出浮点数

输出多个对象

print() 函数可以同时输出多个对象，对象之间用逗号分隔，默认情况下会在对象之间添加一个空格。

name = "Alice"
age = 20
print("Name:", name, "Age:", age)

自定义分隔符和结束符

• sep 参数：用于指定多个对象之间的分隔符，默认值是一个空格。
• end 参数：用于指定输出内容的结束符，默认值是换行符 \n。

print("apple", "banana", "cherry", sep=", ")  # 输出: apple, banana, cherry
print("This is a line.", end=" ")
print("This is another line.")  # 两行内容会在同一行输出

格式化输出

• 旧式格式化：使用 % 操作符进行格式化。

name = "Bob"
age = 25
print("My name is %s and I'm %d years old." % (name, age))

• str.format() 方法：提供了更灵活的格式化方式。

name = "Charlie"
age = 30
print("My name is {} and I'm {} years old.".format(name, age))
# 还可以使用索引指定参数的位置
print("My name is {1} and I'm {0} years old.".format(age, name))

• f - 字符串（Python 3.6+）：在字符串前加上 f 或 F，可以在字符串中直接嵌入表达式。

name = "David"
age = 35
print(f"My name is {name} and I'm {age} years old.")
# 可以在花括号内使用表达式
print(f"The square of {age} is {age ** 2}")

2. 输出到文件

可以使用 open() 函数打开一个文件，并将 print() 函数的输出重定向到该文件。

with open('output.txt', 'w') as f:
    print("This will be written to the file.", file=f)

输入

1. input() 函数

input() 函数用于从标准输入（通常是键盘）读取用户输入的内容，返回一个字符串类型的值。

基本用法

name = input("Please enter your name: ")
print(f"Hello, {name}!")

类型转换

由于 input() 函数返回的是字符串类型，如果需要输入其他类型的数据，需要进行类型转换。

age_str = input("Please enter your age: ")
age = int(age_str)  # 将输入的字符串转换为整数
print(f"You are {age} years old.")

2. 读取文件输入

可以使用 open() 函数打开一个文件，并逐行读取文件内容。

with open('input.txt', 'r') as f:
    for line in f:
        print(line.strip())  # 去除每行末尾的换行符并打印

错误处理

在进行输入操作时，可能会出现用户输入不符合预期的情况，需要进行错误处理。例如，当用户输入的内容无法转换为所需的类型时，可以使用 try - except 语句捕获异常。

try:
    num_str = input("Please enter an integer: ")
    num = int(num_str)
    print(f"The square of {num} is {num ** 2}")
except ValueError:
    print("Invalid input. Please enter a valid integer.")