本文还有配套的精品资源，点击获取

简介：Python 3.6.7 是一个稳定的编程语言版本，其官方中文文档为初学者提供了全面的指南。文档覆盖了基础语法、模块和包、面向对象编程、函数式编程、错误处理、文件I/O操作、正则表达式、网络编程、并发和多线程、高级主题、标准库指南、Python扩展和嵌入等内容。通过这份文档，初学者可以学习Python基础知识和高级特性，适合不同领域的应用。

1. Python基础语法

1.1 Python简介

Python是一种广泛使用的高级编程语言，以其简洁明了的语法和强大的功能而受到程序员的青睐。它的设计哲学强调代码的可读性和简洁的语法（尤其是使用空格缩进来定义代码块，而不是使用大括号或关键字）。

1.2 Python基本数据类型

Python拥有多种内置数据类型，包括数值、字符串、列表、元组、字典和集合等。这些数据类型提供了丰富的方式去存储和操作数据。

# 示例：Python的基本数据类型
number = 42          # 整数
text = "Hello, World!" # 字符串
list_example = [1, 2, 3] # 列表
tuple_example = (1, 2, 3) # 元组
dict_example = {'key1': 'value1', 'key2': 'value2'} # 字典
set_example = {1, 2, 3} # 集合

1.3 控制结构和循环

Python使用缩进来定义代码块，通过 if 、 elif 、 else 关键字进行条件判断，使用 for 和 while 进行循环控制。

# 示例：控制结构
if number > 40:
    print("Number is greater than 40")
elif number < 40:
    print("Number is less than 40")
else:
    print("Number is exactly 40")

for item in list_example:
    print(item)

count = 0
while count < 3:
    print("Count is:", count)
    count += 1

1.4 函数的定义和使用

函数是组织好的，可重复使用的，用来执行特定任务的代码块。Python 使用关键字 def 来定义函数。

# 示例：定义和使用函数
def greet(name):
    return "Hello, " + name + "!"

print(greet("World"))

以上章节内容，通过Python的定义和基础语法进行了概述，为读者介绍了Python编程语言的初窥门径。

2. 模块和包的使用

2.1 Python模块的引入与使用

2.1.1 导入模块的多种方式

Python通过模块的方式支持代码的复用和组织。模块可以是Python文件(.py)，也可以是编译过的文件(.pyc)。Python的导入系统设计得非常灵活，允许我们以多种方式来使用模块。

import math  # 导入整个模块
from math import sqrt  # 导入模块中的特定函数或变量
from math import *  # 导入模块中的所有内容

在导入模块时，Python解释器会在 sys.path 指定的目录中查找模块。这个列表包括了环境变量 PYTHONPATH 指定的目录和标准库目录。

import sys
print(sys.path)

参数说明 ： sys.path 是一个字符串列表，它决定了Python解释器搜索模块的目录。

2.1.2 模块中的变量和函数

模块中的变量和函数是模块对外开放的接口，它们可以在其他模块中被直接访问。模块内部通常会定义一些函数和变量来完成特定的功能。

# example.py
def add(a, b):
    return a + b

number = 42

# 在其他文件中
import example
print(example.add(10, 5))  # 调用模块中的函数
print(example.number)       # 访问模块中的变量

2.1.3 自定义模块的创建和分发

创建一个自定义模块很简单，只需要创建一个 .py 文件，并定义一些变量和函数即可。为了让其他项目能够使用这个模块，我们可以将其发布到PyPI上，通过 pip 进行安装。

# setup.py
from setuptools import setup, find_packages

setup(
    name='my_module',
    version='0.1',
    packages=find_packages()
)

然后可以使用以下命令构建和上传包到PyPI：

