学习进度

15%
已完成
进行中
未开始

1. 入门基础

1.1 Python简介

Python是一种高级、解释型、面向对象的编程语言,由Guido van Rossum于1989年圣诞节期间创建,并在1991年首次发布。

Python的设计哲学强调代码的可读性和简洁性,采用缩进来定义代码块,而不是使用大括号。这使得Python代码更易于阅读和维护。

Python的特点:

  • 简单易学:语法简洁明了,接近自然语言
  • 解释型语言:无需编译,直接运行
  • 面向对象:支持面向对象编程范式
  • 可扩展性:可以通过C/C++等语言扩展
  • 丰富的库:拥有大量的标准库和第三方库
  • 跨平台:可在Windows、Linux、MacOS等系统上运行

Python广泛应用于Web开发、数据分析、人工智能、科学计算、自动化脚本等领域,是目前最受欢迎的编程语言之一。

1.2 环境搭建

要开始学习Python,首先需要在您的计算机上安装Python解释器和合适的开发工具。

安装Python解释器

  1. 访问Python官方网站:https://www.python.org/
  2. 点击"Downloads",选择适合您操作系统的版本(Windows、macOS或Linux)
  3. 运行下载的安装程序
  4. 重要:在Windows安装时,勾选"Add Python to PATH"选项
  5. 按照安装向导完成安装

验证安装

安装完成后,可以通过以下方式验证:

Windows命令提示符 / macOS终端 复制
python --version
# 或者对于Python 3.x
python3 --version

如果安装成功,会显示类似以下的版本信息:

输出 复制
Python 3.11.2

选择开发工具

推荐的Python开发工具:

  • IDLE:Python自带的简单IDE,适合初学者
  • PyCharm:功能强大的Python IDE,有免费社区版
  • VS Code:轻量级编辑器,配合Python插件使用
  • Sublime Text:轻量级编辑器,需要安装相关插件

提示

对于初学者,推荐使用PyCharm社区版或VS Code,它们提供了代码补全、语法高亮等功能,能大大提高学习效率。

1.3 基本语法

Python的语法简洁明了,注重可读性。以下是Python的一些基本语法规则:

1. 缩进

Python使用缩进来定义代码块,而不是其他语言常用的大括号{}。通常使用4个空格作为缩进:

Python 复制
if x > 10:
    print("x大于10")  # 这行有缩进
    print("继续执行")  # 同一代码块
print("这行不在if块内")  # 没有缩进

2. 语句结束

Python语句通常以换行符结束,不需要分号。但可以使用分号将多个语句放在同一行:

Python 复制
# 正常写法,每行一个语句
a = 10
b = 20

# 使用分号在一行写多个语句
x = 5; y = 15; z = x + y

3. 注释

Python中使用#表示单行注释,多行注释可以使用三个单引号'''或三个双引号""":

Python 复制
# 这是一个单行注释

'''
这是一个多行注释
可以跨越多行
'''

"""
这也是一个多行注释
通常用于文档字符串
"""

4. 代码块分隔符

Python使用冒号:来开始一个代码块,如if、for、while、函数定义等:

Python 复制
def greet(name):
    print("Hello, " + name)  # 函数体,有缩进

for i in range(5):
    print(i)  # 循环体,有缩进

5. 第一个Python程序

经典的"Hello, World!"程序:

Python 复制
# 我的第一个Python程序
print("Hello, World!")

运行上述程序,会在屏幕上输出:Hello, World!

1.4 变量与数据类型

变量

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

Python 复制

安装完成后,我们可以通过以下方式验证Python是否安装成功:

Windows 命令提示符 / macOS 终端 复制
python --version
        python3 --version  # 某些系统可能需要使用python3命令

如果安装成功,会显示类似以下的版本信息:

输出结果
Python 3.11.4

选择开发工具

除了Python解释器,您还需要一个合适的代码编辑器或集成开发环境(IDE):

  • IDLE:Python自带的简单编辑器,适合初学者入门
  • PyCharm:功能强大的Python IDE,有免费社区版,适合项目开发
  • Visual Studio Code:轻量级编辑器,安装Python插件后使用,支持多种编程语言
  • Sublime Text:轻量、快速的编辑器,需要安装一些插件增强Python支持

