招聘合适的人选，往往从一项耗时的工作开始：筛选简历。如果你发布过职位招聘，一定体会过收件箱里有数百份申请，而你得花数小时手动审阅每份简历的烦恼。

本文将带你用纯 Python 搭建一个简历筛选系统，重点讲解核心编程概念和多进程的运用。你会创建一个自定义系统，通过将非结构化的简历文档转化为排名榜单，实现评估流程的自动化。

阅读完本指南后，你将能够：

• 解析文档：使用 Python 从 PDF 和 DOCX 简历中提取文本
• 提取信息：从简历内容中识别技能与关键词
• 设计评分算法：用加权逻辑客观地为候选人排序
• 构建 Web 界面：使用 Streamlit 完成
• 部署应用：在 Streamlit Cloud 上部署应用，供公众访问

按照本教程操作，你将构建一个能在几秒内处理数百份简历的工具。

源代码见 GitHub 仓库

目录

• 前置要求
• 项目概览
• 系统如何工作
• 系统架构
• 项目结构
• 步骤 1：搭建项目
• 步骤 2：构建简历解析器
• 步骤 3：构建关键词提取器
• 步骤 4：实现评分引擎
• 步骤 5：构建 Web 界面
• 步骤 6：测试系统
• 步骤 7：部署应用
• 总结

前置要求

要学习本教程，你需要具备：

• Python 基础知识（函数、循环、字典）
• 已安装 Python 3.8 或更高版本
• 会用 pip 安装包
• 代码编辑器（如 VS Code、PyCharm 或任意你喜欢的编辑器）

项目概览

本指南将开发一个系统：输入一个简历文件夹和一份职位描述（JD），系统会处理每份简历、提取相关信息，并根据候选人与职位要求的匹配程度计算得分。

系统如何工作

项目包含四个核心组件：

• 简历解析器：读取 PDF 和 DOCX 文件并提取文本
• 职位描述解析器：分析职位描述以识别所需技能
• 关键词提取器：将简历内容与技能分类体系进行匹配
• 评分引擎：使用加权算法对候选人排序

评分公式

使用的评分公式如下：

总分 =
（必备技能 × 50%）+
（优先技能 × 25%）+
（经验 × 15%）+
（关键词 × 10%）

这样设计可以确保核心技能比次要关键词权重更高。

这种方法如何有助于减少偏见

本系统基于预定义标准评估简历，而不是主观判断。每份简历都根据同一套必备技能、优先技能、经验指标和关键词进行打分。

由于所有候选人都使用同一套加权公式评估，写作风格、排版或个人偏好等主观因素不会影响排名。评分逻辑只关注简历与职位要求的匹配程度。

通过将评估过程标准化，系统促进了更一致、更客观的筛选，有助于在简历初筛阶段减少偏见。

系统架构

输入                    处理                       输出
─────                   ──────────                  ─────

简历 ──► 简历解析器 ──► 关键词提取器 ──┐
(PDF/DOCX)                             │
                                        ├──► 评分引擎 ──► 排名结果
职位描述 ──► 职位描述解析器 ────────────┘
(TXT/PDF)

系统遵循简单的“输入—处理—输出”流程。

简历和职位描述作为输入。简历解析器从每份简历中提取文本，职位描述解析器从职位描述中识别必备技能和优先技能。

提取出的简历文本随后传给关键词提取器，该模块根据预定义的技能分类体系匹配技能和关键词。

最后，评分引擎应用加权公式为每位候选人计算得分，并输出一份按分数排序的简历列表。

项目结构

resume_screening_system/
├── app.py                    # Streamlit Web 界面
├── main.py                   # 命令行界面
├── parsers/
│   ├── resume_parser.py      # PDF/DOCX 文本提取
│   └── jd_parser.py          # 职位描述解析
├── extractors/
│   └── keyword_extractor.py  # 技能与经验提取
├── matcher/
│   └── scorer.py             # 评分算法
├── data/
│   ├── config.json           # 评分权重配置
│   └── skills_taxonomy.json  # 技能数据库
└── requirements.txt          # 依赖

项目按清晰的模块化目录组织。解析逻辑、关键词提取和评分分别放在各自文件夹中，配置文件与数据单独存放，便于浏览、维护和扩展。

步骤 1：搭建项目

创建目录结构并设置虚拟环境：

mkdir resume_screening_system
cd resume_screening_system
mkdir parsers extractors matcher data input output
python -m venv venv

然后激活虚拟环境：

# Windows
source venv/Scripts/activate

# macOS / Linux
source venv/bin/activate

安装所需依赖：

pip install PyPDF2 python-docx streamlit pandas

步骤 2：构建简历解析器

简历解析器针对不同文件格式使用不同的提取方法。

对于 PDF，解析器逐页打开文档，用 PDF 阅读器从每页提取文本，再合并成单个字符串供后续处理。

对于 DOCX，解析器读取文档中的每个段落，将段落文本拼接成一块。这样无论简历格式如何，都能得到一致的文本输出。

将简历统一转为纯文本后，关键词提取和评分等组件就能高效工作。

文件： parsers/resume_parser.py

def _extract_pdf(self, file_path: Path) -> str:
    text = ""
    with open(file_path, "rb") as file:
        pdf_reader = PyPDF2.PdfReader(file)
        for page in pdf_reader.pages:
            page_text = page.extract_text()
            if page_text:
                text += page_text + "\n"
    return text.strip()

def _extract_docx(self, file_path: Path) -> str:
    from docx import Document
    doc = Document(file_path)
    return "\n".join(
        para.text for para in doc.paragraphs
    ).strip()

步骤 3：构建关键词提取器

本项目使用 Kaggle 上的简历数据集，确保逻辑在真实职业数据上可用。关键词提取器通过扫描简历文本来识别技能。

简历文本先转为小写，以便不区分大小写地匹配。预定义的技能分类体系存储每个技能及其可能变体，提取器用这些变体与简历文本比对。

匹配时使用词边界，避免部分匹配（例如在 “JavaScript” 里匹配到 “Java”）。匹配到的技能存入集合以避免重复。

这种方式能在所有简历上实现一致、可控的技能识别。

文件： extractors/keyword_extractor.py

def extract_skills(self, text: str) -> Set[str]:
    text_lower = text.lower()
    found_skills = set()

    for category, skills_dict in self.skills_taxonomy.items():
        for skill_name, variations in skills_dict.items():
            for variation in variations:
                # 防止 "Java" 匹配到 "JavaScript"
                pattern = r"\b" + re.escape(variation) + r"\b"
                if re.search(pattern, text_lower):
                    found_skills.add(skill_name)
                    break

    return found_skills

步骤 4：实现评分引擎

为得到客观排名，系统使用加权评分公式。

总分 =
(S_req × 0.50) +
(S_pref × 0.25) +
(E_exp × 0.15) +
(K_key × 0.10)

评分引擎用上述权重为每份简历计算最终得分。

它统计简历中出现的必备技能、优先技能、经验指标和关键词数量，每个数量乘以其对应权重（必备技能权重最高），加权值相加得到单一分数，再按该分数对简历排序，生成候选人排名列表。

步骤 5：构建 Web 界面

Streamlit 为简历筛选系统提供了简单的 Web 界面。

文本区域用于输入职位描述，文件上传器用于上传多份简历。点击按钮后，Streamlit 触发后端逻辑解析简历、提取数据并计算得分，结果在浏览器中展示，用户无需使用命令行即可完成筛选。

文件： app.py

import streamlit as st

jd_text = st.text_area(
    "在此粘贴职位描述：",
    height=300
)

uploaded_files = st.file_uploader(
    "上传简历文件：",
    type=["pdf", "docx", "txt"],
    accept_multiple_files=True
)

if st.button("筛选简历", type="primary"):
    st.success("正在处理简历...")

运行应用：

streamlit run app.py

应用将运行在 http://localhost:8500。

步骤 6：测试系统

示例职位描述输入

下面是一份可用于测试的示例职位描述：

我们正在寻找一名具有扎实后端开发经验的高级 Python 开发工程师。

必备技能：
- Python
- Django
- REST API
- SQL

优先技能：
- PostgreSQL
- Docker
- AWS

经验要求：
- 3 年以上 Python 专业开发经验
- 有构建 Web 应用的经验

该输入帮助系统识别必备技能、优先技能和经验关键词，供评分引擎对简历排序。

python main.py

示例输出

============================================================
筛选结果
============================================================
第 1 名：Alice Johnson | 得分：85.42/100 | 匹配：python、django、postgresql
第 2 名：Carol Davis   | 得分：72.50/100 | 匹配：python、django

步骤 7：部署应用

若要让系统对外可访问：

1. 将代码推送到 GitHub
2. 打开 share.streamlit.io
3. 选择你的 app.py 文件
4. 部署应用

应用将发布在：

https://your-app-name.streamlit.app

总结

在本教程中，你使用 Python 从零搭建了一个完整的简历筛选系统。通过结合文本处理、结构化评分和自动化，该项目展示了如何将手动简历筛选转变为高效、客观的流程。

该系统有助于减少偏见、节省时间，并更一致地评估候选人。Happy coding!

在本文中，你将学习递归的工作原理。

在学习递归之前，你需要很好地理解函数的工作原理。我在本文中使用了 Python 代码作为示例，因为它的语法简单，但递归的概念对于每种编程语言都是一样的。

什么是递归？

在大多数编程语言中，一个函数可以调用另一个函数。但一个函数也可以调用自身。递归是一种函数调用自身的技术。

