目录

1. 生成随机文本

2. 计算文本文件中的字数

3. 替换文件文件中的字串

4. 多文件名的批量替换

5. 从网站提取数据

6. 批量下载图片

7.批量删除空文件夹

8.Excel表格读写

9.合并Excel表格工作簿

10.数据库SQL查询

11. 系统进程查杀

12.图像尺寸调整和裁剪

13.图片添加水印

14. 创建图像缩略图

15.PDF中提取文本

16. 合并多个PDF文件

---

1. 生成随机文本

import random
import string
def generate_random_text(length):
    letters = string.ascii_letters + string.digits + string.punctuation
    random_text = ''.join(random.choice(letters) for i in range(length))
    return random_text

函数generate_random_text接受一个参数length，用于指定生成的随机文本的长度。函数内部，它首先定义了一个letters字符串，包含了所有的ASCII字母（大写和小写）、数字以及标点符号。然后，它使用列表推导式和random.choice函数从letters中随机选择字符，并将这些字符连接成一个字符串。最后，函数返回这个随机生成的字符串。以下是对代码的详细解释：

1. import random：
   导入Python的random模块，该模块提供了生成随机数的功能。

2. import string：
   导入Python的string模块，该模块包含了一些常用的字符串常量，如ASCII字母、数字、标点符号等。

3. def generate_random_text(length):：
   定义了一个名为generate_random_text的函数，该函数接受一个参数length，表示要生成的随机文本的长度。

4. letters = string.ascii_letters + string.digits + string.punctuation：
   创建了一个名为letters的字符串，该字符串包含了所有ASCII字母（大写和小写）、数字以及标点符号。这是为了确保生成的随机文本可以包含这些字符。

5. random_text = ''.join(random.choice(letters) for i in range(length))：
   使用列表推导式（list comprehension）和random.choice函数来生成随机文本。

   • random.choice(letters)：从letters字符串中随机选择一个字符。
   • for i in range(length)：循环length次，确保生成的随机文本长度为length。
   • ''.join(...)：将生成的随机字符列表连接成一个字符串。

6. return random_text：
   返回生成的随机文本字符串。

2. 计算文本文件中的字数

def count_words(file_path):
    with open(file_path, 'r') as f:
        text = f.read()
        word_count = len(text.split())
    return word_count

函数count_words接受一个文件路径file_path作为参数，并返回该文件中单词的数量。以下是函数的详细解释：

1. def count_words(file_path):
   这是函数的定义行，其中count_words是函数名，file_path是唯一的参数。

2. with open(file_path, 'r') as f:
   使用with语句和open函数来打开指定路径file_path的文件。文件以只读模式（'r'）打开，并将其文件对象赋值给变量f。with语句确保文件在操作完成后会被正确关闭。

3. text = f.read()
   读取文件对象f中的所有内容，并将其作为字符串赋值给变量text。

4. word_count = len(text.split())
text.split()方法用于将text字符串按照空格分割成一个单词列表。split()方法默认使用空格作为分隔符，因此它会分割字符串中所有的空格（包括单词间的空格、换行符后的空格等）。len()函数则用于计算这个列表中元素的数量，即单词的数量。

5. return word_count
   函数返回计算得到的单词数量。

请注意，这个函数简单地通过空格来分割单词，因此可能无法正确处理某些复杂情况，比如标点符号紧挨着单词、缩写词等。对于更准确的单词计数，可能需要使用更复杂的文本处理库，如NLTK（Natural Language Toolkit）或正则表达式。

此外，如果文件非常大，使用f.read()将整个文件内容读入内存可能会导致内存不足。在这种情况下，可以考虑逐行读取文件并计算单词数量，以节省内存。

3. 替换文件文件中的字串

def find_replace(file_path, search_text, replace_text):
    with open(file_path, 'r') as f:
        text = f.read()
        modified_text = text.replace(search_text, replace_text)
    with open(file_path, 'w') as f:
        f.write(modified_text)

函数 find_replace 执行了一个常见的文本文件操作：查找并替换文件中的文本。以下是该函数的详细解释：