对于初学者,推荐先使用IDLE熟悉Python基本操作,之后可以尝试VS Code或PyCharm提升开发效率。

1.3 基本语法

Python语法简洁明了,注重可读性,以下是一些基本语法规则:

注释

注释用于解释代码,不会被执行。Python中使用井号 # 表示单行注释,多行注释可以使用三个单引号 ''' 或三个双引号 """

Python注释示例 复制
# 这是单行注释
        
        """
        这是多行注释
        可以跨越多行
        """
        
        '''
        这也是多行注释
        同样可以跨越多行
        '''
        
        print("Hello, World!")  # 这行代码会执行,打印字符串

缩进

Python使用缩进来定义代码块,而不是其他语言常用的大括号 {}。通常使用4个空格作为缩进:

Python缩进示例 复制
if 5 > 2:
            print("5大于2")  # 这行有缩进,属于if代码块
        print("这句始终执行")  # 这行没有缩进,不属于if代码块

语句

Python通常一行写一条语句,不需要使用分号结尾。但也可以在同一行写多条语句,用分号分隔:

Python语句示例 复制
# 一行一条语句(推荐)
        a = 10
        b = 20
        
        # 一行多条语句(不推荐,影响可读性)
        x = 5; y = 15; z = x + y

标识符

标识符是用来给变量、函数、类等命名的名称,Python标识符规则:

  • 由字母、数字和下划线组成
  • 不能以数字开头
  • 区分大小写(如name和Name是不同的标识符)
  • 不能使用Python关键字作为标识符

关键字

关键字是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

1.4 变量与数据类型

变量

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

变量赋值示例 复制
# 创建变量并赋值
        name = "Alice"  # 字符串变量
        age = 25        # 整数变量
        height = 1.75    # 浮点数变量
        is_student = True  # 布尔值变量
        
        # 打印变量
        print(name)
        print(age)

Python是动态类型语言,变量的类型可以随时改变:

变量类型改变示例 复制
x = 10      # x是整数
        print(x)        # 输出:10
        
        x = "Hello"  # x现在是字符串
        print(x)        # 输出:Hello

基本数据类型

Python有多种内置数据类型,常用的基本数据类型包括:

类型 描述 示例
整数 (int) 没有小数部分的数字 42, -7, 0, 1000
浮点数 (float) 带小数部分的数字 3.14, -0.001, 2.0
字符串 (str) 文本数据,用单引号或双引号包裹 'Hello', "Python"
布尔值 (bool) 表示真或假,只有两个值:True和False True, False

类型转换

可以使用内置函数进行数据类型转换:

类型转换示例 复制
# 字符串转整数
        num_str = "123"
        num_int = int(num_str)
        print(num_int)  # 输出:123
        
        # 整数转字符串
        age = 25
        age_str = str(age)
        print(age_str)  # 输出:"25"
        
        # 字符串转浮点数
        pi_str = "3.14159"
        pi_float = float(pi_str)
        print(pi_float)  # 输出:3.14159
        
        # 数字转布尔值
        print(bool(0))     # 输出:False
        print(bool(1))     # 输出:True
        print(bool(""))    # 输出:False

可以使用 type() 函数查看变量的类型:

查看变量类型 复制
x = 42
        y = "Hello"
        z = 3.14
        
        print(type(x))  # 输出:<class 'int'>
        print(type(y))  # 输出:<class 'str'>
        print(type(z))  # 输出:<class 'float'>

1.5 运算符与表达式

运算符用于对变量和值执行操作。由运算符和操作数组成的式子称为表达式。

算术运算符

用于执行基本的数学运算:

运算符 描述 示例 结果
+ 加法 5 + 3 8
- 减法 5 - 3 2
* 乘法 5 * 3 15
/ 除法(返回浮点数) 5 / 3 1.666...
// 整除(返回整数) 5 // 3 1
% 取余(模运算) 5 % 3 2
** 幂运算 5 **3 125

赋值运算符

用于给变量赋值:

运算符 示例 等价于
= x = 5 x = 5
+= x += 3 x = x + 3
-= x -= 3 x = x - 3
*= x *= 3 x = x * 3
/= x /= 3 x = x / 3
%= x %= 3 x = x % 3

比较运算符

用于比较两个值,返回布尔值(True或False):

运算符 描述 示例 结果
== 等于 5 == 3 False
!= 不等于 5 != 3 True
> 大于 5 > 3 True
< 小于 5 < 3 False
>= 大于等于 5 >= 5 True
<= 小于等于 5 <= 3 False

逻辑运算符

用于组合条件语句:

运算符 描述 示例 结果
and 与 - 两个条件都为True才返回True 5 > 3 and 2 > 1 True
or 或 - 至少一个条件为True就返回True 5 > 3 or 2 < 1 True
not 非 - 取反 not 5 > 3 False

运算符优先级

当一个表达式包含多个运算符时,Python会按照一定的优先级进行计算。可以使用括号改变运算顺序:

运算符优先级示例 复制
# 优先级:乘法高于加法
        result1 = 2 + 3 * 4
        print(result1)  # 输出:14(先算3*4,再算2+12)
        
        # 使用括号改变优先级
        result2 = (2 + 3) * 4
        print(result2)  # 输出:20(先算2+3,再算5*4)
        
        # 逻辑运算符优先级
        result3 = 5 > 3 and 10 < 20 or 1 == 2
        print(result3)  # 输出:True

1.6 条件语句

条件语句用于根据不同的条件执行不同的代码块。Python提供了if、if-else和if-elif-else三种条件语句结构。

if语句

if语句用于当条件为True时执行特定代码块:

if语句基本结构 复制
if 条件:
            # 条件为True时执行的代码
            代码块
            代码块
if语句示例 复制
age = 18
        
        if age >= 18:
            print("你已成年")
            print("可以独立做出决策")
        
        print("程序结束")

if-else语句

if-else语句用于当条件为True时执行一个代码块,为False时执行另一个代码块:

if-else语句示例 复制
score = 75
        
        if score >= 60:
            print("考试通过")
        else:
            print("考试未通过")
            print("需要补考")

if-elif-else语句

当需要检查多个条件时,可以使用if-elif-else语句:

if-elif-else语句示例 复制
score = 85
        
        if score >= 90:
            print("优秀")
        elif score >= 80:
            print("良好")
        elif score >= 60:
            print("及格")
        else:
            print("不及格")

嵌套if语句

if语句可以嵌套在其他if语句中:

嵌套if语句示例 复制
age = 20
        has_id = True
        
        if age >= 18:
            print("年龄符合要求")
            if has_id:
                print("可以进入")
            else:
                print("请出示有效证件")
        else:
            print("年龄不符合要求,不能进入")

条件表达式(三目运算符)

Python支持简洁的条件表达式,语法如下:

表达式1 if 条件 else 表达式2

如果条件为True,返回表达式1的值,否则返回表达式2的值:

条件表达式示例 复制
x = 10
        y = 20
        
        max_num = x if x > y else y
        print(max_num)  # 输出:20
        
        age = 17
        status = "成年" if age >= 18 else "未成年"
        print(status)  # 输出:未成年

1.7 循环语句

循环语句用于重复执行一段代码。Python提供了for循环和while循环两种类型。

while循环

while循环在条件为True时重复执行代码块:

while循环基本结构 复制
while 条件:
            # 条件为True时执行的代码
            代码块
while循环示例:计算1到10的和 复制
sum_result = 0
        i = 1
        
        while i <= 10:
            sum_result += i
            i += 1  # 不要忘记更新循环变量,否则会导致无限循环
        
        print("1到10的和是:", sum_result)  # 输出:55

for循环

for循环用于遍历序列(如列表、字符串等)中的每个元素:

for循环基本结构 复制
for 变量 in 序列:
            # 对序列中的每个元素执行的代码
            代码块
for循环示例:遍历字符串 复制
message = "Python"
        
        for char in message:
            print(char)

使用range()函数生成数字序列:

range()函数用法 复制
# range(stop):生成0到stop-1的数字
        for i in range(5):
            print(i)  # 输出:0, 1, 2, 3, 4
        
        # range(start, stop):生成start到stop-1的数字
        for i in range(2, 7):
            print(i)  # 输出:2, 3, 4, 5, 6
        
        # range(start, stop, step):以step为步长生成数字
        for i in range(1, 10, 2):
            print(i)  # 输出:1, 3, 5, 7, 9

循环控制语句

break语句用于跳出当前循环:

break语句示例 复制
for i in range(10):
            if i == 5:
                break  # 当i等于5时跳出循环
            print(i)  # 输出:0, 1, 2, 3, 4

continue语句用于跳过当前循环中的剩余代码,直接进入下一次循环:

continue语句示例 复制
for i in range(10):
            if i % 2 == 0:
                continue  # 跳过偶数
            print(i)  # 输出:1, 3, 5, 7, 9

嵌套循环

循环可以嵌套在其他循环内部:

嵌套循环示例:打印5x5乘法表 复制
for i in range(1, 6):
            for j in range(1, 6):
                print(i * j, end=" ")
            print()  # 换行

1.8 函数基础

函数是组织好的、可重复使用的代码块,用于执行特定任务。使用函数可以提高代码的复用性和可读性。

函数的定义与调用

使用def关键字定义函数:

函数定义与调用示例 复制
# 定义函数
        def greet():
            # 函数体
            print("Hello, World!")
        
        # 调用函数
        greet()  # 输出:Hello, World!
        
        # 可以多次调用
        greet()  # 输出:Hello, World!

函数参数

函数可以接受参数,使函数更加灵活:

带参数的函数 复制
# 定义带参数的函数
        def greet_person(name):
            print("Hello, " + name + "!")
        
        # 调用函数时传入参数
        greet_person("Alice")  # 输出:Hello, Alice!
        greet_person("Bob")    # 输出:Hello, Bob!

函数可以有多个参数:

多个参数的函数 复制
def add(a, b):
            result = a + b
            print(f"{a} + {b} = {result}")
        
        add(3, 5)    # 输出:3 + 5 = 8
        add(10, 20)  # 输出:10 + 20 = 30

默认参数

可以为参数设置默认值,调用函数时如果不提供该参数,则使用默认值:

带默认参数的函数 复制
def greet_with_title(name, title="先生"):
            print("Hello, " + title + "" + name + "!")
        
        # 提供所有参数
        greet_with_title("Wang", "教授")  # 输出:Hello, 教授 Wang!
        
        # 只提供必要参数,使用默认值
        greet_with_title("Li")          # 输出:Hello, 先生 Li!

关键字参数

调用函数时,可以通过参数名指定参数值,这样可以不按照定义的顺序传递参数:

关键字参数示例 复制
def describe_person(name, age, city):
            print(f"{name}今年{age}岁,住在{city}。")
        
        # 按顺序传递参数
        describe_person("Alice", 25, "北京")
        
        # 使用关键字参数,不按顺序
        describe_person(city="上海", name="Bob", age=30)

函数返回值

使用return语句可以使函数返回一个值:

带返回值的函数 复制
def add(a, b):
            return a + b  # 返回计算结果
        
        # 调用函数并获取返回值
        result = add(3, 5)
        print(result)  # 输出:8
        
                                                

2. 进阶知识

2.1 函数进阶

函数进阶内容包括高阶函数、闭包、装饰器、生成器等高级特性。

高阶函数

高阶函数是指可以接受函数作为参数或返回函数的函数:

高阶函数示例 复制
# 函数作为参数
def apply_func(func, x):
    return func(x)

def square(n):
    return n * n

result = apply_func(square, 5)
print(result)  # 输出:25

闭包

闭包是指内部函数可以访问外部函数的变量:

闭包示例 复制
def outer_func(x):
    def inner_func(y):
        return x + y
    return inner_func

closure = outer_func(10)
result = closure(5)
print(result)  # 输出:15

装饰器

装饰器用于修改或增强函数的功能:

装饰器示例 复制
def timer_decorator(func):
    def wrapper(*args, **kwargs):
        import time
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"函数 {func.__name__} 执行时间:{end_time - start_time:.4f} 秒")
        return result
    return wrapper