这是一个例子：

def call_me():
    call_me()

在这里，函数调用自身，这就是所谓的递归。

但是“调用自身”只是递归的程序定义。递归涉及将一个问题分解为更小的部分，直到无法进一步分解为止。你解决小问题并将它们组合起来以解决整个问题。

用真实生活中的例子类比递归

让我们通过一个例子来理解递归如何真正工作。

想象一下，你在迪士尼乐园排队等候，你不知道前面有多少人。

为了找出答案，你问你前面的人。

试图找出排在你前面的人数

那个人也不知道，所以她们询问她们前面的那个人。

这个过程继续进行，直到问题到达队伍最前面的人，他们看到前面没有人，回答说前面有零人。

然后队伍开始将回复传递回去。每个人在将信息传递回去之前，都会在他们被告知的数字上加 1。

当排在最前面的人回答，“前面有 0 人”时，下一个人加 1 然后回答，“前面有 1 人”，依此类推。

每个人都知道他们前面有多少人

当回复到达直接在你前面的人时，他们再加上 1 并告诉你。通过这种方式，你可以通过将前面的人给的数字添加 1，来确定你在队伍中的位置。

这个例子说明了递归如何将问题分解为更小的子问题，然后结合它们的解决方案以解决原始问题。

队伍中的每个人代表同一问题的一个较小实例：确定前面的人数。通过解决这些较小的实例并结合它们的结果，整个问题得到了解决。这正是递归的工作原理。

递归的技术细节

在编码递归时最重要的是要找出：

• 递归情况：我们可以做的最小工作。在上面的例子中，询问你前面的人他们前面有多少人是我们可以做的最小工作。

• 基本情况：无需工作的条件。在上面的例子中，队伍最前面的人没有必要问任何问题，因此这是无需工作的条件。

递归的简单例子

计算阶乘是递归的最简单例子，它将真正帮助你理解其工作原理。

有很多方法可以计算一个数的阶乘。但在这里，我们将看到递归的方式来找到它。

在思考我们如何做到这一点之前，我们需要知道一个数的阶乘是什么。

一个数的阶乘是从 1 到该数的所有数字的乘积。

例如，5 的阶乘是 120 —— 即 5×4×3×2×1。

我们还可以用数学方式表示如下：

5×(5−1)!

这意味着如果我们知道 (5−1)! 的值，我们就可以通过简单地将 5 乘以它来轻松得到阶乘。

这就是我们如何找到 4、3、2、1 和 0 的阶乘：

Factorial of 4 = 4×(4−1)!
Factorial of 3 = 3×(3−1)!
Factorial of 2 = 2×(2−1)!
Factorial of 1 = 1
Factorial of 0 = 1

通过观察这些，很明显要找到 5 的阶乘，我们必须将 5 乘以 4!。

更普遍的例子

要找到 n 的阶乘，我们需要将 n 乘以 (n−1)!。这就是你需要递归执行的过程。

现在，必须为递归设置一个停止条件。停止条件是我们不再执行其他操作的地方。当 n 是 1 或 0 时，我们可以简单地停止递归，因为这些值的阶乘是已知的。我们可以简单地说 1 的阶乘是 1，对于 0 也是如此。

因此，分解下来，要找到 n 的阶乘，所需做的最小工作量是 n×(n−1)!。当我们找到 1 或 0 的阶乘时，我们可以停止对它进行操作。

让我们看看代码是怎样的：

# 计算 n 的阶乘
def fact(n):

# 最少工作量
return n * fact(n - 1)

n = 5

# 计算阶乘
factorial = fact(n)
print(factorial)

输出:

120

让我们看看它是如何工作的：

在第一次函数调用中，计算了 5 的阶乘。接着在第二次调用中，计算了 4 的阶乘，以此类推，直到计算 2 的阶乘。

递归计算 5 的阶乘

在调用 2 的阶乘时，我们有2×fact(2−1)，即2×fact(1)。

这达到了我们的基本条件。因此，递归停止，2×fact(1)返回2×1给前一个函数调用，并且结果从堆栈中弹出。

第四次函数调用返回 2 给前一个函数调用并从堆栈中弹出

类似地，这里是其他内容的计算方式：

第三次函数调用返回 6 给前一个函数调用并从堆栈中弹出

第二次函数调用返回 24 给前一个函数调用并从堆栈中弹出

第一次函数调用返回 120 给初始函数调用并从堆栈中弹出

所以函数最终将值 120 返回给初始函数调用。

为什么我们需要一个基本条件？

在上面的例子中，我们为代码使用了停止条件。但是如果我们不添加停止条件，或者我们编写的函数永远不满足停止条件呢？

代码会永远运行吗？

不会 – 即使你不终止，代码也不会永远运行。让我们通过一个例子来理解为什么会这样。

def print_five():
    print(5)

    # 调用自身
    print_five()

# 函数调用
print_five()

输出:

5
5
5
...

RecursionError: maximum recursion depth exceeded

如果运行上面的代码，你会看到函数不会永远运行，并以消息 RecursionError: maximum recursion depth exceeded 结束。

当一个函数被调用时，它会被存储在一个调用堆栈中。下面是函数print_five()第一次被调用时在调用堆栈中的存储方式。

第一次函数调用时的调用堆栈

函数一次又一次地调用自身，并且每次调用时，函数被存储在调用堆栈中。

n 次函数调用后的调用堆栈

但是调用堆栈的大小是有限的，不能存储无限数量的函数。

调用堆栈空间不足导致栈溢出

当堆栈已满时，它无法再容纳更多调用，导致栈溢出错误。

因此，基本条件对于防止此类错误并确保递归正确终止是必不可少的。

现在让我们看看另一个例子，以便更深入地理解递归。

如何检查一个单词是否是回文

在深入代码之前，你应当知道什么是回文。回文是指正向和反向读取都相同的单词。

例如，racecar正向和反向读取都是相同的。

要检查一个单词是否是回文，我们需要检查第一个和最后一个字母是否相同。如果相同，我们接着检查第二个和倒数第二个字母是否相同。

检查 racecar 的第一个和最后一个字符是否相同

在racecar这一例子中，第一个和最后一个字母是相同的，所以我们检查第二个和倒数第二个字母是否相同。它们相同，所以现在我们检查第三个和倒数第三个字母是否相同。现在只剩下一个字母需要检查。一个单一字母始终是回文，因为它正反读都是相同的。

如何检查 racecar 是否是回文

所以，现在让我们尝试以递归的方式思考，包括最少的工作量以及确定何时不需要工作。

最少工作量

检查第一个和最后一个字母是否相同，如果相同，则移除单词中的第一个和最后一个字母。

不需要工作

当只剩下一个或没有字母时，我们可以简单地说它是一个回文。

现在，让我们看看代码是什么样子的：

# 检查回文
def check_palindrome(text):

    # 停止条件
    # 如果文本长度是 1 或 0，返回真
    if len(text) == 0 or len(text) == 1:
        return True

    # 最少工作量
    # 检查第一个和最后一个字符是否相同
    # 如果相同，移除字符串中的第一个和最后一个字符
    if(text[0]==text[-1]):
        return(check_palindrome(text[1:-1]))

# 检查字符串是否为回文
text = "racecar"
is_palindrome = check_palindrome(text)
print(is_palindrome)

以下是上述代码的工作原理：

检查 racecar 是否为回文

检查 racecar 是否为回文

何时使用递归

递归看似优雅且简单，但由于反复向堆栈添加方法带来的 CPU 开销，即便是简单问题常也需经过多个步骤方能解决。因此，在使用之前，请确保仔细考虑它是否为解决问题的正确方案。

当代码需要多个循环且显得混乱时，递归可以提供更清晰的解决方案。然而，是否使用递归取决于具体的代码以及所涉及的数据类型或数据结构。对于树和图这类数据结构，递归尤其有用。

尽管递归表面简单，但可能难以理解，即使处理简单问题也可能需要多个步骤。因此，再次提醒，一定要根据具体情况考虑使用。

总结

这只是递归的入门介绍。递归的应用场景很多，你可能对其工作原理感到困惑。我将在下一篇文章中讨论更多递归的高级示例。

顺便说一下，以下是我在学习递归过程中找到的简单且有用的资源：

• freeCodeCamp 的递归视频：我必须感谢 freeCodeCamp，他们优秀的递归视频课程在我写这篇文章时给我了极大的启发。

• Programiz Pro 的递归课程：另一个好资源是 Programiz 的递归课程。这是一个高级课程，需付费，但它经过精心设计。而且，你可以直接在他们的平台上进行练习，真的是很值得。

无论你从哪里学习，都不要花太多时间寻找完美的资源。掌握概念并开始练习——这是你唯一能真正学会的方法。

在本文中，你将学习如何在 Python 中获取当前工作目录（文件夹的另一个名称），和使用 pwd 命令类似。

在 Python 中有几种获取当前工作目录的方法：

• 使用 os 模块和 os.getcwd() 方法
• 使用 pathlib 模块和 Path.cwd() 方法

让我们开始吧！

如何在 Python 中使用 os.getcwd() 方法获取当前目录

os 模块是标准 Python 库（也被称为 stdlib）的一部分，它允许你访问操作系统并与之交互。

要在项目中使用 os 模块，需要在 Python 文件顶部包含以下一行：

import os

导入 os 模块后，就可以使用 os.getcwd() 方法获取当前工作目录的完整路径。

让我们看看下面的示例：

import os

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

# 打印输出到控制台
print(current_working_directory)

