DLAI-初学者的人工智能笔记-全-

DLAI 初学者的人工智能笔记（全）

001：课程介绍与概述 🎯

在本节课中，我们将要学习吴恩达教授《给初学者的AI Python编程课》的引言部分。我们将了解为何在人工智能时代，学习一点编程对每个人都变得至关重要，以及本课程将如何帮助你利用AI工具更轻松地掌握这项技能。

---

欢迎来到《AI Python 编程入门》。无论你的工作角色和职业方向如何，即使你并非想成为AI开发者或软件工程师，我也很高兴你能来到这里。我希望在本课程结束时向你展示，编程是有用的、有趣的，并且能在你的日常工作和生活中提供帮助。

十年前，如果你问我是否每个人都应该学习编程，我会说不。因为当时学习编程需要付出相当多的努力，并且对于技术角色以外的人来说，其具体应用场景并不明确。但随着人工智能的兴起，特别是像ChatGPT和生成式AI这样的工具，我认为这个等式已经改变了。我看到许多在新闻、市场营销、商业研究、投资或行政岗位上的人，都发现工作中使用一点代码很有用，并能完成任务。

如果你能学会写一点点代码，你在许多类型的工作，尤其是知识工作中，效率会高得多。自从ChatGPT发布以及许多生成式AI工具广泛可用以来，人们编写代码的方式已经不同了。具体来说，有了聊天机器人伙伴，你永远不必独自编码。就好像你身边总有一个伙伴，它实际上在编码方面相当不错，可以帮助你编写代码。这使得学习编程变得容易得多。之后，当你自己编写代码时，AI聊天机器人也能让你的工作轻松许多，因为你有了这个经验丰富的伙伴，能在每一步为你提供帮助。

因此，这些新的AI工具极大地降低了学习编码所需的成本和努力。

现在互联网上有很多编程课程。本课程与众多其他课程的一个区别在于，你将立即学习这种与聊天机器人协同编码的新方法。因此，你将学习的技能，我认为会更具未来适应性，并且更符合专业编码的发展趋势。

随着AI的广泛普及，你会发现，如果你懂一点点编程，你真的可以让AI为你做更多事情。这意味着，由于AI正在影响几乎所有的知识工作，如果你从事知识型工作，或者即使你不是，我认为你编写一点点代码的能力，也将成为显著提升你生产力的因素。

所以，我希望你喜欢这门课程。除了它的实用性和有用性之外，我也不想低估这一点：我认为编程真的非常有趣。当你学会一点点编程时，你就能完成许多以前根本无法做到的事情。我和我的许多朋友都觉得这非常有趣，我希望你也会如此。

---

上一节我们介绍了学习编程在AI时代的新意义，本节中我们来看看接下来的学习路径。

那么，让我们进入下一个视频，在那里你将学习什么是编程语言，以及它如何让我们能让计算机为我们做更多事情。我们下个视频见。😊

---

本节课总结：在本节课中，我们一起学习了在当今AI工具普及的背景下，掌握基础编程技能对各行各业人士的重要性。课程强调了与AI聊天机器人协同工作的新方法，这将使学习过程更轻松，并大幅提升未来工作的效率与乐趣。

002：什么是计算机编程 🖥️

在本节课中，我们将要学习计算机编程的基本概念，了解它是什么、为何重要，以及Python语言在当今世界，尤其是在人工智能领域的核心地位。

概述

计算机编程是一门艺术与科学，其核心是编写精确的指令，告诉计算机你希望它为你做什么。事实证明，当你编写出优秀的指令时，计算机能够完成大量工作。

编程的力量：从个人效率到人类进步

上一节我们介绍了编程的基本定义，本节中我们来看看编程在实际生活中展现出的强大力量。

编程能够显著提升个人工作效率。我曾遇到一位前行政助理，她通过学习编程，编写了一个程序来监控她上司的日程。如果她的老板在日程安排上做了任何“有趣”的改动，她就会收到通知，从而能及时去修正。这就是一个通过学习编程，编写少量代码，从而更高效完成工作的例子。

我认为，在几乎各行各业中，学习编程、让计算机按你的意愿行事，都能帮助你完成更多工作。

更广泛地说，编程在诸多方面推动了人类的巨大进步，所有这些都离不开人们编写的代码。

• 科学探索：帮助我们解开宇宙奥秘的哈勃太空望远镜图像，是由科学家编写的计算机程序进行处理和分析的。
• 物理研究：发现希格斯玻色子的粒子加速器，之所以成为可能，是因为开发人员编写了软件来分析其收集的数据，从而推动了我们对物理学的理解。
• 日常生活：我们日常使用的互联网，也完全依赖于人们编写的计算机程序。当你拿起手机给别人发信息时，你就在使用别人编写的程序。
• 辅助技术：如果你使用GPS导航，或者你或你爱的人使用语音识别、眼动追踪等辅助技术，这些改变了无数残障人士生活的技术，也都是由人编写的程序。

编程的核心：向机器下达指令

计算机编程的核心是掌握命令机器为你服务的能力。计算机程序是一组精确的指令，告诉计算机如何执行一项任务。

正如烹饪食谱指导你完成步骤以 consistently 做出美味佳肴一样，计算机程序为计算机执行特定任务提供了指令。

掌握编程能力将使你在能够完成的事情上占据优势。我看到许多人使用编程来自动化重复性任务，例如反复从PDF文档中提取相关数据到电子表格中。

编程与人工智能：获取全新洞察

除了分析你或公司已有的数据，编程还能帮助你获得全新的洞察。

我看到许多团队，包括商业分析师，越来越多地使用像ChatGPT这样的人工智能工具来自动浏览网页、下载大量网页并综合成报告，以帮助他们获得市场洞察，了解世界某个地区正在发生的事情。

当你学会编程后，你自己就能更好地识别并利用人工智能来自动化更多这类任务。事实证明，通过编程，你只需编写几行代码，就能命令你的计算机使用ChatGPT或其他AI语言模型等工具。现在，不是你自己，而是你的计算机可以去使用ChatGPT来帮助它完成任务。

本课程编写代码的一个核心部分，就是让你的计算机通过Python使用AI工具，从而为你做更多事情。

为什么选择Python？ 🐍

大多数像我这样的AI开发者一直在使用Python。事实证明，Python实际上是最流行的编程语言。

Python拥有一个非常支持性的开发者社区。如果你有问题，全世界有如此多的Python开发者，你通常可以找到人来帮助你，或者发现有人曾遇到过同样的问题。

此外，像ChatGPT、Anthropic的Claude和Google的Gemini这样的聊天机器人也对Python相当了解，因此如果你在某个问题上遇到困难，它们可以帮助你。

所以，当你在编程中遇到问题时，我鼓励你尝试询问聊天机器人来帮助你找到解决方案，正如我将在今天的课程中向你展示的那样。

Python的应用：无处不在

Python正在为海量的人工智能应用提供动力。Python代码运行在许多自动驾驶汽车中，是驱动聊天机器人的软件的一部分，并应用于从智能农业到医疗保健、金融服务等众多其他AI应用中，不胜枚举。

Python的使用范围远不止于此。许多网站、智能手机应用程序、视频游戏等都在使用Python运行。

因此，当你学习Python时，你就是在学习编程中最重要的工具之一，无论你的目标是什么。

总结

本节课中我们一起学习了计算机编程的本质——编写精确指令来控制计算机。我们看到了编程如何提升个人效率并推动人类进步，探讨了编程与人工智能结合带来的新可能，并了解了Python作为最流行编程语言的优势及其广泛的应用领域。我希望这门《AI Python for Beginners》课程只是你的第一步，它将为你奠定基础，让你能够不断前进，用Python和编程做越来越多的事情，从而你也可以通过代码推动人类进步。

那么，让我们进入下一个视频，开始看看聊天机器人如何与Python交互。

003：使用聊天机器人编写代码 🚀

在本节课中，我们将学习程序员如何利用AI聊天机器人来辅助编程工作，提高效率。我们将从询问基本概念开始，逐步过渡到让聊天机器人直接为我们生成代码，并学习如何与它交互以修改和优化代码。

概述

程序员在日常工作中频繁使用聊天机器人，这显著提升了工作效率。过去，遇到编程难题时，可能需要花费时间寻找专家求助。现在，你可以直接向AI聊天机器人提问并立即获得答案。本课程提供了内置的聊天机器人供你使用，你也可以自由选择第三方工具，如ChatGPT、Microsoft Copilot、Claude、Google Gemini等。

与聊天机器人交互：提问与回答

上一节我们提到了聊天机器人的便利性，本节中我们来看看如何具体使用它。你可以将问题（也称为“提示”）输入聊天机器人。

例如，如果你想知道“什么是编程”，可以输入这个问题，聊天机器人会生成一个合理的答案。

即使本课程提供了内置聊天机器人，你仍然可以自由使用第三方聊天机器人。现在让我们尝试另一个问题。我将清空当前对话，然后输入提示：“什么是Python”。

我刚刚输入的文本被称为“提示”。输入“什么是Python”并按下回车后，聊天机器人会生成一个“响应”。由于历史原因，计算机程序员有时称此响应为“完成”，但“完成”一词指的就是聊天机器人对提示的回复。

以下是聊天机器人可能给出的关于Python的响应示例：

Python是一种高级编程语言，以其简单的语法而闻名，这使其成为初学者的绝佳选择。

如果你对回答中的某些部分感到好奇，例如“简单的语法”是什么意思，你可以继续提出后续问题。这是我个人常用的工作流程：使用聊天机器人获得答案，如果对某部分不理解，就提出后续问题。对于入门级的编程问题，这类聊天机器人通常能提供很好的答案。

编写你的第一个程序：Hello World

现在，有一个程序传统上是由无数新手程序员编写的，包括许多今天拥有杰出职业生涯的程序员。让我们来找出这个程序是什么。

我们可以询问聊天机器人：“传统上，新手程序员编写的第一个程序是什么？”

聊天机器人会回答，新手程序员传统上编写的第一个程序是“Hello World”程序。它简单地在屏幕上显示“Hello World”这句话。如果你想知道如何编写它，可以继续提问。

以下是让聊天机器人编写代码的示例：

print("Hello, World!")

这段代码告诉计算机打印出“Hello, World!”这条信息。在编程历史上，当你开始编程时，让计算机说“你好”是一种传统，仿佛你的程序第一次“醒来”时说：“你好，世界，我在这里。”

请注意：如果你使用ChatGPT、Claude或Gemini等第三方聊天机器人尝试类似的提示，可能需要明确告诉它你想使用Python编程语言。就像人类有多种语言一样，编程语言也有很多种。如果不指定Python，它可能会用其他编程语言告诉你如何打印“Hello World”。

修改与定制代码

上一节我们让聊天机器人编写了代码，本节中我们来看看如何修改它。如果你想修改代码，例如不说“Hello, World!”而说“Hello, Andrew!”，你也可以使用聊天机器人。

你可以给出这样的提示：“修改你刚刚写的代码，向‘我’问好，而不是向‘世界’问好。我的名字是Andrew。”

聊天机器人随后会生成修改后的代码：

print("Hello, Andrew!")

编写更复杂的代码

聊天机器人不仅能写简单的代码，还能编写更复杂的程序。让我们看一个例子。

假设你想写一段代码来计算圣诞节（12月25日）和你的生日（例如4月18日）之间有多少天（假设是非闰年）。你可以向聊天机器人提出请求。

以下是请求示例：
“编写一些代码来计算圣诞节（12月25日）和我的生日（4月18日）之间有多少天。假设是非闰年。”

聊天机器人可能会生成类似下面的Python代码：

from datetime import date

# 定义日期
christmas = date(2024, 12, 25)  # 假设年份为2024
birthday = date(2024, 4, 18)    # 假设年份为2024

# 计算天数差
delta = christmas - birthday
print(f"There are {delta.days} days between Christmas and my birthday.")

你可以将生日和节日替换成你自己的，让聊天机器人进行计算。

因为AI擅长编写简单的代码片段，这正在改变许多人的编码方式。我鼓励你亲自尝试，如果对代码的任何具体方面想深入了解，可以随时提出后续问题。

总结

本节课中我们一起学习了如何使用AI聊天机器人辅助编程。我们从提出基本问题开始，了解了“提示”和“响应”的概念。然后，我们让聊天机器人编写了传统的“Hello World”程序，并学习了如何通过后续提示来修改和定制代码。最后，我们还看到了聊天机器人处理更复杂计算任务的能力。在下一课中，我们将不仅查看代码，还要学习如何实际运行代码。

004：学习平台介绍 🖥️

在本节课中，我们将了解本课程将使用的编程环境——Jupyter Notebook。我们将学习其界面布局、核心功能以及如何运行代码。

界面概览

上一节我们介绍了如何使用聊天机器人获取代码。本节中，我们来看看实际运行代码的编程环境。在接下来的课程中，你会看到一个类似下图的界面。我想重点介绍几个主要部分。

• 左侧是导航窗格，可以像这样关闭或重新打开。
• 中间区域是你编写和运行代码的地方。
• 右侧是视频播放器。

平台功能

我将快速介绍这个学习平台的几个功能。你可以随时暂停视频进行休息、思考或试验代码。

以下是平台提供的一些控制选项：

• 你可以通过设置控制视频播放速度。
• 你可以将视频切换到画中画模式。
• 中间的分页栏可以调整编码区域与视频播放器的大小比例。
• 这个小箭头是另一种触发画中画的方式。点击它，视频会弹出为画中画；再次点击，视频会回到原处。

现在，让我们关闭左侧导航窗格，专注于中间的编码环境。

Jupyter Notebook 环境

这个编码环境叫做 Jupyter Notebook。它是许多专业程序员和数据科学家日常使用的工具。不过别担心，我们会一步步学习如何使用这些工具。

你可能还记得，在上节课中我们使用了聊天机器人。点击这个聊天按钮可以将其弹出。

好的，聊天机器人显示了代码。现在，我将点击这个按钮来复制代码，然后关闭聊天机器人。

如果我想运行这段代码，我会来到这个编码环境，点击光标位置，然后按下 Command + V（Mac）或 Ctrl + V（Windows）来粘贴刚从聊天机器人复制的代码。

现在，我来介绍 Jupyter Notebook 中可能是最重要的一个命令：Shift + Enter。

按住 Shift 键，然后按下 Enter 键，它就会运行这行代码，并输出“Hello World”。

在下一课中，我们将进行更多关于如何运行代码的练习，就像我刚才演示的那样。我邀请你尝试自己复制粘贴一些代码，然后用 Shift + Enter 运行。

注意事项与课程进度

有一点需要注意：这个平台只会保存你两个小时的工作。如果你在课程结束前停止，并在超过两小时后回来完成，笔记本将会重置，你需要从头开始并重新运行所有单元格。不过这也没关系。

这门短期课程包含多个不同的视频或课程，它们显示在左侧的导航栏中。我建议你按顺序一次学习一个课程。

当你完整看完每个视频后，对应的课程旁边会出现一个绿色的对勾。当所有这些都变成对勾，或者进度变成100%时，就表示你完成了本课程。

我也非常希望获得你对本课程的任何反馈，你可以点击左下角的“课程反馈”链接与我们分享。

总结

本节课中我们一起学习了本课程使用的学习平台。我希望你记住了最重要的命令：Shift + Enter。让我们进入下一课，开始运行你自己的计算机程序。

005：运行你的程序 🚀

在本节课中，我们将学习如何实际运行Python代码，而不仅仅是观看演示。你将亲手在Jupyter笔记本环境中执行代码，并学习如何利用聊天机器人来编写和调试简单的程序。

学习编程与学习一门新的人类语言有相似之处。你可以听老师讲解如何说法语或西班牙语，但除非你亲自开口练习，否则能真正掌握的内容是有限的。学习使用编程语言也是如此。仅仅观看他人操作是不够的，在合适的时机暂停视频，亲自尝试运行代码，这对你的学习至关重要。

运行你的第一行代码

在Jupyter笔记本区域，你需要做的第一件事是使用鼠标点击包含 print("Hello world") 的代码单元格，然后运行该命令。

现在，请按 Shift + Enter 键。计算机会打印出“Hello world”。如果你刚刚成功运行了这行代码，那么恭喜你！你已经加入了数百万通过运行这行代码开启编程冒险之旅的行列。

使用聊天机器人编写程序

接下来，我们将看看如何使用聊天机器人来编写稍微复杂一点的程序。我将首先演示一系列操作，然后请你暂停视频，自己完成相同的步骤。

我将打开聊天机器人，然后输入以下提示词：

修改下面的代码，让它向我问好。这是我的代码：
print("Hello world")
我的名字是Andrew。

我们希望代码不是向“世界”问好，而是向你个人问好。让我来演示一下。

1. 点击底部的聊天按钮，弹出聊天机器人窗口。
2. 输入上述提示词。请注意，请将我的名字“Andrew”替换成你自己的名字。
3. 聊天机器人可能会回复类似这样的代码：print("Hello Andrew")。
4. 点击按钮复制这段代码。
5. 将其粘贴到Jupyter笔记本的单元格中，然后按 Shift + Enter 运行。

现在，代码会说：“Hello, Andrew”。

如果你想从视频中复制文本到聊天机器人，这也是可以的。你可以高亮显示文本，然后使用 Command+C (Mac) 或 Ctrl+C (Windows) 复制，再粘贴到聊天机器人中。

现在，请你暂停视频，尝试让聊天机器人修改代码，让它向你问好，然后将代码粘贴到单元格中，让你的计算机向你打招呼。

添加注释

在代码中，你可能会看到以 # 号开头的一行文本，这被称为“注释”。

例如，一个单元格中可能包含：

# 这是一个注释，计算机将忽略它
print("这是一个打印语句")

如果你点击这个单元格并按 Shift + Enter 运行，计算机会打印出“这是一个打印语句”，而完全忽略注释行。作为开发者，我们有时会写一些注释文本，用来提醒自己或让其他阅读代码的人了解代码的用途。注释是包含在程序中的一种文本类型，计算机会忽略它。

现在，让我们看一个更复杂的Jupyter笔记本单元格（我们称每个这样的输入框为一个“单元格”），看看它会做什么。

以下是一个示例单元格的内容：

# 第一行是注释
# 第二行也是注释
# 第三行还是注释
print("Hello, Andrew")
# 另一个注释跟在打印命令后面
print("How's your day going?")

这个单元格有六行，但只有两行是命令（print语句），另外四行是注释。当我运行这个单元格时，它会打印：

Hello, Andrew
How's your day going?

而所有的注释都会被忽略。

再次请你暂停视频，点击进入Jupyter笔记本单元格，按 Shift + Enter 亲自查看结果。如果你有灵感，可以自由修改这个单元格，例如添加另一行注释（如 # blah blah blah），然后运行它，你会发现这些额外的注释行同样被忽略了。

处理错误（调试）

在编程时，我们所有人都会经常犯错误。我会打错字，在编码时会出错，这是编程中非常正常的一部分。以下是一段包含错误的代码，我们称代码中的错误为“Bug”。当你运行包含错误或Bug的代码时，有时会收到像这样的错误信息。有时我看到错误信息会想：“天啊，我完全不知道这是什么意思。”幸运的是，你可以询问聊天机器人如何修复代码。

让我们拿这段有Bug的代码，让聊天机器人为我们修复它。我将清除聊天记录，然后询问它：“这段代码有什么问题？我该如何修复它？” 然后它给出了解释：代码的问题是字符串的引号不匹配。并提供了修正后的代码：print("Hello, Andrew")。

我可以回到我的笔记本，编辑代码，或者直接粘贴正确的答案，然后运行它，这样就能修复问题。

在编程中查找和修复错误（也称为查找和修复Bug）的方式，因为聊天机器人的出现而发生了真正的改变。因为对于许多至少是简单的错误（比如我们这里的小拼写错误），聊天机器人非常擅长发现哪里出了问题。

如果你有兴趣，也可以使用聊天机器人向你解释错误信息。例如，你可以问它：“这个错误信息是什么意思？” 然后粘贴我们看到的错误信息。它实际上会对发生的情况给出相当不错的解释。现在，你可能不知道其中一些术语是什么意思，比如什么是“字符串”，或者“扫描字符串”是什么意思。在这门短期课程结束时，你将学会很多词汇，例如Python中的“字符串”是什么，这将帮助你理解此类信息。

练习

这几乎将我们带到了本课的结尾。在你观看完这个视频之后，在进入下一课之前，我希望你完成一些小的练习。

例如，尝试写一个打印语句，输出你最喜欢的颜色。我会做第一个示范：print("Blue, that is my favorite color.") 蓝色也是我儿子最喜欢的颜色（不是我女儿的）。

以下是你可以进行的练习：

• 练习打印语句：编写并运行print语句，让它输出“你今天感觉如何？”。
• 故意制造错误：我们都编写过有错误或Bug的代码。有时你甚至可以有意识地这样做，然后看看是否能通过聊天机器人修复错误。

我希望你在这些练习中玩得开心。当你完成后，让我们进入下一课，我们将开始讨论“数据”，这是AI以及Python程序的关键组成部分。我们下个视频见。

---

本节课总结：在本节课中，我们一起学习了如何在Jupyter笔记本中运行Python代码，包括执行简单的print语句。我们探索了如何使用聊天机器人来生成和修改代码，了解了代码中“注释”的作用。我们还初步接触了编程中常见的“错误”（Bug），并学习了如何利用聊天机器人来帮助理解和修复这些错误。最重要的是，你亲自动手进行了实践，这是学习编程不可或缺的一步。

006：如何成功学习编程 🚀

在本节课中，我们将学习一些高效学习编程的关键技巧。这些方法将帮助你更好地理解代码、利用工具并克服学习过程中的常见挑战。

概述

上一节我们成功运行了第一个程序。本节中，我们将探讨一系列实用的学习策略，帮助你更有效地掌握Python编程。

核心学习策略

以下是帮助你成功学习编程的几个关键方法。

动手实践与自我测试

首先，务必动手尝试代码，观看视频并实际运行程序。为了检验你对代码行的理解，可以尝试向自己提问。例如，思考如果漏掉一个引号，或者意外地使用了两个右括号而不是一个，会发生什么。然后修改代码，运行它，看看你的预测是否正确，以此进行练习。

完成练习与利用工具

