青少年编程与数学 02-008 Pyhon语言编程基础 02课题、基础概念

一、标识符
二、关键字
三、字面量
四、变量
五、运算符
- - 1. 算术运算符
  - 2. 比较运算符
  - 3. 逻辑运算符
  - 4. 赋值运算符
  - 5. 成员运算符
  - 6. 身份运算符
六、表达式
七、语句
八、注释
- - 单行注释
  - 多行注释
  - 文档字符串（Docstrings）
  - 注释的注意事项
九、输出
- - 基本输出
  - 多参数输出
  - 指定分隔符
  - 指定结束字符
  - 格式化输出
  - - 1. 百分号（%）格式化
    - 2. `str.format()` 方法
    - 3. f-strings（格式化字符串字面量）
    - 4. `%` 操作符与 `str.format()` 的对比
    - 5. 格式化数字
    - 6. 格式化列表和字典
  - 输出到文件
  - 输出表达式结果
  - 输出字典和列表
  - 打印多个语句在同一行
  - 打印对象的字符串表示

课题摘要:本文详细介绍了Python编程语言的基本概念，包括标识符、关键字、字面量、变量、运算符、表达式、语句、注释和输出。标识符是用于命名变量的规则集合，关键字是预定义的保留字，字面量是代码中直接表示值的符号。变量在Python中是动态类型的，运算符用于执行算术、比较等操作，表达式是可求值的代码片段。语句是执行操作的基本单位，包括赋值、条件、循环等。注释用于解释代码，输出语句用于显示信息。这些概念构成了Python编程的基础。

一、标识符

在Python中，标识符（Identifier）是用来标识变量、函数、类、模块和任何其他用户定义的项目的名称。以下是Python标识符的一些详细规则和特点：

命名规则：
- 标识符可以包含字母、数字和下划线（_）。
- 标识符不能以数字开头。
- 标识符只能包含ASCII字母，不能包含空格、连字符或其他特殊字符。
大小写敏感：
- Python是大小写敏感的，这意味着Variable和variable会被视为两个不同的标识符。
关键字：
- 有一些单词是Python的保留关键字，不能用作标识符。例如：if、for、while、class、def等。
命名约定：
- 驼峰命名法（CamelCase）：首单词小写，后续每个单词首字母大写。常用于类名，例如MyClass。
- 下划线命名法（Snake_case）：所有单词小写，单词之间用下划线分隔。常用于函数和变量名，例如my_function。
- 单字母命名法：通常用于临时或辅助变量，例如i、j。
内置标识符：
- Python有一些内置的标识符，如True、False、None等，它们代表了特定的值或对象。使用这些标识符作为变量名可能会覆盖内置值。
私有标识符：
- 以双下划线（__）开头的标识符被视为私有属性或方法，Python会对其进行名称重整（name mangling），以避免子类不小心覆盖父类的方法。
受保护的标识符：
- 以单下划线（_）开头的标识符被视为受保护的，这是一种约定，表明这些属性或方法不应该被外部访问。
动态命名：
- Python允许在运行时动态地创建和修改标识符，例如使用exec或locals()和globals()函数。
Unicode标识符：
- 从Python 3开始，标识符也可以包含Unicode字母，这意味着可以使用其他语言的字母来命名标识符。
避免使用内置函数名：
- 尽管不是严格禁止，但最好避免使用内置函数名（如list、dict、str等）作为变量名，以免造成混淆。
避免使用保留字：
- 尽管某些保留字（如await、async）在特定上下文中不是关键字，但最好避免使用它们作为标识符，以避免潜在的混淆。
标识符的作用域：
- 标识符的作用域决定了它们可以被访问的区域。例如，局部变量只能在定义它们的函数内部访问，而全局变量可以在整个模块中访问。

了解和遵循这些规则和约定对于编写清晰、可维护的Python代码非常重要。正确的命名可以提高代码的可读性和可维护性。

二、关键字

Python是一种动态的、解释型的、面向对象的脚本语言，它有一些预定义的关键字，这些关键字不能用作标识符名称。以下是Python 3.10版本中的所有关键字：