# 在 macOS 系统上，输出结果将与下面类似
# /Users/dionysialemonaki/Documents/my-projects/python-project

输出是一个字符串，包含当前工作目录的绝对路径，在本例中是 python-project。

要检查输出的数据类型，请使用 type() 函数，如下所示：

print(type(current_working_directory))

# output

# <class 'str'>

请注意，当前工作目录没有尾部的斜线 /。

还要记住，输出结果会因运行 Python 脚本的目录和操作系统而异。

如何使用 Python 中的 Path.cwd() 方法获取当前目录

在上一节中，我们看到了如何使用 os 模块获取当前工作目录。不过，你也可以使用 pathlib 模块来实现同样的结果。

pathlib 模块是在 Python 3.4 版本的标准库中引入的，它提供了一种面向对象的方法来处理文件系统路径和文件。

要使用 pathlib 模块，首先需要在 Python 文件的顶部导入该模块：

from pathlib import Path

导入 pathlib 模块后，就可以使用 Path.cwd() 类方法获取当前工作目录。

让我们看看下面的示例：

from pathlib import Path

# 获取当前工作目录
current_working_directory = Path.cwd()

# 打印输出到控制台
print(current_working_directory)

# 在 macOS 系统上，输出结果将与下面类似
# /Users/dionysialemonaki/Documents/my-projects/python-project

如你所见，输出结果与我使用 os.getcwd() 方法得到的输出结果相同。唯一不同的是输出的数据类型：

print(type(current_working_directory))

# output

# <class 'pathlib.PosixPath'>

结语

现在你知道如何使用 os 和 pathlib 模块获取 Python 中当前目录的完整路径了。

要了解有关 Python 的更多信息，请查看 freeCodeCamp 的 Python 入门课程。

感谢你阅读本文，祝你编码愉快！

我们每天都要使用许多 Python 软件包来解决编码问题。以库 Beautiful Soup 为例，它并不是 Python 的默认库，需要单独安装。

许多项目都依赖于库和其他依赖项，而安装每一个库都很繁琐、耗时。

requirements.txt 是一个包含项目所需的软件包或库列表的文件，这些软件包或库都可以通过该文件安装。它提供了一个一致的环境，使协作变得更容易。

requirements.txt 文件格式

上图显示了创建的 requirements.txt 文件示例，其中包含安装包和版本的列表。

关键术语

到目前为止，我已经提到了一些你可能不知道的术语。以下是它们的含义，以及你在使用 requirements.txt 时会遇到的其他一些重要术语：

• 依赖项是程序正常运行所需的软件组件。它们可以是库、框架或其他程序。
• 软件包是一种将相关依赖项组合在一起的方法。它们使安装和管理依赖项变得更容易。
• 虚拟环境是一个包含 Python 解释器副本和特定项目所需的所有软件包的目录。
• Pip：这是 Python 的软件包管理器。你可以使用 Pip 安装、卸载和管理 Python 软件包。

如何创建 requirements.txt 文件

要创建 requirements 文件，必须先设置虚拟环境。如果你使用 Pycharm，虚拟环境（.venv）已经设置好了。但使用 Visual Studio Code，你必须自己创建虚拟环境。

你可以使用终端或命令提示符来创建 requirements 文件。以下是创建文件时需要遵循的步骤：

首先，打开终端或命令提示符。然后检查显示的文件路径是否是你的工作目录。请使用以下命令：

$ cd folder-name #cd - change directory

在上述命令中，将 folder-name 替换为要访问的目录名。

接着，运行这个命令：

$ pip freeze > requirements.txt

你会发现 requirement 文件被添加了。

输出如下：

这是你新创建的 requirements.txt 文件：

上图显示了可以使用的依赖项及其版本。

如何处理 requirements.txt 文件

现在我们有了 requirements 文件，你可以看到它由一长串不同的软件包组成。

要使用这些软件包，你必须先安装它们。你可以使用命令提示符或终端进行安装。

键入以下命令：

pip install -r requirements.txt

看起来像这样：

现在，所有依赖项都已安装，可以使用 requirements.txt 了。

使用 requirements.txt 的示例

在本例中，我们将使用beautifulsoup4和requests 这两个库来返回网站的一些信息。

在上图中，我们可以看到 requirements.txt 文件中包含了两个库及其版本。现在我们可以使用这些库了，因为我们之前已经安装了它们。

• 从名为 bs4（beautifulsoup4）的软件包中导入 BeautifulSoup 库，同时导入 requests 库。

from bs4 import BeautifulSoup
import requests

• 为了从网站 URL 获取信息，我们使用.get()方法访问 requests 库。

web_data = requests.get("https://www.lithuania.travel/en/category/what-is-lithuania", headers={"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Safari/537.36"})

• 现在我们可以访问 URL，Beautiful Soup 库接受web_data并返回其中的所有 HTML 内容。

soup = BeautifulSoup(web_data.content, features="html.parser")

• 我选择返回的最终结果是 <p> 标记位于第一个位置 [0] 的元素。