@timer_decorator
def slow_function():
    import time
    time.sleep(2)
    print("函数执行完成")

slow_function()
← 上一节:函数基础 下一节:数据结构 →

2.2 数据结构

Python提供了丰富的数据结构,包括列表、元组、字典、集合等。

列表操作

列表是Python中最常用的数据结构之一:

列表操作示例 复制
# 列表创建和基本操作
numbers = [1, 2, 3, 4, 5]
print(numbers[0])      # 输出:1
print(numbers[-1])     # 输出:5
print(numbers[1:3])    # 输出:[2, 3]

# 列表方法
numbers.append(6)      # 添加元素
numbers.insert(0, 0)  # 插入元素
numbers.remove(3)      # 删除元素
print(numbers)         # 输出:[0, 1, 2, 4, 5, 6]

字典操作

字典用于存储键值对:

字典操作示例 复制
# 字典创建和操作
person = {
    "name": "张三",
    "age": 25,
    "city": "北京"
}

print(person["name"])  # 输出:张三
print(person.get("email", "暂无"))  # 输出:暂无

# 添加和修改
person["email"] = "zhangsan@email.com"
person["age"] = 26

# 遍历字典
for key, value in person.items():
    print(f"{key}: {value}")

2.3 模块与包

模块是包含Python代码的文件,包是包含多个模块的目录。使用模块和包可以更好地组织代码。

导入模块

使用import语句导入模块:

导入模块示例 复制
# 导入整个模块
import math
print(math.sqrt(16))  # 输出:4.0

# 导入特定函数
from math import sqrt, pi
print(sqrt(9))        # 输出:3.0
print(pi)            # 输出:3.141592653589793

# 给模块起别名
import numpy as np
print(np.array([1, 2, 3]))  # 输出:[1 2 3]

创建自定义模块

创建my_module.py文件:

my_module.py 复制
# my_module.py
def greet(name):
    return f"Hello, {name}!"

def add(a, b):
    return a + b

PI = 3.14159
使用自定义模块 复制
import my_module

print(my_module.greet("Alice"))  # 输出:Hello, Alice!
print(my_module.add(3, 5))       # 输出:8
print(my_module.PI)            # 输出:3.14159

包的使用

包是包含__init__.py文件的目录:

包结构示例 复制
my_package/
    __init__.py
    module1.py
    module2.py
    subpackage/
        __init__.py
        module3.py
导入包中的模块 复制
# 导入包中的模块
from my_package import module1
from my_package.module2 import some_function
from my_package.subpackage import module3

2.4 文件操作

Python提供了丰富的文件操作功能,包括读写文本文件、二进制文件等。

打开和关闭文件

使用open()函数打开文件,使用close()方法关闭文件:

文件打开和关闭 复制
# 打开文件(推荐使用with语句)
with open("example.txt", "r") as file:
    content = file.read()
    print(content)

# 文件会自动关闭

读取文件

有多种方式读取文件内容:

读取文件示例 复制
# 读取整个文件
with open("example.txt", "r") as file:
    content = file.read()
    print(content)

# 逐行读取
with open("example.txt", "r") as file:
    for line in file:
        print(line.strip())  # strip()去除换行符

# 读取所有行到列表
with open("example.txt", "r") as file:
    lines = file.readlines()
    print(lines)

写入文件

写入文件有不同的模式:

写入文件示例 复制
# 写入文件(覆盖模式)
with open("output.txt", "w") as file:
    file.write("Hello, World!\n")
    file.write("This is a new line.\n")

# 追加模式
with open("output.txt", "a") as file:
    file.write("This line is appended.\n")

# 写入多行
lines = ["Line 1\n", "Line 2\n", "Line 3\n"]
with open("multiline.txt", "w") as file:
    file.writelines(lines)

文件操作常用函数

使用os模块进行文件操作:

文件操作函数 复制
import os

# 检查文件是否存在
if os.path.exists("example.txt"):
    print("文件存在")

# 获取文件大小
size = os.path.getsize("example.txt")
print(f"文件大小:{size} 字节")

# 重命名文件
os.rename("old_name.txt", "new_name.txt")

# 删除文件
os.remove("file_to_delete.txt")

