Python基础知识大全：从零开始掌握Python核心语法

文章目录

• • 前言
  • 一、Python概述与环境搭建
  • • [1.1 Python简介](#1.1 Python简介)
    • [1.2 Python的安装](#1.2 Python的安装)
    • • Windows系统安装
      • macOS系统安装
      • Linux系统安装
    • [1.3 第一个Python程序](#1.3 第一个Python程序)
    • [1.4 开发环境选择](#1.4 开发环境选择)
  • 二、Python基础语法
  • • [2.1 注释](#2.1 注释)
    • [2.2 代码缩进](#2.2 代码缩进)
    • [2.3 语句与换行](#2.3 语句与换行)
  • 三、变量与数据类型
  • • [3.1 变量](#3.1 变量)
    • [3.2 基本数据类型](#3.2 基本数据类型)
    • • [3.2.1 数字类型](#3.2.1 数字类型)
      • [3.2.2 字符串类型](#3.2.2 字符串类型)
      • [3.2.3 类型转换](#3.2.3 类型转换)
    • [3.3 常量](#3.3 常量)
  • 四、运算符
  • • [4.1 算术运算符](#4.1 算术运算符)
    • [4.2 比较运算符](#4.2 比较运算符)
    • [4.3 赋值运算符](#4.3 赋值运算符)
    • [4.4 逻辑运算符](#4.4 逻辑运算符)
    • [4.5 位运算符](#4.5 位运算符)
    • [4.6 成员运算符](#4.6 成员运算符)
    • [4.7 身份运算符](#4.7 身份运算符)
  • 五、输入与输出
  • • [5.1 输出函数print()](#5.1 输出函数print())
    • [5.2 输入函数input()](#5.2 输入函数input())
  • 六、流程控制
  • • [6.1 条件语句（if-elif-else）](#6.1 条件语句（if-elif-else）)
    • [6.2 循环语句](#6.2 循环语句)
    • • [6.2.1 while循环](#6.2.1 while循环)
      • [6.2.2 for循环](#6.2.2 for循环)
    • [6.3 循环控制语句](#6.3 循环控制语句)
  • 七、数据结构
  • • [7.1 列表（List）](#7.1 列表（List）)
    • [7.2 元组（Tuple）](#7.2 元组（Tuple）)
    • [7.3 字典（Dictionary）](#7.3 字典（Dictionary）)
    • [7.4 集合（Set）](#7.4 集合（Set）)
  • 八、函数
  • • [8.1 函数定义与调用](#8.1 函数定义与调用)
    • [8.2 参数类型](#8.2 参数类型)
    • [8.3 作用域](#8.3 作用域)
    • [8.4 匿名函数（lambda）](#8.4 匿名函数（lambda）)
    • [8.5 递归函数](#8.5 递归函数)
  • 九、常用内置函数
  • 十、异常处理
  • • [10.1 基本异常处理](#10.1 基本异常处理)
  • 练习题
  • • 基础题
    • 进阶题
    • 挑战题
  • 总结

前言

Python作为当今最流行的编程语言之一，以其简洁优雅的语法、强大的生态系统和广泛的应用领域而备受青睐。无论你是想从事Web开发、数据分析、人工智能、自动化运维，还是想提升自己的工作效率，Python都是一个绝佳的选择。

一、Python概述与环境搭建

1.1 Python简介

Python由Guido van Rossum于1989年底开始设计，1991年首次发布。它是一种解释型、面向对象、动态数据类型的高级程序设计语言。

Python的主要特点：

• 简单易学：语法简洁清晰，接近自然语言
• 免费开源：Python是FLOSS（自由/开源软件）之一
• 可移植性：支持Windows、Linux、macOS等主流操作系统
• 解释型语言：无需编译，直接运行
• 面向对象：支持面向对象编程范式
• 丰富的库：拥有庞大的标准库和第三方库
• 可扩展性：可以调用C/C++代码

1.2 Python的安装

Windows系统安装

1. 访问Python官方网站：https://www.python.org/downloads/
2. 下载最新的Python安装包（如Python 3.12+）
3. 重要：勾选"Add Python to PATH"
4. 选择"Install Now"或自定义安装
5. 验证安装：打开命令提示符，输入python --version

macOS系统安装

# 使用Homebrew安装（推荐）
brew install python3

# 或者从官网下载安装包

Linux系统安装

# Ubuntu/Debian
sudo apt update
sudo apt install python3 python3-pip

# CentOS/RHEL
sudo yum install python3 python3-pip

1.3 第一个Python程序

创建hello.py文件：

# 这是我的第一个Python程序
print("Hello, World!")
print("欢迎来到Python世界！")

# 中文输出
name = "Python学习者"
print(f"{name}，你好！")

运行方式：

python hello.py
# 或
python3 hello.py

1.4 开发环境选择

推荐的工具：

1. PyCharm：功能最强大的Python IDE
2. VS Code：轻量级，插件丰富
3. Jupyter Notebook：适合数据分析和教学
4. IDLE：Python自带的简单IDE

二、Python基础语法

2.1 注释

注释是代码中不会被执行的说明文字，用于提高代码可读性。

# 这是单行注释

"""
这是多行注释
使用三个双引号
可以写多行内容
"""

'''
这也是多行注释
使用三个单引号
'''

# 实用的注释示例
def calculate_area(radius):
    """
    计算圆的面积
    
    参数:
        radius: 圆的半径
    
    返回:
        圆的面积
    """
    return 3.14159 * radius ** 2

2.2 代码缩进

Python使用缩进来表示代码块，这是Python最重要的特性之一。

# 正确的缩进
if True:
    print("这是正确缩进")
    print("同一代码块缩进必须一致")

# 错误的缩进会导致IndentationError
if True:
print("这会报错")  # 缺少缩进

# 缩进规范：通常使用4个空格
# 不同级别的缩进
def outer_function():
    print("外层函数")
    
    if True:
        print("内层代码块")
        
        for i in range(3):
            print(f"循环中的代码: {i}")

2.3 语句与换行

# 一行写多条语句（不推荐）
x = 1; y = 2; z = 3

# 使用反斜杠换行
total = 1 + 2 + 3 + \
        4 + 5 + 6

# 在括号、花括号、方括号中自动换行
numbers = [1, 2, 3, 4, 5,
           6, 7, 8, 9, 10]

result = (10 + 20 + 30 +
          40 + 50 + 60)

三、变量与数据类型

3.1 变量

变量是存储数据的容器，Python中的变量不需要声明类型，直接赋值即可。

# 变量命名规则
# 1. 只能包含字母、数字和下划线
# 2. 不能以数字开头
# 3. 区分大小写
# 4. 不能使用Python关键字

# 合法的变量名
name = "张三"
age = 25
user_name = "lisi"
user123 = "user"
_private = "私有变量"

# 不合法的变量名
# 123user = "error"  # 不能以数字开头
# my-name = "error"  # 不能使用连字符
# class = "error"    # class是关键字

# 多变量赋值
a = b = c = 10  # 多个变量赋相同的值
x, y, z = 1, 2, 3  # 多个变量赋不同的值

# 变量交换（Python特色）
a, b = 5, 10
a, b = b, a  # 交换a和b的值
print(a, b)  # 输出: 10 5

3.2 基本数据类型

Python有7种基本数据类型：

3.2.1 数字类型

# 整数 (int)
num1 = 10          # 十进制
num2 = 0b1010      # 二进制
num3 = 0o12        # 八进制
num4 = 0xA         # 十六进制
num5 = 1_000_000   # 使用下划线提高可读性

print(f"十进制: {num1}")  # 10
print(f"二进制: {num2}")  # 10
print(f"八进制: {num3}")  # 10
print(f"十六进制: {num4}") # 10

# 浮点数 (float)
pi = 3.14159
e = 2.71828
scientific = 1.2e-5  # 科学计数法
negative_float = -0.5

# 复数 (complex)
c1 = 3 + 4j
c2 = complex(2, 3)
print(f"实部: {c1.real}, 虚部: {c1.imag}")  # 实部: 3.0, 虚部: 4.0

# 布尔类型 (bool)
is_true = True
is_false = False
is_equal = (10 == 10)  # True
is_greater = (5 > 3)   # True

# 布尔值实际上是整数的子类
print(True == 1)   # True
print(False == 0)  # True

3.2.2 字符串类型

# 字符串定义方式
str1 = '单引号字符串'
str2 = "双引号字符串"
str3 = '''三引号字符串
可以跨越多行
保留格式'''
str4 = """也是多行字符串"""

# 字符串转义
escape_chars = "换行符：\n，制表符：\t，反斜杠：\\，单引号：\'，双引号：\""
print(escape_chars)

# 原始字符串（忽略转义字符）
raw_string = r"C:\Users\name\Desktop"
print(raw_string)  # 输出: C:\Users\name\Desktop

# 字符串拼接
s1 = "Hello"
s2 = "World"
s3 = s1 + " " + s2  # "Hello World"
s4 = "Python " * 3   # "Python Python Python "

# 字符串格式化
name = "Alice"
age = 25
score = 95.5

# 方法1：%格式化（老式）
print("姓名：%s，年龄：%d，成绩：%.1f" % (name, age, score))

# 方法2：format()方法
print("姓名：{}，年龄：{}，成绩：{}".format(name, age, score))
print("姓名：{0}，年龄：{1}，成绩：{2:.1f}".format(name, age, score))
print("姓名：{n}，年龄：{a}，成绩：{s:.1f}".format(n=name, a=age, s=score))

# 方法3：f-string（Python 3.6+，推荐）
print(f"姓名：{name}，年龄：{age}，成绩：{score:.1f}")
print(f"计算结果：{10 + 20}")
print(f"调用函数：{name.upper()}")

# 字符串常用方法
text = "  Python Programming  "

print(len(text))                    # 字符串长度
print(text.lower())                 # 转小写
print(text.upper())                 # 转大写
print(text.strip())                 # 去除两端空白
print(text.split())                 # 分割成列表
print("-".join(["a", "b", "c"]))    # 连接字符串
print(text.replace("Python", "Java"))  # 替换
print(text.find("Pro"))             # 查找位置
print("Python" in text)             # 成员判断

3.2.3 类型转换

# 显式类型转换
num_str = "123"
num_int = int(num_str)        # 字符串转整数
num_float = float(num_str)    # 字符串转浮点数
str_num = str(123)            # 数字转字符串

# 其他转换
int_to_bool = bool(1)         # True
zero_to_bool = bool(0)        # False
list_to_tuple = tuple([1, 2, 3])  # (1, 2, 3)
tuple_to_list = list((1, 2, 3))   # [1, 2, 3]

# 类型检查
print(type(10))        # <class 'int'>
print(type("hello"))   # <class 'str'>
print(type(3.14))      # <class 'float'>
print(type(True))      # <class 'bool'>

print(isinstance(10, int))      # True
print(isinstance("hi", str))    # True

3.3 常量

Python中没有真正的常量，通常使用全大写变量名表示常量（约定俗成）：

# 常量命名规范（全大写，下划线分隔）
PI = 3.141592653589793
MAX_VALUE = 100
DEFAULT_COLOR = "blue"
COMPANY_NAME = "Python Technologies"

# 虽然可以修改，但不应这样做
# PI = 3.14  # 技术上可行，但不应该

四、运算符

4.1 算术运算符

a, b = 10, 3

print(f"加法：{a} + {b} = {a + b}")      # 13
print(f"减法：{a} - {b} = {a - b}")      # 7
print(f"乘法：{a} * {b} = {a * b}")      # 30
print(f"除法：{a} / {b} = {a / b}")      # 3.333...
print(f"整除：{a} // {b} = {a // b}")    # 3
print(f"取余：{a} % {b} = {a % b}")      # 1
print(f"幂运算：{a} ** {b} = {a ** b}")  # 1000

# 算术运算的优先级
result = 2 + 3 * 4      # 14 (先乘法后加法)
result = (2 + 3) * 4    # 20 (括号优先)

4.2 比较运算符

x, y = 5, 8

print(f"{x} == {y}: {x == y}")   # False，等于
print(f"{x} != {y}: {x != y}")   # True，不等于
print(f"{x} > {y}: {x > y}")     # False，大于
print(f"{x} < {y}: {x < y}")     # True，小于
print(f"{x} >= {y}: {x >= y}")   # False，大于等于
print(f"{x} <= {y}: {x <= y}")   # True，小于等于

# 链式比较（Python特色）
age = 25
print(18 <= age <= 60)  # True，等价于 age >= 18 and age <= 60

4.3 赋值运算符

a = 10
print(f"初始值: a = {a}")

a += 5   # 等价于 a = a + 5
print(f"a += 5: {a}")   # 15

a -= 3   # 等价于 a = a - 3
print(f"a -= 3: {a}")   # 12

a *= 2   # 等价于 a = a * 2
print(f"a *= 2: {a}")   # 24

a /= 4   # 等价于 a = a / 4
print(f"a /= 4: {a}")   # 6.0

a //= 2  # 等价于 a = a // 2
print(f"a //= 2: {a}")  # 3.0

a %= 2   # 等价于 a = a % 2
print(f"a %= 2: {a}")   # 1.0

a **= 3  # 等价于 a = a ** 3
print(f"a **= 3: {a}")  # 1.0

4.4 逻辑运算符

# and（与）：两个条件都为True时结果为True
print(True and True)    # True
print(True and False)   # False
print(False and False)  # False

# or（或）：至少一个条件为True时结果为True
print(True or True)     # True
print(True or False)    # True
print(False or False)   # False

# not（非）：取反
print(not True)         # False
print(not False)        # True

# 短路求值
x = 5
print(x > 0 and x < 10)     # True
print(x > 10 or x < 0)      # False

# 实际应用
age = 22
has_license = True
can_drive = age >= 18 and has_license
print(f"可以开车: {can_drive}")  # True

# 逻辑运算符的优先级：not > and > or
result = True or False and False  # True (先计算 False and False)

4.5 位运算符

a, b = 5, 3  # 二进制: 5=0101, 3=0011

print(f"{a} & {b} = {a & b}")   # 按位与: 0001 = 1
print(f"{a} | {b} = {a | b}")   # 按位或: 0111 = 7
print(f"{a} ^ {b} = {a ^ b}")   # 按位异或: 0110 = 6
print(f"~{a} = {~a}")           # 按位取反: -6
print(f"{a} << 1 = {a << 1}")   # 左移: 1010 = 10
print(f"{a} >> 1 = {a >> 1}")   # 右移: 0010 = 2

4.6 成员运算符

# in 和 not in
fruits = ["apple", "banana", "orange"]
print("apple" in fruits)       # True
print("grape" not in fruits)   # True

# 字符串中的成员判断
text = "Hello, Python!"
print("Python" in text)        # True
print("Java" not in text)      # True

4.7 身份运算符

# is 和 is not（比较对象ID）
a = [1, 2, 3]
b = [1, 2, 3]
c = a

print(a is c)      # True，同一个对象
print(a is b)      # False，不同对象
print(a == b)      # True，值相等
print(a is not b)  # True

# 小整数缓存（-5到256）
x = 256
y = 256
print(x is y)      # True

x = 257
y = 257
print(x is y)      # False（可能因实现而异）

五、输入与输出

5.1 输出函数print()

# 基本输出
print("Hello World")
print(123)
print(3.14)

# 输出多个值
print("姓名:", "张三", "年龄:", 25)
# 输出: 姓名: 张三 年龄: 25

# sep参数：指定分隔符
print("a", "b", "c", sep="-")     # a-b-c
print(1, 2, 3, sep=", ")          # 1, 2, 3

# end参数：指定结束符
print("第一行", end="")
print("第二行")                    # 第一行第二行
print("第一行", end="\n\n")
print("第二行")                    # 输出后有两个换行

# file参数：输出到文件
with open("output.txt", "w") as f:
    print("写入文件", file=f)

# flush参数：立即刷新输出缓冲区
import time
for i in range(5):
    print(f"\r进度: {i+1}/5", end="", flush=True)
    time.sleep(0.5)

# 格式化输出
name = "李华"
age = 18
print(f"{name:10} {age:3d}")     # 指定宽度
print(f"{3.14159:.2f}")          # 保留两位小数
print(f"{0.25:.1%}")             # 百分比格式: 25.0%
print(f"{123456:,}")             # 千位分隔符: 123,456

5.2 输入函数input()

# 基本输入
name = input("请输入您的姓名: ")
print(f"您好，{name}！")

# 输入数字（input返回字符串）
age_str = input("请输入年龄: ")
age = int(age_str)  # 转换为整数

# 简化写法
age = int(input("请输入年龄: "))
height = float(input("请输入身高（米）: "))

# 多个输入
# 方法1：分别输入
x = int(input("x: "))
y = int(input("y: "))

# 方法2：一行输入多个值
a, b, c = map(int, input("请输入三个数字，用空格分隔: ").split())
print(f"a={a}, b={b}, c={c}")

# 方法3：使用列表推导
numbers = [int(x) for x in input("输入多个数字: ").split()]

# 输入密码（不显示）
import getpass
password = getpass.getpass("请输入密码: ")
print("密码已输入")

六、流程控制

6.1 条件语句（if-elif-else）

# 基本if语句
age = 18
if age >= 18:
    print("成年人")

# if-else语句
score = 85
if score >= 60:
    print("及格")
else:
    print("不及格")

# if-elif-else语句
score = 85
if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 70:
    grade = "C"
elif score >= 60:
    grade = "D"
else:
    grade = "F"
print(f"等级: {grade}")

# 嵌套if
num = 15
if num > 0:
    print("正数")
    if num % 2 == 0:
        print("偶数")
    else:
        print("奇数")
else:
    print("非正数")

# 三元运算符（条件表达式）
age = 20
status = "成年" if age >= 18 else "未成年"
print(status)

# 多个条件的组合
year = 2024
is_leap = (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0)
print(f"{year}年是闰年: {is_leap}")

# 实际应用示例：计算BMI
weight = float(input("体重(kg): "))
height = float(input("身高(m): "))
bmi = weight / (height ** 2)

if bmi < 18.5:
    category = "偏瘦"
elif bmi < 24:
    category = "正常"
elif bmi < 28:
    category = "偏胖"
else:
    category = "肥胖"
print(f"BMI: {bmi:.1f}, 分类: {category}")

6.2 循环语句

6.2.1 while循环

# 基本while循环
count = 0
while count < 5:
    print(f"计数: {count}")
    count += 1

# 无限循环（慎用）
# while True:
#     print("无限循环")

# while-else语句
num = 2
while num < 5:
    print(f"当前数字: {num}")
    num += 1
else:
    print("循环正常结束")

# 实际应用：猜数字游戏
import random
target = random.randint(1, 100)
guess = 0
attempts = 0

while guess != target:
    guess = int(input("猜一个1-100的数字: "))
    attempts += 1
    if guess < target:
        print("太小了")
    elif guess > target:
        print("太大了")
    else:
        print(f"恭喜！用了{attempts}次猜对了！")

6.2.2 for循环

# 遍历范围
for i in range(5):
    print(i)  # 0, 1, 2, 3, 4

for i in range(2, 8):
    print(i)  # 2, 3, 4, 5, 6, 7

for i in range(0, 10, 2):
    print(i)  # 0, 2, 4, 6, 8

# 倒序遍历
for i in range(10, 0, -2):
    print(i)  # 10, 8, 6, 4, 2

# 遍历字符串
for char in "Python":
    print(char)

# 遍历列表
fruits = ["苹果", "香蕉", "橙子"]
for fruit in fruits:
    print(f"我喜欢吃{fruit}")

# 同时获取索引和值
for index, fruit in enumerate(fruits):
    print(f"{index}: {fruit}")

# 遍历字典
person = {"name": "张三", "age": 25, "city": "北京"}
for key in person:
    print(f"{key}: {person[key]}")

for key, value in person.items():
    print(f"{key}: {value}")

# 遍历集合
colors = {"red", "green", "blue"}
for color in colors:
    print(color)

# 遍历元组
coordinates = (10, 20, 30)
for coord in coordinates:
    print(coord)

# for-else语句
numbers = [1, 2, 3, 4, 5]
for num in numbers:
    if num == 6:
        break
else:
    print("没有找到6")  # 会执行

# 实际应用：计算阶乘
n = 5
factorial = 1
for i in range(1, n + 1):
    factorial *= i
print(f"{n}! = {factorial}")

6.3 循环控制语句

# break：跳出整个循环
for i in range(10):
    if i == 5:
        break
    print(i)  # 输出 0-4

# continue：跳过本次循环
for i in range(10):
    if i % 2 == 0:
        continue
    print(i)  # 输出奇数: 1,3,5,7,9

# 嵌套循环中的break
for i in range(3):
    for j in range(3):
        if i == j == 1:
            break  # 只跳出内层循环
        print(f"({i},{j})")

# 使用标志变量
found = False
for i in range(10):
    for j in range(10):
        if i * j == 25:
            found = True
            break
    if found:
        break
print(f"找到乘积为25的数: i={i}, j={j}")

# 实际应用：素数判断
num = 17
is_prime = True
if num < 2:
    is_prime = False
else:
    for i in range(2, int(num ** 0.5) + 1):
        if num % i == 0:
            is_prime = False
            break
print(f"{num}是素数: {is_prime}")

七、数据结构

7.1 列表（List）

列表是Python中最常用的可变序列。

# 列表的创建
list1 = []                    # 空列表
list2 = [1, 2, 3]            # 整数列表
list3 = ["a", "b", "c"]      # 字符串列表
list4 = [1, "hello", 3.14]   # 混合类型
list5 = list("abc")           # ['a', 'b', 'c']
list6 = list(range(5))        # [0, 1, 2, 3, 4]

# 列表推导式
squares = [x**2 for x in range(10)]           # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
evens = [x for x in range(20) if x % 2 == 0]  # 偶数

# 访问元素
fruits = ["苹果", "香蕉", "橙子", "葡萄", "西瓜"]
print(fruits[0])     # 第一个元素: 苹果
print(fruits[-1])    # 最后一个元素: 西瓜
print(fruits[1:4])   # 切片: ['香蕉', '橙子', '葡萄']
print(fruits[::2])   # 步长: ['苹果', '橙子', '西瓜']
print(fruits[::-1])  # 反转: ['西瓜', '葡萄', '橙子', '香蕉', '苹果']

# 修改元素
fruits[1] = "芒果"
print(fruits)  # ['苹果', '芒果', '橙子', '葡萄', '西瓜']

# 添加元素
fruits.append("草莓")          # 末尾添加
fruits.insert(1, "梨")         # 指定位置插入
fruits.extend(["樱桃", "桃子"]) # 扩展列表
print(fruits)

# 删除元素
fruits.remove("橙子")           # 删除指定值（第一个匹配项）
popped = fruits.pop()          # 删除并返回最后一个元素
popped2 = fruits.pop(2)        # 删除并返回指定位置元素
del fruits[0]                  # 删除指定位置
fruits.clear()                 # 清空列表

# 其他常用方法
numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5]
print(len(numbers))            # 长度: 9
print(numbers.count(1))        # 计数: 2
print(numbers.index(5))        # 索引: 4（第一个5的位置）
numbers.sort()                 # 升序排序
numbers.sort(reverse=True)     # 降序排序
numbers.reverse()              # 反转
sorted_list = sorted(numbers)  # 返回新排序列表

# 列表复制
# 浅拷贝
list_a = [1, 2, [3, 4]]
list_b = list_a.copy()          # 方法1
list_c = list_a[:]              # 方法2
list_d = list(list_a)           # 方法3
import copy
list_e = copy.copy(list_a)      # 方法4

# 深拷贝
list_f = copy.deepcopy(list_a)

# 列表操作
list1 = [1, 2, 3]
list2 = [4, 5, 6]
list3 = list1 + list2            # 拼接: [1, 2, 3, 4, 5, 6]
list4 = list1 * 3                # 重复: [1, 2, 3, 1, 2, 3, 1, 2, 3]

# 检查元素
print(3 in [1, 2, 3])           # True
print(5 not in [1, 2, 3])       # True

# 遍历列表
# 遍历元素
for item in fruits:
    print(item)

# 遍历索引和元素
for i, fruit in enumerate(fruits):
    print(f"{i}: {fruit}")

# 同时遍历两个列表
names = ["张三", "李四", "王五"]
ages = [25, 30, 28]
for name, age in zip(names, ages):
    print(f"{name} {age}岁")

7.2 元组（Tuple）

元组是不可变的序列。

# 元组的创建
tuple1 = ()                    # 空元组
tuple2 = (1, 2, 3)            # 整数元组
tuple3 = (1,)                  # 单元素元组（注意逗号）
tuple4 = 1, 2, 3              # 不加括号也可以
tuple5 = tuple([1, 2, 3])     # 从列表转换

# 访问元素（与列表类似）
point = (10, 20, 30)
print(point[0])     # 10
print(point[1:3])   # (20, 30)

# 元组不可变
# point[0] = 5  # 错误！元组不支持修改

# 元组解包
x, y, z = point
print(f"x={x}, y={y}, z={z}")

# 交换变量（实际是元组解包）
a, b = 5, 10
a, b = b, a

# 星号解包
numbers = (1, 2, 3, 4, 5)
first, *middle, last = numbers
print(first)   # 1
print(middle)  # [2, 3, 4]
print(last)    # 5

# 元组方法
t = (1, 2, 3, 2, 4, 2)
print(t.count(2))  # 3
print(t.index(3))  # 2

# 元组的优势
# 1. 性能比列表好
# 2. 可以作为字典的键（列表不行）
# 3. 数据安全（不可变）

# 命名元组
from collections import namedtuple
Point = namedtuple('Point', ['x', 'y'])
p = Point(10, 20)
print(p.x, p.y)  # 10 20
print(p[0], p[1])  # 10 20

7.3 字典（Dictionary）

字典是键值对的无序集合。

# 字典的创建
dict1 = {}                     # 空字典
dict2 = {"name": "张三", "age": 25}
dict3 = dict(name="李四", age=30)  # 使用dict()函数
dict4 = dict([("a", 1), ("b", 2)]) # 从键值对列表创建

# 访问元素
person = {"name": "王五", "age": 28, "city": "上海"}
print(person["name"])          # 王五
print(person.get("age"))       # 28
print(person.get("gender", "未知"))  # 不存在时返回默认值

# 修改和添加
person["age"] = 29             # 修改
person["gender"] = "男"         # 添加

# 删除元素
del person["city"]             # 删除指定键
age = person.pop("age")        # 删除并返回值
last_item = person.popitem()   # 删除并返回最后一个键值对
person.clear()                 # 清空字典

# 字典方法
person = {"name": "赵六", "age": 35, "city": "北京"}
print(person.keys())           # 所有键
print(person.values())         # 所有值
print(person.items())          # 所有键值对

# 遍历字典
for key in person:
    print(f"{key}: {person[key]}")

for key, value in person.items():
    print(f"{key}: {value}")

# 字典推导式
squares = {x: x**2 for x in range(5)}  # {0:0, 1:1, 2:4, 3:9, 4:16}
even_squares = {x: x**2 for x in range(10) if x % 2 == 0}

# 合并字典
dict_a = {"a": 1, "b": 2}
dict_b = {"c": 3, "d": 4}

# 方法1：update()
dict_a.update(dict_b)

# 方法2：解包（Python 3.5+）
dict_c = {**dict_a, **dict_b}

# 方法3：| 运算符（Python 3.9+）
dict_d = dict_a | dict_b

# 默认值字典
from collections import defaultdict
dd = defaultdict(int)          # 默认值为0
dd["a"] += 1
dd["b"] += 1
print(dd["a"], dd["c"])        # 1 0

# 计数器的简便方法
from collections import Counter
text = "hello world"
char_count = Counter(text)
print(char_count)  # Counter({'l': 3, 'o': 2, 'h': 1, 'e': 1, ' ': 1, 'w': 1, 'r': 1, 'd': 1})

# 有序字典（Python 3.7+ 字典已保持插入顺序）
from collections import OrderedDict
od = OrderedDict()
od["a"] = 1
od["b"] = 2
od["c"] = 3

7.4 集合（Set）

集合是无序、不重复元素的集合。

# 集合的创建
set1 = set()                   # 空集合
set2 = {1, 2, 3}              # 整数集合
set3 = set([1, 2, 2, 3, 3])   # 从列表创建，自动去重 -> {1, 2, 3}
set4 = {1, "hello", 3.14}     # 混合类型

# 添加元素
s = {1, 2, 3}
s.add(4)                      # 添加单个元素
s.update([5, 6, 7])           # 添加多个元素
s.update({8, 9}, [10, 11])

# 删除元素
s.remove(5)                   # 删除指定元素（不存在时抛出KeyError）
s.discard(10)                 # 删除指定元素（不存在时不报错）
popped = s.pop()              # 删除并返回任意一个元素
s.clear()                     # 清空集合

# 集合运算
A = {1, 2, 3, 4}
B = {3, 4, 5, 6}

# 并集
print(A | B)          # {1,2,3,4,5,6}
print(A.union(B))     # {1,2,3,4,5,6}

# 交集
print(A & B)          # {3,4}
print(A.intersection(B))  # {3,4}

# 差集
print(A - B)          # {1,2}
print(A.difference(B))    # {1,2}

# 对称差集
print(A ^ B)          # {1,2,5,6}
print(A.symmetric_difference(B))  # {1,2,5,6}

# 子集和超集
C = {1, 2}
print(C <= A)         # True，C是A的子集
print(A >= C)         # True，A是C的超集
print(C < A)          # True，真子集

# 集合推导式
squares = {x**2 for x in range(10)}
even_squares = {x**2 for x in range(10) if x % 2 == 0}

# 去重
numbers = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
unique_numbers = list(set(numbers))  # [1, 2, 3, 4]

# 检查成员
print(3 in {1, 2, 3})      # True
print(5 not in {1, 2, 3})  # True

# 不可变集合（frozenset）
fs = frozenset([1, 2, 3])  # 可以作为字典的键
# fs.add(4)  # 错误！frozenset不可变

八、函数

8.1 函数定义与调用

# 基本函数定义
def greet():
    print("Hello, World!")

# 调用函数
greet()

# 带参数的函数
def greet_name(name):
    print(f"Hello, {name}!")

greet_name("Alice")

# 带返回值的函数
def add(a, b):
    return a + b

result = add(5, 3)
print(result)  # 8

# 多个返回值（实际返回元组）
def get_min_max(numbers):
    return min(numbers), max(numbers)

min_val, max_val = get_min_max([1, 2, 3, 4, 5])
print(f"最小值: {min_val}, 最大值: {max_val}")

# 空函数（占位符）
def placeholder():
    pass  # 什么都不做

8.2 参数类型

# 1. 位置参数
def power(base, exponent):
    return base ** exponent

print(power(2, 3))  # 8

# 2. 默认参数
def greet(name, greeting="Hello"):
    print(f"{greeting}, {name}!")

greet("Bob")                    # Hello, Bob!
greet("Bob", "Hi")              # Hi, Bob!

# 注意：默认参数必须是不可变对象
# 错误示例
def add_item(item, lst=[]):  # 不要这样！
    lst.append(item)
    return lst

# 正确做法
def add_item(item, lst=None):
    if lst is None:
        lst = []
    lst.append(item)
    return lst

# 3. 关键字参数
def person_info(name, age, city):
    print(f"{name}, {age}, {city}")

person_info(city="北京", name="张三", age=25)  # 顺序可调换

# 4. 可变参数 *args（接收多个位置参数）
def sum_numbers(*args):
    return sum(args)

print(sum_numbers(1, 2, 3, 4, 5))  # 15
print(sum_numbers(10, 20))          # 30

# 5. 关键字参数 **kwargs（接收多个关键字参数）
def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_info(name="张三", age=25, city="北京")

# 6. 参数组合（顺序：位置参数 > 默认参数 > *args > **kwargs）
def complex_func(a, b=10, *args, c=20, **kwargs):
    print(f"a={a}, b={b}")
    print(f"args={args}")
    print(f"c={c}")
    print(f"kwargs={kwargs}")

complex_func(1, 2, 3, 4, 5, c=30, d=40, e=50)
# 输出:
# a=1, b=2
# args=(3, 4, 5)
# c=30
# kwargs={'d': 40, 'e': 50}

# 7. 强制关键字参数（*后面的参数必须用关键字传递）
def func_with_keyword(a, *, b, c):
    print(a, b, c)

func_with_keyword(1, b=2, c=3)  # 正确
# func_with_keyword(1, 2, 3)  # 错误

8.3 作用域

# 局部变量
def my_func():
    x = 10  # 局部变量
    print(x)

my_func()
# print(x)  # 错误！x不可访问

# 全局变量
global_var = 100

def access_global():
    print(global_var)  # 可以访问

def modify_global():
    global global_var  # 声明使用全局变量
    global_var = 200

modify_global()
print(global_var)  # 200

# 嵌套函数和非局部变量
def outer():
    x = 10
    
    def inner():
        nonlocal x  # 使用外层函数的变量
        x = 20
    
    inner()
    print(x)  # 20

outer()

# 作用域规则（LEGB规则）
# Local -> Enclosing -> Global -> Built-in
x = 100  # Global

def outer():
    x = 50  # Enclosing
    
    def inner():
        x = 10  # Local
        print(x)
    
    inner()

outer()

8.4 匿名函数（lambda）

# 基本lambda函数
square = lambda x: x ** 2
print(square(5))  # 25

# 多个参数
add = lambda x, y: x + y
print(add(3, 5))  # 8

# 与内置函数配合使用
numbers = [1, 2, 3, 4, 5]

# map
squared = list(map(lambda x: x ** 2, numbers))
print(squared)  # [1, 4, 9, 16, 25]

# filter
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens)  # [2, 4]

# sorted（按指定规则排序）
students = [
    {"name": "张三", "score": 85},
    {"name": "李四", "score": 92},
    {"name": "王五", "score": 78}
]
students.sort(key=lambda s: s["score"], reverse=True)
print(students)

# 条件表达式
max_func = lambda a, b: a if a > b else b
print(max_func(10, 20))  # 20

# 立即执行lambda
result = (lambda x, y: x * y)(5, 3)
print(result)  # 15

8.5 递归函数

# 计算阶乘
def factorial(n):
    if n == 0 or n == 1:
        return 1
    return n * factorial(n - 1)

print(factorial(5))  # 120

# 斐波那契数列
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

print(fibonacci(10))  # 55

# 使用记忆化优化递归
from functools import lru_cache

@lru_cache(maxsize=None)
def fib_memo(n):
    if n <= 1:
        return n
    return fib_memo(n - 1) + fib_memo(n - 2)

print(fib_memo(100))  # 快速计算

# 递归遍历目录
import os

def list_files(path, indent=0):
    for item in os.listdir(path):
        item_path = os.path.join(path, item)
        print("  " * indent + "|-- " + item)
        if os.path.isdir(item_path):
            list_files(item_path, indent + 1)

# list_files(".")  # 遍历当前目录

九、常用内置函数

# 数学相关
print(abs(-5))           # 5，绝对值
print(pow(2, 3))         # 8，幂运算
print(round(3.14159, 2)) # 3.14，四舍五入
print(divmod(10, 3))     # (3, 1)，商和余数
print(sum([1, 2, 3]))    # 6，求和
print(max(1, 5, 3))      # 5，最大值
print(min(1, 5, 3))      # 1，最小值

# 类型转换
print(int("123"))        # 123
print(float("3.14"))     # 3.14
print(str(123))          # "123"
print(bool(0))           # False
print(list("abc"))       # ['a', 'b', 'c']
print(tuple([1, 2, 3]))  # (1, 2, 3)
print(set([1, 2, 2]))    # {1, 2}
print(dict([("a", 1)]))  # {'a': 1}

# 序列操作
print(len([1, 2, 3]))    # 3，长度
print(sorted([3, 1, 2])) # [1, 2, 3]，排序
print(reversed([1, 2, 3])) # 反转迭代器
print(enumerate(["a", "b"])) # 枚举迭代器
print(zip([1, 2], ["a", "b"])) # 压缩迭代器

# 输入输出
# print() - 输出
# input() - 输入

# 其他
print(all([True, True, False]))  # False，全真为真
print(any([False, False, True])) # True，有真为真
print(id(10))                     # 对象ID
print(type(10))                   # <class 'int'>
print(isinstance(10, int))        # True
print(callable(print))            # True，是否可调用
print(chr(65))                    # 'A'，ASCII转字符
print(ord('A'))                   # 65，字符转ASCII
print(hash("hello"))              # 哈希值
print(help(print))                # 查看帮助
print(dir([]))                    # 查看对象属性和方法

十、异常处理

10.1 基本异常处理

# try-except基本结构
try:
    num = int(input("请输入数字: "))
    result = 10 / num
    print(f"结果: {result}")
except ValueError:
    print("输入无效，请输入数字")
except ZeroDivisionError:
    print("不能除以零")
except Exception as e:
    print(f"发生错误: {e}")

# try-except-else-finally
try:
    file = open("test.txt", "r")
    content = file.read()
except FileNotFoundError:
    print("文件不存在")
else:
    print("文件读取成功")
    print(content)
finally:
    print("无论是否发生异常都会执行")
    if 'file' in locals():
        file.close()

# 捕获多个异常
try:
    # 可能抛出异常的代码
    pass
except (ValueError, TypeError) as e:
    print(f"数值或类型错误: {e}")

# 使用raise主动抛出异常
def divide(a, b):
    if b == 0:
        raise ValueError("除数不能为零")
    return a / b

try:
    divide(10, 0)
except ValueError as e:
    print(f"错误: {e}")

# 自定义异常
class AgeError(Exception):
    """年龄错误异常"""
    def __init__(self, message, age):
        super().__init__(message)
        self.age = age

def set_age(age):
    if age < 0:
        raise AgeError("年龄不能为负数", age)
    if age > 150:
        raise AgeError("年龄不能超过150岁", age)
    print(f"年龄设置为: {age}")

try:
    set_age(-5)
except AgeError as e:
    print(f"{e}，输入年龄: {e.age}")

# 断言（调试用）
def calculate_square_root(x):
    assert x >= 0, "x必须大于等于0"
    return x ** 0.5

print(calculate_square_root(9))   # 3.0
# print(calculate_square_root(-1))  # AssertionError

练习题

为了巩固本章所学知识，请完成以下练习题：

基础题

1. 编写程序，输入三个数字，输出它们的平均值。
2. 判断一个年份是否为闰年。
3. 打印九九乘法表。
4. 输入一个字符串，判断它是否为回文串。

进阶题

5. 实现一个简单的计算器，支持加减乘除和幂运算。
6. 编写函数，找出列表中第二大的数。
7. 统计一段文本中每个单词出现的次数。
8. 实现二分查找算法。

挑战题

9. 实现一个函数，生成杨辉三角的前n行。
10. 编写程序，解决经典的"百钱百鸡"问题（公鸡5文钱，母鸡3文钱，小鸡3只1文钱，用100文钱买100只鸡）。

总结

本章我们系统地学习了Python的基础知识，包括：

1. Python环境搭建：安装、配置和开发工具选择
2. 基础语法：注释、缩进、语句结构
3. 变量和数据类型：数字、字符串、类型转换
4. 运算符：算术、比较、逻辑、位运算等
5. 输入输出：print()和input()的详细用法
6. 流程控制：条件语句和循环语句
7. 数据结构：列表、元组、字典、集合的全面解析
8. 函数：定义、参数、作用域、lambda、递归
9. 内置函数：常用的内置函数使用方法
10. 异常处理：错误处理和异常捕获

这些知识是Python编程的基础，掌握它们将为后续学习打下坚实的基础。建议多动手实践，编写代码来加深理解。

如果觉得本文对你有帮助，请点赞、收藏、关注！
有任何问题欢迎在评论区留言交流！