学习进度
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解释器
- 访问Python官方网站:https://www.python.org/
- 点击"Downloads",选择适合您操作系统的版本(Windows、macOS或Linux)
- 运行下载的安装程序
- 重要:在Windows安装时,勾选"Add Python to PATH"选项
- 按照安装向导完成安装
验证安装
安装完成后,可以通过以下方式验证:
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个空格作为缩进:
if x > 10: print("x大于10") # 这行有缩进 print("继续执行") # 同一代码块 print("这行不在if块内") # 没有缩进
2. 语句结束
Python语句通常以换行符结束,不需要分号。但可以使用分号将多个语句放在同一行:
# 正常写法,每行一个语句 a = 10 b = 20 # 使用分号在一行写多个语句 x = 5; y = 15; z = x + y
3. 注释
Python中使用#表示单行注释,多行注释可以使用三个单引号'''或三个双引号""":
# 这是一个单行注释 ''' 这是一个多行注释 可以跨越多行 ''' """ 这也是一个多行注释 通常用于文档字符串 """
4. 代码块分隔符
Python使用冒号:来开始一个代码块,如if、for、while、函数定义等:
def greet(name): print("Hello, " + name) # 函数体,有缩进 for i in range(5): print(i) # 循环体,有缩进
5. 第一个Python程序
经典的"Hello, World!"程序:
# 我的第一个Python程序 print("Hello, World!")
运行上述程序,会在屏幕上输出:Hello, World!
1.4 变量与数据类型
变量
变量是存储数据的容器。在Python中,变量不需要声明类型,可以直接赋值:
安装完成后,我们可以通过以下方式验证Python是否安装成功:
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中使用井号 #
表示单行注释,多行注释可以使用三个单引号 '''
或三个双引号 """
:
# 这是单行注释 """ 这是多行注释 可以跨越多行 """ ''' 这也是多行注释 同样可以跨越多行 ''' print("Hello, World!") # 这行代码会执行,打印字符串
缩进
Python使用缩进来定义代码块,而不是其他语言常用的大括号 {}
。通常使用4个空格作为缩进:
if 5 > 2: print("5大于2") # 这行有缩进,属于if代码块 print("这句始终执行") # 这行没有缩进,不属于if代码块
语句
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 条件: # 条件为True时执行的代码 代码块 代码块
age = 18 if age >= 18: print("你已成年") print("可以独立做出决策") print("程序结束")
if-else语句
if-else语句用于当条件为True时执行一个代码块,为False时执行另一个代码块:
score = 75 if score >= 60: print("考试通过") else: print("考试未通过") print("需要补考")
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语句中:
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 条件: # 条件为True时执行的代码 代码块
sum_result = 0 i = 1 while i <= 10: sum_result += i i += 1 # 不要忘记更新循环变量,否则会导致无限循环 print("1到10的和是:", sum_result) # 输出:55
for循环
for循环用于遍历序列(如列表、字符串等)中的每个元素:
for 变量 in 序列: # 对序列中的每个元素执行的代码 代码块
message = "Python" for char in message: print(char)
使用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
语句用于跳出当前循环:
for i in range(10): if i == 5: break # 当i等于5时跳出循环 print(i) # 输出:0, 1, 2, 3, 4
continue
语句用于跳过当前循环中的剩余代码,直接进入下一次循环:
for i in range(10): if i % 2 == 0: continue # 跳过偶数 print(i) # 输出:1, 3, 5, 7, 9
嵌套循环
循环可以嵌套在其他循环内部:
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 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无论是否发生异常都会运行:
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模块处理正则表达式:
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
函数文档字符串
可以为函数添加文档字符串(docstring),用于描述函数的功能、参数和返回值:
def calculate_area(radius): """ 计算圆的面积 参数: radius: 圆的半径 返回: 圆的面积,计算公式为:π * radius² """ return 3.14159 * radius * radius # 查看函数文档 print(calculate_area.__doc__) # 使用函数 area = calculate_area(5) print(f"半径为5的圆的面积是:{area}")