1. def find_replace(file_path, search_text, replace_text):
   定义了一个名为 find_replace 的函数，它接受三个参数：file_path（要操作的文件路径），search_text（要在文件中查找的文本），和 replace_text（用于替换找到的文本的文本）。

2. with open(file_path, 'r') as f:
   使用 with 语句和 open 函数以只读模式（'r'）打开指定路径 file_path 的文件，并将文件对象赋值给变量 f。

3. text = f.read()
   读取文件对象 f 中的所有内容，并将其作为字符串赋值给变量 text。

4. modified_text = text.replace(search_text, replace_text)
   使用字符串的 replace 方法将 text 中的所有 search_text 实例替换为 replace_text。替换后的文本存储在 modified_text 变量中。

5. with open(file_path, 'w') as f:
   再次使用 with 语句和 open 函数，但这次以写入模式（'w'）打开相同的文件路径 file_path。如果文件已存在，这个操作会覆盖文件的现有内容。如果文件不存在，会创建一个新文件。

6. f.write(modified_text)
   将修改后的文本 modified_text 写入到文件对象中，从而更新文件内容。

请注意，这个函数有几个潜在的问题和限制：

• 如果文件非常大，将整个文件读入内存并进行替换操作可能会消耗大量内存。
• 使用 'w' 模式打开文件会覆盖文件的原始内容，如果替换操作失败，可能会导致数据丢失。
• 该函数不会备份原始文件，所以在进行替换操作之前，最好先备份文件。
• 函数没有处理可能出现的异常，如文件不存在、无法读取或写入等。

在实际应用中，可能需要根据具体需求对这些潜在问题进行适当的处理。

4. 多文件名的批量替换

import os
def rename_files(directory_path, old_name, new_name):
    for filename in os.listdir(directory_path):
        if old_name in filename:
            new_filename = filename.replace(old_name, new_name)
            os.rename(os.path.join(directory_path,filename),os.path.join(directory_path, new_filename))

函数 rename_files 的目的是重命名指定目录中的文件。函数接受三个参数：directory_path（目录路径），old_name（要在文件名中查找并替换的旧名称），和 new_name（用于替换旧名称的新名称）。以下是对函数的详细解释：

1. import os
   导入Python的 os 模块，该模块提供了与操作系统交互的功能，如文件操作、路径名操作等。

2. def rename_files(directory_path, old_name, new_name):
   定义了一个名为 rename_files 的函数，该函数接受三个参数：目录路径、旧文件名部分和新文件名部分。

3. for filename in os.listdir(directory_path):
   使用 os.listdir() 函数列出指定目录 directory_path 下的所有文件和子目录名称。然后，对于目录中的每个文件（包括子目录），函数会执行以下操作。

4. if old_name in filename:
   检查当前处理的文件名 filename 是否包含 old_name。如果包含，则执行下面的代码块。

5. new_filename = filename.replace(old_name, new_name)
   使用字符串的 replace() 方法将文件名 filename 中的 old_name 替换为 new_name。替换后的新文件名存储在 new_filename 变量中。

6. os.rename(os.path.join(directory_path, filename), os.path.join(directory_path, new_filename))
   使用 os.rename() 函数重命名文件。os.path.join(directory_path, filename) 用于构建文件的完整路径（包括目录和文件名），同样地，os.path.join(directory_path, new_filename) 用于构建新文件名的完整路径。这两个路径分别作为 os.rename() 函数的第一个和第二个参数，表示要重命名的原始文件和新文件的路径。

注意：

• 如果目录中包含子目录，这个函数也会尝试重命名子目录，这可能会导致错误，因为子目录通常不能被简单地重命名。
• 如果目录中存在多个文件包含相同的 old_name，这个函数会重命名所有这些文件，即使它们的扩展名不同。
• 这个函数不会处理文件重名的情况。如果新文件名与现有文件名冲突，os.rename() 会引发一个异常。
• 函数没有处理可能出现的异常，如权限问题或文件不存在等。在实际应用中，可能需要添加异常处理逻辑。