python setup.py sdist bdist_wheel
twine upload dist/*

2.2 包的概念与结构

2.2.1 包的基本结构与命名规则

包是一个包含__init__.py文件的目录，它可以包含模块和其他的子包。为了使Python识别该目录为包，必须包含该文件。

假设我们有如下结构的目录 mypackage ：

mypackage/
    __init__.py
    module1.py
    module2.py
    subpackage/
        __init__.py
        submod.py

在Python 3.3+，可以使用 namespace packages ，无需__init__.py文件。

2.2.2 包内__init__.py文件的作用

__init__.py 文件可以是空的，但也可以执行包的初始化代码或者定义包的属性。当包被导入时， __init__.py 会被执行。

# mypackage/__init__.py
__all__ = ['module1', 'module2', 'subpackage']  # 导入时可用的名称列表

2.2.3 包的导入与使用技巧

包可以以多种方式被导入和使用，其中包括导入整个包、导入包中的模块，或者是导入包中的特定函数或类。

import mypackage.module1 as mod1  # 导入整个模块，并给它一个别名
from mypackage import module2      # 从包中导入一个模块
from mypackage.subpackage import submod  # 从子包中导入模块

2.3 模块的搜索路径和__pycache__

当导入一个模块时，Python会在一组目录中查找这个模块。这个目录列表可以通过 sys.path 查看。此外，编译的 .pyc 文件会被放在 __pycache__ 目录下，以便加速模块的加载。

import sys
print(sys.path)

以上就是关于模块和包使用的基础知识。了解这些知识能够帮助我们更好地组织和利用Python的模块系统，提高开发效率和代码的可维护性。

3. 面向对象编程基础

3.1 面向对象基础概念

3.1.1 类与对象的定义

在Python中，一切皆对象。面向对象编程（OOP）是一种编程范式，它使用对象来设计软件。对象是类的实例，类可以看作是对象的蓝图。每个对象都拥有类中定义的属性和方法，但它们的具体值或实现可能不同。创建类是通过关键字 class 后跟类名来实现的。例如：

class Car:
    def __init__(self, model, color):
        self.model = model
        self.color = color
    def drive(self):
        print(f"The {self.color} {self.model} is driving.")

# 创建Car类的对象
my_car = Car("Tesla", "red")

在上述代码中， Car 是一个类，拥有 __init__ 方法（构造函数）和 drive 方法。 my_car 是 Car 类的一个对象，它具有特定的模型和颜色属性。

3.1.2 属性与方法的基本使用

对象的属性是存储在对象内部的变量，用来描述对象的状态或特征。在面向对象编程中，方法是对象的行为或功能的实现。在Python中，方法是定义在类体中的函数。

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def greet(self):
        print(f"Hello, my name is {self.name} and I am {self.age} years old.")

# 创建Person类的对象
person = Person("Alice", 30)
person.greet()

在上述代码中， Person 类有两个属性 name 和 age ，以及一个方法 greet 。通过创建对象 person 并调用它的 greet 方法，我们可以看到属性和方法是如何协同工作的。

3.1.3 self参数的理解与应用

在Python类的方法定义中，第一个参数通常是 self 。它代表类的实例，是方法能够访问类属性和其他方法的关键。在调用对象的方法时，Python解释器会自动将对象本身作为第一个参数传递给方法。

class Circle:
    pi = 3.14159
    def __init__(self, radius):
        self.radius = radius
    def area(self):
        return Circle.pi * self.radius * self.radius

circle = Circle(5)
print(circle.area())

在上述代码中， Circle 类有一个类变量 pi 和一个实例变量 radius 。在 area 方法中，使用 self.radius 来访问实例变量，而使用 Circle.pi 来访问类变量。

3.2 高级面向对象特性

3.2.1 继承与多态的实现

继承是面向对象编程中的一种机制，它允许我们创建一个新类，这个新类可以继承其父类（基类）的属性和方法。多态则是指允许不同类的对象对同一消息做出响应的能力。

class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow"

# 创建不同类型的动物
dog = Dog()
cat = Cat()

# 调用speak方法，展示多态
for pet in [dog, cat]:
    print(pet.speak())

在这个例子中， Dog 和 Cat 类都继承自 Animal 基类。由于它们都实现了 speak 方法，当调用 speak 时，表现出多态行为。尽管方法签名相同，但每个类根据自己的逻辑来实现这个方法。

3.2.2 类变量与实例变量的区别

类变量是定义在类中但不属于任何实例的变量，它被类的所有实例共享。实例变量是定义在方法内部，但使用 self 关键字，这样每个实例都会有自己的变量副本。

class Student:
    school_name = "Global University"  # 类变量
    def __init__(self, name, id_number):
        self.name = name                # 实例变量
        self.id_number = id_number

# 创建两个Student类的实例
student1 = Student("John", "1234")
student2 = Student("Jane", "5678")

print(student1.school_name)  # 输出: Global University
print(student2.school_name)  # 输出: Global University
print(student1.id_number)    # 输出: 1234
print(student2.id_number)    # 输出: 5678

在这个例子中， school_name 是一个类变量，它被 Student 类的所有实例共享。而 id_number 是一个实例变量，每个 Student 实例都拥有不同的 id_number 值。

3.2.3 魔术方法（Magic Methods）的应用

魔术方法是Python中的一类特殊方法，它们具有特定的命名约定（以双下划线开头和结尾）。这些方法在特定的事件发生时自动调用，比如创建对象、算术运算等。例如， __init__ 方法用于初始化对象， __str__ 用于返回对象的字符串表示。

class Book:
    def __init__(self, title, author):
        self.title = title
        self.author = author
    def __str__(self):
        return f"Title: {self.title}, Author: {self.author}"

# 创建Book类的对象
book = Book("Python Programming", "Jane Doe")

# 打印对象时，自动调用__str__方法
print(book)

在这个例子中，当我们打印 book 对象时，Python解释器自动调用 Book 类的 __str__ 方法来获取对象的字符串表示。魔术方法的使用为面向对象编程提供了额外的灵活性和功能。

以上内容详细探讨了面向对象编程的基础概念以及高级特性，包括类和对象、属性和方法、继承、多态、类变量与实例变量的区别以及魔术方法的使用。理解这些概念对于深入学习Python乃至其他面向对象编程语言都至关重要。

4. 函数式编程概念

函数式编程是一种以函数为基本构建块的编程范式。在函数式编程中，函数不仅仅是执行流程控制和数据操作的基本单位，而且可以被当作一等公民对待，即函数可以作为参数传递给其他函数，可以作为结果返回，也可以赋值给变量。Python支持函数式编程特性，并且鼓励开发者利用这些特性来编写简洁、高效和可读性更高的代码。

4.1 函数作为一等公民

函数作为一等公民是函数式编程的核心概念之一。这意味着在Python中，函数可以像其他值一样被操作，例如被赋给变量，作为参数传递，或者作为结果返回。

4.1.1 函数的定义与调用

在Python中定义一个函数非常简单，使用 def 关键字后跟函数名和括号，括号内可以包含参数列表。函数体用冒号 : 开始，并且通过缩进来标识。函数通过其名称调用，后跟括号和所需的参数。

def greet(name):
    return "Hello, " + name + "!"

print(greet("Alice"))  # 输出: Hello, Alice!

在上述代码中，我们定义了一个 greet 函数，它接受一个参数 name ，并返回一个问候语。然后我们通过 print 函数调用它并打印结果。

4.1.2 高阶函数的概念与实例

高阶函数是至少满足以下两个条件之一的函数：接受一个或多个函数作为输入，或者输出一个函数。Python的内置函数 map 、 filter 和 reduce 都是高阶函数的实例。此外，Python允许我们自定义高阶函数。

def apply_function(func, x):
    return func(x)

def square(x):
    return x * x

print(apply_function(square, 3))  # 输出: 9

在这个例子中， apply_function 是一个高阶函数，因为它接受另一个函数 square 作为输入，并将其应用到参数 x 上。

4.1.3 lambda表达式与匿名函数

Python支持匿名函数，也就是没有名称的函数。它们使用 lambda 关键字定义，通常用于那些函数体相对简单的函数。

square = lambda x: x * x

print(square(4))  # 输出: 16

在这个例子中，我们使用 lambda 定义了一个匿名函数 square ，它计算参数 x 的平方。

4.2 函数式编程特性

函数式编程不仅仅关注函数作为一等公民的特性，它还包括一系列概念和模式，旨在提高代码的简洁性和表达力。

4.2.1 函数式编程的优势与适用场景

函数式编程的优势主要体现在代码的简洁性和表达力上。它通过减少副作用和状态改变来提高程序的可预测性和稳定性。这使得函数式编程特别适合于并发和并行程序设计，因为它减少了不同线程或进程之间的冲突风险。

4.2.2 map、reduce和filter的使用

Python提供了三个内置函数 map 、 reduce 和 filter ，它们都是函数式编程的经典操作。

• map 函数将给定函数应用于可迭代对象的每个元素，并返回一个迭代器。 map 适用于对集合中的每个元素应用同一函数，并得到结果集。

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

• reduce 函数会对参数序列中元素进行累积。 reduce 接收一个函数和一个序列，函数将应用于序列的元素，然后将该函数应用于累积的结果和下一个序列元素，以此类推，并返回最终结果。

from functools import reduce

numbers = [1, 2, 3, 4, 5]
product = reduce(lambda x, y: x * y, numbers)
print(product)  # 输出: 120

• filter 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器。

numbers = [1, 2, 3, 4, 5]
even_numbers = filter(lambda x: x % 2 == 0, numbers)
print(list(even_numbers))  # 输出: [2, 4]

4.2.3 列表解析与生成器表达式

列表解析是Python中实现函数式编程的另一个强大工具。它提供了一种简洁的方法来创建列表，通过一个表达式快速生成列表。

squared = [x * x for x in range(1, 6)]
print(squared)  # 输出: [1, 4, 9, 16, 25]

生成器表达式与列表解析类似，但是它返回一个生成器对象而不是列表。这对于处理大数据集合非常有用，因为它可以节省内存。

squared_gen = (x * x for x in range(1, 6))
for num in squared_gen:
    print(num, end=" ")  # 输出: 1 4 9 16 25

列表解析和生成器表达式都是函数式编程中非常实用的工具，它们使代码更加简洁，且易于理解和维护。

5. 错误和异常处理

错误和异常是编程中不可避免的一部分，它们提供了程序执行中出现问题时的反馈信息。正确处理异常是编写健壮代码的关键，它可以帮助我们更好地控制程序的执行流程，提供更友好的用户体验，并确保程序在遇到错误时能够以一种可预测的方式优雅地终止。

5.1 异常处理基础

异常处理是Python中一种处理程序错误的机制，它使得程序在遇到错误时不会立即崩溃，而是可以被恰当地处理。异常处理通常依赖于try-except语句来捕获和处理程序运行时发生的异常。

5.1.1 try-except语句的使用

try-except语句块是异常处理的核心。try部分用于包裹可能会引发异常的代码，而except部分则定义了当特定异常发生时该如何处理。

try:
    # 可能会引发异常的代码块
    result = 10 / 0
except ZeroDivisionError as e:
    # 当捕获到ZeroDivisionError异常时，执行这里的代码
    print(f"捕获到异常：{e}")

在上面的代码中，尝试执行了除以零的操作，这会导致 ZeroDivisionError 异常。通过 try-except 语句，当异常发生时，我们可以捕获它，并输出相应的错误信息而不是程序崩溃。

5.1.2 抛出异常的方法与技巧

在某些情况下，我们可能希望程序根据特定的逻辑主动抛出异常。Python使用 raise 关键字来抛出异常。你可以抛出任何已经存在的异常类型或者自定义的异常类型。

def check_age(age):
    if age < 0:
        raise ValueError("年龄不能是负数")
    return True

# 调用函数，传入非法参数
check_age(-10)

在上述示例中，如果传入的年龄参数小于零， check_age 函数将抛出一个 ValueError 异常，并附带一条错误信息。抛出异常可以强迫调用者处理这个情况，而不是忽略潜在的逻辑错误。

5.1.3 自定义异常的创建和使用

Python允许我们定义自己的异常类来满足特定的需求。通常，自定义异常是通过继承内置的异常类来创建的。例如，我们可以创建一个 NegativeAgeError 异常来专门处理年龄为负的情况。

class NegativeAgeError(Exception):
    """年龄为负数的异常类"""

    def __init__(self, age):
        self.age = age
        self.message = f"年龄不能是负数，当前输入为：{age}"
        super().__init__(self.message)

# 使用自定义异常
try:
    check_age(-10)
except NegativeAgeError as e:
    print(e)

这段代码中定义了一个新的异常类 NegativeAgeError ，它继承自Python的内置异常基类 Exception 。当检测到年龄为负时，我们抛出这个异常，并在 except 块中捕获并打印出异常信息。

异常处理机制不仅能够避免程序因错误而立即中断，而且通过自定义异常还能提供更加清晰和专业的错误处理策略，使得代码的逻辑更加清晰，维护起来更加方便。在下一节中，我们将探索一些更高级的错误处理技巧，以进一步增强程序的健壮性。

6. 文件和I/O操作

6.1 文件操作基础

6.1.1 文件的打开与关闭

文件操作是任何编程语言的基本组成部分，Python 中也不例外。打开文件是在 Python 中读取或写入文件的第一步。Python 提供了内置函数 open() 来打开文件，该函数的基本语法如下：

file_object = open(file_name, mode)

其中 file_name 是你想要打开的文件的路径， mode 是打开文件的模式，例如，’r’ 表示只读，’w’ 表示只写，’a’ 表示追加等等。如果没有指定 mode ，默认值是 ‘r’。

关闭文件是文件操作中同样重要的一环。使用 open() 打开文件后，应该使用 close() 方法来关闭文件，释放系统资源。使用 with 语句可以自动管理文件的打开和关闭。

# 使用 with 语句打开文件，确保文件最终会被关闭
with open('example.txt', 'r') as file:
    content = file.read()
    # 进行文件内容处理
    print(content)
# 文件在离开 with 块的时候自动关闭

文件对象提供了几个方法来读取和写入文件，例如 read() , write() , readline() 等。这些都是处理文件时的基础工具。

6.1.2 文件读写操作的方法

当文件被打开之后，我们就可以根据需要读取或写入内容。文件读取操作涉及到一些方法如 read() , readline() , 和 readlines() 。

• read(size) ：读取文件内容， size 参数指定了读取的最大字节数。
• readline() ：读取文件的一行。
• readlines() ：读取所有行，并将其作为列表返回。

写入文件则需要将文件以写入模式 ‘w’ 或追加模式 ‘a’ 打开。之后可以使用 write(string) 方法来写入字符串。如果文件以 ‘w’ 模式打开，则原有内容会被覆盖。

6.1.3 文件指针定位与文件属性

文件指针（cursor）是文件对象中的一个内部标记，表示当前操作的位置。你可以使用 tell() 方法来获取当前文件指针的位置，使用 seek(offset, whence) 来移动文件指针的位置。

# 读取部分文件内容，然后移动文件指针
with open('example.txt', 'r') as file:
    file.seek(10)  # 移动指针到文件的第10个字节
    content = file.read(5)  # 读取接下来的5个字节

文件对象还提供了获取文件属性的方法，例如 closed 属性检查文件是否已经关闭， name 属性返回文件名， mode 属性返回打开文件的模式。

6.2 高级文件处理技术

6.2.1 使用with语句管理文件上下文

with 语句在处理文件时非常有用，因为它简化了异常处理，并自动管理文件的打开和关闭。当你离开 with 代码块时，文件会自动关闭，即使在读取或写入过程中发生了异常。

6.2.2 文件编码与二进制文件处理

文件编码是指在读取或写入文件时所使用的字符编码，Python 允许你指定 open() 函数的 encoding 参数来明确使用哪种编码。

# 以特定编码打开文件
with open('example.txt', 'r', encoding='utf-8') as file:
    content = file.read()

处理二进制文件时，需要以 ‘b’ 模式打开，例如 ‘rb’ 或 ‘wb’。二进制模式通常用于读取或写入非文本数据，如图片或视频文件。

6.2.3 文件系统操作与路径管理

Python 提供了 os 和 pathlib 模块来进行文件系统操作和路径管理。 os 模块包含大量操作文件和目录的函数，而 pathlib 提供了面向对象的路径操作方法。

import os

# 获取当前工作目录
current_directory = os.getcwd()

# 列出目录下的文件和文件夹
files_and_folders = os.listdir(current_directory)

pathlib 通过 Path 类提供了一个非常直观的接口来处理文件系统路径：

from pathlib import Path

# 创建路径对象
path = Path('example.txt')

# 检查文件是否存在
if path.exists():
    print("文件存在")
else:
    print("文件不存在")

文件和 I/O 操作是许多应用程序的基础。理解如何有效地打开、读取、写入以及关闭文件是构建稳定、高效 Python 应用的关键部分。通过以上的章节内容，我们可以了解到如何在 Python 中执行基本的文件操作，并进一步探讨了处理文件时的一些高级技术。掌握这些知识，可以帮助开发者在处理数据和资源时更加得心应手。

7. 正则表达式应用

正则表达式是处理字符串的强大工具，它提供了一种灵活且高效的方法来进行文本匹配和处理。无论是简单的数据验证还是复杂的文本分析，正则表达式都能极大地简化代码的实现。

7.1 正则表达式基础语法

正则表达式由一系列字符和特殊符号构成，用于定义一个搜索模式。这个模式可以用来执行复杂的匹配和提取操作。

7.1.1 正则表达式的组成与模式匹配

正则表达式通常包含普通字符（比如字母和数字）和特殊字符（称为“元字符”）。普通字符指的是字母、数字、汉字等，它们在正则表达式中通常表示字面意义。

特殊字符则有更复杂的含义，比如：

• . 表示任意字符（除了换行符）。
• * 表示前面的字符重复零次或多次。
• + 表示前面的字符重复一次或多次。
• ? 表示前面的字符重复零次或一次。
• {n} 表示前面的字符重复n次。
• {n,} 表示至少重复n次。
• {n,m} 表示重复n到m次。

举例来说，正则表达式 a.*b 将匹配任何以 a 开始，以 b 结束的字符串。

import re

text = "ab, a1b, a2b, a3b, a4b, a5b"
pattern = r"a.*b"
matches = re.findall(pattern, text)
print(matches)  # 输出 ['ab', 'a1b', 'a2b', 'a3b', 'a4b', 'a5b']

7.1.2 元字符的使用与转义规则

元字符是构成正则表达式的基石，它们赋予了正则表达式强大的匹配能力。例如， \d 匹配任意单个数字字符， \w 匹配任意单个字母或数字字符。

由于一些字符在正则表达式中具有特殊含义，如果需要匹配这些字符本身，就需要进行转义。在Python中，转义是通过在特殊字符前加一个反斜杠 \ 来实现的。

text = "This is a sample text with a #hashtag."
pattern = r"hashtag\."
matches = re.findall(pattern, text)
print(matches)  # 输出 ['hashtag.']

7.1.3 匹配模式与贪婪/非贪婪匹配

正则表达式默认是贪婪模式，它会尽可能多地匹配字符。例如，在表达式 a.*b 中，它会匹配尽可能长的字符串，使得最终能够匹配到结尾的 b 。

非贪婪模式则通过在量词后面添加 ? 实现，它尽可能少地匹配字符。在上面的例子中，如果我们使用 a.*?b ，它会匹配到第一个 b 。

text = "aaaaaa"
pattern_greedy = r"a*ab"
pattern_non_greedy = r"a*?ab"

print(re.match(pattern_greedy, text).group())  # 输出 'aaaaaab'
print(re.match(pattern_non_greedy, text).group())  # 输出 'aab'

7.2 正则表达式高级应用

在基础语法之上，正则表达式还包含许多高级功能，这些功能让文本处理变得更加强大和灵活。

7.2.1 分组与反向引用

分组是通过将表达式的一部分用括号包围起来实现的，这样可以将这部分作为一个单独的单元来处理。分组的主要用途之一是使用反向引用。

反向引用是指在正则表达式中引用前面的某个分组。这通常用于查找重复的单词或者字符串等。

text = "The rain in Spain falls mainly in the plain."
pattern = r"(\w+)\s+\1"
matches = re.findall(pattern, text)
print(matches)  # 输出 ['in in']

7.2.2 正则表达式与搜索替换

在许多编程语言和工具中，正则表达式不仅用于搜索匹配项，还可以用于搜索并替换文本。Python 中的 re.sub() 函数就是用于这个目的的。

text = "The cost of the item is $4.50"
pattern = r"\d+\.\d+"
replacement = "3.99"
new_text = re.sub(pattern, replacement, text)
print(new_text)  # 输出 "The cost of the item is $3.99"

7.2.3 多行模式与前后查找

多行模式通过使用 re.MULTILINE 标志实现，它改变了 ^ 和 $ 的行为。在多行模式下， ^ 匹配每一行的开始，而 $ 匹配每一行的结束。

前后查找是正则表达式中用于查找某个位置前面或后面的特定模式。向前查找使用 ?= ，向后查找使用 ?<= 。

text = """Line one
Line two
Line three
Line four"""
pattern = r"^\w+"
matches = re.findall(pattern, text, re.MULTILINE)
print(matches)  # 输出 ['Line', 'Line', 'Line', 'Line']

正则表达式的应用非常广泛，无论是在编程还是数据分析中，掌握它都能够帮助你更好地处理和分析文本数据。通过学习和实践这些高级特性，你可以为你的工具箱增添一个强大的武器。

本文还有配套的精品资源，点击获取

简介：Python 3.6.7 是一个稳定的编程语言版本，其官方中文文档为初学者提供了全面的指南。文档覆盖了基础语法、模块和包、面向对象编程、函数式编程、错误处理、文件I/O操作、正则表达式、网络编程、并发和多线程、高级主题、标准库指南、Python扩展和嵌入等内容。通过这份文档，初学者可以学习Python基础知识和高级特性，适合不同领域的应用。

本文还有配套的精品资源，点击获取