2.5 异常处理

异常处理用于处理程序运行时的错误,使程序更加健壮。

基本异常处理

使用try-except语句捕获异常:

基本异常处理 复制
try:
    result = 10 / 0  # 这会引发ZeroDivisionError
except ZeroDivisionError:
    print("不能除以零!")

# 程序会继续执行
print("程序继续运行")

捕获多个异常

可以捕获多种类型的异常:

捕获多个异常 复制
try:
    num = int(input("请输入一个数字:"))
    result = 10 / num
    print(f"结果是:{result}")
except ValueError:
    print("输入的不是有效数字!")
except ZeroDivisionError:
    print("不能除以零!")
except Exception as e:
    print(f"发生了未知错误:{e}")

else和finally子句

else在try块成功执行时运行,finally无论是否发生异常都会运行:

else和finally使用 复制
try:
    num = int(input("请输入一个数字:"))
    result = 10 / num
except ValueError:
    print("输入的不是有效数字!")
except ZeroDivisionError:
    print("不能除以零!")
else:
    print(f"计算成功,结果是:{result}")
finally:
    print("程序执行完毕")

自定义异常

可以创建自定义异常类:

自定义异常 复制
class MyCustomError(Exception):
    def __init__(self, message):
        self.message = message
        super().__init__(message)

def check_age(age):
    if age < 0:
        raise MyCustomError("年龄不能为负数!")
    elif age > 150:
        raise MyCustomError("年龄不能超过150岁!")
    else:
        print(f"年龄验证通过:{age}岁")

try:
    check_age(-5)
except MyCustomError as e:
    print(f"自定义错误:{e}")

面向对象编程

类和对象

Python支持面向对象编程,可以创建类和对象:

创建类和对象 复制
class Dog:
    # 类属性
    species = "哺乳动物"
    
    # 初始化方法
    def __init__(self, name, age):
        # 实例属性
        self.name = name
        self.age = age
    
    # 实例方法
    def bark(self):
        print(f"{self.name}汪汪叫!")
    
    # 实例方法
    def get_info(self):
        return f"名字:{self.name},年龄:{self.age}岁,种类:{self.species}"

# 创建对象
dog1 = Dog("Buddy", 3)
dog2 = Dog("Milo", 5)

# 访问属性和方法
print(dog1.get_info())  # 输出:名字:Buddy,年龄:3岁,种类:哺乳动物
dog2.bark()          # 输出:Milo汪汪叫!
print(Dog.species)     # 输出:哺乳动物

继承

Python支持继承,可以创建子类:

继承示例 复制
class Animal:
    def __init__(self, name):
        self.name = name
    
    def speak(self):
        print(f"{self.name}发出声音")

class Cat(Animal):
    def speak(self):
        print(f"{self.name}喵喵叫!")

class Bird(Animal):
    def speak(self):
        print(f"{self.name}叽叽喳喳!")
    
    def fly(self):
        print(f"{self.name}在飞翔")

# 创建对象
cat = Cat("Whiskers")
bird = Bird("Tweety")

cat.speak()   # 输出:Whiskers喵喵叫!
bird.speak()  # 输出:Tweety叽叽喳喳!
bird.fly()    # 输出:Tweety在飞翔

封装和多态

Python支持封装和多态:

封装和多态示例 复制
class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.__balance = balance  # 私有属性
    
    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
            print(f"存款成功,当前余额:{self.__balance}")
    
    def withdraw(self, amount):
        if 0 < amount <= self.__balance:
            self.__balance -= amount
            print(f"取款成功,当前余额:{self.__balance}")
        else:
            print("取款失败,余额不足")
    
    def get_balance(self):
        return self.__balance

# 多态示例
def make_animal_speak(animal):
    animal.speak()

# 使用
account = BankAccount("张三", 1000)
account.deposit(500)   # 存款成功,当前余额:1500
account.withdraw(200)  # 取款成功,当前余额:1300

# 多态演示
animals = [Cat("Kitty"), Bird("Polly")]
for animal in animals:
    make_animal_speak(animal)

正则表达式

re模块基础

Python使用re模块处理正则表达式:

re模块基本用法 复制
import re

# 匹配数字
text = "我的电话是123-456-7890,另一个是555-1234"
pattern = r'\d{3}-\d{3}-\d{4}'  # 匹配电话号码模式

matches = re.findall(pattern, text)
print("找到的电话号码:", matches)  # 输出:['123-456-7890']

# 搜索第一个匹配
match = re.search(pattern, text)
if match:
    print("第一个匹配:", match.group())  # 输出:123-456-7890
    print("匹配位置:", match.span())     # 输出:(5, 17)

常用正则表达式模式

一些常用的正则表达式模式:

常用正则模式 复制
import re

# 邮箱验证
email_pattern = r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}'
emails = "联系我:john@example.com 或 info@company.org"
valid_emails = re.findall(email_pattern, emails)
print("找到的邮箱:", valid_emails)  # 输出:['john@example.com', 'info@company.org']

# URL提取
url_pattern = r'https?://[^\s]+'
html_text = "访问网站:https://www.example.com 或 http://test.org/page"
urls = re.findall(url_pattern, html_text)
print("找到的URL:", urls)  # 输出:['https://www.example.com', 'http://test.org/page']

# 单词匹配
word_pattern = r'\b\w{4,}\b'  # 匹配4个字母以上的单词
text = "Python is a great programming language for data science"
words = re.findall(word_pattern, text)
print("长单词:", words)  # 输出:['Python', 'great', 'programming', 'language', 'science']

分组和替换

使用分组和替换功能:

分组和替换 复制
import re

# 分组提取
date_text = "今天是2023-12-15,明天是2023-12-16"
date_pattern = r'(\d{4})-(\d{2})-(\d{2})'  # 分组:年、月、日

dates = re.findall(date_pattern, date_text)
print("所有日期分组:", dates)  # 输出:[('2023', '12', '15'), ('2023', '12', '16')]

# 使用分组编号
for match in re.finditer(date_pattern, date_text):
    year, month, day = match.groups()
    print(f"{year}{month}{day}日")

# 字符串替换
phone_text = "联系电话:123-456-7890"
new_phone = re.sub(r'\d{3}-\d{3}-\d{4}', "***-***-****", phone_text)
print("替换后:", new_phone)  # 输出:联系电话:***-***-****

# 使用函数进行替换
def mask_phone(match):
    phone = match.group()
    return "***-***-" + phone[-4:]

masked_text = re.sub(r'\d{3}-\d{3}-\d{4}', mask_phone, phone_text)
print("部分隐藏:", masked_text)  # 输出:联系电话:***-***-7890

编译正则表达式

对于需要多次使用的模式,可以编译正则表达式:

编译正则表达式 复制
import re

# 编译正则表达式
email_regex = re.compile(r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}')
phone_regex = re.compile(r'\b\d{3}-\d{3}-\d{4}\b')

# 使用编译后的模式
text = """
联系人信息:
- 邮箱:alice@example.com
- 电话:555-123-4567
- 备用邮箱:bob@company.org
- 工作电话:888-987-6543
"""

# 查找所有匹配
found_emails = email_regex.findall(text)
found_phones = phone_regex.findall(text)

print("找到的邮箱:", found_emails)
print("找到的电话:", found_phones)

# 验证单个字符串
print("邮箱验证:", email_regex.match("test@example.com") is not None)  # 输出:True
print("邮箱验证:", email_regex.match("invalid-email") is not None)  # 输出:False
← 上一节:面向对象编程 下一节:高级应用
# 直接使用返回值 print(add(10, 20)) # 输出:30

函数文档字符串

可以为函数添加文档字符串(docstring),用于描述函数的功能、参数和返回值:

带文档字符串的函数 复制
def calculate_area(radius):
            """
            计算圆的面积
            
            参数:
                radius: 圆的半径
                
            返回:
                圆的面积,计算公式为:π * radius²
            """
            return 3.14159 * radius * radius
        
        # 查看函数文档
        print(calculate_area.__doc__)
        
        # 使用函数
        area = calculate_area(5)
        print(f"半径为5的圆的面积是:{area}")
← 上一节:循环语句 下一节:进阶知识