False：布尔值假。
await：用于定义异步函数。
else：与if一起使用，表示条件不成立时执行的代码块。
import：用于导入模块。
True：布尔值真。
break：用于跳出循环。
except：用于异常处理。
in：用于成员检查。
try：用于异常处理。
class：用于定义类。
finally：用于异常处理，无论是否发生异常都会执行。
is：用于检查两个对象是否为同一对象。
def：用于定义函数。
from：用于从模块中导入特定的类或函数。
lambda：用于创建匿名函数。
return：用于从函数返回值。
nonlocal：用于在嵌套作用域中修改外部变量。
global：用于声明全局变量。
as：用于给导入的模块指定别名。
if：用于条件判断。
elif：用于条件判断的另一种情况。
or：布尔逻辑或。
pass：空操作，不做任何事情。
with：用于上下文管理器。
assert：用于调试，断言某个条件为真。
del：用于删除对象。
for：用于循环。
not：布尔逻辑非。
raise：用于抛出异常。
while：用于循环。
and：布尔逻辑与。
exec：用于执行字符串中的Python代码。
print：用于打印输出。
yield：用于生成器函数。
None：表示空值。
continue：用于跳过当前循环的剩余代码，直接开始下一次循环。
as：用于给导入的模块指定别名（与import一起使用）。
async：用于定义异步函数或方法。
await：用于暂停函数执行，等待可等待对象完成。

这些关键字是Python语言的基础，它们定义了Python的语法结构和行为。了解这些关键字对于编写Python代码至关重要。

三、字面量

Python中的字面量（literal）是指直接在代码中表示值的符号。以下是Python中常见的几种字面量类型：

数值字面量：
- 整数（Integers）：不带小数点的数字，可以是正数或负数。
  - 例如：42, -7, 0, 10
- 浮点数（Floats）：带有小数点的数字，可以是正数或负数。
  - 例如：3.14, -0.001, 2.5e2（科学计数法表示250）
- 复数（Complex numbers）：由实部和虚部组成，使用j或J表示虚部。
  - 例如：1 + 2j, -3.5 - 4.2j
字符串字面量：
- 可以使用单引号'或双引号"来创建字符串。
  - 例如：'hello', "world"