news_info = soup.findAll("p")[0]
print(news_info.text

将一切融合在一起：

from bs4 import BeautifulSoup
import requests
web_data = requests.get("https://www.lithuania.travel/en/category/what-is-lithuania", headers={"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Safari/537.36"})
soup = BeautifulSoup(web_data.content, features="html.parser")
news_info = soup.findAll("p")[0]
print(news_info.text)

输出是这样的：

使用 requirements.txt 文件的好处

• 管理依赖关系：通过在 requirements.txt 文件中列出项目的依赖关系，你可以轻松查看需要哪些软件包以及它们需要的版本。
• 与他人共享项目：如果与他人共享项目，可以将 requirements.txt 文件包括在内，这样他们就可以轻松安装所需的软件包，可以节省他们的时间并降低挫折感，并有助于确保每个人都使用相同版本的软件包。

总结

在本文中，我们学习了如何创建 requirements.txt 文件，并概述了使用它的好处。

你也应该尝试用它来完成一些项目。如果你有任何问题，可以在 Twitter 上联系我💙。

在使用 Matplotlib 绘制图形时，默认的图形尺寸为宽 6.4、高 4.8（单位：英寸）。
在本文中，你将学习如何使用以下方法更改图形尺寸：

• figsize() 属性
• set_figwidth() 方法
• set_figheight() 方法
• rcParams 参数

让我们开始吧！

如何在 Matplotlib 中使用 plt.figsize() 更改图形尺寸

如上一节所述，Matplotlib 图形的默认参数（以英寸为单位）为宽 6.4、高 4.8。下面是一个代码示例：

import matplotlib.pyplot as plt

x = [2,4,6,8]
y = [10,3,20,4]

plt.plot(x,y)

plt.show()

在上面的代码中，我们首先导入了 matplotlib。然后，我们创建了两个包含待绘制值的列表 x 和 y。

使用 plt.plot()，我们在 x 轴上绘制了列表 x，在 y 轴上绘制了列表 y：plt.plot(x,y)。

最后，使用 plt.show() 显示图形。下面是使用默认图形大小参数绘制的曲线图：

我们可以使用 figure() 函数的 figsize() 属性来改变上图的大小。

figsize() 属性包含两个参数，一个是宽度，另一个是高度。

语法如下：

figure(figsize=(WIDTH_SIZE,HEIGHT_SIZE))

这是代码示例：

import matplotlib.pyplot as plt

x = [2,4,6,8]
y = [10,3,20,4]

plt.figure(figsize=(10,6))
plt.plot(x,y)

plt.show()

我们添加了一行新代码：plt.figure(figsize=(10,6))。这将修改/改变图形的宽度和高度。

下面是图形的样子：

如何在 Matplotlib 中使用 set_figwidth() 更改图形宽度

可以使用 set_figwidth() 方法来更改图形的宽度。

我们将把需要更改的宽度值作为参数传递给该方法。

该方法不会更改默认或预设的图形高度值。

下面是一个代码示例：

import matplotlib.pyplot as plt

x = [2,4,6,8]
y = [10,3,20,4]

plt.figure().set_figwidth(15)
plt.plot(x,y)

plt.show()

使用 set_figwidth() 方法，我们将图形的宽度设置为 10。下面是图形的样子：

如何在 Matplotlib 中使用 set_figheight() 更改图形高度

你可以使用 set_figheight() 方法更改图形的高度。

该方法不会更改默认或预设的图形宽度值。

下面是代码示例：

import matplotlib.pyplot as plt

x = [2,4,6,8]
y = [10,3,20,4]

plt.figure().set_figheight(2)
plt.plot(x,y)

plt.show()

使用上面示例中的 set_figheight()，我们将图形的高度设置为 2。图形是这样的：

如何在 Matplotlib 中使用 rcParams 更改默认图形尺寸

你可以使用 rcParams 参数覆盖 Matplotlib 中的默认图形尺寸。

当你希望所有图形都遵循特定尺寸时，这将非常有用。这意味着你不必更改创建的每个图形的尺寸。

下面是两个图形的示例：

import matplotlib.pyplot as plt

x = [2,4,6,8]
y = [10,3,20,4]

plt.rcParams['figure.figsize'] = [4, 4]
plt.plot(x,y)

plt.show()

a = [5,10,15,20]
b = [10,20,30,40]

plt.plot(a,b)

我们使用 figure.figsize 参数将默认宽度和高度设为 4：plt.rcParams['figure.figsize'] = [4, 4]。这些参数将改变两个图形的默认宽度和高度。

下面是这两幅图：

小结

在本文中，我们讨论了在 Matplotlib 中改变图形大小的不同方法。

我们看到了代码示例和图形的可视化表示。这有助于我们理解如何使用每种方法来改变图形的大小。

我们讨论了 Matplotlib 中用于改变图形大小的以下方法：

• figsize() 属性可用于更改特定图形的默认大小。
• set_figwidth() 方法仅用于更改图形的宽度。
• set_figheight() 方法仅用于更改图形的高度。
• 如果想覆盖所有图形的默认图形尺寸，可以使用 rcParams 参数。与 figsize() 属性针对特定图形不同，rcParams 参数针对项目中的所有图形。

Happy coding!

在这篇文章中，你将通过一些代码实例学习如何在 Python 中使用 range() 函数。

Python 中的 range() 函数是什么？range() 函数语法详解

Python 内置的 range() 函数主要在处理 for 循环时使用——你可以用它来循环某些代码块指定次数。

range() 函数接受三个参数——一个是必需的，两个是可选的。

默认情况下，range() 函数的语法就像下面这样：

range(stop)

stop 参数是必需的。

range() 函数返回一个从 0 开始、增量为 1、以你指定的 stop 为结束值的数字序列（不包括结束值）。

但是如果你想遍历你指定的两个数字的范围，而不想从 0 开始计数，怎么办？

你可以传递第二个可选的起始值，start，来指定起始数字。语法是这样的：

range(start, stop)

这种语法在起始值（包括）和结束值（不包括）的基础上生成一个数字序列，以 1 为增量递增。

最后，如果你不希望默认的增量是 1，你可以指定第三个可选的参数，即步长 step。语法是这样的：

range(start, stop, step)

这种语法产生一个数字序列，从 start（包括）开始计数，并根据 step 递增，直到到达 stop（不包括）。

如何使用只有 stop 参数的 range() 函数

当在 range() 中只使用 stop 参数时，计数从 0 开始，按 1 递增，当达到你指定的 stop 值时计数停止。

请记住，你指定的结束值并不包括在内！

如果你指定的 stop 参数是 5，那么范围包括 0-4，而不是 0-5——计数将停止在 4 而不是 5。

让我们看看下面的例子：

for num in range(5):
    print(num)
    
# output 

# 0
# 1
# 2
# 3
# 4

在这个例子中，我指定了一个 range(5)。

该函数从 0 开始计数，每次迭代都递增 1，最后结束于 4。

如何使用带有 start 和 stop 参数的 range() 函数

如果你想有一个两个数字的范围，你可以使用两个参数——start 和 stop。请记住，起始值是包括在内的，而结束值则不是。

如果你想要一个从 5（含）到 10（含）的数值范围，你可以这样写一个 range(5,11)：

for num in range(5,11):
  print(num)
  
# output

# 5
# 6
# 7
# 8
# 9
# 10

你也可以向 range() 传递负的整数值：

for num in range(-5, 1):
  print(num)

# output

# -5
# -4
# -3
# -2
# -1
# 0

这里需要注意的是，你不能向 range() 传递浮点值。

在这个例子中，当我传递两个浮点数作为参数时，会出现错误：

for num in range(5.2, 4.3):
  print(num)

# output

# Traceback (most recent call last):
#  File "main.py", line 1, in <module>
#    for num in range(5.2, 4.3):
# TypeError: 'float' object cannot be interpreted as an integer

你可以传递负整数或正整数作为 start 和 stop 参数。

如何使用带有 start、stop 和 step 参数的 range() 函数

默认情况下，增量值是 1，并且没有指定。也就是说，你可以通过向 range() 函数传递一个 step 参数来改变它。

让我们看看下面的例子：

for num in range(10,21,2):
  print(num)
  
# output

# 10
# 12
# 14
# 16
# 18
# 20

在上面的例子中，我生成了一个从 10 到 20 的数字序列，并将递增量设置为 2，我通过指定 step 值为 2 来实现这一点。

需要注意的是，step 可以是一个负数或正数，但不能是 0。

下面是你如何生成一个带有负数 step 参数的范围：

for num in range(20, 11, -2):
  print(num)

# output

# 20
# 18
# 16
# 14
# 12

上面的代码生成了一个反向的数字序列。

再看看当 step 为 0 时发生了什么：

for num in range(10, 21 0):
  print(num)

# output

#  File "main.py", line 1
#    for num in range(10, 21 0):
                            ^
# SyntaxError: invalid syntax

如何使用 range() 函数创建一个数字列表

你可以通过将 range() 函数作为参数传递给 list() 构造函数来创建一个数字列表，就像这样：

my_numbers_list = list(range(5))

print(my_numbers_list)

# output

# [0, 1, 2, 3, 4]

在上面的例子中，我创建了一个从 0 到 4 的数字列表。

如何在 Python 中使用 len() 函数和 range()

假设你有一个项目的列表，想根据列表的长度对这些项目做一些处理。

为此，你可以使用 range() 并将列表的长度作为参数传给函数。

要计算一个列表的长度，可以使用 len() 函数。

programming_languages = ["Python", "JavaScript", "Java", "C++"]

programming_languages_length = len(programming_languages)

for languages in range(programming_languages_length):
  print("Hello World")
  
# output

# Hello World
# Hello World
# Hello World
# Hello World

总结

你现在知道如何在 Python 中使用 range() 函数了。

要学习更多关于 Python 的知识，请查看 freeCodeCamp 的 Python 入门课程。

感谢阅读，happy coding！

在这篇文章中，你将了解 Python 中的 .append() 方法。你还会看到 .append() 与其他用于向列表添加元素的方法有什么不同。

让我们开始吧！

Python 中的列表是什么？给初学者的定义

编程中的数组是一个有序的项目集合，所有的项目都需要是相同的数据类型。

然而，与其它编程语言不同，数组在 Python 中不是一个内置的数据结构。Python 使用列表取代传统的数组。

列表本质上是动态数组，是 Python 中最常见的和最强大的数据结构之一。

你可以把它们想象成有序的容器。它们将同类相关的数据存储和组织在一起。

存储在一个列表中的元素可以是任何数据类型。

可以有整数列表、浮点数列表、字符串列表，以及任何其它内置 Python 数据类型的列表。

尽管列表有可能只容纳相同数据类型的项目，但它们比传统的数组更灵活。这意味着在同一个列表中可以有各种不同的数据类型。

列表有 0 个或更多的项目，这意味着也可以有空的列表。在一个列表中，也可以有重复的值。

值之间用逗号隔开，用方括号 [] 把值括起来。

如何在 Python 中创建列表

要创建一个新的列表，首先给这个列表起一个名字。然后添加赋值运算符（=）和一对有开头和结尾的方括号。在方括号内添加你希望列表包含的值。

#创建一个包含名字的新列表
names = ["Jimmy", "Timmy", "Kenny", "Lenny"]

#将列表打印到控制台
print(names)

#输出
#['Jimmy', 'Timmy', 'Kenny', 'Lenny']

在 Python 中列表是如何被索引的

列表为每个项目保持一个顺序。

集合中的每个项目都有一个自己的索引号，你可以用它来访问这个项目本身。

Python（以及其它现代编程语言）中的索引从 0 开始，列表中的每一项的索引逐个增加。

例如，前面创建的列表有 4 个值：

names = ["Jimmy", "Timmy", "Kenny", "Lenny"]

列表中的第一个值，“Jimmy”，索引为 0。

列表中的第二个值，“Timmy”，索引为 1。

列表中的第三个值，“Kenny”，索引为 2。

列表中的第四个值，“Lenny”，索引为 3。

要通过索引号访问列表中的一个元素，首先要写出列表的名称，然后在方括号中写出该元素索引，这是一个整数。

例如，如果你想访问索引为 2 的元素，你应该这样做：

names = ["Jimmy", "Timmy", "Kenny", "Lenny"]

print(names[2])

#output
#Kenny

Python 中的列表是可变的

在 Python 中，当对象是可变的时候，这意味着一旦它们被创建，其值就可以被改变。

列表是可变的对象，所以在它们被创建后，你可以更新和改变它们。

列表也是动态的，意味着它们可以在程序的整个生命周期中增长和缩小。

可以从现有的列表中删除项目，也可以给现有的列表添加新的项目。

有一些内置的方法用于从列表中添加和删除项目。

例如，要添加项目，有 .append()、.insert() 和 .extend() 方法。

要删除项目，有 .remove()、.pop() 和 .pop(index) 方法。

.append() 方法的作用

.append() 方法在一个已经存在的列表的末尾添加一个额外的元素。

语法看起来像这样：

list_name.append(item)

让我们把它分解一下：

• list_name 是你给列表起的名字。
• .append() 是列表方法，用于在 list_name 的末尾添加一个项目。
• item 是你要添加的指定的单独项目。

使用 .append() 时，原始列表被修改，不创建新的列表。

如果你想在先前创建的列表中添加一个额外的名字，你可以这样做：

names = ["Jimmy", "Timmy", "Kenny", "Lenny"]

#在列表的末尾添加名字 Dylan
names.append("Dylan")

print(names)

#output
#['Jimmy', 'Timmy', 'Kenny', 'Lenny', 'Dylan']

.append() 和 .insert() 方法之间有什么区别

这两个方法的区别是：.append() 在列表的末尾添加一个项目，而 .insert() 在列表的指定位置插入一个项目。

正如你在上一节看到的，.append() 将把你作为参数传递给函数的项目始终添加到列表的末尾。

如果你不想只是将项目添加到列表的末尾，你可以用 .insert() 指定你想添加的位置。

一般的语法是这样的：

list_name.insert(position,item)

让我们把它分解一下：

• list_name 是列表的名称。
• .insert() 是列表方法，用于在列表中插入一个项目。
• position 是该方法的第一个参数。它总是一个整数——具体地说，它是你希望新项目被放置的位置的索引号。
• item 是该方法的第二个参数。在这里你指定你想添加到列表中的新项目。

例如，假设你有以下的编程语言列表：

programming_languages = ["JavaScript", "Java", "C++"]

print(programming_languages)

#output
#['JavaScript', 'Java', 'C++']

如果你想在列表的开始插入 “Python”，作为列表的一个新项，你可以使用 .insert() 方法，并指定位置为 0（记住，列表的第一个值的索引总是 0）。

programming_languages = ["JavaScript", "Java", "C++"]

programming_languages.insert(0, "Python")

print(programming_languages)

#output
#['Python', 'JavaScript', 'Java', 'C++']

如果你想让 “JavaScript” 成为列表中的第一个项目，然后添加 “Python” 作为新的项目，你会指定位置为 1：

programming_languages = ["JavaScript", "Java", "C++"]

programming_languages.insert(1,"Python")

print(programming_languages)

#output
#['JavaScript', 'Python', 'Java', 'C++']

与 .append() 方法相比，.insert() 方法给了你更多的灵活性，前者只在列表的末尾添加一个新项目。

.append() 和 .extend() 方法之间有什么区别

如果你想一次向列表中添加多个项目，而不是一次添加一个，怎么办？

你可以使用 .append() 方法在一个列表的末尾添加多个项目。

假设你有一个只包含两种编程语言的列表：

programming_languages = ["JavaScript", "Java"]

print(programming_languages)

#output
#['JavaScript', 'Java']

然后你想在它的最后再增加两种语言。

在这种情况下，你传递一个包含你想添加的两个新值的列表，作为 .append() 的一个参数：

programming_languages = ["JavaScript", "Java"]

#在列表的末尾添加两个新项目
programming_languages.append(["Python","C++"])

print(programming_languages)

#output
#['JavaScript', 'Java', ['Python', 'C++']]

如果你仔细看看上面的输出，['JavaScript', 'Java', ['Python', 'C++']]，你会发现一个新的列表被添加到已经存在的列表的末尾。

所以，.append() 在一个列表中添加了一个列表。

列表是对象，当你使用 .append() 将另一个列表添加到一个列表中时，新的项目将作为一个单独的对象（项目）被添加。

假设你已经有两个列表，像这样：

names = ["Jimmy", "Timmy"]
more_names = ["Kenny", "Lenny"]

如果想把两个列表的内容合二为一，把 more_names 的内容加入到 names 中，会怎么样？

当 .append() 方法被用于此目的时，另一个列表会在 names 中被创建：

names = ["Jimmy", "Timmy"]
more_names = ["Kenny", "Lenny"]

#将 more_names 的内容添加到 names
names.append(more_names)

print(names)

#output
#['Jimmy', 'Timmy', ['Kenny', 'Lenny']]

所以，.append() 通过将对象追加到最后，将新的元素作为另一个列表添加。

要真正将列表连接（添加）在一起，并将一个列表中的所有项目合并到另一个列表，你需要使用 .extend() 方法。

一般的语法是这样的：

list_name.extend(iterable/other_list_name)

让我们把它分解一下：

• list_name 是其中一个列表的名称。
• .extend() 是将一个列表的所有内容添加到另一个列表的方法。
• iterable 可以是任何可迭代的东西，比如另一个列表，例如 another_list_name。在这种情况下，another_list_name 是一个列表，它将与 list_name 连接，其内容将作为单独的项目被逐一添加到 list_name 的末尾。

因此，拿前面的例子来说，当 .append() 被替换为 .extend() 时，输出结果将是这样的：

names = ["Jimmy", "Timmy"]
more_names = ["Kenny", "Lenny"]

names.extend(more_names)

print(names)

#output
#['Jimmy', 'Timmy', 'Kenny', 'Lenny']

当我们使用 .extend() 时，名字列表得到扩展，其长度增加了 2。

.extend() 的工作方式是，它将一个列表（或其他可迭代的）作为参数，对每个元素进行迭代，然后将可迭代的每个元素添加到列表中。

.append() 和 .extend() 之间还有一个区别。

当你想添加一个字符串时，如前面所见，.append() 将整个单一项目添加到列表的末尾：

names = ["Jimmy", "Timmy", "Kenny", "Lenny"]

#将名字 Dylan 添加到列表的末尾
names.append("Dylan")

print(names)

#output
#['Jimmy', 'Timmy', 'Kenny', 'Lenny', 'Dylan']

如果你用 .extend() 将一个字符串添加到一个列表的末尾，那么字符串中的每个字符都会作为一个单独的项目被添加到列表中。

这是因为字符串是可迭代的，而 .extend() 是对传递给它的可迭代参数进行迭代。

因此，上面的例子看起来将是像这样的：

names = ["Jimmy", "Timmy", "Kenny", "Lenny"]

#给 .extend() 传递一个字符串（可迭代的）
names.extend("Dylan")

print(names)

#output
#['Jimmy', 'Timmy', 'Kenny', 'Lenny', 'D', 'y', 'l', 'a', 'n']

总结

总而言之，.append() 方法用于在现有列表的末尾添加一个项目，而不创建一个新的列表。

当它用于将一个列表添加到另一个列表时，它在一个列表中创建一个列表。

如果你想学习更多关于 Python 的知识，请查看 freeCodeCamp 的 Python 认证。该课程对初学者友好。你将学习交互式课程，并通过创建五个项目来实践你所学习的知识。

感谢你阅读这篇文章。happy coding!

如果你在运行你的 Python 代码时看到报错 “TypeError: 'int' object is not iterable”，这意味着你正试图遍历一个整数或其他不能应用循环的数据类型。

在 Python 中，可迭代的数据是列表、元组、集合、字典等等。

此外，这个错误是 “TypeError”，意味着你正试图对一个不合适的数据类型进行操作，例如，将一个字符串与一个整数相加。

今天之后，你在运行 Python 代码时就不会遇到这个错误了。因为在这篇文章中，我不仅会告诉你如何解决它，我还会告诉你如何查看 __iter__ 魔法方法，以便你能看到一个对象是否可迭代。

如何解决 Int 对象不可迭代的问题

如果你试图遍历一个整数，你会得到这个报错：

count = 14

for i in count:
    print(i)
# Output: TypeError: 'int' object is not iterable

解决这个问题的一个方法是将变量传入 range() 函数。

在 Python 中，range 函数检查传入的变量，并返回一系列从 0 开始、在指定数字之前停止的数字。

现在循环将运行：

count = 14

for i in range(count):
    print(i)
    
# Output: 0
# 1
# 2
# 3
# 4
# 5
# 6
# 7
# 8
# 9
# 10
# 11
# 12
# 13

另一个使用该解决方案的例子是下面的片段：

age = int(input("Enter your age: "))

for num in range(age):
    print(num)

# Output: 
# Enter your age: 6
# 0
# 1
# 2
# 3
# 4
# 5

如何检查数据或对象是否是可迭代的？

要检查某些特定的数据是否是可迭代的，你可以使用 dir() 方法。如果你能看到神奇的 __iter__ 方法，那么这些数据就是可迭代的。如果没有，那么这些数据就不是可迭代的，你不应该费力地去遍历它们。

perfectNum = 7

print(dir(perfectNum))

# Output:['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', 
# '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']

在输出中没有找到 __iter__ 魔法方法，所以变量 perfectNum 是不可迭代的。

jerseyNums = [43, 10, 7, 6, 8]

print(dir(jerseyNums))

# Output: ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

找到了魔法方法 __iter__，所以列表 jerseyNums 是可迭代的。

小结

在这篇文章中，你了解了 “Int Object is Not Iterable” 错误以及如何解决它。

你也了解了如何检查一个对象或一些数据是否可迭代。

如果你在一些数据中查找 __iter__ 魔法方法而没有找到它，最好不要试图在这些数据中循环，因为它们不是可迭代的。

谢谢你阅读本文。

我们都有一些需要重复做的任务。幸运的是，我们可以将其中一些过程自动化，这样我们就可以专注于做其他真正需要精力和注意力的事情。

在这篇文章中，我们将谈论一些 Python 自动化脚本，你可以轻松地用它们来执行自动化任务。重要的是要明白，它们都是现成的代码，可以帮助我们处理许多日常的重复性任务。

我强烈建议你在继续学习本文之前，先对 Python 编程语言有一些了解。

可以开始了吗？

如何使 Python 校对自动化

列表中的第一个是校对。每当你想消除写作中的语法和拼写错误时，你可以试试这个使用 Lmproof 模块的项目。

# Python Proofreading
# pip install lmproof
import lmproof
def proofread(text):
    proofread = lmproof.load("en")
    correction = proofread.proofread(text)
    print("Original: {}".format(text))
    print("Correction: {}".format(correction))
    
proofread("Your Text")

首先，你需要为这个自动化安装 lmproof 库。然后，你可以使用函数 proofread()，它接收 text 作为参数。该函数运行并打印传入该函数的原始文本以及更正后的文本。你可以用它来快速校对一篇论文或一篇短文。

如何自动播放随机音乐

在工作时，许多开发人员喜欢听音乐。因此，对于音乐爱好者（比如我）来说，这个脚本会从包含歌曲的文件夹中随机挑选一首歌曲，并在 Python 中的 OS 和 random 模块的帮助下播放。

import random, os
music_dir = 'E:\\music diretory'
songs = os.listdir(music_dir)

song = random.randint(0,len(songs))

# Prints The Song Name
print(songs[song])  

os.startfile(os.path.join(music_dir, songs[0])) 

该代码进入包含所有你想播放的歌曲的音乐目录，并将它们全部放在一个列表中。然后它随机地一首接一首地播放每首歌曲。os.startfile 播放歌曲。

自动 PDF-CSV 转换器

有时你需要将 pdf 数据转换为 CSV（comma separated value 逗号分隔值）数据，这样你就可以用它进行进一步的分析。在这些情况下，这个脚本可以派上用场。

import tabula

filename = input("Enter File Path: ")
df = tabula.read_pdf(filename, encoding='utf-8', spreadsheet=True, pages='1')

df.to_csv('output.csv')

你需要用 pip 安装 tabula 库，以便运行这段代码。安装后，你可以将文件传入你的项目。

库中有一个函数 read_pdf()，它接收文件并读取它。你通过使用 to_csv() 函数将输出转换为 CSV 来完成自动化。

自动照片压缩器

你也可以通过压缩来减少图片的大小——同时仍然保持其质量。

import PIL
from PIL import Image
from tkinter.filedialog import *

fl=askopenfilenames()
img = Image.open(fl[0])
img.save("output.jpg", "JPEG", optimize = True, quality = 10)

你可以使用 PIL（Python Imaging Library）来处理图像，对图像做很多事情，例如添加滤镜、模糊、锐化、平滑、边缘检测、压缩图像。

自动 YouTube 视频下载器

这里有一个简单的自动脚本，用于下载 YouTube 视频。只需使用下面的代码就可以下载任何视频，不需要任何网站或应用程序。

import pytube

link = input('Youtube Video URL')
video_download = pytube.Youtube(link)
video_download.streams.first().download()
print('Video Downloaded', link)

pytube 库是一个非常简单的库，你可以用来下载 YouTube 视频到你的本地电脑。你所需要做的就是输入视频的链接，然后用 download() 方法将其下载到你的电脑上。

自动文本转语音

我们将在这个脚本中使用谷歌文本转语音 API。该 API 是最新的，可用于许多语言、音调和声音，你可以从中选择。

from pygame import mixer
from gtts import gTTS

def main():
   tts = gTTS('Like This Article')
   tts.save('output.mp3')
   mixer.init()
   mixer.music.load('output.mp3')
   mixer.music.play()
   
if __name__ == "__main__":
   main()

如何自动转换图像为 PDF

这是一个非常常见的任务，你可能经常执行。你可能想转换一张或多张图像为一个 PDF。

如何转换一张图像为 PDF：

import os
import img2pdf
with open("output.pdf", "wb") as file:
   file.write(img2pdf.convert([i for i in os.listdir('path to image') if i.endswith(".jpg")]))

如何转换多张图像为 PDF：

from fpdf import FPDF
Pdf = FPDF()

list_of_images = ["wall.jpg", "nature.jpg","cat.jpg"]
for i in list_of_images:
   Pdf.add_page()
   Pdf.image(i,x,y,w,h)
   Pdf.output("result.pdf", "F")

这里我们使用 Python 中的 image2pdf 库将我们的图像转换为 PDF。我们也可以只用几行代码就把多张图像转换为 PDF。

自动抄袭检查器

抄袭是将他人的文字或想法作为自己的，无论是否得到他人的许可，将其整合到你的作品中而不注明原作者。

当你想在两个文件之间检查抄袭时，这个脚本会很有帮助。

from difflib import SequenceMatcher
def plagiarism_checker(f1,f2):
    with open(f1,errors="ignore") as file1,open(f2,errors="ignore") as file2:
        f1_data=file1.read()
        f2_data=file2.read()
        res=SequenceMatcher(None, f1_data, f2_data).ratio()
        
print(f"These files are {res*100} % similar")
f1=input("Enter file_1 path: ")
f2=input("Enter file_2 path: ")
plagiarism_checker(f1, f2)

如何生成短 URL

大的 URLs 在阅读和分享时可能相当烦人。为了缩短 URL，这个脚本利用了一个第三方的 API。

from __future__ import with_statement
import contextlib
try:
	from urllib.parse import urlencode
except ImportError:
	from urllib import urlencode
try:
	from urllib.request import urlopen
except ImportError:
	from urllib2 import urlopen
import sys

def make_tiny(url):
	request_url = ('http://tinyurl.com/app-index.php?' + 
	urlencode({'url':url}))
	with contextlib.closing(urlopen(request_url)) as response:
		return response.read().decode('utf-8')

def main():
	for tinyurl in map(make_tiny, sys.argv[1:]):
		print(tinyurl)

if __name__ == '__main__':
	main()
    

'''

-----------------------------OUTPUT------------------------
python url_shortener.py https://www.wikipedia.org/
https://tinyurl.com/bif4t9

'''
    

网速测试器

OOKLA 速度检测 API 允许你检查 ping 和网速。除了检查 ping 之外，这个小的自动化项目还可以检查下载和上传速度。

# Internet Speed tester
# pip install speedtest-cli
import speedtest as st

# Set Best Server
server = st.Speedtest()
server.get_best_server()

# Test Download Speed
down = server.download()
down = down / 1000000
print(f"Download Speed: {down} Mb/s")

# Test Upload Speed
up = server.upload()
up = up / 1000000
print(f"Upload Speed: {up} Mb/s")

# Test Ping
ping = server.results.ping
print(f"Ping Speed: {ping}")

虽然有 fast.com 这样的替代品，但有了这个脚本，你可以用 Python 脚本快速检查网速。

总结

我们在这篇文章中谈到了十个 Python 自动化脚本，我希望你觉得它很有用。你也可以去看看所使用的库，拓展你的知识。

欢迎在 Twitter 和 LinkedIn 联系我。

Happy Coding!

你可以使用 Python 中的 datetime 模块来检索有关日期和时间的数据。

在本文中，你将学习如何使用 datetime 模块中的 datetime 对象来获取当前日期和时间属性。

你还将学习如何使用 datetime.now() 函数和 pytz 模块获取世界各地不同地点的日期和时间。

如何在 Python 中使用 datetime 对象

为了使用 datetime 对象，你必须首先导入它，就是这样：

from datetime import datetime

在下一个示例中，你将看到如何使用 datetime 对象。

from datetime import datetime

current_dateTime = datetime.now()

print(current_dateTime)
# 2022-09-20 10:27:21.240752

在上面的代码中，我们将 datetime 分配给了一个名为 current_dateTime 的变量。

当打印到控制台时，我们得到了当前的年、月、日和时间：2022-09-19 17:44:17.858167。

请注意，我们可以使用 now() 方法访问上述信息：datetime.now()。

如何使用 datetime.now() 属性

在上一节中，我们检索了有关当前日期和时间的信息，包括当前的年、月、日和时间。

但是 datetime.now() 函数为我们提供了用于提取单个数据的额外属性。

例如，要获取当前年份，你可以执行以下操作：

from datetime import datetime

current_dateTime = datetime.now()

print(current_dateTime.year)
# 2022

在上面的示例中，我们将 datetime.now() 函数分配给了一个名为 current_dateTime 的变量。

使用点表示法，我们将 year 属性附加到上面声明的变量：current_dateTime.year。当打印到控制台时，我们得到了 2022。

datetime.now() 函数具有以下属性：

• year
• month
• day
• hour
• minute
• second
• microsecond

这是上面列出的属性的一个使用示例：

from datetime import datetime

current_dateTime = datetime.now()

print(current_dateTime.year) # 2022

print(current_dateTime.month) # 9

print(current_dateTime.day) # 20

print(current_dateTime.hour) # 11

print(current_dateTime.minute) # 27

print(current_dateTime.second) # 46

print(current_dateTime.microsecond) # 582035

如何在 Python 中使用 datetime.now() 和 pytz 获取特定时区

要在 Python 中获取有关世界各地不同时区的信息，你可以使用 datetime.now() 函数和 pytz 模块。

这是一个示例，显示如何获取尼日利亚拉各斯的当前日期和时间：

from datetime import datetime
import pytz

datetime_in_Lagos = datetime.now(pytz.timezone('Africa/Lagos'))

print(datetime_in_Lagos)
# 2022-09-20 12:53:27.225570+01:00

在上面的代码中，我们首先导入了模块：

from datetime import datetime
import pytz

然后我们将 pytz 对象作为参数传递给 datetime.now() 函数：

datetime_in_Lagos = datetime.now(pytz.timezone('Africa/Lagos'))

pytz 对象有一个 timezone 属性，它获取你正在寻找的特定时区的信息/参数：pytz.timezone('Africa/Lagos')。

使用 all_timezones 属性，你可以获得 pytz 库中所有可能的时区的列表，这些时区可以作为参数传递给 timezone 属性——就像我们在上一个示例中所做的那样：

from datetime import datetime
import pytz

all_timezones = pytz.all_timezones

print(all_timezones)
# [List of all timezones...]

小结

在本文中，我们讨论了使用 Python 中的 datetime.now() 函数获取今天的日期和时间。

我们看到了一些示例，展示了如何使用 datetime.now() 函数及其属性。

最后，我们看到了如何使用 datetime.now() 函数和 pytz 模块获取世界各地特定位置的日期和时间。

祝你编程愉快！

许多编程语言都有内置的功能来处理文件和文件夹。作为一种内置了许多令人兴奋的功能的丰富编程语言，Python 也不例外。

Python 有 OS 和 Pathlib 模块，可用于创建文件和文件夹、编辑文件和文件夹、读取文件的内容，以及删除文件和文件夹。

在这篇文章中，我将向你展示如何用 OS 模块删除文件和文件夹。

我们将讨论的内容

• 如何用 OS 模块删除文件
• 如何用 Pathlib 模块删除文件
• 如何用 OS 模块删除空文件夹
• 如何用 Pathlib 模块删除空文件夹
• 如何用 shutil 模块删除非空文件夹
• 总结

如何用 OS 模块删除文件

要用 OS 模块删除任何文件，你可以使用它的 remove() 方法。然后你需要在 remove() 方法中指定特定文件的路径。但首先，你需要通过导入 OS 模块来引入它：

import os

os.remove('path-to-file')

这段代码删除了当前文件夹中的 questions.py 文件：

import os

os.remove('questions.py')

如果文件在另一个文件夹内，你需要指定包括文件名在内的完整路径，而不是仅仅指定文件名：

import os

os.remove('folder/filename.extension')

下面的代码显示了我如何删除 textFiles 文件夹内的 faq.txt 文件：

import os

os.remove('textFiles/faq.txt')

为了使事情变得更好，你可以在删除文件之前先检查该文件是否存在：

import os

# Extract the file path to a variable
file_path = 'textFiles/faq.txt'

#check if the file exists with path.exists()
if os.path.exists(file_path):
    os.remove('textFiles/faq.txt')
    print('file deleted')
else:
    print("File does not exists")

你也可以使用 try..except 实现相同的目的：

import os

try:
    os.remove('textFiles/faq.txt')
    print('file deleted')
except:
    print("File doesn't exist")

如何用 Pathlib 模块删除文件

pathlib 模块是 Python 标准库中的一个模块，它为你提供了一个面向对象的方法来处理文件系统的路径。你也可以用它来处理文件。

pathlib 模块有一个 unlink() 方法，你可以用来删除一个文件。你需要用 pathlib.Path() 得到文件的路径，然后在文件路径上调用 unlink() 方法：

import pathlib

# get the file path
try:
    file_path = pathlib.Path('textFiles/questions.txt')
    file_path.unlink()
    print('file deleted')
except:
    print("File doesn't exist")

如何用 OS 模块删除空文件夹

OS 模块提供了一个 rmdir() 方法，你可以用它来删除一个文件夹。

但是，你删除一个空文件夹的方式与你删除一个有文件或子文件夹的文件夹的方式不同。让我们先看看你如何删除空文件夹。

下面是我如何删除一个空的 client 文件夹：

import os

try:
    os.rmdir('client')
    print('Folder deleted')
except:
    print("Folder doesn't exist")

如果你试图删除一个里面有文件或子文件夹的文件夹，你会得到 Directory not empty error：

import os

os.rmdir('textFiles') # OSError: [Errno 66] Directory not empty: 'textFiles'

如何用 pathlib 模块删除空文件夹

使用 pathlib 模块，你可以将你想删除的文件夹的路径提取到一个变量中，然后对该变量调用 rmdir()：

import pathlib

# get the folder path
try:
    folder_path = pathlib.Path('docs')
    folder_path.rmdir()
    print('Folder deleted')
except:
    print("Folder doesn't exist")

要删除一个有子文件夹和文件的文件夹，你必须先删除所有的文件，然后对现在的空文件夹调用 os.rmdir() 或 path.rmdir()。但你可以使用 shutil 模块来替代。我很快就会向你展示这一点。

如何用 shutil 模块删除一个非空文件夹

shutil 模块有一个 rmtree() 方法，你可以用来删除一个文件夹及其内容——即使它包含多个文件和子文件夹。

你需要做的第一件事是将文件夹的路径提取到一个变量中，然后对该变量调用 rmtree()。

下面是我如何删除 textFiles 文件夹内一个名为 subTexts 的文件夹：

import shutil

try:
    folder_path = 'textFiles/subTexts'
    shutil.rmtree(folder_path)
    print('Folder and its content removed')
except:
    print('Folder not deleted')

下面是我如何删除整个 textFiles 文件夹（它有几个文件和一个子文件夹）：

import shutil

try:
    folder_path = 'textFiles'
    shutil.rmtree(folder_path)
    print('Folder and its content removed') # Folder and its content removed
except:
    print('Folder not deleted')

总结

这篇文章告诉你如何用 Python 的 OS 和 pathlib 模块删除一个文件和空文件夹。因为你可能也需要删除非空文件夹，我们看了一下如何用 shutil 模块来实现。

如果你觉得这篇文章有帮助，不要犹豫，与你的朋友和家人分享它。

在这篇文章中，你将学习 Python 中追加字符串的不同方法。

谈到追加（appending）字符串，另一个常用的术语是拼接（concatenation）。所以你会经常看到这些术语——追加和拼接——可以互换使用。

无论怎样，追加或拼接字符串意味着将一个字符串的值添加或连接到另一个字符串。

让我们通过简单的代码例子来看看可以用哪些不同的方法做到这一点。

如何在 Python 中使用 + 操作符追加一个字符串

你可以使用 + 操作符来追加两个或多个字符串。下面是一个例子：

first_name = "John"
last_name = "Doe"

print(first_name + last_name)
# JohnDoe

在上面的例子中，我们创建了两个字符串变量 - first_name 和 last_name。它们的值分别为 “John” 和 “Doe”。

为了追加这些变量，我们使用了 + 操作符：first_name + last_name。

你会注意到在输出中，我们将两个变量连接起来，没有任何间隔：JohnDoe。

你可以在 first_name 值后面加一个空格：“John ”，或者在 last_name 的值之前：“ Doe”，也就是：

first_name = "John "
last_name = "Doe"

print(first_name + last_name)
# John Doe

你也可以在追加字符串的同时使用引号来增加间距，方法如下：

first_name = "John "
last_name = "Doe"

print(first_name + "" + last_name)
# John Doe

如何在 Python 中使用 join() 方法追加一个字符串

另一种在 Python 中追加字符串的方法是使用 join() 方法。

join() 方法接受一个可迭代对象——列表、元组、字符串、集合、字典——作为它的参数。语法是这样的：

string.join(iterable_object)

下面是一个例子，展示了如何使用 join() 方法追加字符串：

first_name = "John"
last_name = "Doe"

print("".join([first_name, last_name]))
# JohnDoe

在这里，我们把两个字符串变量作为参数传给了 join() 方法。

你还会注意到，这些变量被嵌套在方括号 [] 中，使之成为一个字符串的列表：[first_name, last_name]。这是因为该方法只接受一个参数，而这个参数必须是一个可迭代的对象。

join() 方法的一个奇怪之处在于句号/点之前的引号。

你可以使用这些引号来说明在你的可迭代对象值中的项目之间有什么。让我用一个例子来说明。

first_name = "John"
last_name = "Doe"

print("#".join([first_name, last_name]))
# John#Doe

在上面的例子中，我在引号中加入了 # 符号："#".join([first_name, last_name])。这个 # 号被加在我们的字符串之间： John#Doe。

在上一节中，我们必须使用不同的方法在我们的字符串之间添加间距。你可以通过在 join() 方法之前的引号中添加一个空格来轻松实现这一点：

first_name = "John"
last_name = "Doe"

print(" ".join([first_name, last_name]))
# John Doe

如何在 Python 中使用 String format() 方法追加一个字符串

下面是字符串 format() 方法的语法：

{}.format(value)

基本上，字符串 format() 方法在上面的语法中获取 value 参数并将其插入大括号中。由此产生的值将是一个字符串。

下面是一个例子：

first_name = "John"
last_name = "Doe"

print("{} {}".format(first_name, last_name))
# John Doe

由于我们在例子中提供了两个大括号和两个参数（first_name 和 last_name），字符串 format() 方法将这些字符串插入各自的大括号中。

你可以在有大括号的引号中添加更多的字符串。这不会改变字符串 format() 方法的操作——字符串仍然会被插入到大括号中，就像下面这样：

first_name = "John"
last_name = "Doe"

print("My name is {} {}".format(first_name, last_name))
# My name is John Doe

如何在 Python 中使用 f-string 追加一个字符串

这个方法很容易理解。在 Python 中引入 f-string 是为了使字符串格式化和插值更容易。但是你也可以用它来追加字符串。

要使用 f-string，你只需在 f 后面写上引号：f""。然后你可以在引号之间插入字符串和变量名。所有的变量名必须嵌套在大括号中。

下面是一个例子：

first_name = "John"
last_name = "Doe"

print(f"{first_name} {last_name}")
# John Doe

小结

在这篇文章中，我们讨论了在 Python 中追加字符串的不同方法。

将一个字符串追加到另一个字符串意味着将它们连在一起。

正如本文所讨论的，结合代码实例，你可以在 Python 中使用 + 操作符、join() 方法、format() 方法和 f-string 来追加字符串。

Happy coding!

在 Python 中，当你在一个操作中使用不同的数据类型时，会发生 “Typeerror”。

例如，如果你试图用一个整数（数字）除以一个字符串，就会导致一个 typeerror，因为整数的数据类型与字符串不一样。

其中一个类型错误是 “int object is not callable” 错误。

当你声明一个变量并以内置函数名称（int()、sum()、max() 等等）命名时，就会发生 “int object is not callable” 错误。

当你在进行数学运算时没有指定算术运算符，也会发生这个错误。

在这篇文章中，我将向你展示该错误是如何发生的，以及你可以做什么来修复它。

如何修复内置函数名中的 Typeerror: int object is not callable

如果你用一个内置函数名作为变量，并把它作为一个函数调用，会出现 “int object is not callable” 错误。

例如，下面的代码试图用 Python 的内置 sum() 函数来计算一些孩子的总年龄。这段代码导致了一个错误，因为同样的 sum 已经被用作变量名了：

kid_ages = [2, 7, 5, 6, 3]

sum = 0
sum = sum(kid_ages)
print(sum)

在下面的另一个例子中，我使用 max() 函数来获得这些孩子中最年长的，但我已经声明了一个 max 变量：

kid_ages = [2, 7, 5, 6, 3]

max = 0
max = max(kid_ages)
print(max)

这两个代码例子在终端都出现这个报错：

为了解决这个问题，你需要修改和内置函数相同的变量的名称，这样代码才能成功运行：

kid_ages = [2, 7, 5, 6, 3]

sum_of_ages = 0
sum = sum(kid_ages)
print(sum)

# Output: 23

kid_ages = [2, 7, 5, 6, 3]

max_of_ages = 0
max = max(kid_ages)
print(max)

# Output: 7

如果你不使用内置函数的名称作为变量名，你的代码仍将按预期运行：

kid_ages = [2, 7, 5, 6, 3]

sum = sum(kid_ages)
print(sum)

# Output: 23

kid_ages = [2, 7, 5, 6, 3]

max = max(kid_ages)
print(max)

# Output: 7

如何修复数学运算中的 Typeerror: int object is not callable

在数学中，如果你做像 4(2+3) 这样的事情，你会得到正确的答案是 20。但在 Python 中，这将导致 Typeerror: int object is not callable 错误。

为了解决这个错误，你需要让 Python 知道你想把括号外的数字与括号内的数字之和相乘。

要做到这一点，你可以在括号前面指定一个乘法符号（*）：

print(4*(2+3))

#Output: 20

Python 允许你在开始括号前指定任何算术符号。

所以，你也可以像这样进行其他运算：

print(4+(2+3))

# Output: 9

print(4-(2+3))

# Output: -1

print(4/(2+3))

# Output: 0.8

小结

Typeerror: int object is not callable 是 Python 中的一个初级错误，你可以用简单的方法来避免。

正如本文所示，你可以通过不使用内置函数名作为变量名并在必要时指定运算符号来避免这个错误。

感谢阅读。

数据存在于现代数字世界的所有领域，它有许多不同的形式。

最常见的数据格式之一是 PDF。企业和机构经常将发票、报告和其他表格存储在便携式文档格式（PDF）文件中。

从 PDF 文件中提取数据可能会很费力和费时。幸运的是，为了方便从 PDF 文件中提取数据，Python 提供了各种库。

本教程将解释如何使用 Python 从 PDF 文件中提取数据。你将学习如何安装必要的库，我将提供如何安装的例子。

有几个 Python 库，你可以用来读取和提取 PDF 文件中的数据。这些库包括 PDFMiner、PyPDF2、PDFQuery 和 PyMuPDF。这里，我们将使用 PDFQuery 从多个 PDF 文件中读取和提取数据。

如何使用 PDFQuery

PDFQuery 是一个 Python 库，通过使用类似于 CSS 的选择器来定位文档中的元素，提供了一种从 PDF 文件中提取数据的简单方法。

它将一个 PDF 文件作为一个对象来读取，将 PDF 对象转换为一个 XML 文件，并通过其在 PDF 文件中的特定位置来访问所需的信息。

让我们考虑一个简短的例子来看看它是如何工作的。

from pdfquery import PDFQuery

pdf = PDFQuery('example.pdf')
pdf.load()

# 使用类似 CSS 的选择器来定位元素
text_elements = pdf.pq('LTTextLineHorizontal')

# 从元素中提取文本
text = [t.text for t in text_elements]

print(text)

在这段代码中，我们首先通过传递我们想要提取数据的 PDF 文件的文件名创建一个 PDFQuery 对象。然后我们通过调用 load() 方法将文件加载到该对象中。

接下来，我们使用类似 CSS 的选择器来定位 PDF 文档中的文本元素。pq() 方法被用来定位这些元素，它返回一个代表所选元素的 PyQuery 对象。

最后，我们通过访问每个元素的 text 属性从这些元素中提取文本，并将提取的文本存储在一个叫作 text 的列表中。

让我们考虑另一种方法，读取 PDF 文件，提取一些数据元素，并使用 PDFQuery 创建一个结构化的数据集。我们将遵循以下步骤：

• 安装包
• 导入库
• 读取和转换 PDF 文件
• 读取和转换数据

安装包

首先，我们需要安装 PDFQuery，同时安装 Pandas 以进行一些分析和数据展示。

pip install pdfquery
pip install pandas

导入库

import pandas as pd
import pdfquery

我们导入这两个库，以便能够在我们的项目中使用它们。

读取和转换 PDF 文件

#读取 PDF
pdf = pdfquery.PDFQuery('customers.pdf')
pdf.load()


#将 pdf 转换为 XML
pdf.tree.write('customers.xml', pretty_print = True)
pdf

我们将把 pdf 文件作为一个元素对象读入我们的项目，并加载它。将 pdf 对象转换成可扩展标记语言（XML）文件。这个文件包含了一个给定的 PDF 页面的数据和元数据。

XML 定义了一套规则，用于将 PDF 编码成人类和机器都能阅读的格式。使用文本编辑器查看 XML 文件，我们可以看到我们要提取的数据在哪里。

读取和转换数据

我们可以在 LTTextBoxHorizontal 标签里面得到想要提取的信息，我们可以看到与之相关的元数据。

在 XML 片段中，文本框内的值 [68.0, 231.57, 101.990, 234.893] 是指文本框的左、下、右、上坐标。你可以把它看作是我们要提取的数据周围的边界。

让我们使用文本框的坐标来访问和提取客户名称。

# 使用坐标读取数据
customer_name = pdf.pq('LTTextLineHorizontal:in_bbox("68.0, 231.57, 101.990, 234.893")').text()

print(customer_name)

#output: Brandon James

就这样，我们完成了！

注意：有时我们想提取的数据在每个文件中的位置不完全相同，这可能会导致问题。幸运的是，PDFQuery 也可以查询包含一个给定字符串的标签。

总结

从 PDF 文件中提取数据是一项重要任务，因为这些文件经常被用于文档存储和共享。

Python 的 PDFQuery 是一个强大的工具，可用于从 PDF 文件中提取数据。任何想要从 PDF 文件中提取数据的人都会发现 PDFQuery 是一个很好的选择，因为它语法简单、文档全面，它也是开源的，可以修改以适应特定的用例。

欢迎在 Twitter 和 LinkedIn 联系我。你也可以订阅我的 YouTube 频道。

Happy Coding!

每种编程语言都有一些具有特定功能和意义的关键词。

用这些关键字来命名你的变量或函数，很可能会引起错误。我们将在本文中讨论其中一种情况--Python 中的错误 TypeError: 'str' object is not callable。

TypeError: 'str' object is not callable 错误主要在以下情况下发生：

• 你把一个名为 str 的变量作为参数传给 str() 函数。
• 当你像调用函数一样调用一个字符串时。

在接下来的章节中，你会看到引发 TypeError: 'str' object is not callable 错误的代码例子，以及如何解决这些问题。

例子 #1 - 如果你在 Python 中使用 str 作为变量名会发生什么

在本节中，你将看到当你用一个名为 str 的变量作为 str() 函数的参数时会发生什么。

str() 函数被用来将某些数值转换成字符串。str(10) 将整数 10 转换为字符串。

下面是第一个代码例子：

str = "Hello World"

print(str(str))
# TypeError: 'str' object is not callable

在上面的代码中，我们创建了一个变量 str，其值为 “Hello World”。我们将该变量作为参数传递给 str() 函数。

结果出现了 TypeError: 'str' object is not callable 报错。发生这种情况是因为我们使用的变量名已经被编译器识别为不同的东西。

为了解决这个问题，你可以把变量重命名为一个不是 Python 中预定义关键字的东西。

这里有一个快速解决这个问题的方法：

greetings = "Hello World"

print(str(greetings))
# Hello World

现在代码可以完美运行了。

例子 #2 - 如果你在 Python 中像调用一个函数一样调用一个字符串会发生什么

在 Python 中像调用一个函数一样调用一个字符串会引发 TypeError: 'str' object is not callable 错误。

下面是一个例子：

greetings = "Hello World"

print(greetings())
# TypeError: 'str' object is not callable

在上面的例子中，我们创建了一个名为 greetings 的变量。

当把它打印到控制台时，我们在变量名后面使用了小括号--这是调用函数时使用的语法：greetings()。

这导致编译器抛出 TypeError: 'str' object is not callable 错误。

你可以通过删除括号轻松解决这个问题。

这对其他所有不是函数的数据类型都是一样的。给它们加上小括号会引起同样的错误。

因此，我们的代码应该这样运行：

greetings = "Hello World"

print(greetings)
# Hello World

总结

在这篇文章中，我们讨论了 Python 中的 TypeError: 'str' object is not callable 错误。

我们谈到了为什么会发生这个错误以及如何解决它。

为了避免在你的代码中出现这个错误，你应该：

• 避免用 Python 中内置的关键字来命名你的变量。
• 永远不要像调用函数一样通过添加括号来调用你的变量。

Happy coding!