5. 从网站提取数据

import requests
from bs4 import BeautifulSoup
def scrape_data(url):
    response = requests.get(url)
    soup = BeautifulSoup(response.text, 'html.parser')

这段代码是Python中用于网络爬虫的一个简单示例，具体用于从给定的URL地址抓取数据。这里使用了requests库来发送HTTP请求，以及BeautifulSoup库来解析HTML内容。下面是对代码的逐行解释：

1. import requests：
   导入requests库，这是一个用于发送HTTP请求的库，可以轻松地发送GET、POST等请求。

2. from bs4 import BeautifulSoup：
   从bs4（BeautifulSoup 4）库中导入BeautifulSoup类。BeautifulSoup用于解析HTML和XML文档，并提供了简单、灵活的方法来遍历、搜索、修改分析树等功能。

3. def scrape_data(url):：
   定义一个名为scrape_data的函数，该函数接受一个参数url，这个参数代表要抓取的网页的URL地址。

4. response = requests.get(url)：
   使用requests库的get方法向给定的url发送一个HTTP GET请求。服务器的响应会被存储在response变量中。

5. soup = BeautifulSoup(response.text, 'html.parser')：
   将response中的文本内容（即网页的HTML源代码）传递给BeautifulSoup类，并指定使用html.parser作为解析器。这样，BeautifulSoup就可以将HTML代码解析成一个易于操作和查询的数据结构（通常是一个树形结构）。解析后的数据存储在soup变量中。

一旦你有了soup这个BeautifulSoup对象，你就可以使用它的方法来查找和提取网页中的特定元素、属性或文本内容了。例如，你可以使用soup.find()、soup.find_all()等方法来搜索特定的HTML标签或属性，以及使用.text属性来获取元素的文本内容等。

请注意，这段代码只是网络爬虫的一部分，它只负责从网页上抓取数据。如果你想要对抓取到的数据进行进一步的处理或分析，你还需要编写更多的代码来实现这些功能。此外，在使用网络爬虫时，请务必遵守网站的robots.txt规则以及相关法律法规，不要进行恶意爬取或侵犯他人隐私。

6. 批量下载图片

import requests
def download_images(url, save_directory):
    response = requests.get(url)
    if response.status_code == 200:
        images = response.json() # Assuming the API returns a JSON array of image URLs
        for index, image_url in enumerate(images):
            image_response = requests.get(image_url)
            if image_response.status_code == 200:
                with open(f"{save_directory}/image_{index}.jpg", "wb") as f:
                    f.write(image_response.content)

函数 download_images 用于从指定的 URL 下载多个图像，并将它们保存到指定的目录中。以下是对代码的逐行解释：

1. import requests:
   导入 Python 的 requests 库，这是一个用于发送 HTTP 请求的库。

2. def download_images(url, save_directory)::
   定义一个名为 download_images 的函数，该函数接受两个参数：url 和 save_directory。url 是要请求的 API 的 URL，该 API 应返回一个包含多个图像 URL 的 JSON 数组；save_directory 是要保存下载图像的目录路径。

3. response = requests.get(url):
   使用 requests 库的 get 方法发送一个 HTTP GET 请求到 url 指定的地址，并将响应对象存储在 response 变量中。

4. if response.status_code == 200::
   检查 HTTP 响应的状态码是否为 200，这表示请求成功。

5. images = response.json():
   如果响应成功，使用 response.json() 方法解析响应的 JSON 内容，并将解析后的结果（应是一个图像 URL 的数组）存储在 images 变量中。

6. for index, image_url in enumerate(images)::
   使用 enumerate 函数遍历 images 数组，同时获取每个图像的索引（index）和 URL（image_url）。

7. image_response = requests.get(image_url):
   对于每个图像 URL，发送另一个 HTTP GET 请求以获取该图像，并将响应对象存储在 image_response 变量中。

8. if image_response.status_code == 200::
   再次检查 HTTP 响应的状态码是否为 200，以确保图像请求成功。