我鼓励你完成所有实践练习。同时，你可以随时使用AI聊天机器人。请将AI聊天机器人视为你的伙伴或编程助手，它相当了解Python，非常有耐心，并且乐于提供帮助。在学习本课程时，你可能会产生一些“如果……会怎样”或“为什么”的问题。例如，“如果我那样做会怎样？”或“为什么它是那样的？”。尽管去问聊天机器人，想问多少就问多少。

理解代码与错误处理

你也可以让聊天机器人解释代码。有时，询问它“这段代码如何工作？”或“这是在做什么？”可以帮助你理解一段代码的实际功能。这也是当今专业软件开发者的常用做法。当遇到不理解的代码时，我有时也会将其粘贴到聊天机器人中，看看它是否能帮我解惑。在编写和运行代码时，第一次尝试就失败是完全正常的。出现错误和代码问题是可以预料的，毕竟这对你来说可能是一门全新的语言。

调整学习节奏与深化理解

就像第一次学习说西班牙语或法语时，你不可能第一次就说对每句话。学习新的编程语言时，你也应该预期自己不会第一次就全部做对。如果第一次尝试没有成功，那完全没关系。如果你能想到其他方法，就尝试不同的途径，或者向聊天机器人寻求帮助。事实上，聊天机器人也能帮助你阅读和理解错误信息。最后，与其只是将聊天机器人的答案复制粘贴到你的代码中，不妨也阅读一下聊天机器人的回复，看看它是否能提供新的视角或教会你一些东西，而不仅仅是给出答案。通过这种方式，希望你也能不断加深对编程的理解。

个性化学习建议

我希望你能按照自己的节奏自由学习。如果需要，可以随时暂停视频。我在在线学习时，也经常在觉得自己需要思考时暂停视频，直到我感觉已经理解并准备好继续时再回来。你可以自由选择快慢速度，确保自己真正理解了这些概念。学习编程非常有趣，我希望这些技巧能让这个过程对你来说更加愉快。

总结

本节课中我们一起学习了成功学习编程的多个核心策略：包括动手实践、自我提问测试、利用AI聊天机器人作为学习伙伴、理解而非复制代码以及按照个人节奏学习。掌握这些方法将为你后续的Python学习之路打下坚实基础。

接下来，让我们进入下一个关于Python中数据的视频课程。

007：数据与基础运算

在本节课中，我们将要学习Python编程中两个最核心的概念：数据和基础运算。我们将了解什么是数据，Python如何处理不同类型的数据，以及如何利用Python进行基本的数学计算。

什么是数据？

你可能听说过数据对于计算机编程和人工智能非常重要。数据是信息的载体。以下是日常生活中可能遇到的数据例子：如果你在网上搜索你国家的人口密度地图，那就是数据，它显示了特定区域的人口分布。如果你查看城市的每周天气状况，显示每日温度的数字也是数据。如果你查看股票价格的高低点，那些数字同样是数据。

Python能处理的数据类型

Python或其他计算机程序可以处理特定类型的数据。其中一种数据类型是文本数据。例如，“a”是一个文本片段，“egg”是一个文本片段，“我最喜欢的活动是徒步旅行”也是一个文本片段。Python可以打印文本，并且我们稍后会看到，它还可以对文本进行其他操作。

程序员也可以处理和操作数字，比如圆周率π（3.14）或其他数字。你可能听说过计算机处理的其他数据类型包括表格数据（如电子表格）、图片以及音频。计算机中几乎所有数据最终都会转化为文本或数字。

事实证明，图像是由像素组成的。计算机存储图像的方式是存储大量数字，这些数字可能表示每个像素显示多少红色、绿色或蓝色（三原色）。声音在计算机中也是存储为大量数字。声音是由空气压力的快速变化产生的，计算机通过将这些不同的空气压力测量值存储为一堆数字来存储声音。

因此，我们将要处理的两种最重要的数据类型是文本和数字。

文本数据：字符串

在Python中，文本被称为字符串。单词“string”来源于将“Hello world”视为一串字母的想法。要在Python中指定一个字符串，以下是关键组成部分：我们使用双引号来标记字符串的开始和结束，文本则位于这些引号之间。

从技术上讲，Python中的字符串是任何由双引号括起来的文本、数字或符号字符的组合。在这个字符串中，引号之间的所有内容都是字符串的一部分，包括空格。

以下是一些可以在Python中存储的字符串示例：

• "Hello world"
• "我最喜欢的饮料是拿铁"
• "😊" （一个有趣的表情符号）
• "2.99" （作为字符串存储的2.99）

我稍后会分享，将2.99作为字符串存储与作为数字存储有什么区别。

现在，事实证明Python还有另一种存储字符串的方式。如果你使用三引号，那么你可以存储一个多行字符串，即包含换行符的字符串。

以下是一个多行字符串的例子：

print("""Hello
world""")

我使用三引号，并在中间插入一个换行。如果我运行这段代码，你会看到所有这些空格实际上都是那个多行字符串的一部分。所以如果你不想要所有这些空格，你必须像这样运行它。请随时编辑代码并尝试。

