Python 基础语法（一）¶

Python 是一种简洁、易学、功能强大的编程语言，广泛应用于Web开发、数据分析、人工智能、自动化脚本等领域。本教程将带你从零开始学习 Python 编程的基础语法。

第一章：Python 入门¶

（一）Python 简介¶

什么是 Python？ Python 是由 Guido van Rossum 于 1991 年发布的高级编程语言，具有以下特点：

核心特点：

简洁易读：语法简洁，代码可读性强，接近自然语言
面向对象：完全支持面向对象编程
动态类型：变量无需声明类型，使用时自动推断
解释执行：代码由解释器逐行执行，无需编译
跨平台：可在 Windows、Linux、macOS 等多种平台上运行
丰富的库：拥有庞大的标准库和第三方库生态系统

Python 的应用领域：

Web开发：Django、Flask、FastAPI
数据分析和科学计算：NumPy、Pandas、Matplotlib
人工智能和机器学习：TensorFlow、PyTorch、Scikit-learn
自动化脚本和运维：Ansible、Fabric
网络爬虫：Scrapy、BeautifulSoup
桌面应用开发：PyQt、Tkinter、Kivy
游戏开发：Pygame
数据可视化：Plotly、Seaborn
网络安全：Scapy、Metasploit Framework

Python 的版本：

Python 2.x：旧版本，已于2020年停止支持
Python 3.x：当前版本，持续更新维护
推荐：所有新项目都应该使用 Python 3.x

当前流行版本： - Python 3.10：稳定版 - Python 3.11：性能提升版 - Python 3.12：最新稳定版

（二）Python 安装与配置¶

在 Windows 上安装 Python：

方法一：官网下载安装 1. 访问 Python 官网：https://www.python.org/downloads/ 2. 下载最新稳定版的 Python 安装包 3. 运行安装程序 4. 重要：勾选 "Add Python to PATH" 选项 5. 选择 "Install Now" 或 "Customize installation" 进行自定义安装 6. 等待安装完成

方法二：使用 Microsoft Store 1. 打开 Microsoft Store 2. 搜索 "Python" 3. 点击 "Get" 或 "安装" 按钮

方法三：使用 Winget（Windows 包管理器）

winget install Python.Python.3.12

在 Linux 上安装 Python：

Ubuntu/Debian：

sudo apt update
sudo apt install python3
sudo apt install python3-pip

CentOS/RHEL：

sudo yum install python3
sudo yum install python3-pip

Arch Linux：

sudo pacman -S python
sudo pacman -S python-pip

在 macOS 上安装 Python：

方法一：官网下载安装 1. 访问 Python 官网下载 macOS 安装包 2. 运行安装程序并按提示操作

方法二：使用 Homebrew

brew install python

验证安装：

打开命令行（Windows：CMD 或 PowerShell；Linux/macOS：Terminal），输入：

python --version
# 或
python3 --version

如果显示版本号（如 Python 3.12.0），说明安装成功。

安装包管理器 pip：

Python 3.4+ 版本通常自带 pip。检查 pip 是否安装：

pip --version
# 或
pip3 --version

如果没有安装，可以使用以下命令安装：

python -m ensurepip --upgrade

升级 pip：

python -m pip install --upgrade pip

（三）Python 开发环境配置¶

推荐的开发工具：

1. PyCharm（专业 Python IDE） - 优点：功能强大、智能代码补全、调试功能完善、支持 Django/Flask - 下载：https://www.jetbrains.com/pycharm/ - 版本：Community（免费）和 Professional（付费） - 适合：专业开发、大型项目

2. Visual Studio Code（轻量级编辑器） - 优点：免费开源、插件丰富、启动快速、跨平台 - 下载：https://code.visualstudio.com/ - 插件：Python、Pylance、Black、Jupyter - 适合：日常开发、多语言项目

3. Jupyter Notebook（数据分析首选） - 优点：交互式编程、可视化效果好、适合数据分析 - 安装：pip install jupyter - 启动：jupyter notebook - 适合：数据科学、机器学习、教学

4. Anaconda（科学计算环境） - 优点：内置常用库、环境管理方便、跨平台 - 下载：https://www.anaconda.com/ - 适合：数据分析、科学计算、机器学习

5. Sublime Text / Atom（轻量级编辑器） - 优点：启动快速、界面简洁、可定制性强 - 适合：快速编辑、小型项目