9. with open(f"{save_directory}/image_{index}.jpg", "wb") as f::
   使用 with 语句打开一个文件，文件路径由 save_directory 和 image_{index}.jpg 组成，文件模式为 "wb"（二进制写入模式）。这意味着我们将以二进制格式将图像写入文件。

10. f.write(image_response.content):
    将 image_response 中的内容（即图像的二进制数据）写入到文件中。

这样，该函数将遍历从 API 返回的所有图像 URL，下载每个图像，并将它们以 image_0.jpg, image_1.jpg, image_2.jpg 等的名称保存到指定的目录中。

注意：

• 该代码假设 API 返回的 JSON 数组中的每个元素都是一个有效的图像 URL。
• 代码没有处理可能出现的异常，如网络错误、无效的 JSON 响应或无法写入文件等。在实际应用中，添加异常处理逻辑是很重要的。
• 文件名使用索引编号，如果下载多个图像可能会有命名冲突的问题。在实际应用中，可能需要考虑使用更独特的文件名，例如基于图像 URL 的哈希值。

7.批量删除空文件夹

import os
def remove_empty_folders(directory_path):
    for root, dirs, files in os.walk(directory_path, topdown=False):
        for folder in dirs:
            folder_path = os.path.join(root, folder)
            if not os.listdir(folder_path):
                os.rmdir(folder_path)

函数 remove_empty_folders 用于删除给定目录（及其子目录）中的所有空文件夹。以下是对代码的逐行解释：

1. import os:
   导入Python的os模块，该模块提供了与操作系统交互的函数和方法。

2. def remove_empty_folders(directory_path)::
   定义一个名为remove_empty_folders的函数，它接受一个参数directory_path，该参数代表要检查并删除空文件夹的目录路径。

3. for root, dirs, files in os.walk(directory_path, topdown=False)::
   使用os.walk()函数遍历directory_path目录及其所有子目录。os.walk()返回一个三元组(dirpath, dirnames, filenames)，其中：

   • dirpath是一个字符串，表示目录的路径。
   • dirnames是一个列表，包含了dirpath目录下的所有子目录名（不包括.和..，即不包括当前目录和父目录）。
   • filenames是一个列表，包含了dirpath目录下的所有非目录子项的名字。

   topdown参数设置为False意味着先遍历子目录，再遍历父目录。这有助于在删除子目录时不会影响到父目录的遍历。

4. for folder in dirs::
   对于当前遍历到的目录（root）下的每一个子目录名（folder），执行以下操作。

5. folder_path = os.path.join(root, folder):
   使用os.path.join()函数将当前目录路径root和子目录名folder拼接成一个完整的路径folder_path。

6. if not os.listdir(folder_path)::
   使用os.listdir()函数检查folder_path是否为空。如果folder_path没有包含任何文件或子目录，则os.listdir(folder_path)将返回一个空列表，条件判断为True。

7. os.rmdir(folder_path):
   如果上述条件判断为真，即folder_path是一个空文件夹，则使用os.rmdir()函数删除该空文件夹。

这个函数将遍历给定目录及其所有子目录，并删除所有空文件夹。注意，这个函数不会删除包含隐藏文件或子目录的空文件夹，也不会删除非空文件夹。

8.Excel表格读写

import pandas as pd
def read_excel(file_path):
    df = pd.read_excel(file_path)
    return df
def write_to_excel(data, file_path):
    df = pd.DataFrame(data)
    df.to_excel(file_path, index=False)

函数 read_excel 和 write_to_excel，用于读取和写入 Excel 文件。两个函数都使用了 Pandas 库，一个 Python 的数据分析库。 

1. read_excel 函数

这个函数接受一个参数 file_path，表示要读取的 Excel 文件的路径。

2. write_to_excel 函数

这个函数接受两个参数：data 和 file_path。data 是一个字典、列表或其他可以被转换为 DataFrame 的数据结构，file_path 是要写入数据的 Excel 文件的路径。

通过这两个函数，你可以方便地读取和写入 Excel 文件，而不需要关心底层的 Excel 文件操作细节。