- 可以使用三引号'''或"""来创建多行字符串。
  - 例如：
```
three_lines = """
First line
Second line
Third line
"""
```
- 字符串可以包含转义字符，如\n（换行符）和\t（制表符）。
  - 例如："Hello\nWorld" 会在"Hello"和"World"之间插入一个换行。
布尔字面量：
- True和False表示布尔值真和假。
  - 例如：True, False
空值字面量：
- None表示空值或无值。
  - 例如：None
集合字面量：
- 使用大括号{}创建集合，集合中的元素是唯一的。
  - 例如：{1, 2, 3}
列表字面量：
- 使用方括号[]创建列表，列表中的元素可以重复。
  - 例如：[1, 2, 3]
字典字面量：
- 使用大括号{}创建字典，字典中的元素是键值对。
  - 例如：{'key1': 'value1', 'key2': 'value2'}
元组字面量：
- 使用圆括号()或逗号分隔的值创建元组，元组是不可变的。
  - 例如：(1, 2, 3) 或 1, 2, 3
字节字面量：
- 使用前缀b表示字节字符串。
  - 例如：b'hello'
字节数组字面量：
- 使用bytearray()函数和方括号[]创建字节数组。
  - 例如：bytearray(b'hello')
枚举字面量：
- 使用enum模块创建枚举类型，枚举类型的成员是唯一的。
  - 例如：
```
from enum import Enum
class Color(Enum):RED = 1GREEN = 2BLUE = 3
```

这些字面量是Python中表示数据的基本方式，它们可以直接在代码中使用，无需额外的声明或定义。通过这些字面量，Python能够以一种非常直观和简洁的方式处理数据。

四、变量

Python 是一种动态类型的编程语言，这意味着变量的类型是在运行时确定的，而不是在编译时。在 Python 中，变量的声明和使用非常简单，不需要指定数据类型。以下是关于 Python 变量的一些详细解释：

变量的定义：
在 Python 中，变量是通过赋值来定义的。例如：
```
x = 10
```
这里 x 就是一个变量，它被赋予了整数值 10。
动态类型：
Python 是动态类型语言，这意味着同一个变量可以被赋予不同类型的值：
```
x = 10        # x 是一个整数
x = "Hello"   # x 现在是一个字符串
```
变量名的规则：
- 变量名必须以字母或下划线开头。
- 变量名只能包含字母、数字和下划线（A-z, 0-9, 和 _ ）。
- 变量名是区分大小写的。
变量的作用域：
- 局部变量：在函数内部定义的变量，只能在该函数内部访问。
- 全局变量：在函数外部定义的变量，可以被程序中的任何部分访问。
变量的类型：
Python 中的变量可以存储任何类型的数据，包括但不限于：
- 整数（int）
- 浮点数（float）
- 字符串（str）
- 列表（list）
- 元组（tuple）
- 字典（dict）
- 集合（set）
- 布尔值（bool）
变量的引用：
在 Python 中，变量实际上是对内存中对象的引用。当你将一个值赋给变量时，你实际上是在创建一个指向该值的引用：
```
a = [1, 2, 3]
b = a
```
这里 a 和 b 都指向同一个列表对象。
可变类型与不可变类型：
- 不可变类型：如整数、浮点数、字符串和元组，一旦创建，它们的值不能被改变。
- 可变类型：如列表、字典、集合等，它们的值可以在创建后被修改。
垃圾回收：
Python 使用引用计数和垃圾收集机制来管理内存。当一个对象的引用计数降到零时，它会被垃圾收集器回收。
变量的解包：
Python 允许你将一个序列中的值赋给多个变量，这称为解包：
```
a, b, c = 1, 2, 3
```
关键字参数：
在函数调用中，你可以使用关键字参数来指定变量名和对应的值，这使得代码更清晰：
```
def func(a, b, c):print(a, b, c)func(a=1, b=2, c=3)
```
变量的命名约定：
- 使用小写字母和下划线来命名变量。
- 避免使用 Python 的关键字和内置函数作为变量名。
变量的垃圾回收：
当一个变量不再被引用时，Python 的垃圾收集器会自动回收其占用的内存。

理解这些基本概念对于编写有效和高效的 Python 代码至关重要。

五、运算符

Python 提供了一系列运算符来执行不同的操作，包括算术运算、比较运算、逻辑运算、赋值运算等。以下是 Python 中常用的运算符及其详解：

1. 算术运算符

加法（+）：用于加法运算。
```
a = 5 + 3  # 结果 8
```
减法（-）：用于减法运算。
```
a = 5 - 3  # 结果 2
```
乘法（*）：用于乘法运算。
```
a = 5 * 3  # 结果 15
```
除法（/）：用于除法运算，结果为浮点数。
```
a = 5 / 3  # 结果 1.6666666666666667
```
整除（//）：用于除法运算，结果为整数。
```
a = 5 // 3  # 结果 1
```
模运算（%）：返回除法的余数。
```
a = 5 % 3  # 结果 2
```
指数运算（）**：用于计算幂。
```
a = 5 ** 3  # 结果 125
```
地板除（//）：与整除相同，结果是整数。
```
a = 5 // 3  # 结果 1
```

2. 比较运算符

等于（==）：检查两个值是否相等。
```
a = 5
b = 5
print(a == b)  # True
```
不等于（!=）：检查两个值是否不相等。
```
a = 5
b = 6
print(a != b)  # True
```
大于（>）：检查左边的值是否大于右边的值。
```
a = 5
b = 6
print(a > b)  # False
```
小于（<）：检查左边的值是否小于右边的值。
```
a = 5
b = 6
print(a < b)  # True
```
大于等于（>=）：检查左边的值是否大于或等于右边的值。
```
a = 5
b = 6
print(a >= b)  # False
```
小于等于（<=）：检查左边的值是否小于或等于右边的值。
```
a = 5
b = 6
print(a <= b)  # True
```

3. 逻辑运算符

逻辑与（and）：如果两个操作数都为真，则结果为真。
```
print(True and True)  # True
print(True and False)  # False
```
逻辑或（or）：如果两个操作数中至少有一个为真，则结果为真。
```
print(True or False)  # True
print(False or False)  # False
```

逻辑非（not）：反转操作数的布尔值。

print(not True)  # False
print(not False)  # True

4. 赋值运算符

等于（=）：将右边的值赋给左边的变量。
```
a = 5
```
加等于（+=）：左边的变量增加右边的值。
```
a = 5
a += 3  # a 现在是 8
```
减等于（-=）：左边的变量减少右边的值。
```
a = 5
a -= 3  # a 现在是 2
```
乘等于（*=）：左边的变量乘以右边的值。
```
a = 5
a *= 3  # a 现在是 15
```
除等于（/=）：左边的变量除以右边的值。
```
a = 5
a /= 3  # a 现在是 1.6666666666666667
```
整除等于（//=）：左边的变量整除右边的值。
```
a = 5
a //= 3  # a 现在是 1
```
模等于（%=）：左边的变量取模右边的值。
```
a = 5
a %= 3  # a 现在是 2
```
指数等于（=）**：左边的变量指数右边的值。
```
a = 5
a **= 3  # a 现在是 125
```

5. 成员运算符

in：检查左边的值是否在右边的序列中。
```
a = [1, 2, 3]
print(2 in a)  # True
```
not in：检查左边的值是否不在右边的序列中。
```
a = [1, 2, 3]
print(4 not in a)  # True
```

6. 身份运算符

is：检查两个引用是否指向同一个对象。

a = [1, 2, 3]
b = a
print(a is b)  # True

is not：检查两个引用是否不指向同一个对象。

a = [1, 2, 3]
b = [1, 2, 3]
print(a is not b)  # True

这些运算符是 Python 编程中的基础，掌握它们对于编写有效的 Python 代码至关重要。

六、表达式

在Python中，表达式是一段可以被求值并产生结果值的代码。表达式可以简单到一个单独的数字或变量，也可以复杂到包含多个操作符和函数调用的组合。以下是Python中一些主要类型的表达式及其详解：

字面量（Literals）：
- 数字：如42、3.14（整数和浮点数）
- 字符串：如"hello"或'world'（使用双引号或单引号）
- 布尔值：True和False
- 空值：None
变量（Variables）：
- 变量是存储数据值的名称。例如，x = 10创建了一个名为x的变量，并将其与值10关联。
算术运算符：
- 加法：+
- 减法：-
- 乘法：*
- 除法：/
- 整除：//（结果为整数）
- 模运算：%（返回余数）
- 指数运算：**
关系运算符：
- 等于：==
- 不等于：!=
- 大于：>
- 小于：<
- 大于等于：>=
- 小于等于：<=
逻辑运算符：
- 逻辑与：and
- 逻辑或：or
- 逻辑非：not
成员运算符：
- 属于：in（检查元素是否存在于序列中）
- 不属于：not in
身份运算符：
- 恒等：is（检查两个引用是否指向同一个对象）
- 不恒等：is not
位运算符：
- 按位与：&
- 按位或：|
- 按位异或：^
- 按位非：~
- 左移：<<
- 右移：>>
赋值运算符：
- 单赋值：=
- 复合赋值：+=、-=、*=、/=等
函数调用：
- 调用函数时，函数名后跟括号，括号内可以包含参数。例如，math.sqrt(16)。
列表推导式（List Comprehensions）：
- 用于创建列表的简洁方式，例如，[x*2 for x in range(10)]。
生成器表达式（Generator Expressions）：
- 类似于列表推导式，但返回一个生成器，例如，(x*2 for x in range(10))。
条件表达式（Conditional Expressions）：
- 也称为三元条件运算符，格式为x if condition else y。
lambda表达式：
- 创建匿名函数的简洁方式，例如，lambda x: x*2。
属性访问和方法调用：
- 通过点.访问对象的属性或方法，例如，obj.attribute或obj.method()。
索引和切片：
- 访问序列（如列表、字符串、元组）中的元素，例如，sequence[index]或sequence[start:end:step]。
运算符优先级：
- Python中有一套确定的运算符优先级规则，决定了表达式中运算符的执行顺序。
表达式求值：
- Python会按照运算符优先级和结合性规则来求值表达式。

这些是Python中表达式的一些基本类型和概念。掌握这些表达式对于编写有效和高效的Python代码至关重要。

七、语句

Python语言中的语句是执行特定操作的基本单位。以下是一些基本的Python语句类型及其详解：

赋值语句：
- 用于将值赋给变量。
- 语法：variable = value
- 例如：x = 5
输入输出语句：
- print()：用于输出信息到控制台。
- input()：用于从用户那里接收输入。
- 例如：
```
name = input("Enter your name: ")
print("Hello, " + name)
```
条件语句：
- if：用于条件判断。
- elif：用于条件判断的另一种情况。
- else：用于条件不成立时执行的代码块。
- 例如：
```
if x > 0:print("x is positive")
elif x == 0:print("x is zero")
else:print("x is negative")
```
循环语句：
- for：用于遍历序列（如列表、元组、字典、字符串）。
- while：用于在满足条件时重复执行代码块。
- 例如：
```
for i in range(5):print(i)i = 1
while i <= 5:print(i)i += 1
```
函数定义语句：
- def：用于定义函数。
- 语法：def function_name(parameters):
- 例如：
```
def greet(name):print("Hello, " + name)greet("Alice")
```

类定义语句：

class：用于定义类。
语法：class ClassName:

例如：

class Greeter:def __init__(self, name):self.name = namedef greet(self):print("Hello, " + self.name)greeter = Greeter("Bob")
greeter.greet()

异常处理语句：
- try：用于尝试执行代码块。
- except：用于捕获异常。
- finally：无论是否发生异常都会执行。
- raise：用于抛出异常。
- 例如：
```
try:x = 1 / 0
except ZeroDivisionError:print("You can't divide by zero!")
finally:print("This will always be executed.")
```
导入语句：
- import：用于导入模块。
- from ... import ...：从模块中导入特定的类或函数。
- 例如：
```
import math
from datetime import datetime
```

装饰器语句：

@decorator：用于在不修改函数内容的情况下增加函数功能。

例如：

def my_decorator(func):def wrapper():print("Something is happening before the function is called.")func()print("Something is happening after the function is called.")return wrapper@my_decorator
def say_hello():print("Hello!")say_hello()

返回语句：
- return：用于从函数返回值。
- 例如：
```
def add(a, b):return a + bresult = add(3, 4)
```
全局和非局部变量声明：
- global：用于声明全局变量。
- nonlocal：用于在嵌套作用域中声明变量。
- 例如：
```
x = "global"def func():global xx = "local"print(x)func()
```
断言语句：
- assert：用于调试，断言某个条件为真。
- 例如：
```
assert 2 + 2 == 4
```

这些语句构成了Python编程的基础，通过组合这些基本语句，可以构建出复杂的程序逻辑。

八、注释

在 Python 中，注释是用来解释代码的，它们不会被程序执行。注释可以帮助其他开发者（或未来的你）理解代码的目的和逻辑。Python 提供了两种方式来编写注释：

单行注释

单行注释使用井号（#）开始。井号后面的内容直到行尾都会被 Python 解释器忽略。

# 这是一个单行注释
x = 5  # 这也是一个单行注释，用来说明变量赋值

多行注释

Python 中没有官方的多行注释语法，但可以使用三个连续的引号（单引号 ''' 或双引号 """）来创建多行字符串，这通常被用作多行注释或文档字符串（docstrings）。

"""
这是一个多行注释
它可以跨越多行
并且被用来解释复杂的代码块
"""# 或者使用单引号
'''
这也是一个多行注释
用于同样的用途
'''

文档字符串（Docstrings）

文档字符串是 Python 中一种特殊的注释方式，它使用三个引号创建，通常放在函数、类和模块的开头，用来描述它们的功能和用法。

def my_function():"""这是一个文档字符串它描述了函数的功能"""passclass MyClass:"""这是一个类的文档字符串它描述了类的用途和功能"""pass"""
这是一个模块的文档字符串
它描述了模块的内容和目的
"""

文档字符串不仅是注释，它们还可以被特别地提取和显示，例如使用内置的 help() 函数。

help(my_function)

注释的注意事项

注释应该简洁明了，直接说明代码的目的和逻辑。
避免在注释中包含过多的细节，注释应该是代码的补充，而不是代码的重复。
注释应该保持更新，如果代码更改了，相关的注释也应该更新，以避免混淆。
在团队项目中，注释的风格和格式应该保持一致，以便于理解和维护。

正确和恰当地使用注释可以极大地提高代码的可读性和可维护性。

九、输出

在 Python 中，输出语句通常用于将信息显示在控制台或屏幕上。Python 提供了几种不同的方法来实现输出，最常用的是 print() 函数。基本的输出对于初学编程及程序调试至关重要。

以下是 print() 函数的一些详细用法和特点：

基本输出

print() 函数用于输出信息到控制台。如果没有指定 end 参数，print() 默认在输出后添加一个换行符（\n）。

print("Hello, World!")

多参数输出

print() 可以接受多个参数，并且它们之间默认用空格分隔。

print("Hello", "World", "!")

指定分隔符

通过 sep 参数，可以指定参数之间的分隔符，默认为空格。

print("Hello", "World", "!", sep="-")
# 输出: Hello-World-!

指定结束字符

通过 end 参数，可以指定 print() 函数输出后的结束字符，默认为换行符 \n。

print("Hello, World!", end=" ")
print("Welcome to Python.")
# 输出: Hello, World! Welcome to Python.

格式化输出

Python 提供了多种字符串格式化方法来实现复杂的输出格式。以下是几种常用的字符串格式化方法：

1. 百分号（%）格式化

这是最古老的字符串格式化方法，使用 % 操作符。

name = "Kimi"
age = 30
print("Hello, %s. You are %d years old." % (name, age))

%s 代表字符串
%d 代表整数
%f 代表浮点数
%.2f 代表保留两位小数的浮点数

2. `str.format()` 方法

这是一种更现代的字符串格式化方法，使用 .format() 方法。

name = "Kimi"
age = 30
print("Hello, {}. You are {} years old.".format(name, age))

.format() 方法可以链式调用，也可以使用索引和关键字参数：

# 链式调用
print("Hello, {0}. You are {1} years old.".format(name, age))# 使用索引
print("Hello, {1}. You are {0} years old.".format(age, name))# 使用关键字参数
print("Hello, {name}. You are {age} years old.".format(name=name, age=age))

还可以指定字段宽度、填充字符、对齐方式等：

# 指定宽度和填充
print("Hello, {name:<10}. You are {age:>2} years old.".format(name=name, age=age))
# 输出: Hello, Kimi     . You are 30  years old.# 指定宽度和填充字符
print("Hello, {name:_<10}. You are {age:>2} years old.".format(name=name, age=age))
# 输出: Hello, _Kimi_____. You are 30  years old.

3. f-strings（格式化字符串字面量）

从 Python 3.6 开始，可以使用 f-strings 进行字符串格式化，这是最快的格式化方法。

name = "Kimi"
age = 30
print(f"Hello, {name}. You are {age} years old.")

f-strings 也支持表达式和属性访问：

class Person:def __init__(self, name, age):self.name = nameself.age = ageperson = Person("Kimi", 30)
print(f"Hello, {person.name}. You are {person.age} years old.")

4. `%` 操作符与 `str.format()` 的对比

% 操作符是老式的格式化方法，功能有限。
str.format() 提供了更多的灵活性和功能，如链式调用、关键字参数等。
f-strings 提供了最简洁和最快的格式化方法，但仅在 Python 3.6+ 支持。

5. 格式化数字

格式化输出时，可以指定数字的格式：

# 浮点数
print("{:.2f}".format(3.14159))  # 输出: 3.14# 整数
print("{:08d}".format(10))  # 输出: 00000010# 十六进制
print("{:x}".format(255))  # 输出: ff
print("{:X}".format(255))  # 输出: FF# 二进制
print("{:b}".format(10))  # 输出: 1010

6. 格式化列表和字典

可以使用 * 运算符来解包列表或字典，并在格式化字符串中使用它们：

# 列表
coordinates = [1, 2, 3]
print("Coordinates: x={0[0]}, y={0[1]}, z={0[2]}".format(*coordinates))# 字典
person = {'name': 'Kimi', 'age': 30}
print("Name: {name}, Age: {age}".format(**person))

通过这些格式化方法，Python 允许你灵活地控制输出格式，使代码更加清晰和易于维护。

输出到文件

print() 函数还可以将输出重定向到文件。

with open('output.txt', 'w') as f:print("Hello, World!", file=f)

输出表达式结果

print() 函数可以直接输出表达式的结果。

a = 5
b = 10
print(a + b)  # 输出 15

输出字典和列表

print() 函数可以输出字典和列表的内容。

my_list = [1, 2, 3]
my_dict = {'name': 'Kimi', 'age': 30}
print(my_list)
print(my_dict)

打印多个语句在同一行

使用逗号分隔 print() 函数中的参数，可以让多个输出语句显示在同一行。

print("Hello,", end=" ")
print("World!")

打印对象的字符串表示

print() 函数可以输出任何对象的字符串表示，如果对象没有定义 __str__ 方法，则会使用 __repr__ 方法。

class MyClass:def __str__(self):return "MyClass instance"obj = MyClass()
print(obj)  # 输出: MyClass instance

print() 函数是 Python 中最常用的输出工具，它的灵活性和易用性使得在开发过程中进行调试和展示结果变得非常方便。