相比之下，如果你尝试用单引号来写这个，将会生成一个错误信息。让我现在展示一下，因为这里有一个换行符，所以Python认为这是两行代码，第一行是带有关闭引号的print(“Hello，然后它试图运行这第一行，因此出现错误。而如果使用三引号，Python就知道你正在尝试写一个多行字符串，这不会产生错误。

检查数据类型

事实证明，Python允许你检查特定数据的类型。你已经见过这段代码print(“Hello world”)。print是一个函数或命令。我想向你展示一个不同的函数，即type函数。

如果你告诉Python type(“Hello world”)，那么它将输出str，这告诉你这是一个字符串。所以，type(“Andrew”)输出字符串str，因为这里的“Andrew”是一个字符串。

如果你对一个多行字符串这样做，它也是一个字符串。它与字符串“Andrew”的类型完全相同，只是字符串中包含的文本片段不同。

现在，如果我询问type(“2.99”)，这是一个字符串。现在让我做点不同的事情，我要说type(100)，结果是type(100)，这是一个数字，具体来说是一种称为整数的数字类型，意味着是没有小数部分的数字。

相比之下，type(2.99)的结果是float。浮点数是Python存储或表示数字的另一种方式，但是带有小数部分的数字。

因此，Python有两种主要的方式来存储/表示数字：整数和浮点数。

• 整数表示没有小数点的数字，如42、100、-90。
• 浮点数在小数点后有数字，如3.14、2.99、-0.03等。

请随时暂停视频，输入你自己的不同数字，并对它们运行print或type，看看得到什么结果。

使用Python作为计算器

我经常使用Python的一种方式是作为计算器。如果你想做加法，比如2加6，你实际上可以写一个Python命令：print(2 + 6)，或者print(57 - 40)，或者乘法和除法。

我在Python中这样做的原因是，如果我试图将所有数字相加并犯了错误，我可以回去编辑其中一个数字，并让Python重新进行计算。例如，如果我经营一家销售柠檬水的生意，我想汇总过去12个月的销售额，我可能会输入这样的内容并让它打印出总和。

但是，如果我发现实际上打错了字，我可以回去说：“哦，是的，在三月份，我们不是卖了43个单位，实际上是卖了45个单位。”然后只需编辑它，就能得到像这样的更新答案。因此，我发现使用Python比使用我个人手持计算器更方便，可以回去编辑这些计算。

到目前为止，我们只做了算术运算。事实证明，如果你有其他事情想做，比如你在银行账户里有存款，年利率为5%，你想知道10年后你有多少钱，那么你需要计算1.05的10次方。但如果你不确定如何操作，你可以去聊天机器人那里询问如何计算1.05的10次方。如果你这样做，它会显示这个答案，即使用双星号运算符：1.05 ** 10，结果是大约1.62。所以，你每有1美元，10年后最终会得到1.62美元。

运算顺序

在Python中操作数字时，需要注意的一点是运算顺序。如果你要将温度从华氏度转换为摄氏度，那么你必须先从华氏温度中减去32，然后乘以5/9。

所以，如果是75华氏度，你想把它转换为摄氏度。如果你写这段代码：

print(75 - 32 * 5 / 9)

那么Python会先执行乘法，这将导致错误的答案。因此，像这样使用括号可以告诉Python你希望以什么顺序执行这些操作。运算顺序与普通数学相同，即先乘除后加减。

这就是为什么这段代码会生成从华氏度到摄氏度的错误转换，而这段代码：

print((75 - 32) * 5 / 9)

会生成正确的转换，其中75华氏度等于23.889摄氏度。

总结

本节课中我们一起学习了Python中的数据类型，以及如何将Python用作计算器。这本身就是一个非常强大的工具。在进入下一个视频之前，我鼓励你尝试笔记本末尾的练习，以巩固所学内容。请始终记住，在学习代码时，你可以随时向聊天机器人寻求帮助。养成向聊天机器人提问的习惯是非常有用的。

在下一个视频中，我们将学习Python中一种关键的打印技术，称为F字符串，这将允许你一起打印字符串和数字。请尝试这些练习，我们下个视频再见。

008： 结合文本与计算 📝➗

在本节课中，我们将要学习如何将文本数据（字符串）与我们已掌握的数值计算结合起来，并通过 print 命令一并显示出来。为了实现这一目标，我们将重点介绍 Python 中一个非常实用的工具：F-字符串。

回顾与问题引入

上一节我们介绍了字符串、整数和浮点数，以及如何使用 print 命令显示数据和进行基础计算。例如，我们可以用 Python 作为计算器，将 75 华氏度转换为摄氏度：

print((75 - 32) * 5 / 9)

但如果我们希望打印出更完整的句子，比如“温度 75 华氏度等于 xx 摄氏度”，直接运行以下命令会如何？

print("温度 75 f in degrees Celsius is", (75 - 32) * 5 / 9)

运行后，输出会是：“温度 75 f in degrees Celsius is 23.88888888888889”。这虽然包含了答案，但文本和数字是分开的。如果我们希望将计算结果直接嵌入到句子中，就需要用到 F-字符串。

什么是 F-字符串？

F-字符串，即格式化字符串，是 Python 中用于将表达式嵌入字符串字面量的一种简洁方法。它通过在字符串前加前缀 f 或 F 来创建。

以下是其基本用法：

print(f"温度 75 华氏度等于 {(75 - 32) * 5 / 9} 摄氏度。")

运行这段代码，输出为：“温度 75 华氏度等于 23.88888888888889 摄氏度。”。可以看到，花括号 {} 内的计算表达式被其结果值替换了。

F-字符串的工作原理

为了更好地理解，我们来对比一下普通字符串和 F-字符串的处理过程。

• 普通字符串：print("Isabel is 20 years old.")。Python 的 print 函数识别括号内的字符串，并原样输出每一个字符。
• F-字符串：print(f"Isabel is {20 / 7} dog years old.")。Python 会：
  1. 识别这是一个以 f 开头的格式化字符串。
  2. 查找字符串中的花括号 {}。
  3. 计算花括号内的表达式（此处为 20 / 7，结果是 2.857...）。
  4. 将计算结果转换为字符串，并替换掉原来的花括号及内部表达式。
  5. 最终输出替换后的完整字符串：“Isabel is 2.857142857142857 dog years old.”

控制输出格式

有时我们希望对嵌入的计算结果进行格式化，例如只保留整数或指定位数的小数。

例如，上面的狗年龄例子输出为 2.857...。如果我们希望输出为整数（四舍五入），可以向花括号内的表达式添加格式说明符。

原始代码：

print(f"Isabel is {20 / 7} dog years old.")

通过向 AI 助手（如课程中的聊天机器人）提问：“如何修改代码以输出不带小数位的整数？”，我们可以获得帮助。修改后的代码可能如下：

print(f"Isabel is {20 / 7:.0f} dog years old.")

输出变为：“Isabel is 3 dog years old。”。

格式说明符 :.0f 表示将数字格式化为浮点数，并保留 0 位小数。同理：

• :.1f 会保留一位小数。
• :.2f 会保留两位小数。

核心要点：你无需死记硬背这些格式语法。重要的是掌握如何利用工具（如 AI 助手）来帮助你实现特定的代码修改需求。

多行 F-字符串

F-字符串也可以用于多行文本，只需使用三引号 """ 定义字符串即可。

以下是一个将美制与公制单位进行转换的例子：

print(f"""
美制与公制单位转换：
8 液体盎司的牛奶等于 {8 * 29.5735:.2f} 毫升。
500 毫升的水等于 {500 / 29.5735:.2f} 液体盎司。
""")

输出结果为：

美制与公制单位转换：
8 液体盎司的牛奶等于 236.59 毫升。
500 毫升的水等于 16.91 液体盎司。

本节总结与展望

本节课中我们一起学习了 F-字符串 的用法。它通过在字符串前加 f 前缀，并使用花括号 {} 包裹表达式，能够将计算的结果直接、整洁地嵌入到文本中输出，极大地提升了代码输出结果的可读性。

你可能已经注意到，虽然 F-字符串解决了问题，但当计算公式较复杂时，直接将其写在花括号内会使字符串看起来有些杂乱（例如 f"温度 {(75 - 32) * 5 / 9} 摄氏度"）。在下一节课中，我们将介绍编程中一个非常核心的概念：变量。使用变量可以存储中间计算结果，让 F-字符串（乃至整个代码）变得更加清晰易读，也更容易维护。

课后，请务必尝试 Jupyter Notebook 底部的练习题，实践使用 F-字符串，让你的代码能够以格式优美的形式输出数学计算结果。

009： 变量与F-strings 🐍

在本节课中，我们将要学习计算机编程中的一个核心概念：变量。我们将了解变量是什么、如何创建和使用它们，以及如何将变量与F-strings结合来生成动态文本。掌握这些知识是编写高效、灵活程序的基础。

什么是变量？

在计算机编程中，变量是一个与数据存储和处理方式相关的基本概念。

让我们来看看这意味着什么。

请按照我的顺序，从上到下运行本课中的每一个代码单元格。

这一点很重要。如果你不按相同顺序运行每个代码单元格，可能会出现意外的错误。

创建与使用变量

让我用一个代码片段开始说明。我将输入 age = 28。

这行代码的作用是创建一个变量，并将值 28 存储到其中。所以现在如果我输入 print(age)，你猜会发生什么？它会打印出数字 28。

让我们详细看看刚才发生了什么。通过代码行 age = 28，你是在告诉Python创建一个空间（你可以把它想象成一个空盒子）来存储数字 28。因此，每当我使用这个变量 age 时，Python就知道我指的是 28。

现在，我可以决定改变 age 存储的内容。如果我有一行代码写着 age = 5（我女儿的年龄），那么这行代码的意思是：忘记我们之前存储在盒子里的旧值 28，把它清除掉，然后把新值 5 存储到这个盒子里。所以现在 age 等于 5。

用代码来说明这一点。此刻，age 等于 28，但接下来我会输入 age = 5，然后输入 print(age)。age 现在已经被数字 5 替换了。

变量的数据类型

变量可以用来存储字符串或数字。

在我们看到的例子中，我们将值 28 赋给了 age。或者，你可以有一个名为 name 的变量，并给它赋一个字符串值，比如 "Otto"。或者，如果你有一个游戏，你可以创建一个名为 no_height 的变量，并保存数字 12.7。

让我们看看这在代码中是如何工作的。我将输入 name = "Otto" 和 no_height = 12.7。如果我使用一个F-string来打印变量 age，这将打印出 age 5。类似地，既然我已经将 name 设为 "Otto"，将 no_height 设为 12.7，我就可以打印 name Otto no_height 12.7。

变量命名规则

在定义变量时，使用完全相同的名称很重要。

所以，如果我把 no_height 改成 No_Height，这将无法工作，会生成一个错误信息。因此，我必须使用完全相同的名称才能正确。将字母从小写切换为大写会混淆Python。

变量的常见用途

变量可以用来给一个值（比如某人的年龄）起个名字，以便在后面一个或多个地方使用。

变量的另一个常见用途是使用相同的名称来引用一个会变化的值。

例如，如果你在玩俄罗斯方块游戏，你的分数可能从零开始。但玩了一会儿之后，你的分数变成了50，然后是150，然后是450。游戏结束后，你保存了最高分来纪念你玩俄罗斯方块的成就。

在这个例子中，你的分数可能从零开始，但之后你在游戏中又获得了50分，我们可以设置 score = score + 50。这意味着：取 score 的旧值，给它加上50，然后使用赋值运算符 = 告诉计算机，请用 score 的新值（即 score + 50）替换旧值。

现在，如果你再获得100分，你将取 score 的旧值（即50），加上100，然后将结果存储到标签为 score 的盒子里。所以现在你的分数是150。如果你在游戏中再获得300分，现在 score 就是450。如果你打印你的最终分数 print(score)，这将打印出450。

变量命名注意事项

现在，关于变量名的一些注意事项。如果你尝试 my score = 450，这只会生成一个错误信息，因为变量名不能包含空格。如果你想要一个空格，可以使用下划线 _ 来代替，像这样 my_score，这样就能工作。

如果我没有告诉你这一点，你也可以从聊天机器人那里找到答案。你可以问：“为什么这段代码 my score = 450 不工作？” 然后它会告诉你，你可以放一个下划线，或者直接去掉空格。

一个实用的例子：计算狗狗年龄

让我们看一个有趣的狗狗年龄计算的例子。

假设我们的朋友Otto是49岁。如果你想计算他的“狗狗年龄”（按人类年龄除以7算），你会打印 49 / 7，结果是7。如果你想打印出Otto的狗狗年龄，你可以这样做：print(f"Otto's dog age is {49/7}.")，这将输出 Otto's dog age is 7.0.。

我可以定义变量 dog_age = 49 / 7。现在 dog_age 将等于七。这变得方便的地方在于，如果我想写一段多次引用Otto狗狗年龄的文本。在没有变量之前，你可以这样写，但需要多次重复写 49/7 有点烦人。而且，如果Otto长大了一岁，我们需要在代码中多处将 49 改为 50。

实际上有一个更好的方法，就是使用这段代码，只计算一次 dog_age，然后打印出相同的结果。如果Otto年龄增长了一岁，你只需设置 dog_age = 50 / 7。然后，如果我重新运行这段代码，它现在会在所有不同的地方更新。

所以，通过定义一次变量，你可以在多个地方使用它。这就是为什么变量有助于使计算机程序更加高效。

你甚至可以更改名字 Otto。如果你决定用他的姓氏来称呼他，比如 Otto Matic，那么你可以重新运行这段代码，然后这个名字就会在所有三个地方打印出来。Otto，Maddie，希望你们听懂了这个笑话。

F-strings 与变量如何协同工作

为了详细说明F-strings和变量如何一起工作，这是我们刚才的一个例子，其中 dog_age 是7。

所以，当Python在花括号 {} 中找到 dog_age 时，这会导致它去查找一个名为 dog_age 的盒子。在那里它找到了数字 7.0，然后用 7.0 替换了F-string中的那部分。对于另外两个地方也是如此，这就是为什么它随后打印出了你在代码中看到的字符串。

你在这里看到的这种F-string模式——你有一些文本，并插入一个变量的值来定制字符串——事实证明，这种模式对于定制提示词非常有用，然后你可以通过Python程序将其传递给AI大语言模型。

练习与下一步

所以，请花些时间通过尝试下面的练习来练习一起使用F-strings和变量。与聊天机器人交流，帮助你解决可能遇到的任何问题。当你准备好后，请在下一个视频中与我一起，更深入地了解如何使用F-strings为大型语言模型构建提示词。

总结

本节课中，我们一起学习了：

1. 变量是存储数据的“命名盒子”，使用 变量名 = 值 的语法创建。
2. 变量可以存储不同类型的数据，如数字和字符串。
3. 变量名需遵循规则（如不能包含空格），且区分大小写。
4. 变量的核心价值在于一次定义，多处使用，并能方便地更新值，使代码更高效、易维护。
5. F-strings（格式字符串）允许我们将变量值直接嵌入到字符串中，语法为 f"一些文本 {变量名}"。
6. 这种组合是动态生成文本（包括给AI模型的提示词）的强大工具。

通过掌握变量和F-strings，你已经为编写更复杂、更智能的Python程序打下了坚实的基础。

010：使用变量构建LLM提示词

在本节课中，我们将学习如何结合变量和F字符串来定制和快速更新字符串，并进一步探索如何将这一模式扩展到创建提示词，以便在Python程序中与AI模型进行交互。

概述：从静态字符串到动态提示词

上一节我们介绍了如何使用变量和F字符串来动态生成字符串。本节中，我们来看看如何利用这一技巧，构建能与大型语言模型交互的提示词。

导入辅助函数

首先，我们需要导入一个辅助函数，以便通过Python代码直接与大型语言模型交互。请按顺序从上到下运行代码单元格。

from helper_functions import print_llm_response

不必过于担心这行代码的具体细节。它的作用是加载一个函数，让你能够通过Python代码直接调用大型语言模型。

调用语言模型

要使用这个函数，你可以输入 print_llm_response，然后在括号内输入你的提示词。

print_llm_response("What is the capital of France?")

这段代码实际上调用了ChatGPT，并返回了答案：“The capital of France is Paris”。

括号内的字符串就是提示词，它与你在ChatGPT等聊天机器人网页界面中直接输入的文本是同一类型。

构建动态提示词

现在，你可以运用目前学到的所有Python编程知识，构建包含变量的复杂提示词，然后通过这段代码将其传递给大型语言模型。

以下是一个有趣的例子。我们可以用变量来构建一个关于宠物年龄的提示词。

dog_age = 21 / 7  # 计算结果为3
print_llm_response(f"If a dog is {dog_age} years old in human years, what kind of personality might it have?")

通过使用变量构建F字符串，再将其传递给聊天机器人，你可以得到非常有趣且富有深度的回答。

调试与错误修复

现在，让我们看几个使用变量的例子，并了解一些常见的错误及其修复方法。

假设我们要写一个儿童故事，其中包含驾驶员、车辆和星球等变量。

driver = "unicorn"
vehicle = "a colorful asymmetric dune car"
planet = "Pluto"
print_llm_response(f"Write a children's story about a {driver} racing in {vehicle} on the planet {planet}.")

这段代码存在几个错误。我鼓励你暂停视频，看看是否能发现其中的问题。

以下是修复过程：

1. 变量名中不能有空格或撇号。应使用下划线，例如 driver_vehicle。
2. 在F字符串的 {} 内部不能有空格。
3. 需要确保所有括号和引号都正确闭合。

修复后的代码如下：

driver = "unicorn"
vehicle = "a colorful asymmetric dune car"
planet = "Pluto"
print_llm_response(f"Write a children's story about a {driver} racing in {vehicle} on the planet {planet}.")

运行后，语言模型就会生成一个约300字的儿童故事。

我鼓励你尝试插入不同的驾驶员、车辆，自己运行代码，获得属于你自己的儿童故事。

课程总结与练习

本节课即将结束。请查看Jupyter笔记本末尾的练习题，以练习你的代码编写和调试技能。和之前一样，如果遇到困难，请记住你可以使用聊天机器人来帮助你完成这些练习。

在本节课中，我们看到了几个函数：print、print_llm_response，在之前的视频中还看到了 type。在下一个视频中，我们将更深入地探讨函数：它们是什么以及如何使用它们。下个视频见。

011：函数 🧩

在本节课中，我们将要学习Python编程中一个非常核心的概念：函数。函数就像是大型程序中的迷你程序，用于执行特定的任务。通过函数，我们可以对数据进行操作，或者与世界进行交互。让我们开始深入了解。

什么是函数？

在上一节课中，我们接触了来自辅助函数的命令。现在，让我们更深入地探讨函数的工作原理。

函数允许你对数据采取行动或在现实世界中执行操作。你已经在本课程中遇到并使用过几个不同的Python函数。

第一个是 print 函数，你可以用它来向屏幕显示文本，例如一个有趣的表情。

😊

在之前的视频中，你看到了一个更复杂的函数 print_OEMM_response。这个函数接收一个字符串作为输入（例如你的提示“法国的首都是什么”），通过互联网将其发送给一个大语言模型，然后将AI的响应显示在屏幕上。

实际上，你还见过另一个函数：type 函数。它可以告诉你一个值或变量的数据类型，例如字符串、浮点数或整数。

所以，你看到了 print、print_own_response 和 type。这些都是我们在课程中使用的函数。在本节课中，我想更深入地探讨函数的具体工作原理。

函数的输入与输出

Python中有一个叫做 len 的函数，它代表长度。如果你输入 len("Hello world")，它会将字符串“Hello world”作为输入，并计算其长度，具体来说是字符串中包括标点和空格在内的字符数量。

然后当我打印出结果时，会显示 12。

这是另一个Python函数的例子：round。它接收一个数字，比如 42.17，并将其四舍五入到最接近的整数。如果我们打印 round(42.17) 的结果，会得到 42。

函数的一个常见用途是执行数据计算并返回某个值。例如，len 函数接收输入数据，计算字符数，然后返回答案。或者 round(42.17) 计算42.17四舍五入后的值，然后返回 42。

有时函数用于执行一个动作，例如显示一条信息。所以 print("Hello world") 接收字符串“Hello world”并将其显示出来。

函数调用详解

让我们仔细看看当你对“Hello world”调用 len 函数时具体发生了什么。

len 是函数的名称。当你调用一个函数时，你使用括号来给它数据。在这个例子中，字符串“hello world”就是你提供给 len 函数的数据。你提供给函数的数据在术语上被称为参数。如果你好奇为什么叫参数，可以去问聊天机器人。

当一个函数返回一个数字（比如 12）时，我们说函数返回了这个结果。

我们也看到了 print 函数，它显示你提供的内容。print 是函数名，我们照常使用括号，括号内是参数，也就是提供给 print 函数的数据字符串“hello world”。

使用函数返回值

到目前为止，在我们使用的例子中，我们是从函数获取结果然后立即打印出来。

😊

但是，你不必立即打印出函数的结果。我可以定义一个变量 string_length = len("Hello world")，然后我们可以打印 string_length，这将打印出 12。

所以在我刚刚运行的代码中，你看到了这个命令 string_length，这是我们正在创建的一个新变量的名称，也就是一个存放数据的新盒子。赋值运算符 = 然后 len("Hello world") 返回数字 12，所以这表示将变量 string_length 设置为等于 12，也就是把数字 12 放入标记为 string_length 的盒子中。

在你把 12 放入这个盒子之后，如果你随后打印 string_length，它将打印出数字 12。

一个更复杂的例子

这里有一个更复杂的例子。

我将设置 name 为“Tommy”。😮
设置 potatoes = 4.75。

然后我将写一个提示，这是一个 f-string：
f"写一首关于我的朋友 {name} 的对句诗，他大约有 {round(potatoes)} 个土豆。"

然后 response = get_response(prompt)。

并打印响应。

这里的 get_response 是一个我们之前没有使用过的新函数，但它所做的与 print_element_response 完全相同，只是它不打印出响应，而是（在这种情况下）调用ChatGPT，获取响应，并将其作为一个值返回，然后我们将其存储在这个变量 response 中。

😊

这将创建提示：“写一首关于我的朋友 Tommy 的对句诗，他大约有5个土豆。” 然后要求AI写一首对句诗。

希望这能让你了解如何使用变量将更复杂的计算串联起来。事实上，对于使用生成式AI编写软件的开发者来说，这种编程模式是你经常会看到的：你有一些变量，构建一个提示，调用大语言模型，获取响应，然后在该响应的基础上做其他事情。

😊

课程总结与展望

以上就是本课的全部内容，祝贺你并为你完成这个简短课程的努力点赞！

你已经学习了Python的基础知识，包括数据类型、如何进行数学运算、变量、如何使用函数，以及如何使用Python代码与大语言模型进行交互。

看完这个视频后，请务必尝试Jupyter笔记本底部的额外练习，因为只有通过练习，你才能真正学习并熟练使用Python。

请记住，任何时候如果你遇到困难，都可以咨询聊天机器人寻求帮助或建议，它是一个非常有用的解决问题的伙伴。

当你完成这些后，我希望你能加入我的下一个课程，学习更强大的Python功能。你将学习如何让计算机一遍又一遍地做同样的事情，以及如何根据计算机看到的数据让它采取不同的行动。

😊

随着你不断学习，我相信你会享受用Python和AI做越来越多令人惊叹的事情。

再次祝贺你完成本课程，期待在下一门课程中见到你。

😊

012：使用Python自动化任务 🚀

概述

在本节课中，我们将要学习如何使用Python自动化重复性任务。我们将基于上一课学到的Python基础知识，探索如何让计算机根据我们的指令，自动、准确地执行重复操作和决策。通过本课的学习，你将能够编写代码来处理更复杂的数据，并让程序根据条件自动做出选择。

计算机是完成任务的绝佳工具

计算机能够出色地完成各种任务。例如，它可以在一整本书中搜索特定词汇，备份你的家庭照片，帮助你管理个人笔记集，或者对工作中成千上万行的销售数据进行计算。计算机乐于一遍又一遍地执行相同的工作，并且能做到准确、可预测，有时速度还非常快。

此外，计算机还能自动做出决策或帮助你进行决策。例如，我们稍后会看到一个有趣的例子，使用人工智能来帮助你决定应该优先处理哪些工作。我们可以让它审视哪些任务优先级更高，从而帮助你专注于待办事项清单中优先级较高的任务，而非那些较低优先级的任务。

课程内容衔接

在上一门课程中，你学习了一些Python基础知识，例如什么是数据、数据类型、如何进行运算，以及Python中的变量和函数是什么。

本课程将基于这些核心概念，深入讲解如何通过编写代码，让Python自动化执行任务。你将学会如何指示计算机重复执行动作，并一遍又一遍地做出决策。

你将学到的内容

我们将看到一些有趣的示例，包括一些更复杂的、指示Python存储数据的方法。你还将学习一些特殊的编码模式，即所谓的控制语句。这些语句能让计算机根据所看到的数据，自动决定执行或不执行某些操作。

这在任务优先级排序或使用AI创建食谱（例如根据朋友的饮食偏好决定是否包含某些食材）等场景中非常有用。

实践与应用

在本课程中，你将逐步构建一些AI工具。我希望这些工具能对你有所帮助。例如，如果你为朋友下厨，它们或许能帮你定制食谱；或者帮助你执行高优先级任务；甚至帮你起草一封给老板的关于即将到来的晋升的邮件，或者为朋友构思一封体贴的生日贺卡。

在此过程中，你将持续使用AI聊天机器人来辅助学习和编程。我们将继续探索如何向聊天机器人询问Python的工作原理，或者让这位聊天伙伴帮助你编写代码、查找代码中的错误。

课程目标

本课程包含大量精彩内容。到课程结束时，你的技能将得到显著提升。你将基于上一门课程打下的基础，能够做更多事情，让计算机为你自动化处理任务。

下一节预告

接下来，让我们进入下一个视频，学习Python中一种名为列表的新数据类型。之前你学习了变量，它可以存储一个数字或一个字符串，类似于一个数据片段。而列表则可以容纳多个数据片段。让我们进入下一个视频来详细讨论它。

总结

本节课中，我们一起学习了使用Python进行任务自动化的核心思想。我们了解到计算机擅长重复和决策，并回顾了如何在本课程中基于已有知识进行拓展。接下来，我们将开始学习列表这一能够存储多个数据项的强大工具，这是实现自动化的重要一步。

013：使用列表管理任务 🗂️

在本课程中，你将学习如何用Python代码自动化任务，处理重复性工作，并让程序有时为你做出决策。

在之前的课程中，你处理的数据始终是单个项目，例如一个名字、一个年龄或其他单一数据。但Python有一种称为“列表”的功能，可以将多个数据片段存储在一起。这确实能让Python更轻松地为你执行重复性任务。

创建你的第一个列表

上一节我们介绍了单一数据，本节中我们来看看如何使用列表来存储多个数据。

让我们看看如何在Python中使用列表。首先导入我们将在本笔记本中使用的一些函数。

# 导入必要的函数
from utils import get_completion, print_response

现在，假设我想为我的三位朋友写一首诗。以下是我们如何使用大语言模型来实现。

我将设置变量 name 为我的三位朋友中的第一位朋友的名字，即 Tommy。然后，使用你在上一课程中学到的 f-string 来构建提示词。

name = "Tommy"
prompt = f"""Write a full-line birthday poem for my friend {name}.
The poem should rhyme and start with the first letter of my friend's name."""
print_response(get_completion(prompt))

运行后，我们得到了一首给Tommy的诗。这很酷。

现在，我想为三位朋友都写诗。如果我想继续为第二位朋友写，我需要将变量 name 设置为 Isabel，然后再次运行提示词。最后，为第三位朋友 Daniel 重复此过程。

你看到了吗？写三首诗的过程有点重复。我必须在这里设置三次不同的名字值，然后运行提示词并打印响应三次。事实证明，在Python中使用列表可以让你同时存储所有三位朋友的名字，最终为你提供一种更高效的方式来生成这三首诗。

列表的结构与访问

以下是创建第一个列表的方法。

friends_list = ["Tommy", "Isabel", "Daniel"]

这段代码创建了一个名为 friends_list 的新变量，它存储了三个数据片段：Tommy、Isabel 和 Daniel。

你可以将列表想象成一组小盒子或卡片，如下图所示，每个盒子可以容纳一个数据片段。friends_list 就像一个小拖车，将这三张卡片组装在一起。

每张卡片还有一个与之关联的数字，即 0、1 和 2。虽然人们通常从 1 开始计数，但计算机和Python编程语言喜欢从 0 开始计数。因此，第一张卡片（Tommy）的编号是 0，第二张（Isabel）是 1，第三张（Daniel）是 2。当你想要引用列表中的特定项目（有时称为元素）时，这些数字很重要。

让我们回顾一下创建列表所需的确切代码：

• friends_list 是列表的名称。
• 等号表示将 friends_list 设置为等于右侧的列表。
• 方括号 [ 和 ] 表示列表的开始和结束。
• 中间是列表的元素或项目，用逗号分隔。

你可以使用 type() 函数查看 friends_list 的类型，它会返回 list。你也可以使用 len() 函数来获取列表的长度。

print(type(friends_list))  # 输出: <class 'list'>
print(len(friends_list))   # 输出: 3

现在我们已经创建了一个同时存储三位朋友名字的列表，我可以创建一个像这样的提示词：

prompt = f"Write a full-line birthday poem for my friends {friends_list}"
print(prompt)

这会生成提示词：“Write a full-line birthday poem for my friends ['Tommy', 'Isabel', 'Daniel']”。大语言模型足够智能，能够理解这个提示词并写出三首诗。

访问和修改列表元素

上一节我们创建了列表，本节中我们来看看如何访问和修改其中的特定元素。

要访问 friends_list 中的一个特定元素，例如第一个朋友的名字，我们可以询问AI助手。

它告诉我们：

你可以通过 friends_list[0] 访问第一个朋友（Tommy），friends_list[1] 访问 Isabel，friends_list[2] 访问 Daniel。

# 访问列表元素
print(friends_list[0])  # 输出: Tommy
print(friends_list[1])  # 输出: Isabel
print(friends_list[2])  # 输出: Daniel

请注意，我们使用的是方括号 []，而不是圆括号 ()。如果使用圆括号，会导致错误。遇到错误是编码过程中的正常部分，你可以随时将错误信息复制到聊天机器人中，让它以更易于理解的方式向你解释。

如果你尝试访问不存在的元素，例如 friends_list[3]，Python会报错“list index out of range”，因为索引3超出了列表的范围（只有索引0、1、2）。

Python还提供了一些很好的工具来修改列表中的元素，你可以添加、删除、编辑项目等。

以下是向列表添加元素的方法：

friends_list.append("Otto")
print(friends_list)  # 输出: ['Tommy', 'Isabel', 'Daniel', 'Otto']

append 方法将新元素添加到列表的末尾。我鼓励你暂停视频，尝试在这个包含四位朋友的列表后再添加一个名字。

除了添加元素，你也可以删除元素。假设你使用列表来跟踪需要发送生日贺卡的朋友，而Tommy已经过完生日，你已发送贺卡，那么可以将其从列表中移除。

friends_list.remove("Tommy")
print(friends_list)  # 输出: ['Isabel', 'Daniel', 'Otto']

请你自己尝试修改代码，从列表中移除其他名字并打印出来，看看是否得到了正确的结果。

列表存储多种数据类型

到目前为止，我们一直使用列表来存储字符串或人名。实际上，列表也可以存储其他类型的数据。

例如，如果你想存储朋友的年龄，可以有一个包含三个数字（整数）的列表。

ages_list = [25, 30, 28]
print(ages_list)  # 输出: [25, 30, 28]

在本课程后面，我们将使用Python来帮助我们对要执行的任务进行优先级排序。

以下是一段较长的代码，创建了一个任务列表：

list_of_tasks = [
    "Compose a brief email to my boss explaining I'll be late for tomorrow's meeting.",
    "Write a birthday poem for Otto.",
    "Write a review of the movie The Arrival."
]

这创建了一个包含三个字符串的列表，每个字符串都是一项任务。在Python中，你可以将列表分布在多行代码上，这比将所有内容放在一行中更容易输入和阅读。

事实上，list_of_tasks 中的每一项都是你可以要求大语言模型做的事情。

我们可以这样做：

task = list_of_tasks[0]
print_response(get_completion(task))

这会生成给老板的邮件。如果我想处理下一项任务，可以设置 task = list_of_tasks[1]，依此类推。

通过编写这三段代码，我们依次将 task 设置为 list_of_tasks[0]、list_of_tasks[1]、list_of_tasks[2]，并打印出对这些任务的LLM响应，从而处理了这个待办事项列表中的不同元素。

但这仍然有点重复。我们必须手动输入并运行这段代码三次，以分别处理列表中的每个元素。事实上，如果你的待办事项列表有10项或20项，手动输入并运行这段代码20次会有点烦人和重复。

在下一个视频中，你将学习一种更好的方法来实现这一点——循环。这是一种告诉Python为你反复执行任务的方式。

让我们进入下一个视频，看看它的实际应用。

---

总结

在本节课中，我们一起学习了Python列表的核心概念。我们了解了如何创建列表来存储多个数据项，如何通过索引访问列表中的特定元素，以及如何使用 append() 和 remove() 等方法修改列表内容。我们还看到列表可以存储不同类型的数据，并初步体验了如何利用列表来管理待办任务。虽然手动处理列表中的每个项目是可行的，但效率不高，这为我们下一课学习更强大的循环结构做好了铺垫。

014：使用for循环重复任务 🚀

在本节课中，我们将学习编程中一个非常重要的概念：for循环。这是一种在许多编程语言中都存在的特殊代码模式或命令，它允许你告诉计算机以自动化的方式，对列表中的每一项重复执行操作，而无需一遍又一遍地重写代码。

什么是for循环？ 🔄

上一节我们介绍了列表的概念，本节中我们来看看如何高效地处理列表中的每一个元素。

for循环让你能够为列表中的每个元素重复执行一组命令。如果你有一个包含许多数据项的列表，for循环可以让你告诉计算机对第0项、第1项、第2项……直到列表中的所有项，都执行相同的操作。

for循环的基本语法 📝

以下是使用for循环的代码结构：

for task in list_of_tasks:
    print(get_llm_response(task))

用通俗的语言解释，这段代码的意思是：对于list_of_tasks中的每一个task，都打印出对该任务的LLM响应。

这段代码等同于手动编写以下多行代码：

print(get_llm_response(list_of_tasks[0]))
print(get_llm_response(list_of_tasks[1]))
...

让我们详细解析这段代码的每一部分：

• for：这是一个for命令或语句的开头。
• task：这是你为变量定义的名称，它将依次取值为list_of_tasks[0]、list_of_tasks[1]、list_of_tasks[2]等等。因此，task将轮流成为list_of_tasks中不同元素的值。
• in：这是另一个特殊的Python关键字。
• list_of_tasks：这是我们要遍历的、包含元素的列表。
• :：我们使用冒号来告诉Python，我们希望对列表中每一项运行的命令从哪里开始。
• print(get_llm_response(task))：这是它将在列表每个元素上重复执行的命令。

这段代码的一个特殊部分是这里有四个空格。在编程中，我们称之为缩进。这意味着print(get_llm_response(task))这行代码被缩进或向右移动了四个空格。按照惯例，Python程序员使用四个空格，建议你遵循这个惯例。

实践for循环 💻

让我们看一个实际的代码示例。假设我们已经像上节课那样加载了一些辅助函数，并且有一个任务列表。

list_of_tasks = ["Write a poem", "Draft a birthday message", "Summarize a review"]

现在，我们可以使用for循环自动化处理：

for task in list_of_tasks:
    print(task)

运行这段代码，你会看到task每次都被替换为list_of_tasks列表中的一个项目。

接下来，我们可以结合LLM来生成响应：

for task in list_of_tasks:
    print(get_llm_response(task))

运行后，计算机会依次处理第一个任务、第二个任务（生日消息）和第三个任务（总结评论）。

常见错误与调试 🐛

以下是使用for循环时的一些常见错误：

1. 忘记缩进：如果print语句前没有四个空格（即没有正确缩进），代码将报错。
2. 忘记冒号：在for语句末尾忘记写冒号也会导致语法错误。

如果你遇到错误但不确定如何修复，一个有效的方法是向你的AI聊天机器人伙伴求助。例如，你可以说：“请帮我调试这段代码”，然后粘贴你的代码。AI通常能快速指出问题所在，比如缺少冒号，甚至为你修复代码。自从AI聊天机器人广泛可用以来，程序员通过复制粘贴代码让AI帮助找出错误，已经大大提高了调试效率。

进阶示例：生成冰淇淋描述 🍦

这里有一个更实际的例子：使用大语言模型自动化写作任务，特别是创建冰淇淋口味描述。

首先，我们有一个冰淇淋口味列表：

ice_cream_flavors = ["vanilla", "chocolate", "strawberry", "mint chocolate chip"]

以下是生成描述的代码：

for flavor in ice_cream_flavors:
    prompt = f"For the ice cream flavor listed below, provide a captivating description that you'd use for promotional purposes.\n\n{flavor}"
    print(get_llm_response(prompt))

运行后，你会得到香草、巧克力、草莓和薄荷巧克力片冰淇淋的描述。

关键点：整个代码块（从prompt = ...到print(...)）都必须缩进。Python通过查看哪些代码被缩进来判断哪些代码是你希望为每个冰淇淋口味运行一次的。如果只有部分代码缩进，逻辑就会出错。

在这个循环中，每次运行时，变量flavor会取不同的值（“vanilla”, “chocolate”…），变量prompt也随之被设置为不同的值，然后print(get_llm_response(prompt))会基于不同的提示词输出响应。

保存结果到列表 📋

如果我们想将大语言模型生成的描述保存到它们自己的列表中，该怎么做呢？

我们可以创建一个空列表，然后在循环中使用.append()方法将每个描述添加进去。这是一种在Python中非常常见的编码模式：从一个空列表开始，然后反复向列表末尾添加或追加项目，从而构建该列表。

以下是具体代码：

promotional_descriptions = []  # 创建一个空列表

for flavor in ice_cream_flavors:
    prompt = f"For the ice cream flavor listed below, provide a captivating description that you'd use for promotional purposes.\n\n{flavor}"
    description = get_llm_response(prompt)
    promotional_descriptions.append(description)  # 将描述添加到列表末尾

print(promotional_descriptions)  # 打印整个描述列表

运行后，promotional_descriptions就包含了所有四个描述。如果你想访问其中某个描述，比如我最喜欢的巧克力冰淇淋（它是列表中的第二个口味），可以这样做：

print(promotional_descriptions[1])

for循环与列表的强大之处 💪

for循环和列表的结合非常强大，能让你在Python中做很多事情。在这些例子中，我们使用的列表都很短，可能只有三四个项目。但想象一下，能够遍历成百上千个列表项，你就可以让计算机为你重复执行成百上千次操作。

当前方法的局限性与展望 🔮

不过，这种方法也有一个局限：如果你不知道项目的位置，访问它们可能会很棘手。比如我碰巧记得巧克力冰淇淋是第1项（索引为1），所以可以输入[1]。但如果你有几十种冰淇淋口味，并且不记得你喜欢的口味的具体编号，那么要找到你想要的那个描述就会比较困难。

在下节课中，你将学习一种与此有相似之处，但在查找和处理特定数据项时更加容易的新数据类型。这种数据类型叫做字典。在Python中，列表和字典是存储多个数据项集合的两种最重要的方式。

总结 📚

本节课中我们一起学习了：

1. for循环的概念：一种用于自动化重复处理列表中每个元素的编程结构。
2. for循环的基本语法：for item in list: 后跟缩进的循环体。
3. for循环的实际应用：遍历列表并执行操作，例如打印内容或调用函数（如LLM）。
4. 使用for循环时的常见错误（如忘记冒号或缩进）以及如何利用AI工具进行调试。
5. 如何利用for循环构建新列表：通过创建空列表并在循环中使用.append()方法添加元素。
6. 认识到for循环在处理大量数据时的强大能力，以及当前在通过索引直接访问未知位置元素时的局限性，这为学习下一课的数据类型——字典——做好了铺垫。

通过掌握for循环，你已经学会了如何让计算机自动化地处理重复性任务，这是编程中提高效率的关键一步。

015：使用字典与AI进行任务优先级排序 📚

在本节课中，我们将学习Python中的一种重要数据结构——字典。我们将了解字典如何通过键值对来组织数据，并探索如何使用字典来高效地管理和访问特定信息，例如为待办事项设置优先级。

概述

列表是存储大量数据的好方法，当你希望使用for循环对列表中的每个元素进行操作时，这很有效。但是，如果你想在列表中查找一个特定元素，却不知道它的编号或索引，那么访问这个元素就会变得困难。

Python中还有另一种组织数据集合的方式，称为字典。字典使得从数据集合中提取特定项变得容易得多。在本课中，我们将学习字典，并会看到一个有趣的例子：使用字典来为待办事项设置优先级（例如高、中、低优先级）。让我们深入了解字典的工作原理。

字典简介：从列表到字典

让我们像往常一样先加载一些Python函数。我们将以冰淇淋口味及其描述为例。

以下是一个包含冰淇淋口味和描述的较长列表：

["vanilla", "classic and creamy with a rich smooth flavor", "mango", "tropical and sweet with a fruity punch", "chocolate", "rich and decadent with a deep cocoa flavor"]

使用这样的列表的问题是，如果你想查找特定冰淇淋口味（例如芒果冰淇淋）的描述，却不记得它对应的编号或索引，那么提取芒果冰淇淋的描述会相当困难。

Python中的字典灵感来源于现实世界中人们用来查找单词含义的词典。在纸质词典中，你可能有像“Avocado”这样的词及其定义，然后是另一个词如“Apple”及其描述。

在Python中，存在类似的从单词到定义的映射，只不过我们称之为键和值。例如，你可能有一个键“mint chocolate chip ice cream”，它映射到对该口味的描述；另一个键“cookie dough”则映射到对曲奇面团口味的描述。

创建字典

以下是用于定义字典的Python代码片段：

ice_cream_flavors = {
    "mint chocolate chip": "refreshing mint with rich chocolate chips",
    "cookie dough": "vanilla ice cream with chunks of cookie dough",
    "salted caramel": "sweet caramel with a hint of sea salt"
}

让我们详细分析这段代码的各个组成部分。

用蓝色高亮显示的是字典的键，用橙色高亮显示的是值。在字典中，不同的键（冰淇淋口味）映射到不同的值（在本例中是描述）。注意，键和值之间用冒号分隔。ice_cream_flavors是我们定义的字典的名称，=是常用的赋值运算符。

要定义字典，需要使用花括号{}来开始和结束字典内容的定义，并且用逗号分隔不同的键值对。

让我们来定义这个字典：

ice_cream_flavors = {
    "mint chocolate chip": "refreshing mint with rich chocolate chips",
    "cookie dough": "vanilla ice cream with chunks of cookie dough",
    "salted caramel": "sweet caramel with a hint of sea salt"
}

现在，ice_cream_flavors被定义为一个包含三个键（如左侧所示）和对应值（如右侧文本所示）的字典。不同的行像之前一样用逗号分隔。

字典与列表的区别

再次指出字典和列表之间的一些关键区别。首先，如你所见，定义时使用花括号{}而非方括号[]。其次，每行有两个字符串项，而不是一个字符串。这两个字符串分别是第一个字符串的键和第二个字符串的值，它们用冒号分隔。

因为字典有键和值，我们有时说Python中的字典存储了一组键值对，其中每一行都是一个键值对。

如果你想查看键，可以打印ice_cream_flavors.keys()，这将打印出预期的三个名称。如果你想打印值，可以运行ice_cream_flavors.values()。

访问字典中的项

字典可能看起来有点像列表，但它们的行为不同。如果你尝试通过print(ice_cream_flavors[0])访问字典中的第一项，这将不起作用，因为字典中没有“第零个元素”这样的概念，这会产生错误信息。

那么如何访问字典中的单个项呢？让我们尝试询问ChatGPT。

它给出的建议是：

cookie_dough_description = ice_cream_flavors["cookie dough"]
print(cookie_dough_description)

让我们试试这段代码。访问字典中特定项的代码是：字典名称ice_cream_flavors，后跟方括号[]，方括号内是其中一个键。字典会查找是否存在名为“cookie dough”的键，如果存在，则返回或传递回与该键关联的值（描述），并将其存储在变量cookie_dough_description中，因此打印时会输出曲奇面团口味冰淇淋的描述。

添加和更新字典项

让我们看看如何向字典添加项。假设我们想为“Rocky Road”口味添加描述。我们可以这样做：

ice_cream_flavors["Rocky Road"] = "chocolate ice cream mixed with marshmallows and nuts"
print(ice_cream_flavors)

现在字典扩展了，包含了“Rocky Road”作为新键，映射到描述“chocolate ice cream mixed with marshmallows and nuts”。如果描述有拼写错误，同样的模式也可以用来更新字典中某项的值：

ice_cream_flavors["Rocky Road"] = "chocolate ice cream mixed with other ingredients"
print(ice_cream_flavors)

现在，我们得到了更新后的描述。

字典存储多种数据类型

事实证明，字典可以保存各种类型的数据。在我们使用的示例中，冰淇淋口味映射到对冰淇淋口味的描述，但字典也可以映射到数字，而不仅仅是字符串。

例如，如果我想创建一个关于Isabel的字典，记录她年龄28岁，最喜欢的颜色是红色，我可以这样构建字典：

isabel_facts = {
    "age": 28,
    "favorite_color": "red"
}
print(isabel_facts)

这里，键“age”映射到数字28，键“favorite_color”映射到另一个字符串。字典可以将键映射到不同类型的数据，在本例中是字符串或数字。

如果Isabel有三只猫，并且想存储所有猫的名字，我可以创建一个列表：

cat_names = ["Charlie", "Smoky", "Tabitha"]

那么如何存储这些猫的名字呢？我可以创建一个额外的键：

isabel_facts["cat_names"] = cat_names
print(isabel_facts)

在这个例子中，我获取isabel_facts字典，创建了一个新键“cat_names”。这个键“cat_names”现在映射到一个值，而这个值本身是一个包含三只猫名字的列表。

这是另一个例子，我可以设置Isabel最喜欢的零食：

isabel_facts["favorite_snacks"] = ["pineapple cake", "candy"]
print(isabel_facts)

实践：使用字典管理优先级任务

在结束本视频之前，我想通过一个有趣的例子，展示如何使用字典来帮助你跟踪和完成高优先级任务。

你之前见过使用列表来跟踪一组任务的例子，那是一种不错的方式。但让我们提升个人组织水平，将这些任务存储在三个按优先级组织的列表中。

以下是按优先级分类的任务列表：

high_priority_tasks = ["Compose a brief email", "Create an outline for a presentation"]
medium_priority_tasks = ["Schedule a meeting", "Review project documents"]
low_priority_tasks = ["Organize desk"]

现在，让我们创建一个字典，将这三个列表放入字典中：

prioritized_tasks = {
    "high priority": high_priority_tasks,
    "medium priority": medium_priority_tasks,
    "low priority": low_priority_tasks
}
print(prioritized_tasks)

我们创建了一个键为字符串“high priority”，其映射到的值是之前定义的high_priority_tasks变量。同样，为“medium priority”和“low priority”创建了键。

现在，你看到这是一个字典，其中“high priority”是一个映射到两个项目列表的字符串键，“medium priority”和“low priority”同理。

假设你想使用大语言模型来处理高优先级任务。我可以通过查找prioritized_tasks["high priority"]来获取高优先级任务列表，并打印出来。

这打印出了两个任务：“Compose a brief email”和“Create an outline for a presentation”。

prioritized_tasks["high priority"]是一个包含两个项目的列表。还记得我们在上一课中学到的循环吗？让我们看看这可能会做什么：

for task in prioritized_tasks["high priority"]:
    print(f"AI is handling: {task}")

运行这段代码，AI将处理“Compose a brief email”和“Create an outline for a presentation on remote work”。

如果你愿意，可以随意编辑此代码，让它也为你处理中优先级或低优先级任务。

总结

本节课中，我们一起学习了关于字典和列表的许多知识。你了解了字典如何通过键值对高效地组织和访问数据，以及如何利用字典来管理具有不同优先级的任务。在下一课中，我们将进一步深入字典，特别是利用字典的值来为大语言模型创建定制化的提示。我们将通过一个有趣的例子，使用大语言模型为我们编写定制的食品食谱。让我们在下一个视频中继续探索。

016：使用列表、字典和AI定制食谱 🍳

在本节课中，我们将学习如何结合使用列表和字典来组织数据，并利用这些数据定制提示词，从而让大型语言模型为你的朋友生成个性化的食谱建议。

---

正如你所见，字典和列表都是组织数据的有用方式。本节我们将通过一个有趣的例子，学习如何将朋友的食物偏好存储在列表或字典中，或者结合使用两者，然后将这些数据作为定制提示词的一部分，输入给AI，让它为你的朋友推荐食谱。

这为我们提供了一种更复杂的方式来存储数据，并利用这些数据定制输入给大语言模型的提示词，从而生成一些非常有趣且希望是美味的输出。让我们开始吧。

定义朋友的食物偏好字典

首先，我将定义一个字典来存储Tommy的食物偏好。

记住，我们使用花括号 {} 来定义字典。

以下是字典的键值对：

• dietary_restrictions 键映射到字符串 "vegetarian"。
• favorite_ingredients 键映射到一个包含两种最喜爱食材的列表：["tofu", "olives"]。
• experience_level 键映射到字符串 "intermediate"，表示他的厨师经验水平。
• max_spice_level 键映射到数字 6，表示他接受的辣度等级（满分为10）。

food_preferences_tommy = {
    "dietary_restrictions": "vegetarian",
    "favorite_ingredients": ["tofu", "olives"],
    "experience_level": "intermediate",
    "max_spice_level": 6
}

运行这个代码单元后，你会注意到这个字典有四个键和四个对应的值。第一个值是字符串，第二个值是字符串列表，第三个值是字符串，第四个值是数字。

正如上节课所学，你可以打印字典的键和值：

print(food_preferences_tommy.keys())
print(food_preferences_tommy.values())

使用字典数据定制AI提示词

现在，如果我们想为Tommy推荐一个食谱，可以使用如下提示词。这是一个f-string，它会将字典中的值动态插入到提示词中。

prompt = f"""
Please suggest a recipe for the following ingredients: {food_preferences_tommy['favorite_ingredients']}.
The recipe should be {food_preferences_tommy['dietary_restrictions']}.
The difficulty of the recipe should be {food_preferences_tommy['experience_level']}.
The maximum spice level on a scale of 10 is {food_preferences_tommy['max_spice_level']}.
Please provide a two-sentence description.
"""

在这段代码中，food_preferences_tommy['favorite_ingredients'] 会查找并插入 "tofu" 和 "olives"。其他键值对也会被相应地插入。

运行后，你可以查看生成的完整提示词：

print(prompt)

你会看到，f-string中所有花括号内的值都已被从 food_preferences_tommy 字典中提取的相应数据填充。

接下来，我们将这个提示词发送给AI模型（这里用 get_completion 函数模拟）并打印响应：

response = get_completion(prompt)
print(response)

我们可能会得到类似这样的输出：

地中海风味豆腐橄榄炒菜：将豆腐切块，与彩椒、橄榄一起快速翻炒。这道菜是素食，难度中等，辣度控制在6/10以内，风味浓郁且制作简单。

注意，这个食谱包含了豆腐和橄榄，涵盖了他喜爱的两种食材。

你可以暂停视频，尝试输入你自己喜爱的食材、饮食限制等信息，看看是否能生成你满意的结果。

进一步定制：考虑可用食材

目前我们所有的数据都只与Tommy的食物偏好相关，因此创建一个字典变量来存储这些偏好是合理的。

但如果他告诉我们，他的厨房里香料快用完了，只剩下这四种：孜然、姜黄、牛至和红甜椒粉。我们可以进一步定制提示词。

首先，设置一个可用香料的列表：

available_spices = ["cumin", "turmeric", "oregano", "paprika"]

然后，生成一个新的提示词，将可用香料信息也包含进去：

prompt2 = f"""
{ prompt }
Also, please only use the following spices that are available: {available_spices}.
"""

运行并打印新的提示词，你会发现 available_spices 列表的内容被插入到了指定位置。

再次获取AI的响应：

recipe_suggestion = get_completion(prompt2)
print(recipe_suggestion)

这次生成的食谱（例如，地中海豆腐橄榄炒菜）可能会特别说明使用了孜然、牛至和红甜椒粉，而不会使用他厨房里没有的其他香料。

这样就更贴切了。

动手尝试与扩展

在这个例子中，我主要使用了简短的食谱，并要求提供两句话的描述，以便阅读。

我鼓励你尝试以下修改：

• 更改提示词，让它提供分步烹饪说明。
• 在字典中添加一个新的键值对，比如 "favorite_cuisine": "Italian"，看看AI是否能根据你喜爱的菜系推荐食谱。
• 将 food_preferences_tommy 改为你自己的名字和偏好，看看能得到什么有趣的食谱。

编写此类代码的好处是，如果Tommy用完了另一种香料（比如牛至），你只需从 available_spices 列表中删除 "oregano"，重新运行代码，就能生成基于新香料组合的食谱。

总结与下节预告

本节课我们一起学习了列表和字典的更多用法，以及如何利用它们来定制提示词，从而让AI生成个性化的内容。

作为下节课的预告，你之前看到我们将 food_preferences_tommy['dietary_restrictions'] 设置为 "vegetarian"。其实还有另一种存储此类数据的方式，那就是使用布尔值（True/False）。

例如，可以设置一个键 is_vegetarian，其值为 True。

food_preferences_tommy["is_vegetarian"] = True

这样，food_preferences_tommy 就变成了一个包含五个键的字典。对于非素食者，我们可以将值设为 False，计算机同样能够处理。

将某些值明确存储为 True 或 False 有一些优势，例如当你需要确切追踪某人是否为素食者，以便为他们提供合适的食物选项时。

要了解所有这些内容，以及如何比较数据（这将为我们让AI帮助决策奠定基础），让我们进入下一个视频。

017：在Python中比较数据

在本节课中，我们将学习一种新的数据类型——布尔值（Boolean），并了解如何使用它在Python中比较数据、提出诸如“哪个数字更大”之类的问题，以及如何利用这些比较来回答关于数据的问题。

布尔值简介

上一节我们介绍了如何使用字典存储Tommy的饮食偏好。本节中我们来看看布尔变量。

在上一课结束时，我提到了一个真值变量，当时我们说 Tommy is vegetarian is true。

在本视频中，我们将研究这些真/假值变量，在计算机科学中我们称之为布尔变量，并看看如何在Python中使用这些变量来相互比较数据。

什么是布尔值？

以下是关于布尔值的一些核心事实：

• 布尔值是一种数据类型，只能取两个值：True 或 False。
• 你可以将布尔值视为对“是/否”或“真/假”问题的回答。
• 在Python中，True 和 False 是特殊的关键字，不需要引号。
• 使用 type() 函数检查 True 或 False 的类型，会返回 bool，这是“Boolean”的缩写。

print(type(True))  # 输出：<class 'bool'>
print(type(False)) # 输出：<class 'bool'>

比较运算符

当你在Python中比较两个值时，比较的结果就是一个布尔值。以下是Python中用于比较的一些运算符。

以下是常用的比较运算符：

• >：大于
• <：小于
• >=：大于或等于
• <=：小于或等于
• ==：等于（注意：是两个等号）
• !=：不等于

例如，如果你想检查Isabel的年龄是否大于或等于Tommy的年龄，你可以这样写：

age_isabel >= age_tommy

这个表达式将根据 age_isabel 是否大于或等于 age_tommy 返回一个布尔值（True 或 False）。

比较操作示例

让我们通过一些代码示例来看看比较操作的实际应用。

假设Isabel、Daniel和Tommy在玩游戏，他们决定最年轻的人先开始。以下是一些可以在Python中进行的比较：

age_isabel = 28
age_daniel = 30
age_tommy = 30

# 检查Isabel的年龄是否大于Daniel的年龄
print(age_isabel > age_daniel)  # 输出：False

# 检查Isabel的年龄是否小于Daniel的年龄
print(age_isabel < age_daniel)  # 输出：True

# 将比较结果赋值给一个变量
is_isabel_older_than_daniel = age_isabel > age_daniel
print(is_isabel_older_than_daniel)  # 输出：False

# 使用“小于或等于”运算符
print(age_isabel <= age_daniel)  # 输出：True
print(age_tommy <= age_daniel)   # 输出：True (因为两者都等于30)

相等性测试

除了测试大小关系，我们还可以测试两个事物是否相等。在Python中，使用双等号 == 来测试相等性。

重要提示：单个等号 = 用于给变量赋值，而双等号 == 是比较运算符。混淆两者是一个常见的错误。

# 测试年龄是否相等
print(age_tommy == age_daniel)   # 输出：True (因为都是30)
print(age_isabel == age_daniel)  # 输出：False

# 错误示例：这会将daniel_age的值赋给tommy_age，而不是比较
# age_tommy = age_daniel

# 字符串也可以使用 == 进行比较
print("vegetarian" == "vegan")    # 输出：False
print("vegan" == "vegan")         # 输出：True

字符串相等性测试是计算机检查密码是否正确的基础步骤之一。

逻辑运算符

有时我们需要组合多个布尔条件。Python提供了逻辑运算符来实现这一点。

假设我和Tommy、Isabel在一起，我想知道他们是否都是我的朋友。这时可以使用逻辑运算符。

以下是主要的逻辑运算符：

• and (与)：仅当两个输入都为 True 时，结果才为 True。
• or (或)：只要至少一个输入为 True，结果就为 True。
• not (非)：对布尔值取反。

is_tommy_my_friend = True
is_isabel_my_friend = True

# 使用 and 运算符
print(is_tommy_my_friend and is_isabel_my_friend)  # 输出：True

# 如果Isabel不是我的朋友
is_isabel_my_friend = False
print(is_tommy_my_friend and is_isabel_my_friend)  # 输出：False

# 使用 or 运算符
print(is_tommy_my_friend or is_isabel_my_friend)   # 输出：True (因为Tommy仍是朋友)

综合应用示例

让我们将所学内容结合起来，解决游戏开始时的问题：确定Isabel是否是最年轻的，从而获得先手权。

# 定义年龄
age_isabel = 28
age_daniel = 30
age_tommy = 30

# 进行必要的比较
is_isabel_younger_than_tommy = age_isabel < age_tommy
is_isabel_younger_than_daniel = age_isabel < age_daniel

# 使用 and 判断Isabel是否比两个人都年轻
is_isabel_the_youngest = is_isabel_younger_than_tommy and is_isabel_younger_than_daniel

print(f"Is Isabel the youngest? {is_isabel_the_youngest}")  # 输出：Is Isabel the youngest? True

因为表达式 (28 < 30) and (28 < 30) 的结果是 True and True，最终结果为 True，所以Isabel可以先开始游戏。

总结

本节课中我们一起学习了布尔值（True/False）这一新的数据类型。我们掌握了如何使用比较运算符（>, <, >=, <=, ==, !=）来生成布尔值，以及如何使用逻辑运算符（and, or, not）来组合多个布尔条件。这些工具是编程中实现逻辑判断和决策的基础。在下一个视频中，我们将学习如何利用布尔值来帮助AI做出决策，根据某个条件的真假来执行不同的操作。

018：帮助AI做决策 🧠

在本节课中，我们将学习如何将布尔变量与一种新的编程模式——条件语句——结合起来，以帮助计算机做出决策。这将使我们能够编写一些非常酷的程序，其执行结果取决于输入的数据。例如，根据数据的不同，程序可能会执行操作A或操作B。在本视频中，我们将使用这个技术来帮助你在待办事项列表中确定任务的优先级。让我们开始吧。

---

一个更复杂的待办事项列表示例

让我们通过一个更复杂的待办事项列表（或任务列表）来举例说明。我将定义一个名为 tasks 的列表。

以下是任务列表的内容：

• 任务 0：为老板撰写一封简短的电子邮件。使用AI大语言模型撰写大约需要3分钟，发送需要几分钟。
• 任务 1：为关于远程工作的演示文稿撰写大纲。撰写、清理、编辑并发送给相关人员，预计需要60分钟。
• 任务 2：撰写电影《降临》的影评，预计需要30分钟。
• 任务 3：为与朋友Tommy、Isabel和Daniel的豆腐橄榄炒饭聚餐创建购物清单，预计需要5分钟。

通过结构化这个任务列表，我们可以用它来做更复杂的事情。

假设现在快到午餐时间，你正准备出门吃饭，但还有一点空闲时间可以完成一个快速任务。下面，你将学习如何使用一种名为条件语句的新编程模式来遍历你的任务，并决定是否执行每一项。

---

使用条件语句做出决策

首先，让我们设置 task 等于任务列表中的第一个元素（索引为0），并打印出来。

task = tasks[0]
print(task)

不出所料，这打印出了你任务列表中的第一个任务。

当你准备出门吃午饭时，你可能想做的一件事是检查一个任务是否能在5分钟内完成。让我们看看这个任务。

task.time_to_complete <= 5

如果这是一个快速任务，也许我们可以在出门前快速完成它。上面的表达式结果为 True。

现在，让我向你展示如何编写一个程序，让它只在任务耗时5分钟或更少时才去执行。代码看起来像这样：

if task.time_to_complete <= 5:
    task_to_do = task.description
    response = get_llm_response(task_to_do)
    print(response)

在这里，task.time_to_complete <= 5 是一个布尔表达式，其值为 True 或 False。在Python中，每当有一个冒号 : 时，下一行几乎总是要缩进（通常是4个空格）。这段代码的意思是：如果任务完成时间小于或等于5分钟，那么就将 task_to_do 设置为任务描述，然后让语言模型处理这个任务提示，并打印响应。

在这个例子中，因为 task 是 tasks[0]，其完成时间小于等于5分钟，条件为 True。如果我运行这段代码，它将处理 task_to_do 并打印出语言模型的响应。

---

遍历列表中的其他任务

上一节我们介绍了如何使用 if 语句处理单个任务。本节中，我们来看看如何用同样的逻辑处理列表中的其他任务。

让我们继续处理列表中的下一个项目，即索引为1的任务。

task = tasks[1]
if task.time_to_complete <= 5:
    task_to_do = task.description
    response = get_llm_response(task_to_do)
    print(response)

任务1（撰写演示文稿大纲）需要60分钟。如果我运行这段代码，你认为会发生什么？实际上，什么也不会发生。这正是我们期望的，因为 task.time_to_complete <= 5 的结果是 False。因此，程序决定不执行缩进块内的代码，没有打印语言模型的响应。因为代码的逻辑是：如果耗时少于5分钟，则执行；既然条件不成立，就不执行。

接下来，处理任务2（撰写影评，耗时30分钟），运行同样的代码，同样什么也不会发生。

最后，处理任务3（创建购物清单，耗时正好5分钟）。

task = tasks[3]
if task.time_to_complete <= 5:
    task_to_do = task.description
    response = get_llm_response(task_to_do)
    print(response)

运行这段代码，它会调用语言模型并执行这个最终任务。

---

理解 if 语句

让我们回顾一下刚刚发生了什么。Python中的 if 语句是一种控制流语句，它允许你根据布尔条件的真假来定义程序的不同行为。

对于我们使用的 if 语句，其逻辑是：检查任务是否能在小于或等于5分钟内完成。如果为真（True），则执行任务（打印语言模型对该任务的响应）；否则，在这个例子中，我们什么都不做。稍后我们将看到如何编写代码，在布尔值为假（False）时执行其他操作。

以下是这段代码的关键组成部分：

1. if 关键字。
2. 一个布尔条件（其值必须是 True 或 False）。
3. 一个冒号 :。
4. 缩进的代码块，当布尔条件为 True 时执行。

---

使用 for 循环自动化处理

刚才我们看到的是手动遍历四个任务，并为每个任务编写一段类似的代码。这显然不够高效。我们之前学习过 for 循环，它提供了一种更高效的方式，可以用一个循环告诉计算机对任务列表中的每一项都执行相同的步骤。

让我展示一下实现这个功能的代码：

for task in tasks:
    if task.time_to_complete <= 5:
        task_to_do = task.description
        response = get_llm_response(task_to_do)
        print(response)

注意，我们将想要重复运行四次的代码整体向右缩进了四个空格，使其位于 for 循环的内部。这个 for 循环将对 task0、task1、task2、task3（记住我们从0开始计数）依次运行这段代码，反复检查任务是否能在5分钟内完成。如果可以，则打印该任务的语言模型响应。

运行这段代码，结果会执行第一个任务和最后一个任务，而忽略任务2和3。这正是我们想要的。

---

使用 else 处理条件为假的情况

如果你想在布尔条件为真时做一件事，为假时做另一件事，可以这样修改代码：

for task in tasks:
    if task.time_to_complete <= 5:
        task_to_do = task.description
        response = get_llm_response(task_to_do)
        print(response)
    else:
        print("We will do this task later.")

在Python中，else 后面同样需要冒号，并且其下的代码块需要缩进。逻辑是：如果条件为真，执行 if 块；否则（即条件为假），执行 else 块。

运行修改后的代码，它会执行第一个任务，提示有一个60分钟的任务稍后做，另一个30分钟的任务稍后做，然后执行第四个任务。

当前 else 块中的打印信息可能不够清晰。你可以尝试修改代码，让它打印出更详细的、稍后要完成的任务描述。例如，在 else 块中设置 task_to_do_later = task.description，然后打印它。建议你暂停视频，尝试修改代码来实现这个功能。

---

更好地组织未来任务

到目前为止，对于我们要留到以后处理的任务，我们只是打印一条“稍后做”的消息。实际上，有一种巧妙的方法可以利用我们早先学过的知识，将这些未来任务以更有条理的方式保存起来。

以下是我们可以做的：你可能还记得以空列表开始的编码模式。我将从一个空的“稍后任务”列表开始。

tasks_for_later = []

然后，编写以下代码来遍历任务列表：

for task in tasks:
    if task.time_to_complete <= 5:
        task_to_do = task.description
        response = get_llm_response(task_to_do)
        print(response)
    else:
        tasks_for_later.append(task)

这段代码的逻辑是：如果任务能在5分钟内完成，现在就做；否则（即午餐前不做），就把它添加到 tasks_for_later 列表中。

运行这段代码，我们会立即完成第一个和最后一个任务。现在，如果我们打印 tasks_for_later，我们会得到需要60分钟创建大纲的任务和需要30分钟撰写影评的任务，这些都被保存下来改天处理。

---

总结

本节课中，我们一起学习了如何利用布尔变量和 if 条件语句来帮助程序做出决策。我们通过一个待办事项列表的实例，演示了如何根据任务耗时（是否小于等于5分钟）来决定立即执行还是推迟处理。我们还结合了 for 循环来自动化遍历整个列表，并使用 else 子句来处理条件不满足时的情况。最后，我们学习了如何将推迟的任务收集到一个单独的列表中，以便更好地组织未来的工作。这些核心概念是构建更智能、更灵活程序的基础。

你几乎已经完成了Python任务处理部分的所有内容。在结束之前，还有一个简短的视频，我将介绍一些关于文件操作的内容。让我们进入下一个视频。

019：处理文件

在本节中，我们将预览下一门课程的核心内容：如何让Python和AI处理你自己的数据。你将看到一个具体的示例，了解如何读取本地文件并使用AI分析其中的信息。

---

现在你已经掌握了许多处理数据的工具，包括变量、列表、for循环、字典和条件语句。

我知道课程内容推进得很快，如果你没有记住所有内容，这很正常。你可以随时复习材料，或者更好地，向你的AI聊天伙伴询问任何你想回顾的概念。专业程序员也无法记住所有内容，他们也经常向聊天机器人寻求帮助。

下一阶段的目标，是在你已学知识的基础上，学习如何让Python和AI处理你自己的数据。

你可能不认为自己有数据，但我可以肯定地说，你绝对有。

让我展示一个例子。你的个人数据很可能存储在文件中，例如你的文档、待办事项列表、电子邮件或电子表格等。为了接下来的示例，我们假设你是一位美食评论家，并保存了一份记录不同城市旅行的日记，其中包含对餐厅和特色菜的描述。

假设你想分析你的日记条目，并高亮显示其中的餐厅和菜肴名称。

在这段视频中，你将简要了解如何将你自己的日记文本加载到Python中，并使用AI来高亮显示这些餐厅和菜肴。

为了本视频的目的，你不必担心视频中看到的代码的具体工作原理。你将在下一门课程中学习所有细节。

这里我将加载一些辅助函数。然后是一些Python代码，用于读取存储在我硬盘上的一个包含文本日记的文件。

让我加载并打印它。这是我的日记：“开启开普敦的美食评论之旅……”等等。

然后，我将编写一个提示词，内容是：“给定以下美食评论家的日记条目，识别其中的餐厅及其特色菜。用粗体高亮其名称和特色菜，并为每一项使用不同的颜色。以HTML格式提供输出。”

我们将使用f-string将日记插入到这个提示词中，获取AI的响应，得到一个HTML格式的响应。网页是用HTML格式化的，我们将让AI返回一个HTML响应。最后，我们可以显示这个HTML。

如果我运行这段代码（这需要几秒钟），最终会得到一个结果。在这个结果中，它高亮了餐厅名称，如“The Test Kitchen”、“La Colombe”等，以及用相应颜色标记的不同菜肴。

无论你是否是美食评论家，我希望这个例子能向你说明，如果你有存储在硬盘上的文本文件，你可以用几行代码，让AI帮助你标记和分析你自己的文本。

在下一门课程中，我将利用这个方法来规划一个美妙的假期，这个假期将包括参观许多餐厅和品尝大量美味食物。

---

恭喜你完成了本课程！你已经学习了专业开发人员日常工作中使用的非常重要的概念和编程模式。

你学习了列表和字典，它们可以用来存储数据项的集合。

你学习了for循环，它允许你通过告诉Python对列表中的所有项目执行相同操作来自动化重复性任务。

你学习了布尔变量，其值只能是True或False，以及如何在if语句中使用它们来帮助计算机程序根据看到的数据做出决策。

你涵盖了很多内容，我希望你现在已经掌握了编程工具，或许可以开始使用AI构建一些东西了。当然，还有更多知识需要学习。

我期待在下一门课程中见到你，在那里你将学习如何让Python和AI处理你自己的数据。

020：处理本地文件与数据

概述

在本节课中，我们将要学习如何使用Python处理存储在您自己计算机上的文件和数据。您将了解如何操作文本文件以及存储在电子表格（即数据表）中的数据，并学习如何结合Python与AI技术来快速、重复地处理这些数据。

在前两门课程中，您已经学习了Python的一些基本特性，包括可以处理的数据类型（如整数和字符串），以及如何使用函数与AI进行交互。您还学习了如何使用Python通过特定的代码模式（如for循环和if语句）来自动化任务和做出决策。到目前为止，示例中使用的数据都是在Jupyter Notebook中直接创建或编码的。

实际上，Python也能处理存储在您计算机文件中的数据，这使您能够处理自己的数据。您可能拥有大量数据，无论您是否意识到这一点，例如您的待办事项、电子邮件、家庭食谱或包含个人预算的电子表格。您在计算机或云端生成的文件几乎都是数据。

在本课程中，我们将以规划一次梦想假期为例进行讲解。

从数据到规划：一个假期示例

上一节我们介绍了Python处理外部数据的能力，本节中我们来看看一个具体的应用场景。

虽然我自己并不擅长休假，但那些规划假期的人（我也应该在这方面做得更好）有时会保存他们想参观的地点的电子表格，或者保存关于想做的事情或想去就餐地点的文章或博客帖子。

在这个短期课程中，我们将通过一个示例，演示如何获取所有这些关于美好假期的原始想法数据，并利用AI来帮助规划实际的假期。您将看到，像大型语言模型这样的AI可以帮助您查看并总结所有这些数据，提取关于哪些活动会很有趣的关键信息。围绕此编写的Python代码可以帮助您一次性管理大量数据。

例如，如果同事发给您10份用户访谈记录，您希望快速阅读或让AI阅读每一份记录，以便为营销计划或产品设计提供信息，您可以使用AI来阅读所有10份记录。但也许您最终需要将内容复制粘贴10次到某个AI聊天机器人中。Python可以让您自动化读取和分析所有这10份记录的过程，例如，使用一个for循环。

以下是AI与Python结合处理数据的核心优势：

• 自动化处理：使用for循环等结构，可以自动、重复地对多个文件执行相同操作。
• 信息提取与总结：AI模型能够从大量文本中提取关键信息和进行总结。
• 批量分析：一次性处理和分析多个数据源，提高效率。

课程核心内容与示例

在本课程中，您将学习如何处理自己的文件，包括文本文件和存储在电子表格（即数字表格）中的数据。您还将学习如何使用Python和AI来快速、重复地执行任务以处理这些数据。

例如，您将学习如何使用Python和AI来查看一段文本并判断它是否讨论特定主题，或者学习如何使用它来突出显示文件中的关键信息。

一个有趣的示例将作为贯穿整个短期课程的运行案例。假设您计划了一次旅行，或者正在考虑一个包含七个目的地（纽约、悉尼、东京等许多其他有趣城市）的绿色假期。您可能保存了大量相关文档，如美食评论、旅行日志等。您可以编写一段可重用的代码，利用您可能收集到的所有这些信息，为您想访问的每个城市创建详细的行程安排。

虽然规划一个有趣的假期只是一个例子，但您将看到，我们即将学习的模式对于处理您在个人生活或工作中可能拥有的许多其他类型的数据同样有用。

总结

本节课中我们一起学习了Python处理外部文件数据的基本概念和重要性。我们了解到，Python不仅能处理代码内部的数据，还能高效地读取、分析和操作存储在文本文件及电子表格中的个人数据。通过结合AI技术，我们可以自动化繁琐的数据处理任务，例如从大量文档中提取信息和进行总结。接下来，让我们进入下一个视频，更深入地探讨数据，以及如何获取能让AI帮助您处理的数据。

021：在Python中使用文件 📂

在本节课中，我们将学习如何使用Python读取存储在计算机上的文本文件。你将了解如何打开文件、读取其内容，并将这些文本数据加载到Python变量中，以便后续使用AI模型进行处理。

---

数据通常以文件形式存储在计算机上，例如文档、待办事项列表或笔记。这些笔记可能记录在类似Microsoft记事本或Mac文本编辑器的应用程序中。

实际上，我使用一个名为Obsidian的应用程序来存储我的待办事项。Obsidian基本上将我的待办事项存储在文本文件中，技术上是一种称为Markdown的文件，但大致上就是文本文件。

你可以使用Python读取这些文件中的数据或文本，从而编写代码，利用AI处理你自己文件中的文本。让我们看看如何操作。

在之前的课程中，你处理的数据是在Jupyter笔记本中直接创建并赋值给变量的。

你学习了如何创建多行字符串、列表和字典。你看到了我们如何创建一个食材列表。

以下代码片段中，有一行 from IPython.display import display, Markdown。目前无需担心这行代码。然后，我们使用一个f-string创建了一个提示词，要求大型语言模型使用这些食材创建一个食谱，并将响应存储在名为 response 的变量中，最后打印出来。让我们运行这两个代码单元格。

事实证明，与其像这样在笔记本中键入所有数据（例如鸡肉、西兰花和米饭），你可以从存储在计算机上的文本文件或其他类型的文件中加载数据。

让我们从加载存储在文本文件中的一封电子邮件开始。

---

打开并读取文件

以下是打开并读取文件的核心代码：

with open("email.txt", "r") as f:
    email = f.read()

这段代码执行以下操作：

1. open("email.txt", "r")：打开名为 email.txt 的文件。.txt 后缀表明这是一个纯文本文件。参数 "r" 表示以“读取”模式打开文件。这个打开的文件对象被赋值给变量 f。
2. email = f.read()：读取文件 f 中的所有文本内容，并将其存储在一个名为 email 的字符串变量中。
3. with 语句：使用 with 语句可以确保文件在使用完毕后被正确关闭。关闭文件可以释放计算机的一些内存资源。

运行这段代码后，email.txt 文件中的所有文本都被读取并保存在变量 email 中。现在，如果我们打印 email，就会输出该变量的值，即一封来自Daniel的电子邮件，内容是关于他精彩的环球之旅。

如果我使用文本编辑器打开 email.txt 文件，这正是保存的文件内容。而这就是Python读取到Jupyter笔记本中的内容。

---

使用AI处理文件内容

现在我们已经将文本加载到Python中并保存在变量 email 里，就可以使用大型语言模型来处理它了。

例如，我很高兴读到Daniel的愉快经历，但如果我想让AI模型为我总结这封邮件，我可以编写如下提示词：

prompt = f"""
Extract bullet points from the following email and include the sender information:

{email}
"""

这是一个f-string，它将 email 变量的文本内容嵌入到提示词中。然后，我可以通过调用模型来获取对这个提示词的响应，并打印出总结的要点。

之后，AI模型为我总结了Daniel的邮件。

你可能会注意到输出中有双星号 **，这是一种称为Markdown的格式化语法。如果你希望以更美观的格式化方式显示这些文本，可以使用 display 和 Markdown 函数。

display(Markdown(bullet_points))

这会使Python以这种格式良好的方式打印所有文本。这就是为什么在笔记本的开头，我预先导入了 display 和 Markdown，因为我知道稍后会用到它们。你将在第四门也是最后一门课程中了解更多关于 import 命令的知识。目前只需记住，在使用 display 和 markdown 函数之前，必须先运行那行导入代码。

你并非必须以这种更美观的格式打印输出。但如果你要向朋友展示，或者想让自己更快地阅读，这会让阅读体验更好一些。

---

总结

本节课中，我们一起学习了：

1. 如何使用 with open(...) as f: 和 f.read() 在Python中安全地打开和读取文本文件。
2. 如何将文件内容存储在变量中，以便在程序中使用。
3. 如何将读取的文件内容作为输入，构建提示词，交由AI模型进行处理（如总结）。
4. 如何使用 display(Markdown(...)) 来美化Markdown格式文本的输出显示。

在本视频中，你看到了如何加载一个特定的文件 email.txt。在下一课中，我们将了解如何对你自己的文本文件进行同样的操作。

让我们继续下一课。

022：加载与使用个人数据 📂

在本节课中，我们将学习如何在Python中打开和读取文件，并使用AI大语言模型来总结文档中的关键要点，例如处理电子邮件。

上一节我们介绍了如何与AI模型交互生成文本。本节中我们来看看如何让AI处理我们自己的文本文件。

理解文件与工作目录 💻

在计算机上，你可能将许多不同类型的数据保存在不同的文件中。这可能包括你保存的文档，如报告、待办事项、电子邮件、包含预算的电子表格以及其他类型的公司数据。

在本笔记本中，你将学习如何处理自己的文本文件。

计算机中的文件被组织在不同的文件夹中。开发者倾向于使用“目录”这个词来代替“文件夹”。如果你听到我说“这个文件在那个目录中”，这基本上意味着该文件在一个特定的文件夹中。

在你当前运行的Jupyter Notebook网站上，有一套文件夹存储着不同课程的文件，例如第一课、第二课等。我们现在处于第二课，在lesson2文件夹中。实际上，这里有一个文件列表，代码将在这里运行，它位于一个名为lesson2.ipynb的文件中。文件名中“点”后面的部分称为扩展名。Jupyter Notebook是扩展名为.ipynb的文件。如果你好奇，ipynb代表“IPython Notebook”。之前我们从helper_functions导入代码时，它实际上保存在另一个扩展名为.py（代表Python）的文件中。

Python首先在其中查找文件的文件夹或目录，也称为“工作目录”。因此，如果你告诉它读取email.txt或recipe.txt，Python将在当前工作目录（即lesson2文件夹）中查找你想要读取的文件。

为了更深入地理解工作目录，让我们询问AI助手：“Python首先在哪个文件夹中查找文件？默认是哪个文件夹？”

Python首先在当前工作目录中查找。和往常一样，如果你想了解更多细节，可以随时与你的AI聊天机器人交流。

在代码中操作文件 📝

让我们转到本笔记本中的代码。我将从helper_functions加载一些新函数：upload_text_file、list_files_in_directory以及我们常用的print_response。

请按照与我相同的顺序执行代码单元格。

现在，让我们列出目录中的文件。

以下是当前工作目录中的文件列表。

如果我们打开并读取email.txt文件，然后打印email变量，我们会看到上一节课中见过的电子邮件内容。

类似地，如果我们打开recipe.txt文件并打印recipe变量，我们会得到这份美味的泡菜食谱。

上传你自己的文本文件 ⬆️

现在，让我们上传一个文本文件到当前工作目录。运行代码会创建一个上传按钮。点击它，会弹出一个文件浏览器。我已在桌面上保存了一个关于伦敦（我出生的地方）的文件。

打开london.txt文件。现在，london.txt已被上传。如果我再次列出目录中的文件，一个新的文件london.txt就会出现。

现在，我可以打开这个文件并将其内容读取到变量your_file_content中。

打印your_file_content，它会输出london.txt的全部内容，这是一段关于伦敦的精彩描述。

当你运行这段代码时，我鼓励你创建自己的文本文件，点击上传按钮并上传它。你可以从最近的电子邮件、在线新闻文章或其他地方复制一两段文字。

如果你在Windows系统上，可以使用Microsoft Word；在Mac上，可以使用TextEdit程序；也可以使用Google Docs。然后，转到“文件”->“下载为纯文本(.txt)”，生成一个可以上传到Jupyter Notebook的文本文件。

请注意：请不要上传任何机密文件。

你需要将代码中的london.txt更改为你实际上传的文本文件的名称。如果你这样做了，你就能在Jupyter Notebook中看到你自己的数据运行。

使用AI处理你的文本数据 🤖

对于你提供的任何文本，你都可以创建一个提示词。例如，创建一个提示词：“用两句话总结以下文本的内容。”

然后，让我们打印对该提示词的响应。

现在，AI将那段关于伦敦的长文本总结成了两句话。

除了提供摘要，你还可以尝试其他操作，例如要求“提取关键要点”或“就你刚刚上传的内容，集思广益如何制作演示文稿”。

我希望这些示例能给你一些启发，让你了解在使用AI大语言模型处理自己的文本数据时可以完成哪些任务。我希望你觉得这既有趣，也可能对你手头的项目有用。

在下一课中，我们将继续探索以更复杂的方式处理文本数据。具体来说，你将学习如何从多段文本中读取内容，并使用AI来判断这些内容是否与规划梦想假期相关。

在你尝试用你自己的文本数据运行一些代码之后，让我们进入下一课，在那里我们将学习如何以更复杂的方式处理文本。

总结 📚

本节课我们一起学习了：

1. 文件与目录：理解了计算机中文件的组织方式以及Python的“当前工作目录”概念。
2. 文件操作：使用list_files_in_directory查看目录内容，使用open和read函数读取文本文件内容。
3. 上传个人文件：通过upload_text_file功能将本地的.txt文件上传到Jupyter Notebook环境中。
4. AI文本处理：将读取的个人文本内容传递给AI大语言模型，执行如总结、提取要点等任务。

你已经掌握了如何让AI处理你自己的文档，这是将AI应用于个人或工作项目的重要一步。

023：阅读美食评论家的日志 📖

在本节课中，我们将学习如何使用Python和大语言模型来处理大量文本数据，特别是如何自动筛选出与特定主题（如餐厅和美食）相关的文档。我们将构建一个简单的文本分类系统。

概述

许多人每天需要处理大量文本数据，例如电子邮件、文章和个人笔记。根据任务的不同，你可能希望借助AI来帮助你阅读和处理这些海量文本。

例如，假设你正在规划一次梦想假期，需要决定在不同城市去哪些餐厅以及品尝什么美食。你可能已经保存了许多关于不同目的地的长篇博客文章，其中一些描述了不同城市的餐厅和菜肴。

在本视频的示例中，我们将学习如何将这些信息整合到你即将到来的旅行的美食相关行程中。但在这一大堆文件和文章中，可能也包含许多与餐厅、美食或就餐地点无关的文档。

如果你时间紧迫，不想逐一打开并阅读每个文件来判断它是否与美食相关，那么最好使用AI来查看所有这些文本并帮助你处理它们。

让我们看看如何在Python中实现这一目标。

处理文本数据

我们将使用美食评论家的日志条目，这些条目包含了推荐的餐厅和菜肴，并学习如何使用大语言模型来处理这些数据。

像电子邮件、日志条目和社交媒体帖子这样的文本数据，在风格和格式上可能有很大差异。有些人使用项目符号列表写作，而另一些人则写长段落。

在本课的代码中，你将使用Python和大语言模型从这些文本文件中提取相关信息，例如提取餐厅名称和你可能想尝试的特色菜名。

但在提取餐厅名称和菜名之前，你可能需要先确认这个文本文档是否相关。例如，如果你有一篇关于城市历史的文章，它可能没有任何值得提取的当前餐厅名称。

让我们看看如何使用Python代码来完成所有这些工作。

代码实践

请记住按顺序运行代码单元。首先，我们像上一课一样定义一些常用函数，然后加载文件 Cape_Town.txt 并打印开普敦的日志。

Cape_Town.txt 是由一位美食评论家撰写的日志，重点介绍了“The Test Kitchen”和“The Codfather”等餐厅。

接下来，让我们看看 Tokyo.txt。这个文件记录了前往东京的旅行，并列出了一些令人向往的餐厅。它的格式与开普敦文档的段落文本截然不同。

在处理这些文本文件以提取餐厅和菜名之前，我们希望使用大语言模型来检查文档，判断其是否与餐厅及其特色菜相关。

以下是一个提示词示例。我将打印对该提示词的响应。确实，东京的文章是相关的。事实上，开普敦的文章也是相关的。

我知道在这个目录下有五个文件：Cape_Town.txt、Madrid.txt、Rio_de_Janeiro.txt、Sydney.txt 和 Tokyo.txt。

为了编写处理所有五个文件的Python代码，你还记得代码结构吗？我们可以使用 for 循环来遍历多个文件。

我将设置 files 等于这个包含五个文件名的列表。这里的方括号是我们在Python中创建列表的方式。然后我们说 for file in files:，像往常一样打开并读取文件，然后关闭文件。

接着，我们将创建一个提示词，根据日志是否描述餐厅及其特色菜来响应“相关”或“不相关”。然后，我们将上面刚刚读取的日志变量 journal 放入提示词中。

然后，让我们使用大语言模型从提示词中获取响应。我们将打印文件名，然后是一个右箭头，接着获取响应并打印出每个文件是否与餐厅及其特色菜相关。

让我们运行一下看看结果。希望这能成功。

好的。所以开普敦是相关的，但 Madrid.txt 不相关，其他的是相关的。因此，如果你有100或200个文档的集合，你可以使用这样的循环让Python自动为你读取所有文档，并仅为你指出哪些是与美食相关的。

让我们检查一下 Madrid.txt。让我们读取并打印 Madrid.txt。你会发现这是一篇关于马德里的非常好的文章，但并没有特别关注美食，这就是为什么大语言模型说 Madrid.txt 不相关。

顺便说一下，我也鼓励你尝试不同的提示词。例如，你可以说“用‘是’或‘否’来回应，如果日志描述了餐厅和食物菜肴的话”。有多种方法可以做到这一点。

更高级的做法是让它只打印出相关文件的文件名。这将是一个相当高级的练习。如果你想尝试一下，也可以询问AI聊天机器人伴侣。

作为一个有趣的知识点，如果你对我们刚刚所做事情的名字感到好奇：我使用AI来确定不同文本是否相关。这个任务有一个特定的名称。我们刚刚在这里构建的是一个文本分类系统。

总结

本节课中，我们一起学习了如何使用Python和大语言模型自动处理大量文本数据，并筛选出与特定主题（如餐厅和美食）相关的文档。我们构建了一个简单的文本分类系统，通过循环读取多个文件，并使用提示词让AI判断其相关性。

我鼓励你尝试修改这段代码，让它做不同的事情。请务必尝试不同的提示词，看看会得到什么不同的结果。我希望你能看到，像这样简单的几行代码可以为你快速读取五个甚至更多文档，并帮助你识别出最相关的那些。

编码的好处在于，你可以让计算机执行各种各样的事情。希望你玩得开心。在下一课中，我们将学习如何从一篇相关文章中提取关键信息，例如餐厅名称和菜肴名称。

我们下节课再见。

024：从日记条目中提取餐厅信息

在本节课中，我们将学习如何使用大型语言模型从文本中提取特定信息，例如餐厅名称和招牌菜。我们将看到如何高亮显示这些信息，并将其保存为易于阅读的HTML文件或结构化的CSV文件。

回顾文本分类

上一节我们介绍了文本分类，即判断一段文本是否与食物相关。本节中，我们将以更深入的方式，让大型语言模型查看文档并提取特定的信息片段，例如餐厅和菜品名称，以便在其他地方使用。

高亮显示提取的信息

我们将学习如何高亮显示提取出的信息，并将其保存到新文件中以便阅读。

让我们看看具体如何操作。正如你所见，我们为不同目的地记录的日记条目中可能包含餐厅信息以及值得尝试的招牌菜。提取这些信息后，你可能希望将其保存在一个类似表格的结构中，这样当你在那个城市时，就能轻松决定去哪里用餐。

以下是读取日记文件并构建提示词的代码：

journal_rio_de_janeiro = read_journal("rio_de_janeiro.txt")
prompt = f"""
Given the following journal entry for food tracking, tell me the restaurants and the best dishes.
Highlight and bold each restaurant and best dish within the original text.
{journal_rio_de_janeiro}
We want the large language model to provide the output as HTML suitable for display in the Jupyter notebook.
"""

网页使用HTML格式，这让我们可以使用丰富的格式，例如用橙色或蓝色书写文本。提示词中包含位于下方的日记条目。现在，让我们调用大型语言模型并获取该提示词的响应，我将响应存储在html_response变量中并打印出来。

html_response = get_completion(prompt)
print(html_response)

你会看到大型语言模型输出了HTML。<p>标签表示开始一个段落，这些被称为指定格式的HTML标签。如果你想显示实际的HTML，可以使用以下命令：

display(HTML(html_response))

现在，它会打印出格式精美的HTML，其中餐厅用橙色高亮，菜品名称用蓝色高亮。

接下来，让我们对东京的日记条目进行同样的操作。代码如下：

journal_tokyo = read_journal("tokyo.txt")
prompt = f"""
Given the following journal entry for food tracking, tell me the restaurants and the best dishes.
Highlight and bold each restaurant and best dish within the original text.
{journal_tokyo}
We want the large language model to provide the output as HTML suitable for display in the Jupyter notebook.
"""
html_response = get_completion(prompt)
display(HTML(html_response))

模型做得很好，用橙色标出了餐厅，用蓝色标出了菜品，尽管这段文本的格式与里约热内卢的日记条目非常不同，大型语言模型仍然能够处理。

我鼓励你尝试修改提示词。也许这里有一个挑战：你能修改这个提示词，用绿色高亮任何甜点吗？或者尝试修改代码，在每个食材旁边添加一个表情符号？

提取信息到CSV格式

现在，让我们看看除了用不同颜色高亮某些信息片段外，我们是否可以修改提示词来从文本中提取信息。以下是我要使用的提示词：

Extract the comprehensive list of the restaurants and their respective dishes mentioned in the following journal entry. Ensure the restaurant name is accurately identified and listed.
Provide your answer in CSV format ready to save.

CSV代表逗号分隔值，是计算机存储类似表格信息的非常常见的格式。理解这个的好方法就是运行它并看一个例子。CSV文件的第一行告诉你每行将出现什么数据，每行将包含一个餐厅名称和一个菜品名称。

你可以将其视为计算机如何表示一个有两列的表，其中第一列是餐厅，第二列是菜品。

有了这样的提示词，你还可以遍历你拥有的所有日记条目。让我们逐步看一下这段代码：

files = ["cape_town.txt", "istanbul.txt", "new_york.txt", "paris.txt", "rio_de_janeiro.txt", "sydney.txt", "tokyo.txt"]

for file in files:
    journal = read_journal(file)
    prompt = f"""
    Extract the comprehensive list of the restaurants and their respective dishes mentioned in the following journal entry.
    {journal}
    Provide your answer in CSV format ready to save.
    """
    csv_response = get_completion(prompt)
    print(f"File: {file}")
    print(csv_response)
    print()  # 打印一个空行

代码在几秒钟内遍历了所有这些数据。想象一下，如果你必须一次打开这些文件，阅读并提取菜品，那将花费多长时间。因此，我希望你能想象，随着需要分析的文件数量增加，大型语言模型会变得越来越有用。我认为你节省的所有时间，现在或许可以花在一些美味的餐厅里。

我鼓励你尝试这个提示词的不同版本。例如，也许你可以尝试修改提示词来提取餐厅及其所在的街区（如果已知），或者提取菜品名称及其主要成分。

将数据保存到文件

我们即将结束本课。在总结之前，我想演示一下如何打开文件以及如何将数据保存到文件。

回想一下，之前我们生成了这个HTML响应。为了将这个变量html_response的内容保存到文件中，你可以使用以下代码：

f = open("highlighted_rio.txt.html", "w") # 使用“w”表示写入，而不是“r”表示读取
f.write(html_response)
f.close()

与打开文件进行读取的主要区别在于，使用“w”而不是“r”来写入而不是读取，然后使用f.write而不是f.read。如果你想更好地理解这段代码在做什么，可以询问AI聊天机器人。它会解释open、write和close的作用。

如果你愿意，也可以运行files.download('highlighted_rio.txt.html')来将此文件下载到本地桌面。点击此链接，如果在网页浏览器中打开该文件，你应该会看到类似这样的内容，即你生成的HTML文件。

课程总结

本节课中我们一起学习了很多内容：识别特定术语并高亮显示它们，或者提取它们并保存到CSV文件中，以及如何将数据写入文件并下载。

在下一课中，你将看到如何加载CSV格式的数据（类似于本课中创建的包含餐厅及其菜品的数据），并使用它来帮助规划你的假期。请尝试完成本Jupyter笔记本末尾的练习，之后，我期待在下一个视频中见到你。

025：使用CSV文件规划假期 📅

在本节课中，我们将学习如何处理结构化的数据，特别是CSV文件。我们将了解如何读取CSV文件、从中提取信息，并使用Python代码（无需AI语言模型）来过滤数据，从而辅助我们规划假期行程。

---

文本文件与结构化数据

文本文件非常通用，可以用多种不同方式格式化。因此，我们有时称其为非结构化数据，因为文本文件几乎没有或完全没有预定义的结构。

相比之下，电子表格具有明确定义的格式或结构，数据整齐地排列在行和列中。这种看起来像带有行和列的表格的数据被称为结构化数据。

在Python中，处理像电子表格这样的结构化数据与处理非结构化文本文件略有不同。通常，你甚至可以不使用AI语言模型，而直接使用Python代码来处理它。

例如，如果你一直在电子表格中为梦想假期的每个目的地保存信息，其中一列指定了国家，那么你就可以使用Python来帮助你按位置筛选，并查看特定国家（如日本）的所有停留点。

---

处理行程表示例

在本节中，我们将使用一个处理行程表的例子，该表格如下所示：

每一行对应一个目的地，包含到达和离开时间。如果你要将此表格表示为CSV文件，它可能看起来像这样，其中每一行都有逗号分隔的四个值，对应表格的四列。

所以，如果你的计算机上有这样的CSV文件，你可以将这些数据加载到Python中。

---

读取CSV文件

让我们导入一些函数，这里的新命令是 import csv。

我的行程保存在一个名为 itinerary.csv 的文件中，因此这将打开该文件。

以下是用于将数据加载到 itinerary 变量中的代码。我们将详细讲解每一行的作用，但如果我现在直接运行它，最终会得到以下结果。

import csv
from display_table import display_table

itinerary = []
with open('itinerary.csv', mode='r') as file:
    csv_reader = csv.DictReader(file)
    for row in csv_reader:
        itinerary.append(row)

print(itinerary)

这段代码会逐行读取CSV文件，并将其保存到列表 itinerary 中。让我关闭文件（如果我忘记的话）。如果我打印 itinerary，你会看到这个结果。你可以确认 itinerary 的类型。

让我们看看 itinerary[0]。这本身是一个字典，其键为 arrival、departure、city、country。因此，如果我使用 itinerary[0] 然后访问 country 键，最终会得到 USA。

现在你可能想知道这段代码做了什么。我鼓励你尝试使用聊天监视器并阅读解释，看看是否能理解。但我们将一起详细讲解。

---

代码详解

这是我们刚才用来读取 itinerary.csv 的代码。

第一行以读取模式打开文件。中间部分的代码读取文件内容并将其分配给 itinerary 变量，然后关闭文件。

让我们深入探讨这段代码中间部分的作用。

第一行 csv_reader = csv.DictReader(file) 使用了我们导入的 csv 模块，它将使用字典来存储每一行的数据。

接下来，itinerary 初始化为一个空列表。最后，这段代码遍历CSV文件的每一行，并将该行的内容添加到 itinerary 列表的末尾。

现在，打印 itinerary 会得到这个结果，有点难以阅读。因此，我还提供了一个我们导入的 display_table 函数，它能以美观的方式打印出表格。

这不是很好吗？

---

过滤结构化数据

对于像这样的表格形式的结构化数据，通常更可行的是过滤信息，甚至无需使用AI语言模型。

例如，如果你想获取所有位于日本的目的地，以下是你可以做的。

filtered_data = []
for trip_stop in itinerary:
    if trip_stop['country'] == 'Japan':
        filtered_data.append(trip_stop)

display_table(filtered_data)

这段代码的意思是：遍历行程中的所有行，如果国家是日本，则将该停留点添加到 filtered_data 中。如果我这样做，然后调用 display_table(filtered_data)，最终会得到对应日本的那一个停留点。

---

使用行程建议活动

现在让我们使用行程来建议旅行活动。

首先，检索第一个目的地，即美国的纽约市。

我们可以设置 trip_stop = itinerary[0]，因为记住，0对应列表中的第一个条目。这是一个在纽约、美国的停留点。

现在，让我们将该停留点的所有关键数据存储到四个新变量中：city、country、arrival、departure。提醒一下，这是访问字典中特定键的代码。

然后，我将创建一个语言模型提示，内容是：“我将访问 city country，从 arrival 到 departure。请创建详细的每日行程。”让我们获取模型的响应并显示它。

这会创建一个相当有趣的行程。7月4日是美国独立日，因此它建议去看7月4日的烟花表演。

我鼓励你在看完这个视频后尝试自己的变体。为什么不做出一些改变，看看是否也能得到一个有趣的行程呢？

---

总结与展望

我希望你在思考潜在假期时能获得乐趣。当你完成对这个笔记本的探索后，我期待在下一节课见到你，在那里你将学习如何定义自己的函数。

你已经看到，有些代码行我们最终会反复编写，例如，打开文件、从该文件读取文本、然后关闭文件。在下一节课中，你将看到定义自己的函数如何让你重新运行一组命令，而无需反复编写它们，这种方式比完整的循环更灵活。

期待在下一节课见到你。

026：将代码块转换为可重用函数 🧩

在本节课中，我们将要学习Python中一个非常强大的概念——函数。我们将了解如何将重复的代码块封装成可重用的函数，从而提高代码的效率和可读性。

在前几门课程中，你可能已经注意到，我们偶尔会重复执行某些步骤。例如，反复执行打开文件、读取内容、然后关闭文件的操作；或者定义几个变量，使用f-string创建提示词，然后让大语言模型根据该提示词生成响应。

我们已经看到，for循环可以帮助你连续多次执行相同的操作。但for循环要求你连续地、一个接一个地多次执行该操作，而不是说先加载读取一个文件，然后可能做一些其他事情，再读取另一个文件。这与for循环那种一个文件接一个文件加载的刚性结构不同。

然而，Python提供了另一种非常有用的创建可重用代码块的方法，称为函数。

函数是编程中一个非常重要的概念，所有现代编程语言都提供了定义和使用函数的方法。

在本课程和前几门课程中，你已经在许多地方遇到并使用过函数。在本节课中，你将学习如何创建自己的函数，并了解它们如何帮助你避免重复代码和反复输入相同的内容。

函数很重要，让我们看看如何创建它们。

什么是函数？ 🔧

函数是一组可重用的命令，帮助你执行特定任务。你已经见过print函数，或者len函数（给定一个列表，返回其长度），或者print大语言模型的响应。

现在，让我们看看为什么你可能想要定义自己的函数。

之前，我们写过这样的代码块来打开文件、读取内容并打印从文件中加载的文本。

f = open("Sydney.txt")
journal = f.read()
f.close()
print(journal)

如果我想对另一个城市（如巴黎）执行此操作，我必须这样做，并将文件名替换为“Paris.txt”。

我不想一遍又一遍地这样做。因此，我将定义一个名为print_journal的函数。

定义第一个函数 📝

以下是定义函数的代码：

def print_journal(file):
    f = open(file)
    journal = f.read()
    f.close()
    print(journal)

现在，你可以对“Sydney.txt”调用print_journal函数，让它加载并打印出文件内容。然后，如果你想要“Paris.txt”的内容，你可以再次调用它。

让我们仔细看看这里的每一行代码做了什么。

def是一个特殊的命令，它告诉Python你想要定义一个新函数。print_journal是函数的名称。然后是一对括号，括号内是变量名file。file被称为这个函数的参数。这意味着当你使用或调用这个函数时，这个函数期望你给它一个文件名。

接着是一个冒号，后面跟着一个缩进的代码块。函数将运行这四行代码，即设置f等于打开文件、读取内容、关闭文件并打印日志。因此，每次调用print_journal函数时，都会运行这四行代码。这与你反复使用的四行代码完全相同。

返回值的函数 🔄

上面我们定义了一个函数来加载和打印日志。但如果你想要一个加载日志但不立即打印的函数呢？

让我定义一个不同的函数。我将把它放在下面，以便你可以比较这两个函数。

def read_journal(file):
    f = open(file)
    journal = f.read()
    f.close()
    return journal

首先，函数名从print_journal改为了read_journal。其次，我们移除了print语句，并添加了一行return journal。

return命令的作用是让read_journal函数获取journal的值并将其返回。如果我调用read_journal("Tokyo.txt")，这个函数将返回一个值。因此，我可以定义一个新变量journal_tokyo = read_journal("Tokyo.txt")。运行后，journal_tokyo将被设置为函数返回的值。

现在，如果你打印journal_tokyo，你会得到我们之前看到的文章。由于你将内容保存在变量journal_tokyo中，你还可以做其他事情，比如打印这篇文章的长度。

详细解释一下我们刚才看到的内容：除了将print语句改为return语句外，其他部分与之前相同。return语句获取journal的值并将其返回。在这种情况下，返回的值是变量journal所持有的值。

另一个实用示例：温度转换 🌡️

让我们再看一个例子。之前，你看到Python可以执行计算，比如将华氏度转换为摄氏度，使用的代码如下：

fahrenheit = 72
celsius = (fahrenheit - 32) * 5 / 9
print(celsius)  # 输出 22.22

如果你想转换另一个温度，你可以再次编写这段代码。例如，68华氏度是20摄氏度，76华氏度是24.44摄氏度。因此，如果你想转换多个温度，最终可能会反复编写这段代码。

以下是定义一个函数来进行转换的方法：

def fahrenheit_to_celsius(fahrenheit):
    celsius = (fahrenheit - 32) * 5 / 9
    print(celsius)

我定义了一个名为fahrenheit_to_celsius的函数，并输入参数fahrenheit，它表示华氏温度。必须有一个冒号，然后是一个缩进的代码块。转换到摄氏度的公式是(fahrenheit - 32) * 5 / 9，然后我们可以在这里使用print语句。

现在，如果我运行这段代码，它就定义了fahrenheit_to_celsius函数。现在，如果我调用这个函数并传入71，它会进行转换。如果我要求它转换70度，或者转换212华氏度到摄氏度，结果是100度。

你会发现，如果没有函数，如果你想转换不同的温度，你会反复编写非常相似的代码。但有了函数，你可以定义函数一次，然后反复使用它。因此，右边的代码比之前的例子要短得多。

使用return语句的函数 📤

在上一个例子中，函数没有返回任何值，它只是将结果打印到屏幕上。为了保存温度转换的结果，你可以使用return语句。

因此，我们可以不使用print语句，而是让它返回celsius值。

def fahrenheit_to_celsius(fahrenheit):
    celsius = (fahrenheit - 32) * 5 / 9
    return celsius

现在，当我运行这段代码时，我定义了一个新的fahrenheit_to_celsius函数。现在，如果我说fahrenheit = 45，celsius = fahrenheit_to_celsius(fahrenheit)，然后打印摄氏温度，你会得到7.222。你还可以对celsius做其他事情，比如查看它的类型，在这种情况下它是一个浮点数。

动手练习 ✍️

我们已经编写了将华氏度转换为摄氏度的函数。你能修改这段代码来转换摄氏度到华氏度，或者转换英尺到米吗？

我希望你享受使用函数的乐趣，毕竟“function”（函数）这个词里就包含着“fun”（乐趣）。在下一课中，我们将把你目前所看到的一切整合起来，使用文本和CSV文件来规划一次完美的环球度假。下节课见！

027：为多个城市创建行程

在本节课中，我们将综合运用之前学到的所有知识，来规划一次环球旅行。我们将学习如何遍历一组文件，为每个文件提取关键信息，并利用这些信息调用大语言模型，最终借助Python和AI的力量，规划出完整的旅行行程。

概述

上一节我们学习了如何处理文件和结构化数据。本节中，我们将看看如何将这些技能结合起来，构建更复杂的工作流。具体来说，我们将遍历多个城市的旅行数据文件，为每个城市生成包含餐厅推荐和详细活动的个性化行程。

处理单个城市的行程

首先，让我们回顾一下如何为单个城市（例如悉尼）创建详细行程。我们需要读取该城市的旅行日志和餐厅数据。

读取CSV文件

我们定义一个函数来读取CSV格式的文件。这个函数会打开文件、加载数据并返回。

def read_csv_file(filename):
    with open(filename, 'r') as file:
        data = csv.reader(file)
        return list(data)

运行此函数后，我们可以将CSV数据加载到变量中并显示。

生成详细行程

接下来，我们使用大语言模型为悉尼生成详细行程。我们需要提供城市、国家、抵达和离开日期，以及从CSV文件加载的餐厅字典。

以下是用于提示大语言模型的模板：

为{city}, {country}从{arrival}到{departure}的访问创建一个详细的每日行程，包含详细的活动，并指定早餐、午餐和晚餐的时间。我们希望参观列在以下餐厅字典中的餐厅：{restaurants}。

我们将使用f-string来插入变量，获取大语言模型的响应，并显示结果。运行此代码会生成一个包含餐厅推荐和活动安排的详细行程。

为所有城市创建行程

现在，我们已经掌握了为单个城市创建行程的方法。本节中，我们将看看如何为行程中的所有城市自动完成这一过程。

初始化与循环

我们首先创建一个空字典来存储所有城市的详细行程。

detailed_itineraries = {}

然后，我们遍历行程中的每个旅行站点。对于每个城市，我们设置城市、国家、抵达和离开日期等变量，并从对应的CSV文件（例如 Sydney.csv）加载餐厅数据。

构建提示并获取响应

在循环中，我们为每个城市构建与大语言模型交互的提示。提示结构与之前类似，但会动态插入每个城市的具体信息。

为{city}从{arrival}到{departure}的访问创建详细行程，包含早餐、午餐和晚餐。餐厅字典如下：{restaurant_dictionary}。

接着，我们获取大语言模型对该提示的响应，并将结果保存到 detailed_itineraries 字典中，以城市名为键。

查看结果

循环完成后，所有城市的详细行程都保存在字典中。例如，要查看东京的行程，可以执行：

display_markdown(detailed_itineraries['Tokyo'])

实践与探索

本节我们快速浏览了大量代码。请务必亲自运行代码并仔细阅读，以确保理解。我鼓励你修改代码进行探索，例如，可以告诉大语言模型你是一个早起者，希望行程从每天早上6点开始；或者你习惯晚起，不希望每天上午11点前起床。请查看不同城市的行程安排。记住，如果对任何代码有疑问，你随时可以咨询你的AI聊天助手。

课程总结

恭喜你完成本课程！在本节课中，我们一起学习了：

• 如何综合运用文本和CSV文件处理技能。
• 如何利用大语言模型为多个城市自动生成详细旅行行程。
• 通过遍历文件和数据，构建自动化工作流的方法。

几年前，要实现本课程中展示的内容会非常困难，甚至对于经验丰富的程序员来说也可能无法实现。但得益于AI语言模型的普及，即使是编程新手，现在也能构建出几年前世界上最优秀的程序员都难以完成的应用程序。这正是一个学习编程和使用AI的激动人心的时代。现在，初学者能够实现的事情范围正在迅速扩大，有很多事情是地球上还没有人做过的。因此，为你自己、你的家人、朋友、在工作和家庭中编写代码来提供帮助的机会是巨大的。

希望你在看到编写代码所能实现的一些功能后，能继续探索如何将其应用于你自己的数据和兴趣领域。在本系列简短课程的第四门也是最后一门课程中，你将学习如何访问这些预先编写好的Python程序（称为包或库）。这将让你能够使用大量非常强大的函数，仅用几行代码就能完成真正强大的事情。最后一门课程中的示例将会是最有趣的，我期待在那里见到你。

028：使用第三方代码包与API

概述

在本节课中，我们将学习如何利用他人编写并分享在互联网上的代码来扩展Python的功能。我们将了解Python包（package）的安装与使用，以及如何通过应用程序编程接口（API）调用运行在他人服务器上的代码。这些技能能让你站在巨人的肩膀上，更快、更高效地编写程序。

---

导入命令：加载他人代码的钥匙

在之前的课程中，你已经见过 import 命令。本节中，我们来看看这个命令的实际作用，以及它如何让你加载并使用他人编写的代码。

import 命令是Python中加载外部模块或包的核心机制。其基本语法是：

import module_name

执行这行代码后，Python会搜索名为 module_name 的模块，并将其中的函数、类等定义加载到当前程序中，供你调用。

---

理解Python包：共享代码的集合

上一节我们介绍了如何使用 import 命令。本节中，我们来深入了解这些被导入的代码通常以何种形式存在——那就是“包”。

Python之所以如此流行，一个重要原因是全球的开发者编写了大量优秀的代码，并免费在线分享。这些第三方代码通常被打包成一个“包”（package）。包是一个包含多个模块、数据文件等的目录，它让你能够基于他人的工作成果进行开发，从而大大加快自己编写代码的速度。

Python提供了诸如 pip 这样的工具，让你可以轻松地从互联网下载和安装他人编写的包。安装后，你就能立即调用这些包提供的强大功能。

以下是安装一个包的基本命令示例：

pip install package_name

---

包的应用实例：从网页获取并处理文本

为了让你更具体地理解包的用途，我们来看一个例子。假设你希望你的代码能够下载一个网页，提取其中的文本，并可能对其进行摘要。

你可以找到一个免费的包（例如 requests 用于下载，beautifulsoup4 用于解析HTML）来实现下载和提取文本的功能。这正是在本课程后续你会看到的内容。我们将通过大量示例，展示不同类型的包能为你做些什么。

---

超越本地：使用API调用远程服务

到目前为止，我们讨论的都是安装在你自己电脑上运行的代码包。但还有一类非常重要的包更进一步，它们提供了应用程序编程接口（API）。

API允许你的代码通过互联网，调用运行在他人计算机（服务器）上的代码。例如：

• 有API可以让你的代码联网，向气象服务商的服务器询问某个地点当前的天气情况。
• 也有API可以让你的代码获取实时新闻、股票价格，甚至进行网络搜索。

除了使用API获取信息，代码还能通过API在现实世界中执行操作。例如：

• 你的代码可以使用一个API来发送短信或电子邮件，这条信息最终会到达他人的手机或邮箱。
• 甚至可以使用API下一个网络购物订单，导致一件实体商品被配送到某人的家中。

---

协作与效率：站在巨人的肩膀上

在编程中，基于彼此的工作成果进行构建，一直是我们能够完成如此多任务的关键。通过使用他人的代码、包和API，我们相当于站在了巨人的肩膀上，这让我们所有人都能更快、更有效地编写代码。

如今，随着AI聊天机器人的普及，你还可以就“哪些流行的包或API适合你的项目”获取建议，并让聊天机器人帮助你编写使用这些包或API的代码。

在本课程提供的网站上，我们会为你准备许多工具、包和API，并展示如何将它们安装到你自己的电脑上。

---

总结

本节课中，我们一起学习了如何利用Python的生态来扩展程序能力。我们了解了import命令的作用，认识了“包”作为共享代码的集合形式，并学会了通过pip安装它们。更重要的是，我们探讨了API的概念，它允许我们的程序与远程服务交互，获取信息或执行操作。掌握这些知识，将显著扩展你的计算机所能完成的任务范围。接下来，让我们在视频中具体看看如何操作。

029：从本地文件导入函数 📂

在本节课中，我们将要学习如何从本地文件中导入函数。这是复用代码、组织项目以及使用他人编写好的工具函数的关键技能。

在上一节课程中，我们学习了如何使用 def 命令来定义函数，例如定义华氏度转摄氏度的转换函数。

导入函数的方法

除了自己定义函数，另一种将函数引入代码的方式是使用 import 命令。在之前的代码中，你可能见过类似 from helper_functions import print_llm_response 或 display_table 的语句。

实际上，import 是 Python 用于从计算机上的某个位置加载一个或多个函数的命令。

深入理解 import 命令 🛠️

让我们深入了解一下 import 命令背后的实际运作机制。

在 Python 中，函数允许你将执行某个动作（并可能返回值）的一段代码打包在一起。例如，我们之前定义的华氏度转摄氏度函数。在课程中，你看到的 from helper_functions import print_llm_response 这类代码，其本质是 Python 在寻找一个名为 helper_functions.py（.py 代表 Python 文件）的文件，并从中加载 print_llm_response 函数。

helper_functions.py 文件的内容是我们预先编写好的一系列函数定义，例如 def print_llm_response 函数，它接收一个提示词，进行一些处理，最终打印出响应。该文件还包含一个我们新定义的 celsius_to_fahrenheit 函数，用于执行转换并打印结果。

那么，如何将这个文件中的函数引入到你的代码中呢？

实践导入过程

如果直接调用 celsius_to_fahrenheit(20)，会导致错误，因为该函数在当前环境中尚未定义。

以下是几种使用 import 命令的方法：

方法一：导入特定函数

你可以从文件中导入你需要的特定函数。

from helper_functions import celsius_to_fahrenheit

运行这行代码后，你就可以直接使用 celsius_to_fahrenheit(20) 了。

方法二：导入整个模块

你也可以导入整个文件（称为“模块”）。

import helper_functions

这种方式会导入 helper_functions.py 中定义的所有函数。但在调用时，需要在函数名前加上模块名作为前缀。

helper_functions.print_llm_response("What is the capital of France?")

方法三：导入所有函数（不推荐）

使用 from ... import * 可以导入模块中的所有函数。

from helper_functions import *

这样，你可以直接调用 get_llm_response("What is capital France?") 而无需前缀。但我不常使用这种方法，因为它会导入大量可能不需要的函数，不够清晰。

我个人的习惯是只导入需要的特定函数，或者导入整个模块并在调用时使用 module.function() 的格式。

本节总结

本节课中，我们一起学习了如何从本地文件（如 helper_functions.py）导入函数。主要方法有：

• from file import function：从指定文件导入特定函数。
• import file：导入整个文件模块，调用时使用 file.function()。
• from file import *：导入文件中的所有函数（谨慎使用）。

Python 还内置了许多称为“包”的函数库，它们不一定对应你当前目录下的文件，也无需预先安装。在下一节视频中，我们将学习如何从这些内置包中导入函数，你会发现这些函数能极大地提升你的编码效率。我们下节课见。

030：内置包 📦

在本节课中，我们将要学习如何使用Python内置的包。Python自带了许多功能强大的工具和函数，例如处理CSV文件、进行数学运算、统计分析以及绘制简单图形等。这些内置包由Python语言的支持团队维护，你无需一次性掌握所有，可以根据代码需求选择性地导入。本节课我们将重点学习如何导入和使用数学、统计以及随机数相关的包，为下一课学习第三方包打下基础。

---

导入与使用数学包 🧮

上一节我们介绍了Python内置包的概念，本节中我们来看看如何使用数学包进行基础运算。

Python内置的math包提供了丰富的数学函数和常数。你可以将其想象为一本关于数学的参考书，在需要时从中选取特定的工具。

以下是导入和使用math包中函数的示例：

from math import cos, sin, pi

print(pi)  # 输出圆周率π的近似值

在上面的代码中，我们从math包中导入了余弦函数cos、正弦函数sin以及常数pi。常数pi是一个高精度的浮点数，代表圆的周长与直径之比。

接下来，我们可以计算不同角度的余弦值：

angles = [0, pi/2, pi, 3*pi/2, 2*pi]
for angle in angles:
    print(cos(angle))

你可以尝试将cos替换为sin，来计算这些角度的正弦值。

此外，math包还包含其他实用函数，例如向下取整函数floor：

from math import floor
print(floor(5.7))  # 输出 5

---

使用统计包分析数据 📊

除了数学运算，Python还内置了用于统计分析的statistics包。

现在，我们来看看如何使用这个包来计算数据集的平均值和标准差。

以下是导入和使用statistics包的示例：

from statistics import mean, stdev

heights = [165, 170, 175, 180, 185]  # 朋友的身高列表，单位厘米
print(mean(heights))    # 计算平均身高
print(stdev(heights))   # 计算身高的标准差

statistics包还提供了计算中位数、分位数等其他统计量的函数，可用于对数据进行简单的统计分析。

---

利用随机包增加不确定性 🎲

有时，我们希望程序能产生一些随机结果。Python的random包正是为此设计。

本节我们将学习如何使用random包中的sample函数，从列表中随机抽取元素。

以下是一个有趣的应用示例：随机选择食材来生成新食谱。

首先，我们定义一些食材列表：

spices = ["Paprika", "Oregano", "Cumin", "Cinnamon"]
vegetables = ["Broccoli", "Carrot", "Spinach", "Bell Pepper"]
proteins = ["Chicken", "Beef", "Tofu", "Salmon"]

然后，我们从每个列表中随机抽取指定数量的食材：

from random import sample

![](https://github.com/OpenDocCN/dsai-notes-pt1-zh/raw/master/docs/dlai-ai-bgn/img/b879da940b47054bbb462790ca8245ff_16.png)

![](https://github.com/OpenDocCN/dsai-notes-pt1-zh/raw/master/docs/dlai-ai-bgn/img/b879da940b47054bbb462790ca8245ff_17.png)

random_spices = sample(spices, 2)
random_vegetables = sample(vegetables, 2)
random_protein = sample(proteins, 1)

![](https://github.com/OpenDocCN/dsai-notes-pt1-zh/raw/master/docs/dlai-ai-bgn/img/b879da940b47054bbb462790ca8245ff_19.png)

![](https://github.com/OpenDocCN/dsai-notes-pt1-zh/raw/master/docs/dlai-ai-bgn/img/b879da940b47054bbb462790ca8245ff_21.png)

print(random_spices)
print(random_vegetables)
print(random_protein)

每次运行这段代码，你都会得到一组不同的随机食材组合。接下来，你可以将这些随机食材组合成一个提示词，发送给大语言模型来生成一个全新的食谱创意。

prompt = f"Suggest a recipe using {random_spices}, {random_vegetables}, and {random_protein}."
print(prompt)
# 此处可以调用大语言模型API来获取食谱建议

通过导入random包中的sample函数，你可以编写出每次运行都能产生不同随机结果的代码，这为程序增添了趣味性和灵活性。

---

总结 ✨

本节课中我们一起学习了Python内置包的使用方法。我们首先介绍了如何从math包导入函数来进行数学计算，然后使用statistics包对数据进行统计分析，最后利用random包为程序注入随机性。这些内置包是Python强大功能的基础组成部分。在下一课中，我们将超越内置包，探索如何从互联网下载和安装第三方包，这将极大地扩展Python的能力范围。

031：使用第三方包 🧩

在本节课中，我们将学习如何使用他人编写并分享的Python代码包，即第三方包。我们将重点介绍两个在数据处理和图表绘制中极为流行的包：pandas和matplotlib。通过它们，你可以高效地处理表格数据并创建可视化图表。

---

许多人编写了Python代码并在网上免费分享，供任何人使用。也许有一天你也会这样做。编写代码、在线分享并看到他人使用你的成果，会是一件非常酷且令人满足的事情。

得益于他人已在网上分享的代码，你可以通过下载和安装他们的包来利用他们的工作成果。

我将这些包称为第三方包，因为它们是由你或Python官方维护者之外的其他人编写的。

如今，至少有数十万个这样的第三方包存在。本节课中，你将看到一些由第三方开发的最流行的包，用于处理数据和绘制图表，这两者都是我在工作中经常使用的。你将看到的包叫做pandas和matplotlib。让我们开始吧。

---

使用pandas处理数据 📊

最流行的Python第三方包之一是pandas，它常用于处理结构化数据，例如电子表格和CSV文件中的数据。需要说明的是，这里的“pandas”与可爱的动物无关，它来源于经济学术语“面板数据”的缩写。如果你想知道更多，可以询问AI助手或在线搜索。

导入pandas包最常见的方式是使用以下命令：

import pandas as pd

这里的pd是一个新的东西。接下来，我们问问AI助手这行代码的作用。

原来，如果你直接运行import pandas，那么在使用其功能时需要写成pandas.函数名()。但如果你不想每次都输入pandas，而想用pd作为简短的别名，那么import pandas as pd就告诉Python：加载pandas包，但在后续代码中将其称为pd。这让我们可以写pd.函数名()而不是pandas.函数名()，节省了一些打字时间。我提到这一点是因为，如果你让AI助手编写使用pandas包的代码，它很可能会使用import pandas as pd这种形式。

在本节中，我们将使用一个关于二手车售价的数据集。该数据改编自一个公开URL，由Nehalal Burer等人提供。我将使用pandas的read_csv函数读取数据，然后将其打印出来。

pandas也允许你筛选重要信息。例如，你可以获取所有售价高于10,000美元的汽车数据。pandas有很多不同的命令，很难全部记住。

但事实证明，我们的AI助手非常了解pandas。我们使用代码加载一些数据，告诉AI助手数据的样子，并希望筛选出售价大于等于10,000美元的数据。

我们运行它，AI助手说你可以使用以下语法来筛选数据：

filtered_data = data[data[‘Selling_Price’] >= 10000]

如果你想知道这具体做了什么，可以随时请AI助手解释。我将直接复制这段代码片段。

回到Jupyter笔记本，我们打印从AI助手那里得到的筛选结果。现在，它打印出了售价超过10,000美元的汽车数据。

或者，如果你想找到所有年份为2015年的汽车，你也可以这样做，这会打印出2015年款的汽车。

以下是另一个你可以做的操作。你可以说：

filtered_data = data[data[‘Year’] == 2015]

我们也可以打印filtered_data，然后查看所有2015年款汽车的价格，并打印出中位数价格。这相当于查看所有这些价格，并打印出2015年所有汽车的中位数价格。看起来5,465美元是该年份汽车的中位数价格。

我知道我在这里展示了很多不同的例子。你不需要记住任何特定的代码行，因为如果你想要筛选数据、计算平均值或中位数，我鼓励你向AI助手寻求帮助。顺便说一下，pandas是一个非常强大的工具，专业的数据科学家在日常工作中也使用完全相同的pandas包。

---

使用matplotlib绘制图表 📈

除了操作数据，另一个非常流行的用于绘制图表的包叫做matplotlib。要从matplotlib导入绘图函数，最常见的代码行是：

import matplotlib.pyplot as plt

这个包名有点不寻常，因为中间有一个点。但就我们的目的而言，你不需要担心那意味着什么。

导入plt函数后，我可以使用plt.scatter绘制一个散点图，展示价格与行驶里程的关系。如果我运行它，会显示一个图表，其中X轴是行驶里程（公里），Y轴是价格（美元）。

事实证明，如果你想给坐标轴添加标签，可以添加一些额外的命令。如果我重新运行，你会得到一个看起来像这样的图表。

有时你会看到开发者多写一行plt.show()，这明确告诉Python显示图表。让我也这样做。这样我们就得到了一个关于价格与里程的漂亮图表。

现在，操作数据时你可能想做的一件事是修改已有的图表。例如，如果你想给图表添加网格线，将散点图的颜色改为红色，并增大标题字体大小，该怎么做呢？

我们可以向AI助手提问：“对于下面的绘图命令，请添加网格线，将散点图颜色改为红色，并增大标题字体大小。”让我们看看它是否能为我们解决这个问题。

我将直接获取代码并运行，看看是否有效。然后我运行它，图表中点的颜色变成了红色，并且添加了网格线，标题字体也变大了。

AI助手并不总是给你完全正确的代码，但它们通常工作得相当好。因此，许多开发者会让AI助手生成代码，快速检查一下确保它看起来合理，然后运行看看是否有效。有时它可能不工作。但如果你去告诉AI助手：“谢谢，但它不太对，字体或列名不是我预想的。”有时你可以让AI助手再试一次，第二次得到正确答案的机会更大。但在这里，它第一次就工作得很好。

---

总结 ✨

在本节课中，你尝试使用了两个第三方包：pandas包和matplotlib包。你看到了在使用它们之前需要先导入函数。这种导入命令与你用于内置包（如math包）或保存在文件中的函数（如helper_functions文件）非常相似。

对于Python内置包，它们已经是Python的一部分，你不需要安装它们。在这个Jupyter笔记本环境中，我们已经确保pandas和matplotlib已经安装好了。

但是，还有很多第三方包尚未安装在你的电脑或特定的Jupyter笔记本环境中。那么，你如何让你的电脑连接到互联网，去下载并安装一些全新的第三方Python包呢？让我们进入下一课来学习如何做到这一点。

032：安装Python包

在本节课中，我们将要学习如何在Jupyter Notebook中安装Python包。你将了解安装包的基本流程，并通过安装bs4和ai-setup这两个具体的包来实践。掌握这项技能后，你将能够在自己的环境中使用各种强大的Python库。

概述

到目前为止，本网站上的所有Jupyter Notebook都已预先安装了运行所需的所有包。

但是，如果你在单独的Jupyter Notebook中工作，例如在你自己的电脑上而非本网站，你可能需要自己安装一些包。

在本课程后期，如果你有兴趣，会看到如何在自己的电脑上设置Python运行环境。

在本节课中，你将看到下载和安装包的过程是怎样的。你将完成一个用于解析HTML网页的包的安装过程。

安装包的基本方法

安装Python包有多种方式。这里，我将介绍如何直接在Jupyter Notebook中完成安装。

我们想在本节课中使用一个名为bs4的包来解析HTML网页。要安装bs4包，我使用命令!pip install，后面跟上包名。

!pip install bs4

运行此命令后，我的电脑将联网查找bs4包，然后下载并安装它。看起来它已成功安装bs4版本0.0.2。顺便说一下，bs4代表Beautiful Soup版本4。Beautiful Soup这个名字引用了《爱丽丝梦游仙境》中的一首诗，如果你好奇这个名字的由来，可以在网上搜索或询问AI聊天机器人。

这是一个用于解析HTML网页的Python包。bs4是一个相对较小的包，所以它在几秒钟内就安装完成了。有些包可能需要几分钟才能安装。

安装此包后，你就可以导入该包或其包含的任何函数。

使用已安装的包

我将从刚刚安装的bs4包中导入BeautifulSoup函数。这里，bs4是包名，BeautifulSoup是函数名。对于今天要使用的例子，我们还需要导入一些其他东西。

以下是需要导入的模块和函数：

from bs4 import BeautifulSoup
import requests
import helper
from IPython.display import display, HTML

• requests 将用于下载网页。
• helper 是辅助函数。
• from IPython.display import display, HTML 用于在Jupyter Notebook中打印HTML网页。

实践：从网页抓取文本

要从网络抓取数据，首先需要获取网页的内容。这里有一个URL，它实际上是我在一份名为“The Batch”的每周通讯中写的一封信的链接。

为了获取这个URL，我将使用requests库。

url = "https://example.com/the-batch-letter"  # 示例URL
response = requests.get(url)

我们使用了点号表示法requests.get(url)。如果我们之前写的是from requests import get，那么就可以直接写get(url)，但这是程序员使用requests包更常见的方式。

现在，让我们看看网页实际是什么样子。下面的代码将在Jupyter Notebook中显示该网页地址的URL，技术上是在一个叫做iframe的东西里。

display(HTML(f'<iframe src="{url}" width="800" height="600"></iframe>'))

这显示了我写的那封信，内容是关于为什么我认为世界会因更多智能而变得更好。如果你愿意，可以随时在你自己的网络浏览器中加载这个URL，你会看到相同的网页。

这个网页包含许多元素。有一个菜单栏，有许多不同的字体，有一个徽标图片，下面还有另一张图片。它有一堆指向其他网页的链接。所以这里有很多不同的东西。

但是，如果你想使用你的大语言模型来为你总结这封信，你可能只想提取其中的主要文本。

使用Beautiful Soup，你可以获取我们之前得到的响应，并仅提取网页的文本。

soup = BeautifulSoup(response.content, 'html.parser')
paragraphs = soup.find_all('p')
combined_text = ' '.join([para.get_text() for para in paragraphs])
print(combined_text)

如果你需要自己编写这样的代码，不必过于担心细节，实际上你可以请AI聊天机器人为你编写代码。

我使用Beautiful Soup从响应中获取文本并解析（即解释）HTML，然后找到HTML页面中所有段落里的文本，最后将所有内容合并成一个巨大的文本并打印出结果。

这样做之后，你最终会得到信中的文本。如果在你运行此代码时网页内容已更改，你自己运行时可能会得到略有不同的结果。

但希望你能看到，如何获取像这样的文本并将其传递给大语言模型，让它为你生成要点摘要，因为我们在这里打印的组合文本只是一个字符串，然后你可以将其插入到大语言模型的提示词中。

事实上，如果你想这样做，这里有一个提示词：“从文本中提取关键要点”，后面跟着combined_text，然后是print_response。

prompt = f"""
请从以下文本中提取关键要点：
{combined_text}
"""
print_response(prompt)

这样，它就从信中提取出了最重要的要点。

核心要点

我向你展示这些的主要目的并不是专门介绍Beautiful Soup，尽管如果你想了解这段代码具体在做什么，可以询问AI聊天机器人。

我希望你从中学到的关键要点是：使用 !pip install 加包名。安装包之后，你就可以导入包中的函数，并立即在你自己的代码中开始使用它。

安装另一个包：ai-setup

让我再展示一个安装另一个包的例子。运行 !pip install ai-setup。

!pip install ai-setup

ai-setup 是由DeepLearning.AI团队提供的一个包，它包含了你在本课程和先前课程中见过的关键辅助函数，并配置你的电脑以识别这些你一直在使用的关键辅助函数。这样你就可以在你自己的代码中使用它们。

例如，安装后你可以运行：

from ai_setup import get_response

现在你可以提问，比如：“为什么编程语言叫Python？”，然后你会得到答案。我认为这是一个有趣的答案，其灵感来源于一个非常有趣的电视节目《蒙提·派森的飞行马戏团》。

因此，从 !pip install ai-setup 中得到的启示是：这让你可以立即导入函数，并在你自己的代码中开始使用它们。

ai-setup 的这个特定例子在本网站上有效。要在你自己的电脑上实际使用 ai-setup，还需要一个步骤，我们将在后面的课程中讨论。

事实证明，get_response 正在使用一种叫做API（应用程序编程接口）的东西，通过互联网访问某个大语言模型提供商的网站（在本例中是OpenAI），来获取这个问题的答案。

事实证明，API是一种非常强大的方式，让你可以用代码在获得许可的情况下访问别人的计算机，并从别人的计算机获取答案。

总结

本节课中，我们一起学习了如何在Jupyter Notebook中安装Python包。我们通过安装bs4包来解析HTML网页，并安装了ai-setup包来获取课程中的辅助函数。你学会了使用 !pip install [package_name] 命令，并在安装后导入和使用包中的功能。这项技能是扩展Python编程能力的基础。

在下一个视频中，我们将深入探讨什么是API以及如何在你自己的代码中使用它们。让我们进入下一个视频，学习API以及它们如何帮助你快速使你的程序变得更强大。

033：使用API从网络获取数据 🌐

在本节课中，我们将学习如何使用API从互联网获取实时数据。我们将以获取天气数据为例，了解API的工作原理，并编写代码来获取和解析这些数据。

---

有时，您希望编写代码解决的问题可能涉及实时数据。例如，使用天气数据来规划当天的着装，或许是在您度假时。

为了访问诸如当前天气、股票价格、新闻或调用网络搜索引擎查找相关网页等数据，您需要使用一种称为API（应用程序编程接口）的东西。API为您的计算机提供了一种与另一台计算机通信的方式，让那台计算机为您执行某些操作，例如获取某个城市的当前天气并将其返回给您的计算机。互联网上有很多API，有些是免费的，许多可能需要付费，因为运行计算机和操作该API服务通常需要成本。

但与下载软件包在本地运行不同，API允许您在获得许可的情况下，让别人的计算机为您完成工作。

让我们通过一个有趣的例子来看看API是如何工作的：使用API获取实时天气数据来规划当天的着装。

---

API如何工作 🤔

API是您的计算机让另一台计算机为您获取数据或执行工作的方式。可以将其类比为您坐在餐厅里想要一些食物。您与一位友好的服务员交谈，然后服务员会去厨房获取并递送您点的餐。服务员就是您和厨房之间的中间人，而API的作用就是作为您和提供数据或服务的其他计算机之间的中间人。

---

获取天气数据示例 🌤️

让我们通过一个示例来实践。我将导入必要的库，并使用一个名为openweathermap.org的网站提供的API。我现在位于美国加利福尼亚州的帕洛阿尔托，此刻这里的天气是24摄氏度，相当不错。但与其使用网页界面查询天气，我将展示如何使用API让我的计算机自动从另一台计算机获取天气。

大多数API会要求提供所谓的“密钥”或“API密钥”。您可以将API密钥视为一个专属于您的密码。这样，处理您请求的计算机就知道请求来自谁。

以下是加载我的专属API密钥的简单代码。目前不必过于担心这段代码在做什么，稍后我会再详细说明。

import os
import requests
from ai_setup import print_lm_response
import dotenv

我将指定我所在位置的纬度和经度，然后构建一个URL字符串。这是一个指向API的URL，在字符串中插入纬度、经度和API密钥。然后，我将通过向该URL发送请求来获取响应。以下是打印我们从响应中获取的数据的语法。

# 加载API密钥（示例，实际使用时需替换为您的密钥）
api_key = os.getenv('OPENWEATHER_API_KEY')

# 指定位置（以帕洛阿尔托为例）
lat = 37.4419
lon = -122.1430

# 构建API请求URL
url = f"https://api.openweathermap.org/data/2.5/weather?lat={lat}&lon={lon}&appid={api_key}&units=metric"

# 发送请求获取数据
response = requests.get(url)
data = response.json()

返回的数据是一个包含许多值的字典。温度是24.02度，体感温度是23.98度。描述显示天空晴朗。这里还有风速等信息。这是一个相当复杂的字典。

为了提取我可能想要的关键信息，如温度、描述和风速，我可以让我的AI聊天机器人帮我编写代码。我会问它：“如何从这个数据变量中获取温度、描述和风速？”

然后，我将复制聊天机器人提供的代码并运行它。

# 假设这是从AI聊天机器人获得的代码，用于解析数据
temperature = data['main']['temp']
description = data['weather'][0]['description']
wind_speed = data['wind']['speed']

![](https://github.com/OpenDocCN/dsai-notes-pt1-zh/raw/master/docs/dlai-ai-bgn/img/a0b9f7247bb2d093c66c4f5cc2fb4460_9.png)

print(f"温度: {temperature}°C")
print(f"天气状况: {description}")
print(f"风速: {wind_speed} m/s")

运行后，它会将温度提取到temperature变量中，以及描述和风速。如果您想要一份美观的天气报告，我们可以提取这些数据并像这样打印出来。

运行此代码时，您可以自由查找您自己城市的纬度和经度，并填入其中，以查看您所在城市的当前天气。

---

根据天气建议着装 👕

一件有趣的事情是，我们可以根据以下天气情况建议合适的户外着装。如果您有特定的着装偏好，可以添加到提示中，但为了保持通用性，例如轻便的T恤和短裤、太阳镜或防晒霜（防晒霜实际上是个好主意）。

# 根据天气数据提供简单的着装建议
if temperature > 20:
    outfit_suggestion = "建议穿着轻便的T恤和短裤。"
elif temperature > 10:
    outfit_suggestion = "建议穿着长袖衬衫和长裤。"
else:
    outfit_suggestion = "建议穿着外套或夹克。"

print(f"着装建议: {outfit_suggestion}")

这就是您如何通过互联网调用API，从其他计算机（如openweathermap.org的Web服务器API）获取信息。

---

关于API的更多信息 📚

对于不同类型的数据服务，会有不同的API。您可能需要在线查找文档或咨询其他AI聊天机器人，以了解如何调用不同的API。AI聊天机器人更可能知道如何调用互联网上更流行的API；对于不太流行的API，您可能需要自己查看文档。

对于许多API，您需要提供一个API密钥值。这是一个秘密的字符串（由数字和字母组成），让网站知道是您在发出此API请求调用。

我们已经设置了这个Jupyter笔记本环境来使用此API。但如果您想在自己的计算机上实际操作，您需要访问相关网站注册账户并获取一个秘密的API密钥，然后将api_key变量设置为等于该密钥。一种方法是编写一行代码，如api_key = "您的秘密字符串"。如果您使用实际的API密钥运行这行代码，然后调用API，那将起作用。

但事实证明，尽管这可行，大多数程序员不会这样编写代码，因为如果您将API密钥直接放在代码中，那么如果您的代码泄露给他人，其他人将能够访问您的秘密API密钥。

因此，大多数程序员会使用dotenv包的load_dotenv函数，它通过几个额外的步骤来安全地加载和使用API密钥。如果您想了解这两行代码的作用，可以询问AI聊天机器人，以更详细地解释如何更安全地存储API密钥（如果您感兴趣的话）。

---

总结 📝

在本节课中，我们学习了如何获取实时数据（即天气数据）。实际上，还有许多API可以让您访问先进的AI模型。事实上，print_lm_response函数就是使用互联网上的API来访问OpenAI的ChatGPT大型语言模型。在下一课中，我们将深入探讨print_lm_response函数实际如何工作，以及您如何编写代码通过互联网访问先进的AI模型。

让我们在下一个视频中继续学习。

034：使用API调用AI模型 🧠

概述

在本节课中，我们将学习如何使用应用程序编程接口来调用在线AI模型。你将了解get_response函数背后的工作原理，并学习如何通过API与OpenAI的ChatGPT等大型语言模型进行交互。

---

上一节课我们学习了如何使用API获取实时天气数据。但API的功能远不止获取数据，它们还能帮助你访问在线AI工具，例如OpenAI的ChatGPT、Google的Gemini或Anthropic的Claude等。

例如，你一直在使用的get_response函数，其底层就是调用了OpenAI的ChatGPT API。

OpenAI的大型语言模型运行在互联网上的计算服务中。你可以通过API向ChatGPT提问并获取答案。

在本节中，我们将深入探究你在过去几门课程中一直使用的get_response函数的具体实现。让我们来看一看。

使用OpenAI API的步骤

以下是使用OpenAI API的方法。我已经安装了openai包。如果你的电脑上还没有安装，可能需要运行pip install openai，但我已经完成了这一步，所以这里不再重复。

来自openai包的openai函数，正是你在helper_functions或ai_setup包中使用的get_response函数的动力来源。

让我们看看get_response函数实际上做了什么。我知道这段代码看起来有点复杂，你不需要理解每一行，但我希望快速浏览一遍，让你对现代前沿API的使用方式有一个直观感受。

以下是get_response函数的核心代码示例：

completion = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "system", "content": "You are a helpful AI assistant."},
        {"role": "user", "content": prompt}
    ],
    temperature=0
)
response_text = completion.choices[0].message.content
return response_text

client.chat.completions.create是OpenAI提供的一个函数。

这行代码选择了我们想要使用的大型语言模型，这里我们使用的是gpt-4o-mini模型。

当你使用大型语言模型时，我们常做的一件事是告诉它如何回应，这被称为系统消息。我们告诉大型语言模型，我们希望它扮演一个AI助手的角色。稍后我们将看到一个例子，看看如果你改变这个系统消息会发生什么。

然后我们还指定了提示词，它可以是一个问题，例如“法国的首都是什么”。

事实证明，大型语言模型有一个名为温度的参数，它控制着响应的随机程度。在我的代码中，我经常将其设置为零，如果我不希望响应过于随机的话。这是你可以使用大型语言模型的最低温度。

接着，顶部的这行代码从大型语言模型（我们有时称之为“补全”）获取结果，然后你提取响应的文本，最后返回响应的文本。

如果你不理解这段代码的每一行，请不要担心。我只是想让你了解一下，如果你自己要实际使用它，代码会是什么样子。你可以直接复制这段代码块，粘贴到你自己的代码中并运行。

事实上，如果你访问OpenAI的网站，那里有API的在线文档，你很可能会找到一个看起来很像这样的代码示例。因此，你可以直接从OpenAI文档、Anthropic Cloud文档、Google Gemini文档或你正在使用的任何工具的文档中获取代码示例，然后让它在你自己的代码中运行，而无需担心这里的每一行代码具体在做什么。

理解代码与寻求帮助

如果你想理解这段代码每一行的作用，像往常一样，你也可以询问一个语言模型。

它会逐行为你讲解。请注意，你的语言模型是通过阅读互联网上的文本学习的，因此它们会更擅长理解更知名、在互联网上存在时间更长的API。对于不太流行的API，或者由互联网上其他人刚刚创建和发布的API，它们的理解能力可能就没那么强。

配置API密钥与运行示例

现在，为了使用OpenAI API，你需要使用从OpenAI网站获取的秘密API密钥。我将使用load_dotenv方法来安全地获取这个API密钥。

然后，这行代码你也可以从OpenAI文档中获取，用于初始化OpenAI服务或OpenAI客户端。运行之后，我现在就定义了get_response函数。

现在，如果我发送提示词“法国的首都是什么”，它将生成响应。因为我在这里使用了我的API密钥，所以会向我的账户收取一小部分费用。

为了展示一些有趣的东西，如果你将系统消息改为“你是一个讽刺的AI助手”，让我重新定义一下。

如果我再次运行，让我们看看它会说什么。哦，这确实相当讽刺。是的，答案是巴黎，但带着很多态度。这就是系统消息的作用，它告诉大型语言模型你希望它如何表现。

也许再展示一个有趣的现象，如果我将温度设置为一个更高的数字，比如1.0（这是一个相当高的温度），这会使响应更加随机。每次我运行它，在这种情况下，都会得到一个不同的讽刺性回应。

这个温度参数可以在0到2之间变化，让你可以控制你希望响应具有的随机程度。许多人使用大约0.7的值，这是一个常见的选择，这会给你带来一点随机性，也许是一点创造性的表象，而不会过度随机。

我鼓励你尝试这个参数，试试不同的温度值并多次运行，或者尝试不同的系统消息。也许尝试创建一个总是返回押韵句子的AI系统，或者一个只说某种语言（如西班牙语或日语）的AI系统，看看你会得到什么结果。

在本地计算机上运行

最后，如果你想在自己的计算机上本地运行所有这些，我想分享一些关于如何将API密钥放入代码中的细节。

在通过pip install ai_setup安装ai_setup之后，你可以从ai_setup导入一个名为authenticate的函数，以及print_response和get_response。

authenticate函数需要传入一个你可以从OpenAI网站获取的API密钥。这是一项付费服务，因此可能会要求你提供信用卡信息。其他大型语言模型提供商通常也会要求提供信用卡信息以获取访问其服务的API密钥。

但如果你这样做，这将使用你安全的API密钥对你的程序进行身份验证，以访问OpenAI的API服务，然后你就可以用它来生成大型语言模型的响应。

将你的API密钥存储在代码内部并不是最安全的方式。一个更好、更推荐的方式如下：

import os
from dotenv import load_dotenv
load_dotenv()
api_key = os.getenv("OPENAI_API_KEY")
# 然后使用 api_key 进行身份验证

这三行新代码会将API密钥存储在一个.env文件中，从该文件加载密钥，然后使用更安全地从.env加载的API密钥进行身份验证。你还需要from dotenv import load_dotenv并运行这段代码，以及另一个名为os的库。

我现在不想深入探讨这些细节，但你可以询问AI语言模型，它将能够为你详细讲解所有这些步骤。如果你尝试这个并遇到任何错误信息，那么我会将错误信息复制粘贴到AI聊天机器人中，让它尝试帮助你调试。

因此，如果你在自己的计算机上设置了Python，而不是在DeepLearning.AI等网站通过互联网运行，这就是你将使用的代码。

后续步骤与课程总结

在这段视频之后，有一个可选的阅读材料，它将向你展示如何在本地计算机上安装Python和Jupyter笔记本的一些选项。有不同的方法可以实现，在Mac和Windows机器上可能略有不同。该材料免费提供了几个选项，以便你可以在需要时安装这些东西并在自己的计算机上运行。

阅读这个材料以及安装相关软件对你来说完全是可选的。但我个人很喜欢在我的笔记本电脑上运行Jupyter笔记本和Python，我认为你可能也会喜欢，因为即使在没有网络连接的情况下（比如在飞机上或其他地方）也能在自己的计算机上运行东西，这真的很酷。

无论你是否阅读那个材料，我们都将以最后一个视频结束，在视频中我们将讨论完成本课程后你接下来可能要去往何方。

---

总结

本节课我们一起学习了如何使用API来调用在线AI模型。我们探讨了get_response函数的核心代码，了解了系统消息和温度参数如何影响AI的响应。我们还介绍了如何安全地配置API密钥，并简要提及了在本地计算机上设置开发环境的可选步骤。通过API，你可以将强大的AI能力集成到自己的应用程序中。

035：课程总结与后续步骤 🎉

在本节课中，我们将对《给初学者的AI Python编程课》进行总结，并探讨完成课程后可以采取的后续学习与实践步骤。

恭喜你完成了这门课程，也完成了“AI Python for Beginners”系列的学习。在这几门课程中，你学到了很多知识。

课程回顾 📚

上一节我们介绍了如何使用外部包来扩展Python的能力。现在，让我们回顾一下整个系列的学习成果。

你从Python的基础知识学起，例如数据类型、函数和变量，以及代码模式，比如for循环和if语句。

# 示例：一个简单的for循环
for i in range(5):
    print(i)

你还学会了如何让Python读取计算机中的文件，从而能够处理你自己的文档和数据，或者利用AI来规划梦想假期。

在这最后一门课程中，你看到了如何通过使用其他程序员编写的包来扩展Python的能力。这些包让你可以下载和处理网页、制作图表、获取天气数据，甚至通过互联网调用大型语言模型。

后续步骤建议 🚀

现在你可能想知道接下来可以做什么。有很多事情可以做。

以下是你可以考虑的一些具体后续步骤。

首先，如果你还没有这样做，请考虑在你自己的计算机上安装Jupyter。在自己的笔记本电脑上运行代码会很有趣。

此外，我希望你继续学习课程，不断进步。在DeepLearning.AI平台上，有几门短期课程你可以考虑。

一门是ChatGPT Prompt Engineering for Developers，它将教你如何以更复杂的方式提示ChatGPT。

另一门是Prompt Engineering with Llama 2。

如果你想学习更深入、更实质性的内容，可以考虑参加我们的机器学习专项课程。

开始你的项目 💡

在你继续学习课程的同时，如果你有项目想法，请付诸实践。

请负责任地运用你的技能，即以帮助他人的方式使用它们。我见过初学者从事的项目可能涉及下载网页并处理该页面，也许是为了总结它，或者收集与你的业务相关的见解。

其他项目可能包括通过使用网络搜索引擎的API进行网络搜索，或者从PDF中提取文本并处理该文本，以及许多其他有趣的例子。

如何获取帮助与持续成长 🌱

如果你还不知道如何做某件事，我鼓励你去询问AI聊天机器人。不一定是本网站上的那个，而是打开ChatGPT、Anthropic的Claude、Google的Gemini或其他机器人，向它们寻求帮助。

也许还可以快速进行网络搜索，看看是否有任何相关的Python包或API可以使用。

许多人从做小项目开始，然后随着时间的推移逐渐发展到越来越大的项目。所以不要觉得你的第一个项目必须是改变世界的庞然大物。如果你能做一些小而有趣的项目，那就很棒了。

无论你的项目是否成功，你都可以吸取这些经验教训，并希望进行第二个稍大一点的项目，通过这个过程学习更多，依此类推。

直到今天，我仍然经常尝试编写代码，有时我做的事情就是行不通。这发生在我们所有人身上，这就是练习。

总结与寄语 ✨

通过完成这门课程，你正在不断提升自己的技能。你是一名Python程序员。你刚刚起步，但你现在已经是全球AI编码社区的一员了。我很高兴你能加入我们，并且我乐观地认为，你会找到运用这些技能来改善日常生活和工作的方法。

我们共同的旅程暂时告一段落，我有点难过，但也非常感谢你为学习Python在这些课程上投入的所有时间和精力。

😊，我希望很快能再次见到你，希望你能继续学习和实践，并用你的新技能做出美好的事情，帮助自己和他人。

本节课中我们一起学习了整个AI Python初学者系列的总结，回顾了从基础语法到使用外部包的关键知识点，并为你规划了安装工具、学习进阶课程、开启实践项目以及寻求帮助的清晰路径。记住，编程是一场持续的旅程，重要的是开始行动并享受过程。