9.合并Excel表格工作簿

import pandas as pd
def merge_sheets(file_path, output_file_path):
    xls = pd.ExcelFile(file_path)
    df = pd.DataFrame()
    for sheet_name in xls.sheet_names:
        sheet_df = pd.read_excel(xls, sheet_name)
        df = df.append(sheet_df)
        df.to_excel(output_file_path, index=False)

函数 merge_sheets 用于将多个 Excel 工作表（sheets）合并到一个单一的 DataFrame 中，并将该 DataFrame 保存到一个新的 Excel 文件中。以下是代码的逐行解释：

1. import pandas as pd
   导入 pandas 库，并为其指定一个别名 pd。Pandas 是一个用于数据分析和处理的 Python 库。

2. def merge_sheets(file_path, output_file_path):
   定义一个名为 merge_sheets 的函数，该函数接受两个参数：file_path（要合并的 Excel 文件的路径）和 output_file_path（输出文件的路径）。

3. xls = pd.ExcelFile(file_path)
   使用 pandas 的 ExcelFile 类来读取 file_path 指定的 Excel 文件，并将其存储在 xls 变量中。

4. df = pd.DataFrame()
   创建一个空的 DataFrame 对象 df。这个 DataFrame 将用于存储从 Excel 文件的不同工作表中读取的数据。

5. for sheet_name in xls.sheet_names:
   遍历 xls 对象中存储的所有工作表名称。sheet_names 是一个包含所有工作表名称的列表。

6. sheet_df = pd.read_excel(xls, sheet_name)
   对于每一个工作表名称 sheet_name，使用 read_excel 函数从 xls 对象中读取该工作表的数据，并将其存储在 sheet_df（一个 DataFrame 对象）中。

7. df = df.append(sheet_df)
   将 sheet_df 中的数据追加到 df 中。这样，df 最终将包含所有工作表的数据。

8. df.to_excel(output_file_path, index=False)
   将合并后的 DataFrame df 保存到指定的 output_file_path 路径。index=False 表示在保存时不包含 DataFrame 的索引。

需要注意的是，虽然这段代码能够合并多个工作表，但它有一个效率问题。在循环中，每次迭代都会将 sheet_df 追加到 df 并立即保存到 output_file_path。这意味着每次迭代都会覆盖之前的输出文件。实际上，你可能只想在循环结束后保存一次合并后的 DataFrame。正确的做法应该是将 df.to_excel(output_file_path, index=False) 语句移出循环，放在循环结束之后。这样，所有工作表的数据都会被合并到一个 DataFrame 中，然后一次性保存到输出文件。

10.数据库SQL查询

import sqlite3
def connect_to_database(database_path):
    connection = sqlite3.connect(database_path)
    return connection
def execute_query(connection, query):
    cursor = connection.cursor()
    cursor.execute(query)
    result = cursor.fetchall()
    return result

这段代码的两个函数分别用于连接数据库及执行SQL查询。以下是代码的逐行解释：

1. 导入sqlite3模块：这行代码导入了Python的sqlite3模块，该模块提供了一个轻量级的磁盘上数据库，不需要单独的服务器进程或系统配置。

2. connect_to_database函数：接受一个参数database_path，它代表要连接的SQLite数据库文件的路径。

3. execute_query函数：这个函数接受两个参数：connection：一个到SQLite数据库的连接对象，通常是通过connect_to_database 函数获得的。 query：一个SQL查询字符串，你希望执行这个查询来从数据库中检索数据。 

使用示例：

# 连接到数据库  
conn = connect_to_database('example.db')  
  
# 创建一个新的表  
create_table_query = '''  
CREATE TABLE IF NOT EXISTS users (  
    id INTEGER PRIMARY KEY,  
    name TEXT NOT NULL,  
    age INTEGER  
)  
'''  
execute_query(conn, create_table_query)  
  
# 插入一些数据  
insert_data_query = '''  
INSERT INTO users (name, age) VALUES (?, ?)  
'''  
execute_query(conn, insert_data_query, ('Alice', 30))  
execute_query(conn, insert_data_query, ('Bob', 25))  
  