配置 Python 虚拟环境：

为什么使用虚拟环境？ - 隔离项目依赖 - 避免版本冲突 - 便于项目管理和部署

使用 venv 创建虚拟环境：

# 创建虚拟环境
python -m venv myenv

# 激活虚拟环境（Windows）
myenv\Scripts\activate

# 激活虚拟环境（Linux/macOS）
source myenv/bin/activate

# 退出虚拟环境
deactivate

使用 conda 创建虚拟环境：

# 创建环境
conda create --name myenv python=3.12

# 激活环境
conda activate myenv

# 退出环境
conda deactivate

# 删除环境
conda remove --name myenv --all

（四）第一个 Python 程序¶

Hello World 程序：

创建文件 hello.py，内容如下：

# 这是你的第一个 Python 程序
print("Hello, World!")

运行程序：

python hello.py

输出：

Hello, World!

程序解析：

# 开头的行是注释，用于解释代码，不会被解释器执行
print() 是一个内置函数，用于将内容输出到控制台
"Hello, World!" 是一个字符串，用引号括起来
Python 语句通常以换行结束，不需要分号

更多示例：

# 打印多行文本
print("Hello, World!")
print("欢迎来到 Python 世界！")
print("让我们开始编程之旅吧！")

# 打印空行
print()  # 打印一个空行

# 打印多个内容（用逗号分隔）
print("姓名:", "张三", "年龄:", 20, "城市:", "北京")

交互式模式：

除了运行 .py 文件，你还可以使用 Python 的交互式模式：

python

进入交互式环境后：

>>> print("Hello, World!")
Hello, World!
>>> 2 + 3
5
>>> x = 10
>>> x * 2
20
>>> exit()

IPython（增强的交互式环境）：

安装 IPython：

pip install ipython

启动 IPython：

ipython

IPython 提供了更好的代码补全、语法高亮等功能。

第二章：变量和数据类型¶

（一）变量¶

变量的定义：变量是用于存储数据的内存位置，通过变量名可以访问存储的数据。

变量命名规则：

只能包含：字母、数字和下划线
不能以数字开头
区分大小写（myVar 和 myvar 是不同的变量）
不能使用 Python 关键字
命名要有意义，遵循见名知意的原则

有效变量名示例：

name = "张三"
age = 20
student_id = 2024001
is_student = True
total_score = 95.5

无效变量名示例：

2name = "错误"  # 不能以数字开头
my-name = "错误"  # 不能使用连字符
class = "错误"  # class 是 Python 关键字

Python 关键字列表：

False, None, True, and, as, assert, async, await, break, class, continue, def, del, elif, else, except, finally, for, from, global, if, import, in, is, lambda, nonlocal, not, or, pass, raise, return, try, while, with, yield

变量赋值：

# 基本赋值
x = 10
name = "张三"
height = 1.75
is_active = True

# 多重赋值
a = b = c = 10
print(a, b, c)  # 10 10 10

# 多元赋值（解包）
x, y, z = 1, 2, 3
print(x, y, z)  # 1 2 3

# 交换变量值
a, b = 10, 20
a, b = b, a
print(a, b)  # 20 10

# 使用其他变量的值
radius = 5
area = 3.14159 * radius ** 2
print(f"半径为 {radius} 的圆的面积是 {area}")

变量删除：

x = 10
print(x)  # 10

del x
# print(x)  # NameError: name 'x' is not defined

（二）基本数据类型¶

Python 的基本数据类型：

整数：没有大小限制，可以是任意大
浮点数：带小数点的数字
布尔值：True 或 False
字符串：文本数据
空值（None）：表示空或无值

1. 整数¶

整数类型：

# 十进制
decimal = 42

# 二进制（以 0b 或 0B 开头）
binary = 0b101010  # 十进制 42

# 八进制（以 0o 或 0O 开头）
octal = 0o52  # 十进制 42

# 十六进制（以 0x 或 0X 开头）
hexadecimal = 0x2A  # 十进制 42

print(decimal)      # 42
print(binary)       # 42
print(octal)        # 42
print(hexadecimal)  # 42

整数运算：

a = 10
b = 3

# 加法
print(a + b)  # 13

# 减法
print(a - b)  # 7

# 乘法
print(a * b)  # 30

# 除法（浮点数结果）
print(a / b)  # 3.333...