# 查询所有数据  
select_all_query = 'SELECT * FROM users'  
users = execute_query(conn, select_all_query)  
for user in users:  
    print(user)  
  
# 关闭连接  
conn.close()

11. 系统进程查杀

import psutil
def get_running_processes():
    return [p.info for p in psutil.process_iter(['pid', 'name', 'username'])]
def kill_process_by_name(process_name):
    for p in psutil.process_iter(['pid', 'name', 'username']):
        if p.info['name'] == process_name:
            p.kill()

这段代码使用了 psutil 库来查询和管理操作系统中的进程。psutil 是一个跨平台库，能够获取系统运行状态信息，包括 CPU、内存、磁盘、网络、进程等。代码中定义了两个函数：

1. get_running_processes(): 这个函数返回一个包含当前运行的所有进程信息的列表。每个进程信息是一个字典，包含进程ID（pid）、进程名称（name）和进程所属用户名（username）。 

2. kill_process_by_name(process_name): 这个函数接受一个进程名称作为参数，并尝试杀死（结束）所有与该名称匹配的进程。

这里有一些要注意的点：

• psutil.process_iter() 函数用于遍历系统中的所有进程。你可以通过传递一个字段列表来限制返回的信息量，这里我们只关心进程的 pid、name 和 username。
• p.info 是一个字典，包含了进程的所有信息。我们通过 p.info['name'] 来获取进程的名称。
• p.kill() 方法用于结束进程。这个方法会发送一个 SIGTERM 信号给进程，告诉它应该优雅地关闭。如果进程不响应，可能会发送一个 SIGKILL 信号来强制结束它。

请注意，结束进程（特别是你没有权限结束的进程）可能会引发异常。在实际使用中，你可能需要添加适当的错误处理逻辑来处理这些异常。

此外，使用 kill_process_by_name 函数时要小心，因为它会无条件地杀死所有匹配的进程，这可能会导致不期望的行为。你可能需要添加一些额外的逻辑来确认你要结束的进程确实是你想要的，或者至少确保你不会意外地结束重要的系统进程。

12.图像尺寸调整和裁剪

from PIL import Image
def resize_image(input_path, output_path, width, height):
    image = Image.open(input_path)
    resized_image = image.resize((width, height), Image.ANTIALIAS)
    resized_image.save(output_path)
def crop_image(input_path, output_path, left, top, right, bottom):
    image = Image.open(input_path)
    cropped_image = image.crop((left, top, right, bottom))
    cropped_image.save(output_path)

函数 resize_image 和 crop_image 分别用于调整图像的大小和裁剪图像。这些函数都使用了Pillow库（PIL），这是一个用于处理图像的库。

1. resize_image 函数：

   • 参数：

     • input_path：要调整大小的图像的输入路径。
     • output_path：调整大小后的图像的输出路径。
     • width：新图像的宽度。
     • height：新图像的高度。

   • 功能：

     • 打开位于 input_path 的图像。
     • 使用 Image.ANTIALIAS 作为重采样方法，将图像的大小调整为 width 和 height。ANTIALIAS 是一种高质量的重采样滤镜，可以减少调整大小时产生的锯齿状边缘。
     • 保存调整大小后的图像到 output_path。

2. crop_image 函数：

   • 参数：

     • input_path：要裁剪的图像的输入路径。
     • output_path：裁剪后的图像的输出路径。
     • left：裁剪框的左边界。
     • top：裁剪框的上边界。
     • right：裁剪框的右边界。
     • bottom：裁剪框的下边界。

   • 功能：

     • 打开位于 input_path 的图像。
     • 使用 crop 方法，根据提供的 left、top、right 和 bottom 边界裁剪图像。
     • 保存裁剪后的图像到 output_path。

这些函数为图像处理提供了基本的功能，可以帮助你轻松地调整图像的大小或裁剪图像。

13.图片添加水印

from PIL import Image
from PIL import ImageDraw
from PIL import ImageFont
def add_watermark(input_path, output_path, watermark_text):
    image = Image.open(input_path)
    draw = ImageDraw.Draw(image)
    font = ImageFont.truetype('arial.ttf', 36)
    draw.text((10, 10), watermark_text, fill=(255, 255, 255, 128), font=font)
    image.save(output_path)

函数 add_watermark 用于在给定的图像上添加水印。水印是一个文本字符串，被放置在图像的指定位置。这里使用了Python的Pillow库（PIL的一个分支）来处理图像。

以下是代码的详细解释：

1. 导入必要的模块:

   • Image: 用于打开、处理和保存多种格式的图像文件。
   • ImageDraw: 提供了简单的图形绘制功能，用于在图像上绘制。
   • ImageFont: 用于处理字体，这样你就可以在图像上绘制文本。

2. 定义 add_watermark 函数:

   • input_path: 要添加水印的原始图像的路径。
   • output_path: 添加水印后的图像的保存路径。
   • watermark_text: 要作为水印添加到图像上的文本。

3. 函数内部逻辑:

   • image = Image.open(input_path): 打开位于 input_path 的图像文件。
   • draw = ImageDraw.Draw(image): 创建一个可以在上面绘制的Draw对象。
   • font = ImageFont.truetype('arial.ttf', 36): 使用TrueType或OpenType字体文件创建一个字体对象。这里使用了Arial字体，大小为36。你需要确保arial.ttf文件在你的工作目录中，或者提供正确的路径。
   • draw.text((10, 10), watermark_text, fill=(255, 255, 255, 128), font=font): 在图像上的位置(10, 10)绘制水印文本。文本的颜色是白色（RGB值为(255, 255, 255)），并且有一定的透明度（alpha值为128）。
   • image.save(output_path): 保存带有水印的图像到output_path指定的路径。

这个函数允许你简单地为图像添加水印，但你可能需要根据你的具体需求调整字体、大小、颜色、位置等参数。

14. 创建图像缩略图

from PIL import Image
def create_thumbnail(input_path, output_path, size=(128, 128)):
    image = Image.open(input_path)
    image.thumbnail(size)
    image.save(output_path)

这段代码定义了一个名为 create_thumbnail 的函数，用于创建一个指定大小的缩略图。这个函数使用了 Python 的 Pillow 库（PIL 的一个分支）来处理图像。以下是代码的详细解释：

1. 导入 Image 类：from PIL import Image，这行代码从 PIL 库中导入了 Image 类，该类提供了打开、操作和保存图像文件的方法。
2. 定义 create_thumbnail 函数，三个参数分别为：
   * `input_path`: 输入图像的路径。  
   * `output_path`: 缩略图图像的保存路径。  
   * `size`: 缩略图的大小，默认为 `(128, 128)`（即宽度为 128 像素，高度为 128 像素）。
3. 打开输入图像：image = Image.open(input_path)
   这行代码使用 Image.open 方法打开位于 input_path 的图像文件，并将其存储在 image 变量中。
4. 创建缩略图：image.thumbnail(size)
   这行代码使用 Image 对象的 thumbnail 方法来创建缩略图。thumbnail 方法会保持图像的纵横比，同时确保图像的最大尺寸不超过 size 参数指定的宽度和高度。如果原始图像的宽度和高度都小于 size，则图像不会进行缩放。
5. 保存缩略图：image.save(output_path)
   这行代码将创建好的缩略图保存到 output_path 指定的路径。
6. 调用示例：使用这个函数，你可以轻松地为任何图像创建一个指定大小的缩略图。
   例如：create_thumbnail('path/to/input.jpg', 'path/to/output.jpg', size=(200, 200))
   这行代码将创建一个最大尺寸为 200x200 像素的缩略图，并将其保存到 'path/to/output.jpg'。 

15.PDF中提取文本

import PyPDF2
def extract_text_from_pdf(file_path):
    with open(file_path, 'rb') as f:
        pdf_reader = PyPDF2.PdfFileReader(f)
        text = ''
        for page_num in range(pdf_reader.numPages):
            page = pdf_reader.getPage(page_num)
            text += page.extractText()
    return text