# 整除（向下取整）
print(a // b)  # 3

# 取余
print(a % b)  # 1

# 幂运算
print(a ** b)  # 1000

# 负数
print(-a)  # -10

# 绝对值
print(abs(-5))  # 5

大整数运算：

# Python 可以处理任意大的整数
big_number = 123456789012345678901234567890
print(big_number ** 2)

# 阶乘
import math
print(math.factorial(100))

2. 浮点数¶

浮点数类型：

# 常见表示法
pi = 3.14159
e = 2.71828
negative = -3.14

# 科学计数法
large = 1.23e5    # 123000.0
small = 1.23e-5   # 0.0000123

print(large)  # 123000.0
print(small)  # 1.23e-05

浮点数精度问题：

# 浮点数精度问题
a = 0.1 + 0.2
print(a)  # 0.30000000000000004

# 解决方法1：使用 round() 函数
print(round(a, 2))  # 0.3

# 解决方法2：使用 decimal 模块（高精度计算）
from decimal import Decimal, getcontext
getcontext().prec = 10
a = Decimal('0.1') + Decimal('0.2')
print(a)  # 0.3

浮点数运算：

a = 3.14
b = 2.71

# 基本运算
print(a + b)  # 5.85
print(a - b)  # 0.43
print(a * b)  # 8.5094
print(a / b)  # 1.158...

# 数学函数
import math
print(math.pi)        # 3.14159...
print(math.e)         # 2.71828...
print(math.sqrt(16))  # 4.0
print(math.pow(2, 3)) # 8.0
print(math.floor(3.7)) # 3
print(math.ceil(3.2))  # 4
print(math.trunc(3.7)) # 3

3. 布尔值¶

布尔类型：

is_true = True
is_false = False

print(is_true)   # True
print(is_false)  # False

布尔运算：

a = True
b = False

# 逻辑与（and）
print(a and b)  # False
print(True and True)  # True

# 逻辑或（or）
print(a or b)   # True
print(False or False)  # False

# 逻辑非（not）
print(not a)    # False
print(not False)  # True

# 短路求值
result = True or print("这不会执行")  # True
result = False and print("这不会执行")  # False

比较运算符返回布尔值：

a = 10
b = 20

print(a == b)  # False（等于）
print(a != b)  # True（不等于）
print(a > b)   # False（大于）
print(a < b)   # True（小于）
print(a >= b)  # False（大于等于）
print(a <= b)  # True（小于等于）

类型转换：

# 转换为布尔值
print(bool(0))     # False
print(bool(1))     # True
print(bool(""))    # False
print(bool("text")) # True
print(bool([]))    # False
print(bool([1, 2])) # True
print(bool(None))  # False

4. 字符串¶

字符串创建：

# 单引号
str1 = 'Hello'

# 双引号
str2 = "World"

# 三引号（多行字符串）
str3 = """
这是一个
多行字符串
"""

print(str1)
print(str2)
print(str3)

字符串访问：

text = "Hello, World!"

# 访问单个字符（索引从 0 开始）
print(text[0])   # 'H'
print(text[6])   # 'W'
print(text[-1])  # '!'（最后一个字符）
print(text[-2])  # 'd'（倒数第二个字符）

# 字符串切片
print(text[0:5])    # 'Hello'（从索引 0 到 4）
print(text[7:12])   # 'World'（从索引 7 到 11）
print(text[:5])     # 'Hello'（从开头到索引 4）
print(text[7:])     # 'World!'（从索引 7 到结尾）
print(text[::2])    # 'Hlo ol!'（每隔一个字符）
print(text[::-1])   # '!dlroW ,olleH'（反转字符串）

# 字符串长度
print(len(text))    # 13

字符串操作：

text = "Hello, World!"

# 大小写转换
print(text.upper())        # 'HELLO, WORLD!'
print(text.lower())        # 'hello, world!'
print(text.title())        # 'Hello, World!'
print(text.capitalize())    # 'Hello, world!'
print(text.swapcase())     # 'hELLO, wORLD!'

# 查找和替换
print(text.find("World"))  # 7（首次出现的索引）
print(text.rfind("o"))     # 8（最后出现的索引）
print(text.count("l"))     # 3（出现次数）
print(text.replace("World", "Python"))  # 'Hello, Python!'

# 分割和连接
parts = text.split(",")    # ['Hello', ' World!']
print(parts)

separator = "-"
joined = separator.join(parts)
print(joined)              # 'Hello- World!'

# 去除空白
whitespace = "  Hello  "
print(whitespace.strip())      # 'Hello'
print(whitespace.lstrip())     # 'Hello  '
print(whitespace.rstrip())     # '  Hello'

# 判断
print(text.startswith("Hello"))  # True
print(text.endswith("!"))        # True
print("hello".isalpha())        # True（是否全为字母）
print("123".isdigit())          # True（是否全为数字）
print("hello123".isalnum())     # True（是否全为字母或数字）
print(" ".isspace())            # True（是否全为空白字符）

字符串格式化：

name = "张三"
age = 20
height = 1.75

# f-string（推荐，Python 3.6+）
print(f"我的名字是{name}，今年{age}岁，身高{height}米")

# format() 方法
print("我的名字是{}，今年{}岁，身高{}米".format(name, age, height))
print("我的名字是{0}，今年{1}岁，身高{2}米".format(name, age, height))
print("我的名字是{n}，今年{a}岁，身高{h}米".format(n=name, a=age, h=height))

# % 格式化（旧方式）
print("我的名字是%s，今年%d岁，身高%.2f米" % (name, age, height))

# 格式化选项
pi = 3.1415926
print(f"π ≈ {pi:.2f}")      # π ≈ 3.14（保留两位小数）
print(f"π ≈ {pi:.4f}")      # π ≈ 3.1416（保留四位小数）
print(f"π ≈ {pi:.10f}")     # π ≈ 3.1415926000（保留十位小数）
print(f"π ≈ {pi:e}")        # π ≈ 3.141593e+00（科学计数法）

number = 42
print(f"数字: {number:05d}") # 数字: 00042（宽度为5，前面补0）
print(f"数字: {number:>10}") # 数字:         42（右对齐，宽度为10）
print(f"数字: {number:<10}") # 数字: 42         （左对齐，宽度为10）

5. 空值（None）¶

None 的使用：

# None 表示空值
x = None
print(x)  # None

# 检查是否为 None
if x is None:
    print("x 是 None")
else:
    print("x 不是 None")

# 函数默认返回 None
def do_nothing():
    pass

result = do_nothing()
print(result)  # None

# 作为可选参数的默认值
def greet(name, greeting=None):
    if greeting is None:
        greeting = "Hello"
    return f"{greeting}, {name}!"

print(greet("张三"))        # Hello, 张三!
print(greet("张三", "Hi"))   # Hi, 张三!

（三）类型转换¶

隐式类型转换：

# 整数和浮点数运算会自动转换为浮点数
result = 10 + 3.14  # 13.14
print(result)       # 13.14
print(type(result)) # <class 'float'>

# 布尔值在算术运算中会被转换
print(True + 1)     # 2（True = 1）
print(False + 1)    # 1（False = 0）
print(True * 3)     # 3

显式类型转换：

# 转换为整数 print(int(3.14)) print(int("123")) print(int("3.14")) print(int(True)) print(int(False))  # 转换为浮点数 print(float(10)) print(float("3.14")) print(float("10")) print(float(True)) print(float(False))  # 转换为字符串 print(str(123)) print(str(3.14)) print(str(True)) print(str(False)) print(str([1,  # 转换为布尔值 print(bool(0)) print(bool(1)) print(bool(0.0)) print(bool(0.5)) print(bool("")) print(bool("text")) print(bool([]))           # False print(bool([1, print(bool(()))           # False print(bool((1, print(bool({}))           # False print(bool({"key": print(bool(None))

# 3 # 123 # ValueError: invalid literal # 1 # 0 # 10.0 # 3.14 # 10.0 # 1.0 # 0.0 # '123' # '3.14' # 'True' # 'False' 2, 3])) # '[1, 2, 3]' # False # True # False # True # False # True 2])) # True 2))) # True 1})) # True # False

（四）类型检查¶

使用 type() 函数：

# 检查变量类型
x = 10
y = 3.14
z = "Hello"
w = True
v = None

print(type(x))  # <class 'int'>
print(type(y))  # <class 'float'>
print(type(z))  # <class 'str'>
print(type(w))  # <class 'bool'>
print(type(v))  # <class 'NoneType'>

使用 isinstance() 函数：

# 检查是否为指定类型
x = 10
y = 3.14
z = "Hello"
w = [1, 2, 3]

print(isinstance(x, int))       # True
print(isinstance(y, float))     # True
print(isinstance(z, str))       # True
print(isinstance(w, list))      # True
print(isinstance(x, (int, float)))  # True（检查多种类型）
print(isinstance(x, str))      # False

类型比较：

# 比较 type() 返回的值
x = 10
print(type(x) == int)          # True
print(type(x) == float)        # False

# 推荐：使用 isinstance() 而不是 type()
# isinstance() 支持继承关系

第三章：运算符¶

（一）算术运算符¶

基本算术运算符：

a = 10
b = 3

# 加法
print(a + b)    # 13

# 减法
print(a - b)    # 7

# 乘法
print(a * b)    # 30

# 除法（浮点数结果）
print(a / b)    # 3.333...

# 整除（向下取整）
print(a // b)   # 3

# 取余（模运算）
print(a % b)    # 1

# 幂运算
print(a ** b)   # 1000
print(2 ** 10)  # 1024

取余运算的应用：

# 判断奇偶
number = 15
if number % 2 == 0:
    print(f"{number} 是偶数")
else:
    print(f"{number} 是奇数")

# 判断是否为闰年
year = 2024
if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
    print(f"{year} 是闰年")
else:
    print(f"{year} 不是闰年")

# 循环中的取余
for i in range(10):
    print(f"{i} % 3 = {i % 3}")

（二）比较运算符¶

比较运算符：

a = 10
b = 20

# 等于
print(a == b)  # False

# 不等于
print(a != b)  # True

# 大于
print(a > b)   # False

# 小于
print(a < b)   # True

# 大于等于
print(a >= b)  # False

# 小于等于
print(a <= b)  # True

字符串比较：

# 字符串比较（按字典序）
str1 = "apple"
str2 = "banana"
str3 = "Apple"

print(str1 < str2)  # True
print(str1 == str1)  # True
print(str3 < str1)   # True（大写字母的 ASCII 值小于小写字母）

# 忽略大小写比较
print(str1.lower() == str1.lower())

（三）逻辑运算符¶

逻辑运算符：

a = True
b = False

# 逻辑与（and）
print(a and b)          # False
print(True and True)    # True
print(True and False)   # False
print(False and False)  # False

# 逻辑或（or）
print(a or b)           # True
print(True or True)     # True
print(True or False)    # True
print(False or False)   # False

# 逻辑非（not）
print(not a)            # False
print(not True)         # False
print(not False)        # True

短路求值：

# and 短路：如果第一个操作数为 False，不会计算第二个
result = False and print("这不会执行")
print(result)  # False

# or 短路：如果第一个操作数为 True，不会计算第二个
result = True or print("这不会执行")
print(result)  # True

# 实际应用示例
x = 10
y = 0

# 安全的除法（避免除以零）
result = (y != 0) and (x / y)
print(result)  # False

# 默认值设置
name = None
display_name = name or "匿名用户"
print(display_name)  # 匿名用户

（四）赋值运算符¶

基本赋值：

x = 10
y = "Hello"
z = [1, 2, 3]

复合赋值运算符：

a = 10

# 加法赋值
a += 5   # 相当于 a = a + 5
print(a)  # 15

# 减法赋值
a -= 3   # 相当于 a = a - 3
print(a)  # 12

# 乘法赋值
a *= 2   # 相当于 a = a * 2
print(a)  # 24

# 除法赋值
a /= 4   # 相当于 a = a / 4
print(a)  # 6.0

# 整除赋值
a //= 2  # 相当于 a = a // 2
print(a)  # 3.0

# 取余赋值
a %= 2   # 相当于 a = a % 2
print(a)  # 1.0

# 幂运算赋值
a **= 3  # 相当于 a = a ** 3
print(a)  # 1.0

（五）位运算符¶

位运算符：

a = 10  # 二进制: 1010
b = 6   # 二进制: 0110

# 按位与（&）
print(a & b)   # 2（二进制: 0010）

# 按位或（|）
print(a | b)   # 14（二进制: 1110）

# 按位异或（^）
print(a ^ b)   # 12（二进制: 1100）

# 按位取反（~）
print(~a)      # -11（二进制补码）

# 左移（<<）
print(a << 2)  # 40（二进制: 101000）

# 右移（>>）
print(a >> 2)  # 2（二进制: 0010）

位运算的应用：

# 判断奇偶
number = 15
if number & 1:
    print(f"{number} 是奇数")
else:
    print(f"{number} 是偶数")

# 交换两个数（不使用临时变量）
a, b = 10, 20
a = a ^ b
b = a ^ b
a = a ^ b
print(a, b)  # 20 10

# 快速计算 2 的幂
print(1 << 10)  # 1024（2^10）
print(1 << 20)  # 1048576（2^20）

（六）成员运算符¶

成员运算符：

# in 和 not in
text = "Hello, World!"
fruits = ["苹果", "香蕉", "橙子"]
person = {"name": "张三", "age": 20}

# 字符串
print("Hello" in text)        # True
print("Python" in text)       # False
print("Python" not in text)   # True

# 列表
print("苹果" in fruits)        # True
print("葡萄" in fruits)        # False
print("葡萄" not in fruits)    # True

# 字典（检查键）
print("name" in person)        # True
print("address" in person)     # False

（七）身份运算符¶

身份运算符：

# is 和 is not
a = 10
b = 10
c = [1, 2, 3]
d = [1, 2, 3]

# 比较身份（是否为同一个对象）
print(a is b)       # True（小整数会被缓存）
print(c is d)       # False（列表是不同的对象）
print(c == d)       # True（值相等）

# None 的比较
x = None
print(x is None)    # True
print(x is not None) # False

# 最佳实践：比较 None 时使用 is 而不是 ==
if x is None:
    print("x 是 None")

（八）运算符优先级¶

运算符优先级（从高到低）：

指数运算：**
正负号：+x, -x
乘除模：*, /, //, %
加减法：+, -
比较运算符：<, <=, >, >=, ==, !=
逻辑非：not
逻辑与：and
逻辑或：or

优先级示例：

# 不同优先级
result = 2 + 3 * 4      # 14（先乘后加）
result = (2 + 3) * 4    # 20（括号优先）

result = 10 - 6 / 2     # 7.0
result = (10 - 6) / 2   # 2.0

result = 2 ** 3 ** 2    # 512（从右到左）
result = (2 ** 3) ** 2  # 64

# 逻辑运算符优先级
result = True or False and False    # True（and 优先于 or）
result = (True or False) and False  # False

建议：使用括号明确运算顺序，提高代码可读性。

第四章：输入输出¶

（一）输入¶

input() 函数：

# 基本输入
name = input("请输入你的名字：")
print(f"你好，{name}！")

# 输入整数
age = int(input("请输入你的年龄："))
print(f"你明年 {age + 1} 岁")

# 输入浮点数
height = float(input("请输入你的身高（米）："))
print(f"你的身高是 {height} 米")

# 输入多个值（用空格分隔）
values = input("请输入多个数字（用空格分隔）：").split()
numbers = [int(x) for x in values]
print(f"你输入的数字是：{numbers}")

输入验证：

# 验证整数输入
while True:
    try:
        age = int(input("请输入你的年龄："))
        if age > 0:
            break
        else:
            print("年龄必须大于0！")
    except ValueError:
        print("请输入有效的整数！")

print(f"你的年龄是 {age} 岁")

# 验证浮点数输入
while True:
    try:
        height = float(input("请输入你的身高（米）："))
        if 0.5 < height < 3.0:
            break
        else:
            print("身高必须在 0.5 到 3.0 米之间！")
    except ValueError:
        print("请输入有效的数字！")

print(f"你的身高是 {height} 米")

（二）输出¶

print() 函数：

# 基本输出
print("Hello, World!")
print("欢迎来到 Python 世界！")

# 输出多个值（用空格分隔）
print("姓名:", "张三", "年龄:", 20, "城市:", "北京")

# 输出不换行
print("Hello", end=" ")
print("World")  # Hello World

# 自定义分隔符
print("姓名", "年龄", "城市", sep=" | ")  # 姓名 | 年龄 | 城市

# 输出到文件
with open("output.txt", "w", encoding="utf-8") as f:
    print("Hello, File!", file=f)

格式化输出：

name = "张三"
age = 20
height = 1.75
pi = 3.1415926

# f-string（推荐）
print(f"我的名字是{name}，今年{age}岁")
print(f"身高：{height:.2f}米")
print(f"π ≈ {pi:.4f}")

# format() 方法
print("我的名字是{}，今年{}岁".format(name, age))
print("我的名字是{0}，今年{1}岁".format(name, age))
print("我的名字是{n}，今年{a}岁".format(n=name, a=age))

# % 格式化（旧方式）
print("我的名字是%s，今年%d岁" % (name, age))

# 对齐和填充
print(f"{'姓名':<10}{'年龄':>5}{'城市':^10}")
print(f"{'张三':<10}{20:>5}{'北京':^10}")

# 数字格式化
number = 1234567.89
print(f"{number:,}")      # 1,234,567.89（千位分隔符）
print(f"{number:.2e}")    # 1.23e+06（科学计数法）
print(f"{number:.2%}")    # 123456789.00%（百分比）

第五章：注释¶

（一）单行注释¶

使用 # 号：

# 这是一个单行注释
print("Hello, World!")  # 这也是注释

# 计算圆的面积
radius = 5
area = 3.14159 * radius ** 2
print(f"圆的面积是 {area}")

（二）多行注释¶

使用三引号：

"""
这是一个多行注释
可以跨越多行
通常用于文档字符串
"""

'''
这也是多行注释
使用单引号也可以
'''

def greet(name):
    """
    向某人打招呼的函数

    参数:
        name (str): 要打招呼的人的名字

    返回:
        str: 打招呼的字符串
    """
    return f"Hello, {name}!"

（三）注释的最佳实践¶

注释原则：

解释为什么，而不是是什么：代码本身应该说明"是什么"，注释说明"为什么"
保持注释更新：代码修改时，同步更新相关注释
避免显而易见的注释：如 i = i + 1 # 加1 这种注释是多余的
使用文档字符串：为函数、类、模块编写文档字符串
注释复杂的逻辑：对于复杂的算法或逻辑，添加注释说明

好的注释示例：

# 使用埃拉托斯特尼筛法找出所有小于等于 n 的质数
def sieve_of_eratosthenes(n):
    """找出所有小于等于 n 的质数

    Args:
        n (int): 上限

    Returns:
        list: 质数列表
    """
    if n < 2:
        return []

    sieve = [True] * (n + 1)
    sieve[0] = sieve[1] = False

    # 从 2 开始，标记每个数的倍数为非质数
    for i in range(2, int(n**0.5) + 1):
        if sieve[i]:
            # 从 i² 开始标记，因为更小的倍数已经被标记过了
            for j in range(i*i, n + 1, i):
                sieve[j] = False

    return [i for i, is_prime in enumerate(sieve) if is_prime]

坏的注释示例：

# 定义变量
x = 10  # x 等于 10

# 加法
y = x + 5  # y 等于 x 加 5

# 打印结果
print(y)  # 输出 y

第六章：练习题目¶

基础练习¶

变量和类型
创建变量存储你的姓名、年龄、身高、是否是学生
打印这些变量的值和类型
将年龄转换为字符串并与姓名拼接
运算符练习
计算两个数字的和、差、积、商
判断一个数字是否为偶数
判断一个年份是否为闰年
字符串操作
输入一个字符串，统计其中字母、数字、空格的数量
输入一个字符串，将其反转
输入一个字符串，判断是否为回文串

进阶练习¶

类型转换
输入一个数字，判断它是整数还是浮点数
将字符串 "123.45" 转换为浮点数并计算其平方
将布尔值 True 和 False 转换为整数并相加
格式化输出
打印九九乘法表
打印当前日期和时间，格式化为 "YYYY年MM月DD日 HH:MM:SS"
打印一个数字的各种格式（十进制、二进制、八进制、十六进制）
输入验证
编写程序，要求用户输入一个正整数，验证输入的有效性
编写程序，要求用户输入一个有效的日期（YYYY-MM-DD）
编写程序，要求用户输入一个有效的邮箱地址

综合练习¶

简单的计算器
实现一个简单的计算器，支持加减乘除运算
支持多个数字的连续运算
处理除以零等错误情况
个人信息管理系统
输入个人信息（姓名、年龄、性别、城市等）
格式化输出个人信息
计算年龄和出生年份
单位转换器
实现温度单位转换（摄氏度、华氏度、开尔文）
实现长度单位转换（米、千米、英里、英尺）
实现重量单位转换（千克、克、磅、盎司）

恭喜你完成了 Python 基础语法（一）的学习！继续学习下一章，掌握更多 Python 知识！