这段代码是一个用于从PDF文件中提取文本的函数，使用了PyPDF2库。

1. 导入PyPDF2库。
2. 定义函数extract_text_from_pdf，它接受一个参数file_path，这是要从中提取文本的PDF文件的路径。
3. 使用with open(file_path, 'rb') as f:打开文件，'rb'表示以二进制读模式打开文件。
4. 创建一个PdfFileReader对象pdf_reader来读取打开的PDF文件。
5. 初始化一个空字符串text，用于存储从PDF文件中提取的文本。
6. 使用for循环遍历PDF文件中的每一页（range(pdf_reader.numPages)生成一个从0到pdf_reader.numPages - 1的整数序列）。
7. 对于每一页，使用getPage(page_num)方法获取该页的对象，然后使用extractText()方法提取该页的文本，并将其添加到text字符串中。
8. 函数最后返回存储了所有提取文本的text字符串。

请注意，PyPDF2的extractText()方法可能无法完美地提取所有PDF文件中的文本，特别是对于那些包含复杂布局或特殊字体的文件。对于这种情况，可能需要使用其他更高级的PDF处理库，如PDFMiner或pdfplumber。

16. 合并多个PDF文件

import PyPDF2  
def merge_pdfs(input_paths, output_path):  
    pdf_writer = PyPDF2.PdfFileWriter()  
    for path in input_paths:  
        with open(path, 'rb') as f:  
            pdf_reader = PyPDF2.PdfFileReader(f)  
            for page_num in range(pdf_reader.getNumPages()):  
                page = pdf_reader.getPage(page_num)  
                pdf_writer.addPage(page)  
    with open(output_path, 'wb') as f:  
        pdf_writer.write(f)

这段代码使用PyPDF2库合并多个PDF文件。函数 merge_pdfs 接受一个包含多个PDF文件路径的列表input_paths和一个输出文件路径output_path。然后，它遍历输入文件列表，读取每个文件，并将每一页添加到一个PdfFileWriter对象中。最后，它将所有页面写入到指定的输出文件中。以下是这段代码的逐行解释：

1. import PyPDF2
   导入PyPDF2库，这是一个用于处理PDF文件的Python库。

2. def merge_pdfs(input_paths, output_path):
   定义一个名为merge_pdfs的函数，它接受两个参数：一个包含多个PDF文件路径的列表input_paths和一个输出文件路径output_path。

3. pdf_writer = PyPDF2.PdfFileWriter()
   创建一个PdfFileWriter对象，该对象将用于写入合并后的PDF文件的内容。

4. for path in input_paths:
   遍历input_paths列表中的每个文件路径。

5. with open(path, 'rb') as f:
   使用with语句打开当前路径下的PDF文件，'rb'表示以二进制读模式打开文件。文件对象存储在变量f中。

6. pdf_reader = PyPDF2.PdfFileReader(f)
   创建一个PdfFileReader对象来读取打开的PDF文件。

7. for page_num in range(pdf_reader.getNumPages()):
   遍历当前PDF文件的每一页。getNumPages()方法返回PDF文件中的页面数量。

8. page = pdf_reader.getPage(page_num)
   使用getPage方法获取当前页码对应的页面对象。

9. pdf_writer.addPage(page)
   将获取到的页面对象添加到PdfFileWriter对象中，以便稍后写入到输出文件中。

10. with open(output_path, 'wb') as f:
    使用with语句打开（或创建）输出文件，准备以二进制写模式写入合并后的PDF内容。

11. pdf_writer.write(f)
    将PdfFileWriter对象中的所有页面写入到输出文件中。

当你调用这个函数并传入一个PDF文件路径列表和一个输出文件路径时，它将读取所有输入文件，并将它们的页面合并到一个单一的输出文件中。请确保你安装了PyPDF2库（使用pip install PyPDF2），并且输入的PDF文件都是有效的。

---

完