谷歌高级数据分析-II-笔记-全-

谷歌高级数据分析 II 笔记（全）

001：《Python入门》课程介绍 🐍

在本节课中，我们将要学习Python编程语言的基础知识，了解它为何成为数据专业人士的强大工具，并预览整个课程的学习路径。

概述

恭喜您完成第一门课程的学习。您已经了解了数据专业人士如何为组织的成功做出贡献，以及他们在工作中使用的主要工具和技术。

现在，您将学习如何使用数据专业人士可用的最强大工具之一：Python编程语言。

编程是指向计算机发出指令以执行一个或一系列操作的过程。您可以使用不同的编程语言来编写这些指令。您可以根据正在进行的项目或想要解决的问题来选择特定的语言。

Python编程语言对于处理数据非常有用。数据专业人士使用Python以更快、更高效、更强大的方式分析数据，因为它优化了数据工作流的每个阶段，从探索、清理和可视化数据到构建机器学习模型。

本课程将为您打下坚实的Python基础，为您未来职业生涯中更高级的数据工作做好准备。

课程起点与导师介绍

如果这是您第一次接触Python编程语言，欢迎您。本课程不假定您有任何Python的先验知识。我们将从头开始，逐步讲解每个概念。请一步一步来，按照自己的节奏学习。在您发展Python技能的同时，您将应用所学知识来获得处理数据的宝贵实践经验。

如果您有Python经验，那也很好。我将帮助您以新的方式应用您的知识，并专门演示如何使用Python进行数据分析。

让我自我介绍一下。我叫Adrian，在Google Cloud担任客户工程师。这意味着我与客户合作，了解他们可以利用哪些技术来满足数据分析需求。我第一次学习Python是为了创建一个电子日记本。我厌倦了每年都买新的实体日记本，我学会了如何为它设置密码保护，直到今天，这仍然是我使用Python最自豪的时刻之一。

在您作为数据专业人士的整个职业生涯中，您将有机会不断学习和成长。对我来说，这是这份工作最酷的方面之一。而学习Python是这个成长过程中最有价值的部分之一。无论是在工作中还是为了乐趣，我一直在学习使用Python的新方法。

课程内容预览

现在，让我们回顾一下您将学习的内容。

我们将从对Python的总体介绍开始，并讨论为什么它在数据专业人士中如此受欢迎。

您将学习基本的编码概念，例如变量和数据类型，以及它们如何帮助存储和组织数据。您还将有机会开始编写自己的Python代码。

接下来，您将探索函数，即可重复使用的代码块，它们让您可以执行特定任务。函数帮助您快速高效地处理数据。

您还将学习条件语句，它告诉计算机如何根据您的指令做出决策。

然后，您将发现循环的强大功能，它可以重复一部分代码直到某个过程完成。

您还将学习如何处理字符串，即字符序列，例如字母和标点符号。

之后，您将探索Python中的数据结构，这是在计算机中存储和组织数据的方法。您将回顾对数据专业人士最有用的结构，例如列表、集合、字典和数据框。

最后，您将在课程结束项目中应用您的Python技能，该项目可以添加到您的专业作品集中。

课程项目与价值

课程结束项目基于一个工作场景，包含一个独特的数据集。在未来的工作面试中，您可以分享您的项目，作为您技能的展示，给潜在雇主留下深刻印象。

学习Python将使您的数据分析技能提升到一个新的水平。它也将是您简历上的一个很好的补充。知道如何使用Python是数据专业人士的关键资质，将极大地提升您作为求职者的竞争力。

我将在这里帮助您完成每一步。请记住，您自己设定节奏。请随意多次观看视频，并复习对您来说是新的主题。

在本课程结束时，您将知道如何使用Python来探索和分析数据。

让我们开始吧。

总结

本节课中，我们一起学习了本门Python入门课程的概述、学习目标、导师背景以及详细的学习路径。我们了解到Python是数据分析的核心工具，本课程将从零开始，涵盖变量、函数、条件语句、循环、字符串和数据结构等核心概念，并通过一个实战项目来巩固所学。准备好开启您的Python数据分析之旅了吗？

002：我的数据职业发展之路 🚀

在本节课中，我们将跟随谷歌客户工程师阿德里安的分享，了解他从非技术背景转型进入数据分析领域的职业发展之路。我们将探讨可迁移技能的重要性以及如何开启数据分析职业生涯。

背景介绍

我的名字是阿德里安，我在谷歌云担任客户工程师。这意味着我与客户合作，帮助他们理解并运用现有技术来满足数据分析需求。

从护理到科技的转型 🩺➡️💻

我来自一个非传统的背景，最初从事护理工作。我在护理领域工作了几年后意识到，虽然与病人打交道并帮助他们确实很有成就感，但这并非我余生想从事的事业。

可迁移的技能

以下是我从护理职业生涯中学到的、可迁移到数据分析领域的几项关键技能：

  • 批判性思维：在高级数据分析中，批判性思维至关重要。
  • 问题解决能力：当尝试调试代码或解决问题时，问题解决能力变得关键。
  • 评估能力：在网上寻找答案时，你需要能够评估所获得的信息，并理解如何应用这些信息来解决你的问题。

上一节我们介绍了硬技能，本节中我们来看看同样重要的软技能。

我从护理工作中带来的另一项技能是软技能，即人际交往能力。当你尝试在协作空间中与他人合作时，这些技能在高级数据分析中同样至关重要。

进入数据分析领域的契机

我之所以进入这个职业，是因为我在生活中积累了一些与编程相关的技能。然而，当时我并未真正理解如何应用这些技能，甚至没有意识到我可以应用它们。我本科攻读的是英语和历史专业。在了解到人文学科的就业机会后，我不得不重新思考我的下一步。这时，技术进入了我的视野。我发现，我实际上可以运用技术，并将其与我从人文学科（英语和历史）角度所做的事情结合起来，从而进入数字人文领域。

通往数据分析之路

通过知识管理的过程或概念，我最终进入了数据分析领域。我们处在一个每个公司都将成为数据公司的时代。无论你从事医疗、零售还是其他任何行业，数据以及处理和利用数据的能力都将是至关重要的。

数据分析的魅力

关于数据分析，我最喜欢的一点是它的入门门槛可以非常低。一旦你理解了那些基础知识，你就可以自己开始学习。你不需要拥有正规的大学学位，也不需要拥有多年的经验。只要你投入努力打下基础，就可以开始学习。

本节课中我们一起学习了阿德里安从护理专业成功转型为谷歌云数据分析工程师的职业路径。我们了解到，批判性思维、问题解决能力和人际交往等可迁移技能在数据分析领域极为重要，并且进入这个领域的关键在于掌握基础并付诸实践。

003：模块1概述 🐍

在本节课中，我们将一起探索Python编程语言，了解其核心特性、基本概念以及如何利用Python进行高效的数据分析工作。课程内容将涵盖Python的基础知识、Jupyter Notebook的使用、面向对象编程的概念、变量的定义与命名规则，以及基本的数据类型及其操作。

Python概述与基础

Python是一种功能强大的编程语言，特别适合数据分析工作。它具备简洁的语法和丰富的库支持，能够帮助数据专业人员快速、高效地处理数据。

接下来，我们将深入了解Python的主要特性和基本编程概念。

Jupyter Notebook：交互式编程环境

上一节我们介绍了Python的基本特性，本节中我们来看看Jupyter Notebook。Jupyter Notebook是一个交互式的编码和数据工作环境，为数据分析和编程提供了极大的便利。

以下是Jupyter Notebook的主要功能：

  • 它允许用户在笔记本环境中编写和运行Python代码。
  • 支持实时查看代码执行结果。
  • 便于结合代码、文本说明和可视化结果进行展示。

面向对象编程（OOP）基础

在熟悉了编程环境后，我们需要理解Python的编程范式。Python是一种面向对象的编程语言，其核心思想是基于对象进行编程。

面向对象编程对数据专业人员非常有益，因为它能帮助组织和管理复杂的代码与数据结构。

以下是其基本概念：

  • 对象：包含数据（属性）和相关操作（方法）的实体。
  • 类：创建对象的蓝图或模板。

一个简单的类定义示例如下：

class DataPoint:
    def __init__(self, value):
        self.value = value

变量：数据的容器

理解了编程范式后，我们来学习一个具体的编程构件：变量。变量是Python编程的基础构建块之一，用于存储和标记数据。

以下是关于变量的关键点：

  • 变量帮助存储数据并为数据赋予有意义的标签。
  • 通过赋值操作符 = 可以将特定值分配给变量，例如 count = 10。
  • 遵循变量命名约定可以使代码更清晰、精确和一致。

基本数据类型

最后，我们来探讨Python中的基本数据类型。有效组织数据是数据分析的前提，而数据类型是数据的分类方式。

Python有几种基本的数据类型，用于表示不同种类的数据。

以下是三种最常用的基本数据类型：

  • 整数（int）：表示没有小数部分的数字，如 42。
  • 浮点数（float）：表示包含小数点的数字，如 3.14。
  • 字符串（str）：表示文本数据，用引号包围，如 "数据分析"。

你可以通过类型转换函数来转换和组合这些数据类型，例如 int(), float(), str()。

总结

本节课中我们一起学习了Python编程的入门知识。我们从Python的概述开始，了解了Jupyter Notebook交互环境，探讨了面向对象编程的基本概念，学习了如何使用变量存储数据，并认识了整数、浮点数和字符串这三种基本数据类型。这些知识为你后续的数据分析工作奠定了坚实的基础。

准备好后，请进入下一个视频继续学习。

004：《Python入门》课程 04_01_06_Python入门 🐍

在本节课中，我们将要学习Python编程语言的基础知识，包括它的起源、特点以及为何在数据分析领域如此受欢迎。

什么是Python？ 🤔

Python是一种强大的编程语言，已成为全球数据专业人士的首选工具之一，这有其充分的理由。

编程语言的基本元素 💻

在深入了解Python之前，让我们先讨论一下编程语言的一些基本元素。

编程语言起源于电子计算机的发展。它们过去是，现在仍然是我们用来编写计算机执行指令的词语和符号。

与计算机的通信最终依赖于计算机硬件。

晶体管：计算机的基础

晶体管是计算机最基本的组件，因为它控制着电路中电流的流动。

一个晶体管可以存在于两种状态：开或关，就像一个开关。当晶体管处于“开”状态时，电流通过它；当它处于“关”状态时，它会阻断电流。这种二元性定义了计算机的运作方式。

从晶体管到二进制

如果你将足够多的晶体管（每个都处于开或关状态）连接在一起，就可以创建复杂的逻辑。

那么，这与计算机编程有什么关系呢？因为计算机本质上只是数十亿个晶体管或开关，它们只能理解二进制概念。你可能之前接触过这个概念。

二进制用1和0表示。这些数字只是指代晶体管开关序列的一种更简单的方式。当计算机从程序接收指令时，它处理的就是这些二进制序列。

编程语言的诞生与发展 📜

计算机功能强大，但仍需要被给予指令，并且它们只能理解以二进制形式给出的指令。

最初设计计算机的工程师们遇到了这个问题，并发现了一个难题：计算机非常擅长理解二进制，但人类却不擅长。正是这个难题催生了第一批编程语言。

最早的编程语言使用困难，需要大量培训，并且通常只能在为其设计的特定机器上运行。这类语言被称为低级语言。

随着时间的推移，新的编码语言发展起来，以简化和通用化编程指令。编程语言变得更容易学习，因为它们采用了更简单的规则和结构，即语法。

大多数现代编程语言使用的语法对人类来说要熟悉得多。这些语言被称为高级语言。这又把我们带回了Python。

Python：一种高级语言 🚀

Python是一种高级语言，它功能多样且易于学习。简单来说，Python很友好。

事实上，有些人可能会认为它的名字本身听起来有点吓人，但Python的创造者并不是以一条巨蛇来命名的。他以英国喜剧团体“Monty Python”来命名，因为他希望这门语言简单且平易近人。

除了功能多样和易于学习之外，Python还很强大。这种品质的结合使其不仅成为数据专业人士的最爱，也深受科学家和网络开发者的青睐。

Python的强大之处：开源与库 📚

Python如此强大的部分原因在于它是开源的，并且开发者们创建了许多库和工具，使得许多需要使用Python的工作变得更加容易。

一个库是一个可重用的代码集合。

例如，你可以手动编写一个函数，该函数接收两个数字，将它们相加，然后返回总和。但如果你现在想加三个数字或四个数字呢？你可以编写一个更复杂的函数，让你输入任意数字组合，并返回总和。

然而，求和是一个非常常见的任务，因此你可以通过直接使用包含求和函数的数学库来节省大量时间。

有成千上万的Python库，其中包含的代码任务范围广泛，从简单的数字求和到为人工智能应用程序构建神经网络的复杂任务。

你很快会学到更多关于库的知识，并且在后续课程中，你将了解神经网络、人工智能以及它们如何融入数据分析的世界。

Python在数据分析中的应用 🔍

本证书课程侧重于高级数据分析，因此你将学习如何将Python最常用于数据分析工作中。

你还将了解以下代码库，这些是数据专业人士在日常工作中每天都会使用的：

  • NumPy：用于高效的数值计算。
  • Pandas：用于数据操作和分析。
  • Statsmodels：用于统计建模和检验。
  • Matplotlib 和 Seaborn：用于数据可视化。
  • Scikit-learn：用于机器学习。

你将在后续课程中详细探索这些库。

学习Python的优势与社区 🌟

易于学习、易于使用、功能多样且强大，这些特点使Python成为当今使用最广泛的编程语言之一。

正因为其应用广泛，Python拥有一个庞大且活跃的用户社区，他们乐于提供帮助和支持，这使得Python成为一门非常适合探索和学习的编程语言。

给初学者的建议 💡

在你学习本课程乃至整个证书课程的过程中，请始终记住：编码既是简单的，也是复杂的。换句话说，每一行代码都代表一个简单的小想法，但这些代码行组合在一起，可以表达非常复杂的逻辑。

编码有时可能会令人沮丧，但也充满乐趣且非常有回报。你将在本课程中进行大量编码练习，从而不断进步。

最后，不要害怕犯错。实验是学习过程的一部分，练习将帮助你快速提高编码技能。

本节课总结：在本节课中，我们一起学习了Python编程语言的基础知识。我们了解了编程语言如何从计算机的二进制本质发展而来，以及Python作为一种高级语言如何因其友好、强大、开源和拥有丰富的库生态系统而脱颖而出。我们还探讨了Python在数据分析中的核心应用库，并获得了作为初学者开始学习编码的宝贵建议。

005：深入了解Python 🐍

在本节课中，我们将通过一系列简单的示例，初步了解Python编程语言的基本概念和功能。我们将学习如何打印输出、进行计算、使用变量、评估逻辑语句、编写条件判断与循环，以及定义和使用函数。这些基础操作是构建更复杂程序的基石。

打印输出与计算

上一节我们介绍了Python是一种高级编程语言。本节中，我们来看看如何让Python执行最基本的任务：在控制台输出信息以及进行数学计算。

使用print()函数可以向控制台输出信息。在括号内输入的内容将被打印出来。

print("Hello world")

Python也能执行数学运算。运算符与数学中类似，例如+用于加法，/用于除法，**用于计算幂。

print((5 + 4) / 3)

变量与赋值

变量可以看作是一个有名字的容器，用于存储数据（即值）。我们可以通过变量名来引用这些值。

以下是创建和使用变量的示例：

country = "Brazil"
age = 30
print(country)
print(age)

运算符与逻辑评估

Python使用运算符进行运算和比较。需要注意的是，单个等号=用于赋值，而双等号==用于检查两个值是否相等。

以下是使用运算符进行逻辑评估的示例：

print(10 ** 3 == 1000)  # 检查10的3次方是否等于1000
print(10 * 3 == 40)     # 检查10乘以3是否等于40
print(10 * 3 == age)    # 使用之前定义的变量age进行比较

条件判断

条件判断允许程序根据不同的情况执行不同的代码块。其基本结构是if...else...。

以下是一个判断年龄是否为成年人的示例：

if age >= 18:
    print("adult")
else:
    print("minor")

循环

循环用于对一组元素中的每一个执行相同的操作。for循环是其中一种常见形式。

以下是两个循环的示例。第一个直接遍历数字列表，第二个遍历一个已赋值的变量列表。

示例一：遍历并打印数字1到5。

for number in [1, 2, 3, 4, 5]:
    print(number)

示例二：创建一个列表变量，并遍历其中的每个元素进行计算。

my_list = [3, 6, 9]
for number in my_list:
    print(number / 3)

函数

函数是一段可重复使用的代码块，用于执行特定任务。它可以接收输入（称为参数）并返回结果。

我们可以将上面的条件判断逻辑封装成一个函数，以便重复使用。

以下是定义和调用函数的示例：

def is_adult(age):
    if age >= 18:
        print("adult")
    else:
        print("minor")

# 调用函数
is_adult(14)
is_adult(30)

内置函数

Python拥有一个丰富的内置函数库，可以执行许多常见任务，例如排序。

以下是使用内置sorted()函数对列表进行排序的示例：

new_list = [20, 25, 10, 5]
print(sorted(new_list))

总结

本节课中我们一起学习了Python的多个核心概念。我们了解了如何打印输出、进行数学计算、使用变量存储数据、利用运算符进行比较、编写条件判断和循环结构、创建可复用的函数，以及调用Python强大的内置函数。这些简单的操作可以通过组合与叠加，构建出能够解决复杂问题、甚至改变世界的算法与程序。Python的能力仅受限于你的想象力。

006：Jupyter笔记本介绍 🧑‍💻

在本节课中，我们将要学习Jupyter笔记本这一在数据分析领域广泛使用的工具。我们将了解它的基本概念、核心功能以及它为何成为数据专业人士的首选平台。

什么是Jupyter笔记本？ 📓

上一节我们探讨了Python的强大功能，本节中我们来看看编写和运行Python代码的一种流行环境。

Jupyter笔记本是一个开源的Web应用程序，用于创建和共享包含实时代码、数学公式、可视化图表和文本的文档。在课程中，我们将使用这个平台来编写代码和进行分析。

我们也会提供如何在您自己的电脑上设置Jupyter笔记本的信息，但这对于完成高阶数据分析课程是可选的，并非必需。

为何选择Jupyter笔记本？ 🤔

为了说明原因，我们先看看计算世界的另一个例子。

在大多数情况下，代码是在类似这样的环境中编写的：这是一个基于终端的文本编辑器。请注意，它就像一个无限长的单页。

如果我执行一个操作或写一行代码，当我移动到下一行时它会立即执行，并且我只能向前移动。我无法返回到更早的代码行，将光标插入那里并更改或运行它。

基于终端的文本编辑器在许多情况下是非常有用的环境，但对于数据分析项目而言，它并不总是最好或最容易使用的。

Jupyter笔记本的核心优势 ✨

现在，将其与我们之前的笔记本环境进行比较。

在这里，我可以更轻松地将代码模块化为单元格，以便分节组织它们。

单元格是Jupyter笔记本被划分成的模块化代码输入输出区域。

我可以移动代码、添加代码、或通过点击鼠标或按下按钮来删除代码。它非常适合可视化和演示。

我可以使用Markdown语法添加注释、注解和解释。

Markdown允许您在编码环境或纯文本编辑器中编写格式化的文本。

例如，我可以添加标题、项目符号、表格和数学公式。

Jupyter笔记本的主要功能列表

以下是Jupyter笔记本的一些关键功能，使其在数据专业人士中备受欢迎：

  • 模块化单元格：将代码和输出组织在独立的单元中，便于管理和测试。
  • 交互式执行：可以单独运行任何一个单元格，并立即看到结果。
  • 非线性和可编辑：可以自由地向前或向后移动，修改并重新运行任何单元格中的代码。
  • 丰富的文档支持：使用Markdown在代码旁添加格式化的文本说明。
  • 内置可视化：直接在同一文档中生成和显示图表、图形。
  • 易于分享：整个笔记本（包含代码、输出和文档）可以保存为一个文件并共享。

总结与展望 📈

本节课中我们一起学习了Jupyter笔记本的基本概念和优势。它通过单元格的模块化设计、交互式的代码执行环境以及Markdown文档支持，极大地提升了数据分析和探索的效率和清晰度。

随着课程的深入，您将在Jupyter笔记本中创建项目，以展示您作为数据专业人士的技能。

007：面向对象编程 🐍

在本节课中，我们将学习Python中一个核心且强大的概念：面向对象编程。我们将重点介绍类、方法和属性，理解它们如何共同作用，使Python代码更加组织化、可访问和可重用。

概述

面向对象编程是一种基于“对象”的编程范式。对象将数据（属性）和操作该数据的代码（方法）捆绑在一起。这种结构使得代码更易于管理和扩展，是Python成为数据分析强大工具的重要原因之一。

什么是面向对象编程？🤔

面向对象编程是一种编程体系，它围绕“对象”构建。对象包含数据以及用于操作这些数据的有用代码。一个对象是某个“类”的实例。你可以将其视为Python的基本构建模块。列表、函数、字符串，这些都是对象。

面向对象编程的核心思想是将数据和处理数据的方法都封装在对象内部，从而创建出更有组织、更易访问和可重用的代码。

核心概念：类 🧱

面向对象编程中最重要的概念是类。

一个类是一种对象的数据类型，它将数据和功能捆绑在一起。换句话说，对象之所以有用，是因为它属于某个类，这允许我们将一系列有用的工具直接打包到对象本身。

通过一个例子会更容易理解。当我们把单词 "hocus pocus" 放在引号中，并将其赋值给一个名为 magic 的变量时，这个变量就成为了字符串类的一个实例。

magic = "hocus pocus"

因为它属于字符串类，所以它以一种特定的方式行为，并拥有许多为字符串保留的内置功能。

类的方法：执行操作 🛠️

以下是字符串类的一些内置功能示例。

我们可以通过输入 magic.swapcase() 来交换字符的大小写。

print(magic.swapcase())  # 输出：HOCUS POCUS

我们可以通过输入 magic.replace() 并用新字符替换某些字符。

print(magic.replace('pocus', 'focus'))  # 输出：hocus focus

我们可以使用 .split() 和一对空括号将字符串拆分为两个字符串的列表。

print(magic.split())  # 输出：['hocus', 'pocus']

这些操作被称为方法。方法是属于某个类的函数，通常用于执行某个动作或操作。它们使用括号 ()。在我们的例子中，每个方法都作用于我们变量的值，并以某种方式改变了它。

你不需要记住所有方法。大多数编码环境都提供了访问给定类可用方法列表的方式。在Jupyter Notebook中，你可以输入一个点 . 然后按Tab键。请注意，我们使用点 . 将方法附加到其类的实例上，这被称为点表示法，是我们访问属于类实例的方法和属性的方式。

Python中的类 📦

Python中有许多不同的类。你已经遇到过其中一些了。

Python的核心类包括：

  • 整数 (int)
  • 浮点数 (float)
  • 字符串 (str)
  • 布尔值 (bool)
  • 列表 (list)
  • 字典 (dict)
  • 元组 (tuple)
  • 集合 (set)
  • 冻结集合 (frozenset)
  • 函数 (function)
  • 范围 (range)
  • 空值 (NoneType)，这是一种返回空值的数据类型。

此外，还有许多随库和包提供的额外自定义类，你甚至可以创建自己的类。

类的属性：访问特征 📐

我们要讨论的最后一个概念是属性。

属性是与对象或类关联的值，通过使用点表示法按名称引用。它们不使用括号 ()。属性对于自定义构建的类和更复杂的数据结构（如DataFrame）尤其重要。

这里有一个例子。假设我们有一个名为 planets 的DataFrame，它包含每个行星的行，以及代表行星名称、半径和卫星数量的列。

这个DataFrame的一个属性是它的形状 (shape)。这个DataFrame是8行乘3列。

# 示例：获取DataFrame的形状属性
print(planets.shape)  # 可能输出：(8, 3)

DataFrame类的另一个属性是列 (columns)。在DataFrame对象上调用此属性会返回一个包含DataFrame列名的索引对象。

# 示例：获取DataFrame的列名属性
print(planets.columns)

属性允许你访问类的特征，但它们不会对类执行任何操作或改变它。

总结

在本节课中，我们一起学习了Python面向对象编程的基础知识。

我们了解到，类是对象的蓝图，它将数据与功能捆绑在一起。方法是属于类的函数，用于对对象执行操作。属性是与对象关联的值，用于描述其特征。

通过将数据与操作和了解数据的方法打包在一起，面向对象编程是数据分析的理想结构。对象是Python的基本构建模块，也是使其成为数据专业人士强大工具的部分原因。

希望这节课能帮助你开始欣赏Python代码的组织之美和强大功能。在未来的数据职业生涯中，你将有机会进一步探索面向对象编程。

008：Python如何助力我的数据科学职业 🚀

概述

在本节课中，我们将跟随应用机器学习工程师哈姆扎，了解Python编程语言如何成为他数据科学职业生涯的核心工具，并探索Python在数据科学领域的独特优势。

我叫哈姆扎，是一名应用机器学习工程师。我热爱构建模型。

我热爱构建大规模系统，这正是我工作中的主要内容。

对我而言，这就像一种艺术形式：你从零开始创造一些不存在的东西，将其投入生产，并被大约一亿用户使用。我的工作范围是构建、维护并使大规模模型投入生产。

因此，Python几乎是我工作的核心主题。

Python是一种编程语言，它帮助你操作数据，帮助你构建模型，并且你可以用它来创建可用于生产的模型和软件。

有很多其他编程语言也能实现你想要的相同功能。就我个人而言，我使用Python是因为它有大量的文档和帮助资源，并且它吸收了许多其他编程语言过去的失败经验，这些经验被整合进来，使Python变得用户友好，易于被世界各地的人使用和适应。

你永远不会因为拥有好刀而被聘为一名好厨师，你被聘为一名好厨师是因为你拥有出色的烹饪技能。这是同样的道理。

Python帮助我成为一名更好的数据科学家，一名更好的机器学习工程师。

它帮助我理解了机器学习中多样化的数学应用，这些是我以前未曾意识到的。

我认为Python的独特优势在于它是一个多面手工具，它不仅仅用于一件事。它不仅仅用于数据操作或数据清洗。

你可以进行数据转换、数据清洗，你可以构建模型，将它们投入生产，你可以基于它创建API，你还可以在其之上构建监控系统。这些是Python的优势，使你在数据科学领域几乎成为全能大师。

当你进行在线课程或学习任何东西时，最重要的一点是：学习过程不是线性的。

学习曲线非常陡峭，但最终你会迎来“顿悟”时刻。

关键在于，在你学习某个课程的前两周，你可能会觉得：“好吧，这没有意义，对我不起作用，没有达到我想要的效果。”所以，请坚持下去，保持一致性。

在这些事情上，学习曲线总是陡峭的，但最终你会达到一个阶段，你会说：“哦，我知道所有这些事情，我可以将我所有的知识结合起来，构建出很棒的东西。”

总结

本节课中，我们一起学习了哈姆扎作为应用机器学习工程师的视角。我们了解到Python不仅是他工作的核心工具，更是一个功能全面的多面手，覆盖了从数据清洗、模型构建到系统部署的整个数据科学流程。同时，我们也认识到学习编程和数据分析的过程充满挑战，但保持坚持和一致性是跨越陡峭学习曲线、最终实现能力飞跃的关键。

009：变量与数据类型 📊

在本节课中，我们将要学习Python编程中的两个核心概念：变量与数据类型。理解它们是编写有效、清晰代码的基础。

变量：代码中的“名词” 📦

上一节我们介绍了编程的基本思想，本节中我们来看看如何用变量为数据赋予意义。在编程中，变量就像语言中的名词，用于标识和指向特定的值。

变量本身并不是值，而是指向存储在计算机内存中某个值的标签或容器。例如，在表达式 X = 3 中，X 是变量，而 3 是它指向的存储值。

另一种理解方式是，变量像一个贴有标签的容器。容器和它内部装的东西是分开的，但标签让我们知道里面是什么。

数据类型：数据的属性 🔢

变量可以存储任何数据类型的值。数据类型是根据数据的值、在编程语言中的角色或可执行的操作来描述数据片段的属性。

在Python中，常见的数据类型包括字符串、整数、浮点数、列表和字典等。本课程中你已经接触过其中一些，我们将在整个课程中深入探索。

如何创建变量：三个关键问题 ❓

在编写代码创建新变量之前，思考以下三个问题会很有帮助：

  • 变量名称是什么？
  • 变量类型是什么？
  • 变量的初始值是什么？

思考这些问题有助于你创建含义明确、便于后续引用的变量名。

以下是命名变量和考虑数据类型的重要性：

  1. 变量名是提示：好的变量名能提醒你和其他人该变量存储了什么内容。
  2. 数据类型决定功能：明确数据类型有助于你理解数据能做什么、不能做什么。

接下来，考虑如何通过赋值和表达式来使代码更简洁。

在Python中实践：赋值与动态类型 🐍

赋值是指将值存储到变量中的过程。表达式则是数字、符号或其他变量的组合，经计算后会产生一个结果。

现在，让我们在Python中实践。我们将把一个变量算法转化为Python代码。

首先，我们有一个职业篮球队首发五名球员的年龄列表。我们将把这个列表赋值给一个名为 age_list 的变量。

age_list = [22, 28, 34, 24, 30]

注意，我们没有将其命名为 X，因为 X 无法告诉我们它包含什么值。Python的一个优点是，当我们赋值一个新变量时，计算机会自动解释其数据类型，这称为动态类型。

动态类型意味着变量可以指向任何数据类型的对象。同时，大多数新变量没有默认类型，因此我们需要在调用它们之前进行赋值或初始化。

回到我们的例子。我们将使用Python内置的 max() 函数，并将 age_list 作为参数传递给它，以找到球员的最大年龄。然后将结果赋值给一个新变量 max_age。

max_age = max(age_list)
print(max_age)  # 输出：34

当我们调用这个变量时，计算机返回值 34，这是一个整数。所以 max_age 变量的数据类型是整数。

修改变量：类型转换与重新赋值 🔄

现在，假设我们想让 max_age 变量包含一个字符串值。我们可以使用 str() 函数将其转换为字符串，并将结果重新赋值给 max_age 变量。

max_age = str(max_age)
print(max_age)  # 输出：'34'

现在，我们的变量数据类型变成了字符串，输出中的引号表明了这一点。引号是字符串独有的特征。

我们也可以完全覆盖变量的内容。例如，我们可以在其中存储文本字符串 "99"。

max_age = "99"
print(max_age)  # 输出：'99'

这里有两点非常重要：

  1. 重新赋值：当我们将 max_age 从整数转换为字符串时，我们将其结果重新赋值给了它自己。如果只是使用 str() 函数而不重新赋值，计算机虽然会返回一个字符串，但变量的内容不会改变。通常，要修改变量的内容，必须重新赋值。
  2. 运行顺序：在Jupyter Notebook等环境中，运行单元格的顺序很重要。如果重新运行最初赋值 max_age 的单元格，然后再在新单元格中调用它，它的值会变回整数 34，而不再是字符串 "99"。

在这些例子中，max_age 变量包含的值在我们每次重新赋值时都改变了，这就是它“动态”的原因。

变量的便利性：进行计算 🧮

变量很方便，因为你可以引用它们，而不是直接引用它们包含的值。

如果我们定义一个新变量 min_age 来存储年龄列表中的最小值，我们就可以用这两个变量相减来找出最年长和最年轻球员的年龄差。

min_age = min(age_list)
age_difference = max_age - min_age  # 注意：此处的max_age在上一步已被覆盖为字符串"99"，直接相减会报错。应使用原始的整数变量。
# 正确的做法是使用最初存储整数最大年龄的变量，或重新计算。
max_age_int = max(age_list) # 重新获取整数最大值
age_difference = max_age_int - min_age
print(age_difference)

总结 📝

本节课中我们一起学习了Python中变量与数据类型的基础知识。

我们了解到，变量是存储和指向数据的标签，如同语言中的名词。数据类型（如整数、字符串）描述了数据的特性与可执行的操作。创建变量前思考名称、类型和初始值至关重要。Python的动态类型特性让变量使用更加灵活。重要的是，要修改变量必须进行重新赋值，并且在Jupyter Notebook中需要注意代码单元格的运行顺序。

变量和表达式在Python中功能强大，程序提出问题，变量帮助我们从特定输入中捕获答案。

记住，如果你想修改变量的内容，通常需要重新赋值。同时，在Jupyter Notebook中编码时，考虑单元格的运行顺序也很重要。

接下来，我们将学习变量的命名规范和限制。

010：变量命名规则与括号使用 🐍

在本节课中，我们将学习Python中变量命名的核心规则与限制，以及括号在数学运算中的基本作用。掌握这些基础概念是编写清晰、有效代码的关键。

变量命名规则与限制

上一节我们介绍了变量的基本概念，本节中我们来看看如何为变量选择合适的名称。Python对变量命名有明确的拼写和语法规则，就像任何语言一样。在编程中，我们称这些规则为命名规范和命名限制。

命名规范是一套一致的指导原则，用于描述文件内容、创建日期和版本。命名限制则是语言语法本身内置的、必须遵守的规则。

以下是Python中需要牢记的一些重要命名规范：

  • 避免使用关键字：关键字是保留用于特定目的的特殊单词，只能用于该目的。你已经遇到过一些关键字，例如 for、in、if 和 else。命名变量时绝不应使用关键字。
  • 避免使用内置函数名：例如 print 和 str。你也应该避免使用现有函数的名称。

关于变量命名规范，一个重要的注意事项是：不要使用保留的关键字或函数名。

编程中精确性至关重要，这就是为什么变量有命名限制。

以下是主要的命名限制：

  • 变量名只能包含字母、数字和下划线（_）。
  • 这意味着不能使用空格、制表符或特殊字符，如美元符号（$）或与符号（&）。
  • 变量名可以包含数字，但必须以字母或下划线开头。
  • Python是大小写敏感的，这意味着大写很重要。
  • 变量名不能包含圆括号，因为圆括号在Python中有其他用途。

有效与无效的变量名示例

为了更清楚地理解这些规则，让我们看一些有效和无效的变量名示例。

以下是有效的变量名：

  • any_variable
  • any_variable_2

以下是无效的变量名：

  • 1_is_a_number：无效，因为变量名必须以字母或下划线开头。
  • apples_&_oranges：无效，因为它使用了特殊字符“&”。

在为变量命名时，你确实有一定的灵活性。由于这些是你创建的引用，上述规范和限制只是帮助它们保持一致性和实用性。

括号在运算中的作用

好了，现在让我们回到括号，以更深入地了解它们在Python中的功能。在进行计算时，括号的规则遵循数学中的运算顺序。

例如：

  • 如果我们输入 2 * (3 + 4)，Python会先计算 (3 + 4)，因为它遵循运算顺序。这等于 14。
  • 但是 (2 * 3) + 4 等于 10。这是因为括号内的运算总是会优先完成。

顺便说一下，如果我们不使用任何括号，Python将遵循标准的数学运算顺序。

总结

在本节课中，我们一起学习了Python变量命名的核心规则与括号的基本用法。变量命名规范和限制有助于在你进行各种Python活动时保持代码的一致性和实用性。作为一名数据分析专业人士，能够有效地命名变量以创建有意义的代码，是使用Python工作的关键部分。接下来，我们将探索数据类型转换，但目前，请先掌握好这些基础。

011：数据类型与转换 📊➡️🔀

在本节课中，我们将要学习Python中的不同数据类型，以及如何在这些类型之间进行转换。理解数据类型是编写有效程序的基础，它可以帮助我们避免错误并正确地处理数据。

变量与值：数据的容器 📦

上一节我们介绍了变量及其命名规则。变量指向存储在计算机内存中的值。换句话说，变量就像容器，而它们存储的值就是其中的内容。

现在，我们将更深入地了解变量可以包含的值的类型。

认识基本数据类型 🔤

程序需要处理数据，而数据可以有许多不同的形式或类型。这些数据类型包括字符串、整数和浮点数。

以下是三种核心数据类型：

  • 字符串：字符串是一个包含文本信息的字符和标点符号序列。字符串用单引号或双引号实例化，也可以使用str()函数。这是一种不可变的数据类型，意味着其值永远不能被更改或更新。
  • 整数：整数是一种用于表示没有小数部分的整数的数据类型。
  • 浮点数：浮点数据类型用于表示包含小数的数字。

数据类型冲突与错误提示 ⚠️

大多数计算机知道如何将两个整数相加，或者将两个字符串相加。但一般来说，计算机不知道如何处理不同的数据类型。

如果你尝试混合不同的数据类型，有时会引发错误。计算机总是会告诉我们错误的原因，这就像一个小线索，可以帮助你提高编程技能。

请仔细阅读错误信息，理解它们试图告诉你什么，并利用这些知识来修复错误。

在这个例子中，错误信息的最后一行说我们遇到了一个“类型错误”。数字7被读取为整数，而"8"因为引号被读取为字符串。难怪会出现错误——你不能把一个数字和一个“词”相加。

识别数据类型：type()函数 🔍

作为数据专业人士，你经常需要聚合许多不同类型的数据。这就需要转换各种类型，以便能够成功地将它们组合起来。

有一个有效的方法可以做到这一点，但首先，了解你正在处理的数据类型至关重要。Python提供了一个有用的type()函数来识别数据类型。

你可以使用type()函数让计算机告诉你数据的类型。例如：

type('a')  # 输出：<class 'str'>
type(2)    # 输出：<class 'int'>
type(2.5)  # 输出：<class 'float'>

这里的type()函数告诉我们，'a'属于str类（字符串的缩写），数字2属于int类（整数），而2.5属于float类（浮点数）。

提醒一下，类是对象的数据类型，它将数据和功能捆绑在一起。

数据类型转换 🛠️

现在让我们看看如何组合这些不同的数据类型。在Python中，有两种转换数据的方式。

隐式转换

隐式转换会自动将一种数据类型转换为另一种，无需用户参与。

以下是一个例子。在涉及整数和浮点数的算术运算中，解释器会在后台工作，将整数转换为浮点数。你不需要在代码中指定任何内容来完成这个转换。

显式转换（类型转换）

然而，如果你想将数值转换为字符串，就需要进行显式转换。

显式转换是指用户将对象的数据类型转换为所需的数据类型。我们使用预定义的函数int()、float()和str()。这有时被称为类型转换，因为用户“投射”或更改了数据类型。

让我们在希望被解释为输出的字符串内部使用str()函数：

result = "The answer is " + str(7 + 8)
print(result)  # 输出：The answer is 15

现在，这个计算的结果将作为字符串存储和输出。

总结与职业建议 💡

本节课中我们一起学习了Python的核心数据类型——字符串、整数和浮点数，以及如何使用type()函数识别它们。我们还探讨了隐式转换和显式转换（类型转换），这是处理混合数据类型操作的关键技能。

调试代码或找出代码不工作的原因，对任何数据专业人士来说都是一项非常有用的技能。

最后，作为一个专业提示：我们行业中的所有人，即使是经验丰富的数据专业人士和代码开发者，在遇到错误时也会在线搜索答案。这是一个常见的策略，可以节省大量时间。

请始终向数据社区寻求答案和灵感。

012：12_01_01_总结_1

在本节课中，我们将对《Python入门》课程的第一部分进行回顾与总结。我们将梳理已学习的关键概念和技能，并为接下来的评估做好准备。

课程回顾与总结

我们已经完成了Python课程第一部分的全部内容。

你已经掌握了许多新的Python技能，做得很好。

在此过程中，你发现Python是数据专业人士的强大工具，并学习了Python如何帮助你快速高效地处理数据。

1. Python语言简介

我们首先对Python编程语言进行了总体介绍，并探讨了数据专业人士如何使用Python来驱动数据分析。

2. Jupyter Notebooks 环境

接着，我们讨论了Jupyter Notebooks。你了解了Jupyter Notebooks的主要功能，以及如何在Notebook环境中编写Python代码。

3. 面向对象编程基础

上一节我们介绍了编程环境，本节中我们来看看编程范式。你探索了面向对象编程对数据专业人士的好处，并学习了其基本概念。

4. 变量与数据存储

之后，我们重点学习了如何使用变量。你学会了如何为变量赋值，以及如何有效地存储和标记你的数据。

我们还回顾了变量的标准命名规范。

以下是关于命名规范的核心要点：

  • 使代码清晰、精确且一致。

5. Python数据类型

最后，我们探索了Python中的不同数据类型，例如整数（int）、浮点数（float）和字符串（str）。

你学习了如何转换和组合数据类型以组织你的数据。

准备迎接评估

接下来，你将面临一次分级评估。

为了做好准备，请复习列出了所有新术语的阅读材料，并随时重新观看视频、阅读资料和其他涵盖关键概念的资源。

祝贺你到目前为止取得的进步，我们很快会再次见面。

013：模块2概述 🐍

在本节课中，我们将要学习Python编程的进阶概念，包括函数、编写整洁代码、注释、运算符以及条件语句。这些知识将帮助你编写更高效、更易于协作的Python代码。

欢迎来到模块2 🚀

上一节我们介绍了Python的基础知识，包括变量、数据类型和编写简单代码。本节中，我们将继续构建你的Python知识体系。

在本课程结束时，你将能够编写Python代码语句来对数据执行多步骤操作。你还将学习如何编写整洁、可读的代码，这些代码可以轻松地被其他数据专业人员理解和复用。

对于数据专业人员来说，能够与团队成员协作是最重要的技能之一。编写整洁的代码是与队友协作并帮助团队实现目标的绝佳方式。使用整洁的代码有助于团队工作更快、沟通更有效并产生更好的结果。

核心概念详解

1. 函数：代码的“动词” 🔧

我们将从函数开始学习。函数是可重用的代码块，用于执行特定任务。函数就像是编程语言中的动词或动作词。

你可以在任何时候调用函数来帮助你执行对数据有用的操作，例如排序、分类、汇总等等。

代码示例：定义一个简单的函数

def greet_user(name):
    """向用户打招呼"""
    print(f"Hello, {name}!")

# 调用函数
greet_user("Alice")

2. 编写整洁代码：可重用性与模块化 ✨

接下来，我们将讨论如何编写易于队友和协作者理解的整洁代码。你将学习编写整洁代码的两个重要元素：可重用性和模块化。

这两种实践都能加速项目开发，帮助数据专业人员专注于核心业务需求，避免花费时间进行返工。

3. 注释：记录你的思路 📝

之后，我们将探讨编写整洁代码的另一个关键方面：注释。注释是一种有用的实践，因为它帮助你在为队友记录工作流程的同时，理清自己的思路。

使用注释来描述问题的组成部分，可以帮助你以清晰、简单的步骤解决问题。

代码示例：使用注释

# 计算列表的平均值
def calculate_average(numbers):
    total = sum(numbers)  # 求和
    count = len(numbers)  # 计数
    average = total / count  # 计算平均值
    return average

4. 运算符：比较与逻辑判断 ⚖️

接下来，我们将讨论如何使用运算符来比较值。我们将回顾两种类型的运算符：比较运算符和逻辑运算符。

  • 比较运算符（如大于 > 或小于 <）允许你比较两个值。
  • 逻辑运算符（如 and 和 or）让你将多个语句连接在一起，执行更复杂的比较。

数据专业人员使用运算符来分析和决策他们的数据。

公式示例：比较与逻辑运算

比较: value1 > value2
逻辑: (condition1) and (condition2)

5. 条件语句：让代码做决策 🤔

最后，我们将探讨条件语句，它告诉计算机如何根据你的指令做出决策。你将学习如何编写 if、else 和 elif 语句。

数据专业人员使用条件语句来构建复杂的操作，并执行各种实际任务，例如数据分箱和组织文件。条件语句使你的Python代码更加灵活和强大。

代码示例：条件语句

temperature = 25

if temperature > 30:
    print("It's hot outside.")
elif temperature > 20:
    print("It's warm outside.")
else:
    print("It's cool outside.")

总结 🎯

本节课中我们一起学习了Python编程的进阶主题。我们探讨了函数作为可重用的代码块，编写整洁代码的原则（可重用性与模块化），注释的重要性，用于值比较和逻辑连接的运算符，以及让代码能够做出决策的条件语句。掌握这些概念将使你能够编写更高效、更清晰且易于协作的Python代码，为处理复杂数据分析任务奠定坚实基础。

当你准备好后，我们将在下一个视频中再见。

014：应对编程学习挑战的技巧 🧠

概述

在本节课中，我们将跟随谷歌客户工程师拉蒂法，学习她如何克服学习Python编程时遇到的挑战。课程将分享实用的心态调整方法和学习技巧，帮助初学者顺利开启编程之旅。

从服务员到工程师的启示

我的名字是拉蒂法，是谷歌云的一名客户工程师。我的专长是数据分析，主要工作是将客户在其他云提供商或数据中心已有的架构，迁移并适配到我们的云平台上。

小时候，我有两个梦想职业：秘书和服务员。这两份工作我都做过，并且非常享受。从服务员经历中，我学到的最重要一课是：直面问题。

刚开始做服务员时，我非常胆怯。如果客人的订单出了问题，我会躲在厨房里，直到新菜做好，然后假装一切正常。可以想象，这通常不会让事情变好，反而会让客人更生气。因此，我学会了承认错误、直面问题，并且不害怕与人沟通解决。

初学Python的挑战与突破

学习Python起初有些困难。我遇到的第一个主要问题是环境设置和IDE选择。

如果你玩过电子游戏，就会知道你可能在初始的角色选择界面花费大量时间。同样，在开始编程的核心内容之前，你很容易在挑选这些细枝末节的小事上陷入困境。

我克服这些挑战的方法是：第一，承诺开始行动。我意识到“开始做”这件事本身的力量非常强大。你可以设定一个时间段专门做这件事，即使没有进展，至少当晚你可以对自己说：“我已经尽力了。”如果这还不够，那也只是说明今天还不够。

第二，我花时间学习如何阅读Stack Overflow。刚开始编程时，我对它感到非常沮丧，因为我只想把代码复制粘贴到控制台，然后魔法般地让它为我工作。或者，我总是试图将问题归咎于正在运行的Python版本或包版本。但事实并非如此。学会放慢速度，真正理解错误信息在说什么，以及它如何与我遇到的错误或问题相关联，而不是试图强行进入下一个主题或问题，这对我帮助巨大。

编程带来的实际价值

在我第一个纯销售团队工作时，我们被要求为大约2300个不同的客户或潜在客户创建商业智能报告。当时的经理计算过，我们所有人每周必须工作50小时，连续三周才能完成这个任务。

这显然不理想。没有人愿意每天花8到10小时制作智能报告。但凭借我的编程知识，我能够自动化这些商业报告的生成过程，并在一个半小时内创建了2300份报告。知道自己有能力做到这一点，感觉非常好。

给编程初学者的核心建议

以下是给想要开始编程的人的核心建议：

首要建议：你将会观看大量视频，接收大量信息，有人会和你谈论优化、如何编写最佳代码。但除非你真正动手去做，否则你无法理解编码和调试过程中所有复杂的细节。

第二个建议：学会调试。

第三个建议：学会处理“噪音”。如果你能开始分门别类，区分“这是我入门和前进必须掌握的知识”和“这些是锦上添花的知识”，你将真正加速你的学习旅程。

总结

本节课中，我们一起学习了拉蒂法分享的编程学习心得。核心要点包括：以行动克服起步的犹豫、学会有效利用Stack Overflow等资源、理解编程带来的自动化价值，以及给初学者的三个关键建议：动手实践、掌握调试和聚焦核心、过滤噪音。记住，编程之旅始于直面挑战和写下第一行代码。

015：定义函数与返回值 📘

在本节课中，我们将要学习Python编程中的一个核心概念：函数。我们将了解什么是函数，如何定义自己的函数，以及如何使用return语句从函数中获取计算结果。掌握这些知识将帮助你编写更高效、可重用的代码。

概述

之前我们已经探索了变量、表达式和数据类型。本节视频将介绍编程和Python中的另一个重要组成部分：函数。函数是一段可重复使用的代码，用于执行特定的过程或任务。

什么是函数？ 🤔

我们已经遇到过一些Python内置函数。例如：

  • print()函数在屏幕上输出文本。
  • type()函数告诉我们变量中包含的数据类型。
  • str()函数将一个对象转换为字符串。

需要注意的是，在Python 3中，print的语法是一个函数，因此需要使用括号，即使括号内没有参数。

Python虽然有许多内置函数，但如果我们想让计算机执行特定于我们自己用例的任务，学会定义自己的函数就非常重要。

如何定义函数

要定义一个函数，我们使用关键字def来开始函数块。

以下是定义函数的步骤：

  1. 始终以def关键字开头。
  2. 接下来是函数名，例如我们将其命名为greeting。
  3. 然后是函数的参数（也称为形参），写在括号内。参数是你提供给函数以进行某种修改的东西。你可以随意命名它们，但在函数体内必须使用定义时使用的名称。
  4. 定义完参数后，关闭括号，在末尾加上冒号，然后按回车键转到新的一行。

现在，我们可以编写函数体了。这里是我们指定函数实际要执行的操作的地方。

请注意，函数体会自动向右缩进。在Python中，代码行是分层的。任何缩进的行都专门属于前面缩进较少的代码。

我们可以向函数体添加任意多行代码，但每一行都必须向右缩进。通常使用四个空格，这使代码更具可读性。

让我们看一个例子。我们的greeting函数将接收一个名字，并使用该名字输出问候语。

def greeting(name):
    print("Welcome, " + name + "!")
    print("You are part of the team.")

要完成函数的定义，只需让下一行代码取消缩进即可。

现在，我们可以调用这个函数了。在括号内使用函数名greeting并传入参数。

greeting("Rebecca")

运行单元格后，将输出：

Welcome, Rebecca!
You are part of the team.

当然，函数能做的远不止打印信息。这只是定义自定义函数的一个简单示例。

使用return返回值

接下来，让我们看看如何从函数中获取值。这时就可以使用返回值。

return是Python中的一个保留关键字，它让函数执行计算以产生新结果，但不是打印结果，而是将结果保存起来供后续使用。

让我们定义一个新函数，它接受两个参数（三角形的底和高），并返回三角形的面积。面积计算公式为：底 × 高 ÷ 2。

def triangle_area(base, height):
    area = base * height / 2
    return area

我们使用关键字return来告诉Python，这是我们希望从函数中输出的值。与print不同，return允许我们将这个值存储在变量中。

假设我们有两个三角形，想要计算它们面积的总和。我们可以这样做：

# 分别计算两个面积，将每个值存储在自己的变量中
area1 = triangle_area(5, 10)
area2 = triangle_area(7, 8)

# 将两个面积相加，结果赋值给变量 total_area
total_area = area1 + area2

# 调用这个变量，Jupyter Notebook会返回它的值
total_area

如果我们调用这个变量，Jupyter Notebook会返回它的值，但我们不一定非要调用它，可以根据需要继续编写代码。这展示了return语句的强大之处，它使我们能够将函数调用与其他操作结合起来，从而使代码可重用。

再举一个例子

这里还有一个名为get_seconds的函数。这个函数接收小时、分钟和秒作为输入，并返回这些输入所代表的总秒数。

def get_seconds(hours, minutes, seconds):
    total_seconds = hours * 3600 + minutes * 60 + seconds
    return total_seconds

在第一行，我们以关键字def开始，并将函数命名为get_seconds。在括号内，我们给它三个参数：hours、minutes和seconds。下一行执行计算，计算总秒数并将该值赋给变量total_seconds。第三行也是最后一行是return语句，它返回total_seconds的值。

当我们调用这个函数时，必须提供三个参数：小时、分钟和秒。

get_seconds(16, 45, 20)

运行后得到结果：60320秒。

总结

本节课中，我们一起学习了Python函数的基础知识。我们了解了如何定义自己的函数，包括指定函数名、参数和函数体。更重要的是，我们学习了如何使用return关键字从函数中返回计算结果，并将其保存下来供后续使用，这是实现代码重用的关键。

代码重用是Python的一个关键要素，作为数据分析专业人士，你会越来越体会到它的价值。你的数据工具箱正在不断扩充，未来还有更多内容等待探索。

016：编写整洁代码 🧹

在本节课中，我们将学习如何编写整洁、可重用且易于理解的Python代码。我们将探讨代码复用、模块化、重构以及编写自文档化代码的重要性，这些实践能帮助数据专业人员更高效地协作并减少错误。

在软件开发早期，开发者通常需要自己编写每一段代码。

如今我们知道，复用他人编写并存放在在线代码仓库中的代码要高效得多。

我们也可以开发模块化代码，这将在本视频中学习。

这两种实践都能加速开发进程，并帮助数据专业人员专注于使用代码逻辑来满足业务需求，而不是进行重复劳动。

正如我们讨论过的，可复用性意味着定义一次代码，然后多次使用它而无需重写。

😊 考虑以下示例。这个脚本使用了 len 函数，它返回对象的长度。

在这个例子中，它是字符串的字符数。

然后它使用这个长度来计算一个数字，我们称之为幸运数字。最后，它打印一条包含姓名和数字的消息。每次我们想执行这个计算时，都需要更改变量的值并重写公式。

请注意，在代码的第一部分和第二部分中，有两行代码是完全相同的。

当你在脚本中发现代码重复时，最好检查是否可以通过使用函数来清理代码。

让我们重写这段代码，创建一个函数，将所有重复的代码整合到一行中。😊

更新后的脚本给出了与原始脚本完全相同的结果，但它更整洁、更易于理解。最重要的是，它现在是可复用的。

我们只需用不同的名字调用 lucky_number 函数，就可以根据需要多次执行其中的代码。

由于其模块化特性，Python非常适合编写可复用的代码。

模块化是指编写代码并将其分离成可以协同工作、并且可以被其他程序复用的独立组件的能力。

😊 模块化与可复用性密切相关，因为它允许你复用代码块或代码段。

复用代码块可以帮助你更有效地与数据工程师在大型项目上协作，这样他们就不必从头开始编写代码。

以下是一个例子。这些变量名并没有真正告诉我们这段代码试图做什么。

我们可以运行它。是的，它确实做了些事情，但阅读和理解那段代码相当困难。

因此，让我们尝试让这段代码对其他用户来说更清晰。

重构是在保持原始功能的同时重组代码的过程。

这是创建自文档化代码的一部分。自文档化代码是指以可读性强且目的明确的方式编写的代码。

这涉及到从选择变量名到编写清晰、简洁的表达式的方方面面。

注释是对代码的有益补充说明。

当你的计算机识别到注释行前的井号 # 字符时，它会忽略该行中该字符之后的所有内容。

所以，让我们重构这段代码，使其成为自文档化的。现在，代码的意图和结构更加清晰了。

它也被分解成了函数和带注释的部分。添加注释是一个有用的实践，因为它能帮助你在为其他协作者记录工作流程的同时，思考自己的过程。

😊 虽然混乱的代码不一定会导致脚本失败，但代码越整洁，对你的团队其他成员就越有用。你的同事会欣赏整洁的代码，因为他们可以理解并复用它，从而为自己节省时间和精力。

此外，代码复用和模块化可以减少错误、增强团队合作并建立信任。

本节课中，我们一起学习了编写整洁Python代码的核心原则。我们了解了如何通过创建函数来复用代码，如何通过模块化组织代码结构，以及如何通过重构和添加注释使代码更清晰、更易于维护。记住，整洁的代码不仅能提高个人效率，也是团队协作成功的基石。

017：使用注释构建代码框架 📝

在本节课中，我们将学习如何使用注释来构建代码框架。注释是代码中不会被计算机执行的文本，它们的主要作用是向阅读代码的人解释代码的意图和逻辑。我们将探讨如何通过注释来规划复杂的函数，并介绍如何编写清晰、有用的文档字符串。

算法思维与注释的重要性

上一节我们介绍了编写整洁代码的概念。本节中，我们来看看如何通过注释来辅助我们像程序员一样思考，即进行“算法思维”。

在编程中，算法是一套用于解决问题或完成任务的指令集。一个日常生活中的算法例子是烘焙面包的食谱。

算法示例（食谱）：

  1. 将烤箱预热至 425 华氏度。
  2. 将两杯面粉、三个鸡蛋、两杯水和一茶匙酵母放入碗中，用手持电动搅拌器混合。
  3. 让面团发酵一小时。
  4. 将面团从碗中转移到烤盘上。
  5. 将烤盘放入烤箱。

同样，每个计算机设备都通过算法形式的指令（基于硬件或软件的例程）来执行其功能。因此，学会如何向计算机进行逻辑解释非常重要，这就是算法思维的含义。你已经通过函数开始了这种思维方式，因为函数本身就是算法。

随着编码技能的发展，你将能够编写更长、更复杂的函数。处理新函数的最佳方法是将其分解为小而简单的部分，并从注释开始。

使用注释构建代码框架：一个示例

在编写任何代码之前，先用注释勾勒出步骤，这有助于你更好地理解问题。让我们通过一个例子来实践。

假设我们有一个方形喷泉，我们想在喷泉周围种植一圈草。我们需要编写一个函数来计算所需的草籽量，已知条件是喷泉的边长和草带的宽度。

以下是构建函数框架的步骤：

首先，我们使用 def 关键字定义函数，将其命名为 seed_calculator。它的参数是我们已知的两个量：喷泉边长和草带宽度。

现在，我们来编写函数体，用注释将其分解为小步骤。

以下是该函数逻辑步骤的注释框架：

def seed_calculator(fountain_side, grass_width):
    # 第一步：计算喷泉的面积
    # 第二步：计算喷泉和草带的总面积
    # 第三步：通过相减得到草带的面积
    # 第四步：计算所需草籽量（每平方米35克）
    # 第五步：将克转换为千克
    # 第六步：返回结果

我们使用注释在编写任何代码之前创建了一个逻辑框架。换句话说，我们用注释分解了思维过程，勾勒出为实现目标所需的每一段代码。剩下要做的就是逐步用代码填充它。

填充代码并添加文档字符串

现在，让我们将注释转换为实际的代码，并添加一个重要的部分：文档字符串。

文档字符串是位于函数体开头的一个字符串，用于总结函数的行为并解释其参数和返回值。它以三个引号开始和结束。

以下是填充代码并添加文档字符串后的完整函数：

def seed_calculator(fountain_side, grass_width):
    """
    计算围绕方形喷泉的草带所需的草籽千克数。

    参数:
        fountain_side (float): 喷泉一边的长度，单位米。
        grass_width (float): 草带的宽度，单位米。

    返回:
        seed (float): 草带所需草籽的量，单位千克。
    """
    # 第一步：计算喷泉的面积
    fountain_area = fountain_side ** 2

    # 第二步：计算喷泉和草带的总面积
    total_side = fountain_side + 2 * grass_width
    total_area = total_side ** 2

    # 第三步：通过相减得到草带的面积
    grass_area = total_area - fountain_area

    # 第四步：计算所需草籽量（每平方米35克）
    seed_grams = grass_area * 35

    # 第五步：将克转换为千克
    seed = seed_grams / 1000

    # 第六步：返回结果
    return seed

我们完成了一个可以执行复杂任务并可根据需要多次使用的函数。使用注释来分解问题的各个部分，使我们能够以清晰、简单的步骤解决问题。最重要的是，其他人可以使用这段代码并准确理解它的作用，因为我们编写了文档字符串和简洁的注释。

测试函数

那么，如果我们的喷泉是边长为12米的正方形，并且我们想要一个2米宽的草带，需要多少草籽呢？

result = seed_calculator(12, 2)
print(result)  # 输出：3.92

答案是 3.92 千克。

总结 🎯

本节课中，我们一起学习了如何使用注释构建代码框架。注释充当了脚手架，将你的代码分解为可管理的部分。结合函数的文档字符串，它们能帮助你和他人理解并使用你的代码。养成编写有良好文档的代码的习惯对数据专业人士非常重要。虽然前期需要多做一些工作，但你以后会感谢自己，你的同事也会感谢你。

018：使用运算符进行比较 🔍

概述

在本节课中，我们将要学习Python中的比较运算符和逻辑运算符。这些运算符能帮助我们比较数值、字符串等数据，并根据比较结果（真或假）来控制程序的逻辑流程。这是编写复杂代码和进行数据分析的基础。

布尔数据类型

在之前的课程中，我们学习了整数、字符串和浮点数等数据类型。另一种重要的数据类型是布尔数据。

布尔数据只有两个可能的值：True（真）或 False（假）。这个词来源于19世纪英国数学家乔治·布尔。在Python中，每次进行比较操作时，结果都是布尔类型的数据。数据专业人员每天都会使用布尔数据来控制代码的逻辑流程。

比较运算符

上一节我们介绍了布尔数据类型，本节中我们来看看如何使用比较运算符来生成布尔值。

比较运算符用于比较两个值，并产生一个布尔值结果。例如，如果我们执行 print(10 > 1)，比较运算符 > 会产生结果 True。

Python中有六种比较运算符：

  • >：大于
  • >=：大于或等于
  • <：小于
  • <=：小于或等于
  • ==：等于
  • !=：不等于

数据专业人员利用这些比较表达式的结果来对数据做出决策。例如，"cat" == "dog" 的结果是 False。

现在，让我们看看 !=（不等于）运算符的例子：

print(1 != 2)  # 输出：True

这段代码检查1是否不等于2，并产生布尔值 True。

正如我们所学过的，+ 运算符不能在整数和字符串之间使用。那么，如果我们尝试比较一个整数和一个字符串会发生什么呢？是的，会出现类型错误。

逻辑运算符

了解了基本的比较后，我们可以进行更复杂的逻辑判断。Python还提供了一组逻辑运算符。

逻辑运算符用于连接多个语句，并执行更复杂的比较。以下是主要的逻辑运算符：

  • and：与
  • or：或
  • not：非

and 运算符要求两个表达式都为真，整个结果才为真。以下是使用字符串比较的例子：

print(("yellow" > "cyan") and ("brown" > "magenta"))

当用于文本字符串时，比较运算符会根据字母顺序（a最小，z最大）评估每个字符串的第一个字母。如果两个字符串首字母相同，则会比较第二个字母。在这个例子中，"yellow" 中的 ‘y’ 大于 "cyan" 中的 ‘c’，所以第一部分为真。但 "brown" 中的 ‘b’ 并不在 "magenta" 中的 ‘m’ 之后，所以第二部分为假。因此，整个 and 语句的结果是 False。

or 运算符则相反。如果使用 or 运算符，只要任意一个表达式为真，整个表达式就为真；只有当两个表达式都为假时，结果才为假。

尝试运行以下代码：

print((25 > 50) or (1 != 2))

25肯定不大于50，但1不等于2。所以，最终整个表达式的结果是 True。

not 运算符会反转其后表达式的布尔值。如果它为真，则变为假；如果它为假，则变为真。

print(not (42 == "answer"))  # 输出：True

因为 42 == "answer" 的结果是 False，前面的 not 语句将其反转为 True。

总结

本节课中，我们一起学习了Python中的比较运算符和逻辑运算符。我们了解到，比较运算符（如 >、==、!=）用于比较两个值并返回布尔结果。而逻辑运算符（and、or、not）则用于连接多个比较，构建更复杂的逻辑条件。这些工具在数据领域非常有用，它们使得编写复杂的数据处理和分析代码成为可能。请继续练习和复习这些运算符，我们很快会再次见面，演示这些表达式的更多实际例子。

019：使用if-elif-else语句进行决策 🧠

在本节课中，我们将要学习Python中的分支概念。分支允许程序根据特定条件改变其执行顺序，这是编写有用脚本的关键组成部分。我们将重点学习如何使用 if、elif 和 else 语句来构建决策逻辑。

上一节我们介绍了变量、表达式、函数、数据类型、比较运算符和逻辑运算符。本节中我们来看看如何利用这些知识，通过分支结构让脚本根据不同的值执行不同的操作。

什么是分支？

分支描述了程序改变其执行顺序的能力。它使用基于特定条件的 if 语句来实现。

if 是Python中的一个保留关键字，用于设置条件。if 语句（也称为条件语句）就像在日常生活中使用“如果”这个词一样。

以下是几个日常生活中的例子：

  • 如果现在是中午之前，你会用“早上好”问候别人。
  • 如果外面在下雨，你可能会选择带伞。
  • 如果外面在下雪，你可能会穿夹克。

使用 if 语句

让我们通过一个商业场景的例子来理解这个概念。在一家公司，新员工可以选择他们的用户名，但用户名需要符合一套给定的规则。例如，一个有效的用户名可能需要至少8个字符。

作为该公司的数据专业人员，你的任务是编写一个程序，告诉用户他们的选择是否有效。

为了完成这个任务，我们将编写一个函数。目标是定义一个函数，使其能使用 if 语句生成用户名提示。

提醒一下，内置的 len() 函数将返回对象的长度，它可以与小于比较符 < 配对，以识别不符合标准的用户名。

def hint_username(username):
    if len(username) < 8:
        print("用户名无效")

现在，你的函数会检查用户名的长度是否小于8。如果是，函数会打印一条消息，说明用户名无效。

让我们回顾一下 if 语句的结构：

  1. 我们写下关键字 if。
  2. 接着是我们想要检查的条件。
  3. 然后是一个冒号 :。
  4. 之后是 if 代码块的主体，它需要进一步向右缩进。

这里有一个非常重要的点：只有当条件评估为 True 时，if 代码块的主体才会执行。否则，它不会执行。 这意味着，如果你运行一个 if 块，但参数条件不满足，其下方缩进的代码将被忽略。

扩展 if 语句：使用 else

if 语句是Python语法中一个有用的结构。但如果我们能扩展它，使其更强大呢？如果我们想让计算机做点别的事情呢？

else 是一个保留关键字，当前面的条件评估为 False 时执行。else 语句让我们可以设置一段代码，仅在 if 语句的条件为 False 时运行。

以下是一个日常例子：如果你饿了，你就吃饭。但如果你不饿（即“饿了”这个概念为假），那么你会做点别的事情，比如选择打个盹。

回到我们公司的用户名例子。现在，我们可能想在用户名有效时也打印一条消息。根据用户名的长度，函数现在可以走向不同的方向。

def hint_username(username):
    if len(username) < 8:
        print("用户名无效")
    else:
        print("用户名有效")

如果用户名不够长，会提示无效。但如果函数验证用户名足够长，则会打印一条有效消息，这是由 else 语句决定的。

注意当前函数的结构：if 语句缩进在函数体内，我们希望在该语句为真时执行的动作则缩进在其下方。我们可以在这里写任意多行代码，只要它们都缩进在 if 语句下方，它们都会在 if 语句为真时执行。

然后我们有 else 语句。注意它取消缩进到与 if 语句相同的级别。if 语句及其对应的 else 语句总是写在同一个级别。在 else 语句下方，我们再次缩进，以表示这是当 if 语句不为真时必须执行的内容。

理解 if 语句的流程

有时你不需要添加 else 语句，因为逻辑已经内置在代码中。让我们探索一个有助于理解这一点的新运算符：取模运算符 %。

取模运算符 % 返回一个数除以另一个数后的余数。整数除法产生两个结果（都是整数）：商和余数。

  • 5 / 2：商是 2，余数是 1。
  • 11 / 3：商是 3，余数是 2。

偶数是2的所有倍数，这意味着偶数与2的整数除法的余数总是 0。所以 10 % 2 的结果是 0。

让我们看一个例子：

def is_even(number):
    if number % 2 == 0:
        return True
    return False

这个函数通过将数字除以2并使用取模运算符检查余数是否为0，来检查一个数字是否为偶数。如果余数是 0，函数将返回 True。

现在，有趣的部分来了：你可以在这里放一个 else 语句，那样也能工作，但由于 if 语句的工作方式，这并不是严格必需的。记住，当 if 语句评估为 True 时，其下方缩进的代码会执行。但当 if 语句评估为 False 时，其下方缩进的代码不会执行。代码将继续运行，直到到达函数末尾。

让我们尝试使用我们定义的 is_even 函数输入奇数 19。函数返回 False，因为 19 % 2 的评估结果不为真，所以 if 语句下方缩进的代码不执行。然后函数继续运行。在这种情况下，函数中剩下的唯一代码是 return False，所以它返回 False。

起初，你可能更倾向于在这种情况下包含 else 语句，这没关系。但重要的是要知道两种方式都是正确的。不过请记住，这种技术只能在 if 语句内部返回值时使用。

处理多个条件：使用 elif

对于需要考虑更多条件的情况，elif 语句（else if 的缩写）非常有用。elif 关键字是一个保留关键字，当先前的条件不为真时，它执行后续的条件。这是Python表达“如果先前的条件不成立，那么试试这个条件”的方式。

让我们考虑一个例子来更好地理解 elif。天气可能会影响你下午选择做什么。如果天气好，你可能会去公园。如果下雨，你可能会去看电影。根据你选择的活动，你还需要决定如何去那里。活动可能决定你的交通方式。所以你做的选择取决于每个点的不同条件。这些是你日常生活中可能遇到的 if/elif 语句。

让我们回到用户名验证的例子。也许现在我们想限制用户名的长度。可能我们的公司规定不允许用户名超过15个字符。

def hint_username(username):
    if len(username) < 8:
        print("用户名无效")
    elif len(username) > 15:
        print("用户名不能超过15个字符")
    else:
        print("用户名有效")

注意这里有两个 else 语句吗？第一个 elif 是第二个行动方案：如果第一个条件不满足（即用户名的长度大于或等于8），换句话说，如果第一个 if 语句为假，那么代码执行第一个 elif 语句。这个 elif 语句本身又有两个嵌套条件：一个 if 和一个 else。

缩进使不同分支语句之间的关系更容易阅读，但嵌套增加了一些复杂性。记住，你可以选择使用任意多或少空格进行缩进，但通常，为了可读性最好使用四个空格，并且保持一致很重要。

为了避免不必要的嵌套并使代码更清晰，Python的 elif 关键字让我们可以处理两个以上的比较情况。事实上，elif 关键字允许我们处理无限数量的比较情况。

elif 语句类似于 if 语句。else if 的缩写防止了大量嵌套的 if 和 else 语句。如果所有上述条件都为假，则执行最后的 else 语句。

现在让我们在一个非常长的用户名上运行我们的函数。

hint_username(“这是一个非常非常长的用户名”)

这个脚本的工作原理与我刚才演示的嵌套 if-else 比较的脚本完全相同，但更容易理解。让我们分析一下：

  1. 函数首先检查用户名是否少于8个字符。如果是这种情况，它打印一条消息。
  2. 接下来，如果用户名至少有8个字符，函数然后检查它是否长于15个字符，并在为真时打印一条消息。
  3. 如果上述条件都不满足，函数打印一条消息，表明用户名有效。

总结

本节课中我们一起学习了如何在Python中使用 if、elif 和 else 语句在函数内部进行决策。

  • if 语句根据特定条件为真来分支执行。
  • else 语句设置一段代码，仅在 if 语句的条件为假时运行。
  • elif 语句允许我们处理多个比较情况，使代码更清晰、更易读。

这种分支在决定脚本流程时非常有帮助。使用分支来选择执行不同的代码片段，使你的脚本非常灵活和高效。分支还有助于处理各种实际事务，例如根据值对数据进行分箱、备份文件，或者仅在一天中的特定时间允许登录服务器访问。

任何时候你的程序需要做出决定，你都可以用分支语句来指定其行为。现在，你有了在代码中构建分支的坚实基础，这将使你作为一名数据专业人员能够在Python中完成大量有用的工作。

020：《Python入门》课程总结 🎯

在本节课中，我们将对《Python入门》课程的第二部分进行总结，回顾已学习的关键概念与技能。

你已经完成了Python课程第二部分的全部内容。你为你的技能库增添了许多新的Python技能，并在处理数据方面获得了宝贵的实践经验。做得很好。

在此过程中，我们探讨了Python代码如何帮助你快速对数据执行复杂操作。你也学会了如何编写清晰、可读的代码，这些代码能够被其他数据专业人士轻松理解和复用。这是在任何数据项目中与团队成员协作的重要部分。编写清晰的代码将帮助你的团队减少错误、提高工作效率、更有效地沟通，并交付更好的成果。

我们首先探讨了函数，即可重复使用的代码块，它们让你能够执行特定任务。接下来，我们讨论了编写清晰代码的两个重要元素：可复用性和模块化。我们还讨论了编写清晰代码的另一个最佳实践：代码注释。

之后，我们回顾了两种Python运算符：比较运算符和逻辑运算符。最后，你学习了如何编写条件语句，例如 if、else 和 elif 语句。

接下来，你将迎来一次分级评估。

为了做好准备，请复习列出了所有新术语的阅读材料，并随时重新观看视频、阅读材料以及其他涵盖关键概念的资源。

祝贺你取得的进步。让我们继续保持前进。

021：模块3 欢迎与字符串循环 🚀

在本节课中，我们将学习如何使用循环（Loops）来自动化重复性任务，并重点探索如何对字符串（Strings）进行迭代操作。掌握这些技能将帮助你更高效地处理数据，减少重复劳动和人为错误。

回顾与过渡 🔄

上一节我们介绍了Python的基础概念，包括变量、数据类型、函数、运算符和条件语句。你已经掌握了编写清晰、可重用代码的能力，这是进行更高级数据分析的第一步。

本节中，我们来看看如何利用循环自动化重复任务。作为数据专业人士，你经常需要对大量数据执行相同操作，例如对数百个价格值进行相同计算。手动为每个值编写代码既低效又容易出错，而循环可以自动重复执行代码段，直到过程完成。

循环：自动化重复任务 🔁

循环能自动重复执行一部分代码，直到某个过程完成。我们将讨论两种类型的循环：while循环和for循环。

使用Python自动化重复任务可以节省大量时间和精力，降低人为错误的风险。这不仅能减轻整体工作量，还能提高工作效率，使你有更多时间专注于数据分析的主要目标：为利益相关者生成洞察。

字符串迭代 📝

在Python中，你可以对多种数据类型进行迭代，例如字符串、列表、集合和字典。本节课程我们将重点讨论字符串。后续课程中，我们会详细讨论其他数据类型。

作为数据专业人士，你在分析数据时经常会处理字符串。例如，你可能需要分析与公司产品、服务、客户反馈等相关的文本数据。索引（indexing） 和切片（slicing） 等操作能让你快速高效地选择、筛选和编辑数据。

以下是字符串索引和切片的基本示例：

# 字符串索引示例
text = "数据分析"
print(text[0])  # 输出：数

# 字符串切片示例
print(text[0:2])  # 输出：数据

这些是每位数据专业人士都应掌握的宝贵Python技能。

总结 🎯

本节课中，我们一起学习了如何使用循环自动化重复性任务，并重点探索了字符串的迭代操作。掌握循环和字符串处理技能，将使你在数据分析工作中更加高效和精准。

准备好学习更多内容后，我们将在下一个视频中继续探索。

022：以分析性思维解决问题 💡

在本节课中，我们将跟随谷歌数据工程师米歇尔的分享，学习如何运用分析性思维解决实际问题。课程将重点介绍如何克服自我怀疑、将复杂问题分解，并最终通过自动化工作流来达成目标。

我叫米歇尔，是谷歌的一名数据工程师。我大学刚毕业时，最初担任的是文档专员。

但身处众多从事分析工作的技术人员之中，让我对这个领域产生了浓厚兴趣，并渴望加入团队，投身于那个世界。我曾预想，在刚进入这个领域时，会因为自己没有分析学学位而面临他人的评判或轻视。

我很高兴根据我的经验告诉大家，这种情况并未发生。那只是我自己脑海中的负面自我对话。我周围的每个人都热情、包容，并且非常高兴团队中有一位通过非传统路径进入工程和分析领域的人，因为我带来了独特的视角。

冒名顶替综合症是非常真实的存在。我认为每个人都会经历，我也一样。有很多次，我会停下来想：也许我不属于这里。我没有分析学或信息科学的高级学位。此时此刻，在这个房间里，我真的能做出任何贡献吗？

我克服它的方式是认识到：从事数据分析和数据科学的职业，并非要记住所有可能场景下的每一个答案。完全不是这样。其目的是培养你以分析性思维处理问题的能力。

在我职业生涯早期，有一个项目，我非常想自动化分析工作流的某个部分。我知道我需要做什么，但我不确切知道如何去做。

解决问题的步骤 🛠️

上一节我们讨论了分析性思维的重要性，本节中我们来看看米歇尔解决具体问题的实际步骤。

以下是米歇尔解决问题的方法：

  1. 用通俗语言描述目标：首先，在不使用任何计算机代码或编程语言的情况下，用简单的英语写下我想要实现的目标。
  2. 分解与搜索：然后，我需要在谷歌上进行大量搜索。我在各种论坛上查找如何在Python中实现X、Y、Z功能，如何使用for循环，以及如何利用Python进行数据科学和自动化分析。
  3. 逐步实现自动化：我慢慢地、一步一步地，最终完全自动化了我想要自动化的工作流。

能够自动化那个工作流，给我带来了一种成就感，这种成就感一直持续到今天。

总结与启示 🌟

本节课中，我们一起学习了米歇尔从非技术背景转型为数据工程师的经历，以及她如何运用分析性思维解决问题。

有时，当你面前有一大堆工作，或者有一个看似遥不可及的目标时，可能会感到非常气馁，觉得这不可能完成。但事实并非如此，只要你把事情分解成更小、更易管理的部分，你绝对能够到达彼岸。然后，你会到达一个节点，回头一看，心想：天啊，我做到了。我已经一路走到了这里。

关键在于：将复杂问题 分解 为可执行的步骤，并相信通过持续学习和实践，你能够克服挑战，实现目标。

023：while循环简介 🌀

在本节课中，我们将要学习Python编程中一个非常重要的概念——while循环。循环能帮助我们让计算机自动重复执行某些任务，从而节省时间，避免重复劳动。我们将通过具体的例子，理解while循环的工作原理、语法结构以及如何在实际编程中应用它。

循环基础概念回顾

上一节我们介绍了循环的基本概念，本节中我们来看看这些概念的具体定义。

  • 循环：用于执行迭代的代码块。
  • 迭代：一组语句的重复执行。一次迭代即代码块的一次执行。
  • 可迭代对象：可以被循环或迭代的对象。

数据专业人员通常使用for循环和while循环来处理可迭代对象。本视频将重点介绍while循环。

什么是while循环？🤔

一个while循环是一种根据条件值，指示计算机持续执行代码的循环。

我们可以通过一个生活场景来理解它：想象Maggali拿着一袋零食，只要零食袋还在她腿上，小狗Fido就会一直待在那里吃零食。一旦Maggali把零食袋收起来（条件不再满足），Fido就会离开。

while循环的运行方式与此类似。它的逻辑是：只要某个条件为真，就重复执行循环体内的代码。

while循环的工作方式与分支结构中的if语句相似，区别在于：在while循环中，循环体可以多次执行，而不仅仅是执行一次。这能有效避免代码冗余。

while循环语法解析

让我们通过一个例子来解析while循环的语法。

x = 0
while x < 5:
    print("x的当前值是：", x)
    x += 1
print("循环结束，x的最终值是：", x)

以下是这段代码的逐步解析：

  1. 初始化变量：首先，我们将变量x的值赋为0。这称为初始化，即给变量一个初始值。
  2. 设置循环条件：使用while关键字开始循环，并设置条件x < 5。由于x刚被初始化为0，这个条件目前为真。
  3. 定义循环体：在while语句末尾的冒号:之后，缩进的代码块就是循环体。只要条件为真，这个块中的代码就会重复执行。
  4. 执行循环体：
    • 第一行打印一条消息和x的当前值。
    • 第二行使用x += 1将x的值增加1。这是一种简写，等同于x = x + 1。
  5. 循环迭代：执行完循环体后，计算机会返回并重新评估while的条件。只要条件x < 5仍为真，就会再次执行循环体。
  6. 退出循环：当x的值增加到5时，条件x < 5变为假，循环停止。
  7. 执行后续代码：循环结束后，程序会继续执行循环体之后的第一行代码，即打印x的最终值。

重要提示：while循环所使用的条件，其最终结果必须能评估为真（True）或假（False）。无论是使用比较运算符（如<, >, ==）还是调用其他函数，都需要满足这一点。

我们也可以像在if语句中一样，在while循环的条件中使用逻辑运算符and、or和not来组合多个表达式。

综合应用示例：猜数字游戏 🎮

现在，我们将运用目前学到的多个概念（甚至包括一些新概念）来编写一个猜数字的小程序。通过上下文理解新概念是学习编程的有效方法。

在这个例子中，我们将编写一个程序：它生成一个随机数，然后给用户5次机会来猜中它。

import random

number = random.randint(1, 25)
number_of_guesses = 0

while number_of_guesses < 5:
    print('猜一个1到25之间的数字：')
    guess = input()
    guess = int(guess)

    number_of_guesses += 1

    if guess == number:
        break

    if number_of_guesses == 5:
        break
    else:
        print('不对，再试一次。')

if guess == number:
    print(f'恭喜你！你在第{number_of_guesses}次猜中了。')
else:
    print(f'很遗憾，你没猜中。正确的数字是{number}。')

以下是代码的详细解释：

  1. 导入模块：import random 导入了Python的random模块，用于生成随机数。
  2. 生成目标数字：random.randint(1, 25) 生成一个1到25之间（包含1和25）的随机整数，并赋值给变量number。
  3. 初始化计数器：变量number_of_guesses被初始化为0，它将作为计数器，控制程序的逻辑。
  4. while循环开始：条件是 number_of_guesses < 5，即最多允许猜5次。
  5. 获取用户输入：
    • input()函数会创建一个提示，让用户输入他们的猜测。
    • int(guess)将输入的字符串转换为整数，这是进行比较的关键步骤。
  6. 更新计数器：number_of_guesses += 1 每次猜测后，计数器加1。这一步至关重要，如果遗漏，循环将永远不会停止（无限循环）。
  7. 分支逻辑判断：
    • 如果猜测正确 (guess == number)，则执行 break 语句。break是一个关键字，它能让你立即跳出循环，并且不会触发循环内后续的else语句。
    • 如果这是第5次猜测且仍未猜中 (number_of_guesses == 5)，同样执行 break 跳出循环。
    • 如果以上都不是，则执行 else 分支，提示“不对，再试一次。”，然后循环继续。
  8. 循环后判断：循环结束后，根据guess是否等于number来打印成功或失败的消息。

运行这个程序，尝试猜出数字吧！

总结 📝

本节课中我们一起学习了while循环。我们了解到while循环是一种在条件为真时重复执行代码块的结构。我们分析了它的基本语法，并通过一个“猜数字”的综合示例，实践了如何将变量初始化、条件判断、用户输入、类型转换以及break关键字等概念整合到一个脚本中，来解决一个包含复杂逻辑的问题。

掌握循环是成为数据专业人士的宝贵技能，它能让你自动化处理重复性任务，专注于更有意义的分析工作。

024：For循环简介 🐕

在本节课中，我们将要学习Python编程中一个非常核心的概念——for循环。循环允许我们自动重复执行某些操作，这在处理数据、读取文件或模拟现实场景（如ATM取款）时非常有用。

什么是For循环？ 🔄

上一节我们介绍了编程中重复执行任务的需求，本节中我们来看看如何用for循环来实现它。

一个for循环会遍历一个序列中的每个值。一个简单的例子是遍历一系列数字：

for x in range(5):
    print(x)

请注意for循环的结构与典型的Python语句语法相似。第一行包含一个关键字for。与函数和其他开启独立代码块的表达式一样，它以冒号:结束。for循环的主体部分向右缩进。此处的不同之处在于我们还有关键字in。

此外，在关键字for和in之间，我们有一个变量名x。这个变量将依次取用循环遍历的序列中的每一个值。在这个例子中，x会取值0、1、2、3和4。我们不一定非得使用x，可以使用任何我们想要的名称，比如n、number、monkey。只要我们在命名和后续引用时保持一致，用什么名字并不重要。

理解Range函数 📊

现在，让我们来仔细看看range函数。

range函数是一个Python函数，它返回一个数字序列。默认情况下，它从0开始，以1为增量递增，并在给定的数字之前停止。它可以在while或for循环中使用。在Python和许多其他编程语言中，一个数字范围默认从值0开始。生成的数字列表将比给定的值少1。

检查一下：默认情况下，我们的range函数从0开始。第一次迭代后，值将是1。第二次迭代输出2，依此类推。无论我们在循环体中放入什么代码，都会在每个值上执行，一次一个值。

For循环的实用场景 📂

你还可以使用for循环来读取文件，并逐行遍历文件内容。

with open语句使用文件路径来读取文件。在这个例子中，它是一个包含《Python之禅》的文本文件，这是软件工程师Tim Peters在1999年写的一首著名诗篇。

为了便于表示，将文件对象赋值给f。否则，我们将不得不再次写入文件路径。在下一行，开始for循环遍历每一行。在缩进内部，告诉计算机打印每一行。循环完成后，告诉计算机打印“I‘m done”。

嵌套循环与实例 🐶

以下是一个嵌套循环的例子：

我曾经需要在一个二维文本数组中定位所有唯一的单词。我在一个for循环内部使用了另一个for循环。外部循环遍历每一列，内部循环为该列迭代每一个单元格。这只是一个例子。

让我们看看Maggali和Fido的另一个例子。Maggali不想让Fido吃太多零食，所以她每天只给他五块零食。Fido每次得到一块零食都会摇尾巴。一旦他拥有了全部五块，他就会停止摇尾巴。真是条好狗，Fido。

总结 ✨

本节课中我们一起学习了for循环。数据专业人士会经常在Python和其他编程语言中使用for循环。它们是编码的基本工具之一，非常适合对具有固定长度的对象执行重复过程以创建新内容。

接下来，我们将探索更多使用循环的方法。

025：多参数范围循环 🔄

在本节课中，我们将学习如何在Python的range函数中使用多个参数来控制循环的起始值、结束值和步长。掌握这些技巧能让你更灵活地处理数据序列。

概述

之前我们学习了range函数，它默认生成一个从0开始的数字序列。然而，在数据分析工作中，我们并不总是需要从0开始。range函数允许我们设置起始值、结束值和步长，从而精确控制循环的范围。本节将详细介绍如何使用这三个参数。

使用起始值和结束值

首先，我们来看一个使用起始值和结束值的例子。以下是一个计算9的阶乘的for循环：

product = 1
for n in range(1, 10):
    product = product * n
print(product)  # 输出：362880

在这个例子中，range(1, 10)生成一个从1开始、到9结束的序列（注意结束值10不被包含）。循环依次将product乘以序列中的每个数字，最终得到9的阶乘，即362880。

关键点：我们选择从1开始而不是0。如果从0开始，任何数与0相乘的结果都是0，这将导致整个乘积为0。

引入步长参数

range函数还允许我们指定第三个参数——步长。步长决定了序列中相邻数字之间的差值。默认步长为1，但我们可以根据需要调整。

下面是一个使用步长参数的例子。我们将创建一个函数，将华氏温度转换为摄氏温度，并打印出从0°F到100°F每隔10°F的转换表。

首先，定义转换函数：

def fahrenheit_to_celsius(x):
    return (x - 32) * 5 / 9

接下来，使用for循环和带步长的range函数生成转换表：

for temp_f in range(0, 101, 10):
    temp_c = fahrenheit_to_celsius(temp_f)
    print(f"{temp_f}°F = {temp_c:.2f}°C")

在这个循环中，range(0, 101, 10)生成一个从0开始、到100结束、步长为10的序列。注意，为了包含100，我们将结束值设为101。循环体计算每个华氏温度对应的摄氏温度并打印出来。

for循环与while循环的选择

在编程中，我们经常需要在for循环和while循环之间做出选择。以下是选择建议：

  • 使用for循环：当你需要遍历一个序列（如列表、元组或数据集中的记录）时，for循环是更合适的选择。它不仅代码简洁，还能提高可读性。
  • 使用while循环：当你需要重复执行某个操作，直到某个布尔条件发生变化时，while循环是理想选择。布尔条件是一种数据类型，通常表示为True或False。
  • 个人偏好：如果某个任务既可以用for循环也可以用while循环完成，选择你更习惯的那种即可。两种循环都是Python工具箱中非常有用的工具。

总结

本节课我们一起学习了如何在range函数中使用起始值、结束值和步长参数来控制for循环。通过调整这些参数，我们可以更灵活地处理数据序列，满足不同的编程需求。同时，我们还探讨了在for循环和while循环之间如何做出选择，以便在编写代码时做出更明智的决策。

026：字符串操作 🧵

在本节课中，我们将学习Python中字符串的基本操作。字符串是包含文本信息的字符序列，掌握其操作是数据处理的基础。

概述

到目前为止，我们已经学习了很多内容。你了解了函数、条件语句和循环。

现在，我们将从字符串开始，更深入地学习Python中的不同数据类型。

字符串基础

字符串是一个包含文本信息的字符和标点符号序列。

这是一种不可变的数据类型，这意味着其值永远不能被更改或更新。

尽管字符串是不可变的，我们仍然可以对它们进行很多操作。

字符串连接

我们可以连接字符串。“连接”意味着链接或结合在一起。

因此，连接字符串就是将两个或多个较短的字符串组合成一个更长的字符串。

要在Python中连接字符串，我们只需使用加法运算符。

如果我们有两个字符串：“Hello”和“world”，我们可以通过将它们相加来连接它们。

"Hello" + "world"

结果是单个字符串，但它也是一个单词。这是因为空格（在计算机编程中称为空白字符）本身算作一个字符。

如果你想在连接的字符串之间有一个空格，其中一个字符串必须包含一个空格，或者你必须在它们之间添加一个只包含空格的第三个字符串。

使用指向字符串的变量时，适用相同的规则。

如果“Ho”被赋值给变量greeting1，“world”被赋值给变量greeting2，我们可以通过将这两个变量相加来连接字符串。

greeting1 = "Ho"
greeting2 = "world"
greeting1 + greeting2

字符串乘法

我们也可以使用乘法运算符来“乘以”字符串。

"Danger" * 3

结果是“DangerDangerDanger”。

但是，我们不能对字符串进行除法或减法运算，尝试这样做会导致错误。

处理特殊字符

如你所知，在处理字符串时，某些字符被保留用于特定目的。

例如，引号用于指示字符串的开始和结束。

但是，如果我们希望字符串包含引号怎么办？有两种方法可以解决这个问题。

第一种方法是利用字符串既可以用单引号也可以用双引号书写这一事实。

如果你想在字符串中包含双引号，请使用单引号来开始和结束你的字符串，反之亦然。

'She said, "Hello."'

第二种方法是使用反斜杠，它充当转义字符。转义字符会改变其后字符的典型行为。

在这种情况下，引号的典型行为是开始或结束字符串。但如果我们在每个引号前加上反斜杠，它们就会在字符串中表现为常规的标点符号。

"She said, \"Hello.\""

反斜杠字符作为其他特殊字符的转义字符也很有用。

例如，\n 是一个特殊的字符组合，用于在打印字符串时指示换行。

print("Line 1\nLine 2")

但是，如果你想在打印字符串时将 \n 作为字符包含在字符串中，你必须在组合前加上一个初始的反斜杠。

print("This is a backslash-n: \\n")

遍历字符串

接下来，我们也可以用循环来遍历字符串。

在这个例子中，我们使用一个for循环来遍历单词“Python”的每个字母，并打印该字母加上字母“UT”。

for letter in "Python":
    print(letter + "UT")

这些只是处理字符串的几种方法。作为一名数据专业人士，在分析数据时，你会经常处理字符串。

在接下来的课程中，我们将介绍更多可以对字符串执行的有用操作。

总结

本节课中，我们一起学习了Python字符串的基础操作。我们了解了字符串是不可变的数据类型，学习了如何连接和“乘以”字符串，掌握了在字符串中包含引号等特殊字符的技巧，并探索了如何使用循环遍历字符串。这些是处理文本数据的基本技能，将在后续的数据分析工作中发挥重要作用。

027：字符串切片 🍰

在本节课中，我们将要学习Python中一个非常实用的概念——字符串切片。切片允许我们从字符串中提取特定的部分，这对于数据清洗和预处理至关重要。

上一节我们介绍了字符串的基础知识。本节中，我们来看看如何通过索引和切片来更精细地操作字符串。

索引：定位字符的基础 🔢

在深入了解切片之前，我们需要理解Python的索引机制。索引是Python让我们通过相对位置来引用可迭代对象中单个元素的方式。

核心概念：Python使用0起始索引。这意味着序列的第一个元素的索引是0。对于字符串，索引将字符串解释为一个字符序列，每个字符都有一个编号的位置。

  • 从左向右读取时，第一个字符位于位置0。
  • 第二个字符位于位置1，第三个位于位置2，依此类推。

索引不仅仅是字符串的专利，它也适用于列表、元组等其他可迭代的数据类型。

索引的实践应用 🛠️

以下是使用索引的一些基本方法。

使用 index() 方法

index() 是一个字符串方法，用于输出某个字符在字符串中的索引号。其基本语法是 变量名.index(‘字符’)。

pets = "cats and dogs"
position = pets.index('s')
print(position)  # 输出：3

需要注意的是，如果存在多个相同字符，index() 方法只返回第一个匹配的位置。如果搜索不存在的子字符串，则会引发 ValueError 错误。

直接通过索引访问字符

我们可以将索引号放在变量名后的方括号中，来访问特定位置的字符。

name = "Jolene"
print(name[0])  # 输出：J
print(name[5])  # 输出：e

如果使用的索引超出了字符串的范围（例如 name[6]），Python会引发 IndexError 错误。

使用负索引

即使不知道字符串的长度，我们也可以使用负索引来访问末尾的字符。索引-1代表最后一个字符，-2代表倒数第二个，以此类推。

greeting = "Hello!"
print(greeting[-1])  # 输出：!
print(greeting[-2])  # 输出：o

字符串切片：提取子字符串 ✂️

现在我们已经掌握了索引的基础，让我们开始进行切片。字符串切片是字符串的一部分，也称为子字符串。

切片通过在方括号内使用冒号分隔的起始和结束索引来定义范围：字符串[起始索引:结束索引]。请注意，结束索引对应的字符不会被包含在切片结果中。

例如，从字符串 "orange" 中提取索引1到4（不包含4）的字符：

fruit = "orange"
slice_result = fruit[1:4]
print(slice_result)  # 输出：ran

省略索引的切片

我们可以省略切片中的一个或两个索引。

  • 如果省略起始索引（如 [:4]），则默认从0开始。
  • 如果省略结束索引（如 [4:]），则默认切片到字符串末尾。
word = "pineapple"
print(word[:4])  # 输出：pine
print(word[4:])  # 输出：apple

检查子字符串是否存在 🔍

数据专业人员经常需要检查一个字符串是否包含特定的子字符串。这时可以使用关键字 in。

fruit = "pineapple"
print("banana" in fruit)  # 输出：False
print("apple" in fruit)   # 输出：True

确认子字符串是否存在于一个字符串中，是各类数据工作中常见的实践。

总结 📝

本节课中我们一起学习了Python字符串的索引和切片。

  • 索引让我们能够通过位置（从0开始）访问字符串中的单个字符，包括使用负索引从末尾开始计数。
  • 切片 [start:end] 让我们能够提取字符串的任意部分，是处理数据（如移除货币符号）的强大工具。
  • 使用 in 关键字可以快速检查一个子字符串是否存在于目标字符串中。

我鼓励你花时间自己重新演练这些步骤。你越多地应用所学知识，就会感到越得心应手。

028：格式化字符串 📝

在本节课中，我们将要学习如何使用Python的format方法高效地创建和操作字符串。掌握字符串格式化技巧，能帮助你更灵活地构建输出信息，提升代码的可读性和工作效率。

概述

上一节我们介绍了字符串的基础知识。本节中，我们来看看如何使用format方法对字符串进行格式化。这种方法允许你将特定的值插入到字符串的指定位置，并能控制其显示格式。

使用format方法插入值

format方法使用花括号{}来标记变量应插入到字符串中的位置。

以下是基本用法示例：

name = "Data"
number = 100
print("{} is number {}".format(name, number))

在这段代码中，name和number两个变量被作为参数传递给format方法。format方法会将这些变量所代表的值作为字符串插入。值的插入顺序与它们作为参数输入的顺序一致。第一个{}对应name，第二个{}对应number。

使用关键字参数明确指定位置

你可以通过为花括号内的占位符命名关键字，来更明确地指定每个子字符串的插入位置。

以下是使用关键字参数的示例：

name = "Data"
number = 100
print("{name} is number {numb}".format(name=name, numb=number))

这种方法下，在方法参数中为关键字显式分配变量。运行时，变量值会根据其关键字被插入到打印的字符串中。此时，方法参数的输入顺序不再重要，name会被插入到字符串的name字段，number会被插入到numb字段。

这种方法非常有用。例如，当输出信息需要翻译成另一种语言时，许多语言会改变词序来表达相同的意思。此方法使得重新排列字符串变得快速而简单。

使用索引指定插入顺序

另一种将值插入字符串的方法是，在花括号中使用整数值来指示插入参数的顺序。

以下是使用索引的示例：

name = "Data"
number = 100
print("{1} is number {0}".format(number, name))

请注意在这个例子中，我们可以在参数字段中以与它们插入打印字符串不同的顺序输入变量number和name。

作为一名数据专业人士，这些不同的向字符串插入值的方法，为你如何选择工作和解决问题提供了很大的灵活性。

格式化数值输出

以下是一个不仅将子字符串插入更大字符串，还对其格式进行设置的例子。

想象你需要打印一件商品含税和不含税的价格。根据税率，数字的小数点后位数可能超过两位。我们可以使用字符串格式化来限制输出中的小数位数，使其更易读。

price = 7.75
tax_rate = 0.07
price_with_tax = price * (1 + tax_rate)
print("Price without tax: ${:.2f}".format(price))
print("Price with tax: ${:.2f}".format(price_with_tax))

在这段代码中，我们的商品不含税价格为7.75美元，税率为7%。因此含税价格为8.2925美元。为了将输出限制在小数点后两位，我们使用了特殊的语法：以冒号开头，将表达式与关键字名称（如果使用的话）分开。冒号后，写入.2f。.2指的是小数点后两位，f代表浮点数。

现在，让我们检查运行此单元格时会发生什么。很好，含税价格现在有两位小数了。你可以将表达式中的2替换为你想要的任意小数位数。如果填入0，则只会打印整数。

对齐文本输出

format函数还有更多方法来优化表达式。让我们探索之前将华氏温度转换为摄氏温度的示例。

顶部是我们编写的用于计算转换的函数。但现在，我们不仅要打印结果，还要对它们进行格式化。

def fahrenheit_to_celsius(f):
    return (f - 32) * 5/9

temperatures_f = [32, 50, 68, 86, 104]
print("{:>3}°F | {:>6}°C".format("F", "C"))
for temp_f in temperatures_f:
    temp_c = fahrenheit_to_celsius(temp_f)
    print("{:>3.0f} | {:>6.2f}".format(temp_f, temp_c))

再次以冒号开始，然后使用大于运算符>将文本右对齐，使输出格式整洁。>3将使输出右对齐3个空格。对于转换后的摄氏温度值，使用>6，这将使摄氏温度右对齐6个空格。请注意输出是多么整洁。我们的小数被截断到百分位，并且值以漂亮的表格形式输出。

总结

本节课中，我们一起学习了Python中format方法的各种应用。你了解了如何向字符串中插入值，如何使用关键字和索引控制插入位置，以及如何格式化数值和对齐文本。关于字符串的一切知识都将帮助你更有效地工作，简化流程，并为你的公司节省大量时间和资源。使用Python的核心在于以最小的努力实现最大的生产力，使其成为帮助你实现这些目标的完美工具。

029：第3节总结 🎯

在本节课中，我们将回顾Python入门课程的第三部分内容。这一部分主要聚焦于如何使用Python自动化重复性任务，以及字符串的基本操作。通过学习循环和字符串处理，你将能够更高效地处理数据，为未来的数据分析工作打下坚实基础。

课程第三部分结束 🏁

这是Python课程第三部分的结尾。

自课程开始以来，你已经取得了长足的进步。祝贺你取得的所有进展。

在课程的这一部分，我们重点学习了使用Python代码自动化重复性任务，而不是每次想让计算机重复一个动作时都编写新的代码。

你可以编写迭代语句或循环来实现自动化。

循环会自动重复一部分代码，直到某个过程完成。

使用Python自动化重复性任务将帮助你更有效地工作，简化流程，并节省大量的时间和精力。

作为一名数据专业人士，你将拥有更多时间来处理最重要的任务：分析数据，为利益相关者生成有用的见解。

自动化重复性任务的两种方法 🔄

我们讨论了自动化重复性任务的两种不同方法：while循环和for循环。

你学习了如何为while循环和for循环编写代码，以及何时使用每种方法。

以下是两种循环的基本代码结构：

while循环示例：

while condition:
    # 执行的代码块

for循环示例：

for item in sequence:
    # 执行的代码块

字符串操作 📝

我们还讨论了字符串，即由字母和标点符号等字符组成的序列。

你学习了如何通过切片、索引和格式化来操作字符串。

作为一名数据专业人士，你将经常处理文本数据，例如产品信息或客户反馈。

切片和索引等操作使你能够快速高效地选择、筛选和编辑数据。

以下是字符串索引和切片的基本公式：

  • 索引：string[index]
  • 切片：string[start:end:step]

持续学习与成长 🌱

学习Python是一段令人兴奋的旅程，将在你未来的职业生涯中持续进行。

我参与的每个数据项目都有其特定的挑战。我总是在网上探索或与队友交流，在工作中学习新的Python技能。这帮助我解决问题并更高效地工作。

随着你继续学习和练习Python，你的数据分析技能将不断增长。

接下来，你需要准备一个分级评估。复习列出所有新术语的阅读材料，并随时重新观看视频、阅读材料以及其他涵盖关键概念的资源。

你做得很好。继续保持。😊

总结 📚

在本节课中，我们一起回顾了Python入门课程第三部分的核心内容。你学习了如何使用while循环和for循环自动化重复性任务，以及如何通过切片、索引和格式化操作字符串。这些技能将帮助你在数据处理中节省时间，提高效率，为后续的数据分析工作奠定坚实基础。继续练习和探索，你的Python技能将不断进步！

030：数据结构与库 🚀

在本模块中，我们将学习Python中用于高效组织和处理数据的核心数据结构，并介绍两个对数据分析至关重要的库：NumPy和pandas。

欢迎回来。你的学习之旅已经取得了长足的进步。

回顾一下你在此过程中掌握的所有新Python技能。

你已经学会了如何使用变量来存储和标记数据，以及如何处理不同的数据类型，例如整数、浮点数和字符串。

你可以调用函数来对数据执行操作，并使用运算符来比较值。

你也知道如何编写清晰易懂、便于其他数据专业人员理解和重用的代码。

你可以编写条件语句，告诉计算机如何根据你的指令做出决策。

最近，你还学会了如何使用循环来自动化重复性任务。

接下来，我们将探索数据结构。数据结构是数据值或包含不同数据类型的对象的集合。

数据专业人员使用数据结构来快速高效地存储、访问、组织和分类数据。

了解哪种数据结构适合你的特定任务是数据工作的关键部分，并将有助于简化你的分析。

我们将重点介绍对数据专业人员最有用的一些数据结构：列表、元组、字典、集合和数组。

使Python成为一种强大且多功能的编程语言的部分原因，在于其可用的库和包。

在回顾了基本数据结构之后，我们将讨论对数据专业人员最重要的两个库和包。

第一个是NumPy（Numerical Python），以其高性能计算能力而闻名。

数据专业人员使用NumPy来快速处理大量数据。我经常在工作中使用NumPy，因为它对于分析大型复杂数据集非常有用。

第二个是pandas（Python Data Analysis Library），它是高级数据分析的关键工具。

pandas使得以行和列表格形式分析数据变得更加容易和高效，因为它拥有专门为此设计的工具。

当你准备好后，我们将在下一个视频中继续学习。

031：列表简介 📚

在本节课中，我们将要学习数据类型与数据结构之间的区别，并重点探索Python中一种重要的数据结构——列表。我们将了解列表的特性、如何创建和操作列表，以及它与字符串的异同。

数据类型与数据结构 📊

上一节我们介绍了Python的基础语法，本节中我们来看看数据是如何被组织和存储的。

数据类型 是描述一段数据的属性，它基于数据的值、编程语言或可执行的操作。在Python中，常见的数据类型包括整数（int）、字符串（str）、浮点数（float）和布尔值（bool）。

数据结构 是数据值或对象的集合，可以包含不同的数据类型。数据结构能够更高效地存储、访问和修改数据，并允许你组织和关联数据集合。

列表简介 📝

列表是Python中的一种数据结构，用于存储和操作一个有序的项目集合。例如，一个与用户账户关联的电子邮件地址列表。

列表与字符串有许多相似之处。例如，两者都允许重复元素，并且都支持索引和切片操作。此外，它们都属于序列——即按位置顺序排列的项目集合。

然而，关键区别在于：字符串是字符的序列，而列表可以存储任何数据类型元素的序列。

可变性与不可变性 🔄

不同数据结构具有可变或不可变的特性。

  • 可变性 指的是改变数据结构内部状态的能力。
  • 不可变性 则相反，数据结构的元素值永远不能被更改或更新。

列表及其内容是可变的，这意味着可以修改、添加或删除其中的元素。
字符串是不可变的，一旦创建就无法更改。

可以将列表想象成一个被分成多个槽位的长盒子。每个槽位包含一个值，每个值可以存储任何数据——可以是另一个数据结构（如另一个列表），也可以是整数、字符串、浮点数或另一个函数的输出。

列表的索引与切片 🔢

当处理列表时，我们使用索引来访问每个元素。索引提供了有序序列中每个元素的编号位置。

以下是创建和访问列表的示例：

# 创建一个列表并赋值给变量 x
x = ["Now", "we", "are", "cooking", "with", "seven", "ingredients"]

在Python中，我们使用方括号 [] 表示列表的开始和结束，并使用逗号 , 分隔其中的每个元素。

要打印列表中的特定元素，需要使用其索引号。索引总是从0开始。

# 打印列表中的第三个元素（索引为2）
print(x[2])  # 输出: are

我们也可以使用索引范围来创建列表的切片，使用两个由冒号分隔的数字。

# 获取列表中索引1到3（不包括3）的元素
print(x[1:3])  # 输出: ['we', 'are']

# 获取从开始到索引2（不包括2）的所有元素
print(x[:2])   # 输出: ['Now', 'we']

# 获取从索引2到列表末尾的所有元素
print(x[2:])   # 输出: ['are', 'cooking', 'with', 'seven', 'ingredients']

切片规则与字符串相同：如果起始索引留空，则默认为0；如果结束索引留空，则默认为列表的长度。

检查列表成员资格 ✅

要检查某个元素（例如单词 "this"）是否存在于列表中，可以使用关键字 in 来生成一个布尔语句。

# 检查 "this" 是否在列表 x 中
print("this" in x)  # 输出: False

此检查的结果是一个布尔值（True 或 False），我们可以在代码的其余部分将其用作分支或循环的条件。

列表的实用性 💡

当你处理许多相关值时，列表非常有用。它们使你能够：

  • 将正确的数据保持在一起。
  • 简化你的代码。
  • 一次性对多个值执行相同的操作。

总结 📋

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

  1. 数据类型与数据结构的基本概念。
  2. 列表作为一种有序、可变的数据结构，可以存储多种数据类型。
  3. 列表的创建、索引和切片操作。
  4. 使用 in 关键字检查元素是否存在于列表中。
  5. 列表的可变性与字符串的不可变性之间的核心区别。

列表是Python编程中组织和管理数据的强大工具。在接下来的课程中，我们将继续深入学习列表的更多操作方法。

032：修改列表内容 📝

在本节课中，我们将学习如何修改Python列表的内容。你将掌握如何向列表中添加新元素、移除现有元素以及更改特定位置上的元素值。这些操作能让你更灵活地管理和更新数据集合。

上一节我们介绍了列表的基本概念和索引方法，本节中我们来看看如何实际改变列表中的内容。

理解列表的可变性 🔄

我们可以将列表想象成一个被分成多个格子的盒子。修改列表意味着我们保留这个盒子本身，但可以增加、移除或更换盒子里的物品。这与字符串不同，字符串是不可变的，而列表是可变的。

为了说明这一点，请看以下对比：

# 字符串不可变示例
my_string = "hello"
# my_string[0] = 'H'  # 这行会报错，因为字符串不可变
my_string = 'H' + my_string[1:]  # 必须创建新字符串并重新赋值

# 列表可变示例
my_list = ['a', 'b', 'c']
my_list[0] = 'A'  # 可以直接修改，不会报错

向列表添加元素 ➕

以下是向列表中添加元素的常用方法。

使用 append() 方法

append() 方法将一个元素添加到列表的末尾。它只需要一个参数，即要添加的元素。

fruits = ['apple', 'banana', 'cherry']
fruits.append('kiwi')
print(fruits)  # 输出: ['apple', 'banana', 'cherry', 'kiwi']

你甚至可以从一个空列表开始，然后不断添加元素。

shopping_list = []
shopping_list.append('milk')
shopping_list.append('eggs')

使用 insert() 方法

insert() 方法在列表的指定索引位置插入一个元素。它需要两个参数：索引位置和要插入的元素。

fruits = ['apple', 'banana', 'cherry']
fruits.insert(1, 'orange')  # 在索引1（第二个位置）插入'orange'
print(fruits)  # 输出: ['apple', 'orange', 'banana', 'cherry']

# 在列表开头插入元素
fruits.insert(0, 'mango')
print(fruits)  # 输出: ['mango', 'apple', 'orange', 'banana', 'cherry']

从列表移除元素 ➖

以下是几种从列表中移除元素的方法。

使用 remove() 方法

remove() 方法根据元素的值来移除列表中第一个匹配到的项。它只需要一个参数。

fruits = ['apple', 'banana', 'cherry', 'banana']
fruits.remove('banana')  # 移除第一个'banana'
print(fruits)  # 输出: ['apple', 'cherry', 'banana']

如果要移除的元素不在列表中，Python会引发一个 ValueError。

# fruits.remove('strawberry')  # 会报错: ValueError

使用 pop() 方法

pop() 方法根据元素的索引来移除并返回该元素。如果不提供索引，默认移除并返回最后一个元素。

fruits = ['apple', 'orange', 'banana', 'cherry']
removed_fruit = fruits.pop(2)  # 移除索引为2的元素（'banana'）
print(removed_fruit)  # 输出: banana
print(fruits)         # 输出: ['apple', 'orange', 'cherry']

# 不提供索引，移除最后一个元素
last_fruit = fruits.pop()
print(last_fruit)  # 输出: cherry

直接修改列表元素 ✏️

除了增删，我们还可以直接通过索引来修改列表中某个位置的值。

fruits = ['apple', 'pineapple', 'cherry']
fruits[1] = 'mango'  # 将索引1处的'pineapple'替换为'mango'
print(fruits)  # 输出: ['apple', 'mango', 'cherry']

总结 📚

本节课中我们一起学习了如何修改Python列表。我们掌握了三种核心操作：

  1. 添加元素：使用 append() 在末尾添加，或使用 insert() 在指定位置插入。
  2. 移除元素：使用 remove() 按值移除，或使用 pop() 按索引移除。
  3. 修改元素：通过索引直接赋值来更改特定位置的值。

理解列表是“可变的”这一特性至关重要，它意味着我们可以在不创建新列表的情况下直接修改其内容，这与字符串的行为截然不同。现在你已经掌握了操控列表数据的基本技能，可以更自如地处理各种数据集合了。

033：元组简介 🧱

在本节课中，我们将要学习Python中一个重要的数据结构——元组。我们将了解它是什么、如何创建、它与列表的区别，以及它在数据处理工作中的实际应用。

概述

作为数据专业人士，有时访问和引用数据比更改和操作数据更为重要。当你只需要查找信息，但需要保持数据完整无缺时，可以使用一种名为元组的数据结构。元组是一种不可变的序列，可以包含任何数据类型的元素。

上一节我们介绍了列表，本节中我们来看看它的“安全”版本——元组。

什么是元组？

元组类似于列表，但它们更安全，因为无法轻易更改。它们有助于将需要一起处理的数据保存在同一结构中。

元组通过圆括号 () 或 tuple() 函数来实例化或表示。

以下是一个表示某人全名的元组：

full_name = ('Grace', 'B', 'Hopper')

请注意，它是使用圆括号实例化的。元组的第一个元素是名字，第二个是中间名的首字母，第三个是姓氏。

元组的不可变性

元素在元组中的位置是固定的。因此，你不能在中间添加新元素，也不能更改任何元素。

如果我们尝试将索引号为2的姓氏从 'Hopper' 更改为 'Copper'：

full_name[2] = 'Copper'  # 这将引发错误

代码将抛出错误。你只能在重新赋值整个元组的情况下，在末尾添加值。

使用 tuple() 函数创建元组

创建元组的另一种方法是使用 tuple() 函数将输入转换为元组。

例如，我们的名字最初表示为一个列表：

name_list = ['Grace', 'B', 'Hopper']
name_tuple = tuple(name_list)

现在，name_tuple 是一个元组，不再有列表的方括号。

元组与函数返回值

元组也用于从函数返回值。实际上，当一个函数返回多个值时，它返回的就是一个元组。

例如，这里有一个函数，它接收一个代表价格的浮点值作为参数，并返回美元和美分数额：

def dollars_and_cents(price):
    dollars = int(price)
    cents = int((price - dollars) * 100)
    return dollars, cents  # 实际上返回一个元组

result = dollars_and_cents(6.55)  # 返回 (6, 55)

元组解包

尽管元组是不可变的，但它们可以被解包到单独的变量中。

当我们运行上述函数时，可以直接将输出赋值给不同的变量：

dollars, cents = dollars_and_cents(6.55)

存储在 result 变量中的元组信息现在已被重新赋值给两个独立的变量，我们可以随意操作它们。这个过程称为解包元组。请注意，解包后的变量本身不再是元组（在这个例子中是整数）。

元组的优势：在数据结构中存储不同类型的数据

使用元组的一个巨大优势是，它允许你在其他数据结构中存储不同类型的数据。

以下是一个展示其用法的例子。这是一个大学女子篮球队首发五名球员的列表：

starting_five = [
    ('Sarah', 20, 'Guard'),
    ('Emily', 21, 'Forward'),
    ('Jessica', 19, 'Center'),
    ('Amanda', 22, 'Guard'),
    ('Rachel', 20, 'Forward')
]

这是一种处理此类信息的有效方式。球员的顺序不太重要，我们可能想添加或重新排列他们，因此我们使用可变的列表。然而，球员本身是由元组表示的独立记录。它们更安全，因为元组是不可变的，更不容易被意外更改。

遍历元组列表

因为列表和元组都是可迭代的，我们可以使用循环从中提取信息。

例如，我们可以编写一个 for 循环，将每个元组解包为三个单独的变量，然后在每次迭代中打印其中一个变量：

for name, age, position in starting_five:
    print(name)

这等价于遍历每个球员记录并打印索引0处的记录（即名字）。

总结

本节课中我们一起学习了Python中的元组。

我们了解到：

  • 元组是不可变的序列，用于安全地存储数据。
  • 可以使用圆括号 () 或 tuple() 函数创建元组。
  • 元组支持解包，方便地将值分配给多个变量。
  • 元组常用于函数返回多个值，以及在其他可变结构（如列表）中存储固定的记录。
  • 在数据专业工作中使用元组有助于提高流程效率、节省内存并优化程序。同时，当他人与你协作时，你对元组的使用能清晰地表明这些值序列不打算被修改，这是为团队节省时间和精力的又一个好方法。

元组是构建可靠、清晰的数据处理代码的基石之一。

034：循环、列表与元组进阶 🔄

在本节课中，我们将学习循环、列表与元组的进阶用法。课程将介绍一些对数据专业人士有用的新工具，并通过更复杂的示例来展示如何结合使用字符串格式化、循环、元组和列表。

上一节我们介绍了循环和列表的基础知识，本节中我们来看看如何将它们应用于更实际的场景。

处理球员数据列表 🏀

我们继续使用上一视频中的女子篮球队球员列表。这个列表由多个元组组成，每个元组包含球员的姓名、年龄和位置。

我们将定义一个函数，用于提取每位球员的姓名和位置，并将信息格式化为一个列表以便打印。

该函数名为 player_position，其参数是一个包含球员信息的元组列表。

首先，实例化一个空列表来存放结果，该列表将在我们遍历数据时逐步构建。

接下来，使用 for 循环来解包球员列表中的元组。

循环中分配的变量必须与元组的格式对齐。每个元组包含三个部分：姓名、年龄和位置，因此我们的 for 循环需要三个变量。

如果尝试仅用两个变量（如 for name, age in players）来解包元组，计算机会报错，因为它不知道如何处理元组中的第三个元素。

因此，我们这样开始 for 循环：for name, age, position in players。

然后，使用字符串格式化将每个姓名和位置附加到结果列表中。每个字符串都包含一些位置格式和一个换行符。

最后，在一个 for 循环中调用此函数。该循环将遍历函数输出的结果列表，并打印每一项。

现在，我们得到了一个格式美观、易于阅读的球员和位置表格。

嵌套循环的应用 🎲

以下是循环和列表的另一个应用示例，展示了嵌套循环的用法。嵌套循环是指一个循环位于另一个循环内部。

这段代码生成了一副多米诺骨牌游戏中所有不同的骨牌。多米诺骨牌是一种使用带有点数（或称“点”）的游戏棋子进行的游戏。

以下是生成骨牌的代码逻辑：

我们首先确定骨牌左侧的数字，这些数字代表骨牌上的点数，范围从0到6。

对于这个范围内的每个数字，我们将运行另一个循环来生成骨牌右侧的点数。

然后，将左侧数字和右侧数字插入一个格式化的打印语句中。

以下是生成的骨牌。请注意，在第一个打印语句中，我们包含了一个名为 end 的参数，其值是一个空格。

默认情况下，当打印语句执行时，它会以换行符结束。因此，如果没有这个参数，所有骨牌将被打印成一条垂直线，一个接一个。

但当我们把结束字符设置为一个空格时，它会在每个骨牌之间打印一个空格。

使用列表存储与索引 📊

同样的代码，我们也可以不将骨牌打印为字符串，而是将每个骨牌作为整数元组存储在一个名为 dominoes 的列表中。

现在，假设我们想检查索引为4的元组中的第二个数字。我们可以通过索引来实现。

首先访问我们想要访问的列表 dominoes，并在括号中放入我们想要访问的元组的索引。然后，再添加一对括号，其中包含该元组内值的索引。

例如：dominoes[4][1]。

如果我们想计算每个骨牌上的总点数，可以用一个 for 循环遍历每个元组，将索引0的值和索引1的值相加，并将总和附加到一个列表中。

列表推导式：更优雅的解决方案 ✨

但有一个更简单的方法，叫做列表推导式。列表推导式可以根据现有列表中的值，以公式化的方式创建一个新列表。

以下是它的工作原理：

首先，为一个新列表分配一个变量，我们称之为 pips_from_list_comp。为其值创建一个空列表。

然后，我们基本上是以相反的顺序编写一个 for 循环。我们从创建列表每个元素的计算开始。

在本例中，我们希望每个元素是骨牌上的总点数，即 domino[0] + domino[1]。

然后，我们添加一个 for 语句。

我们可以检查以确保它给出的结果与我们的 for 循环相同。结果是相同的。

请注意发生了什么。这就是为什么我说列表推导式就像一个反向编写的 for 循环。它的 for 部分在语句的末尾，而计算部分在开头。

for 循环和列表推导式做的是同一件事，但列表推导式通常更优雅，执行速度也更快。

总结 📝

本节课中我们一起学习了循环、列表与元组的进阶应用。我们通过处理结构化数据（球员列表）和生成组合数据（多米诺骨牌）的示例，实践了嵌套循环和字符串格式化。最后，我们介绍了列表推导式这一强大而优雅的工具，它能更简洁高效地基于现有列表创建新列表。

希望你现在能体会到Python这些基础构建模块的强大之处。鼓励你自行探索本课程中的代码，通过添加或修改内容来尝试会发生什么。动手实践是学习编程的最佳方式之一。

035：字典简介 📚

在本节课中，我们将要学习Python中一个极其重要且广泛使用的数据结构——字典。我们将了解字典的基本概念、创建方法、核心特性以及如何访问其中的数据。

什么是字典？

字典是一种由键值对集合组成的数据结构。它使用花括号 {} 或 dict() 函数来创建。无论是资深的数据专家还是入门级的数据从业者，都会利用字典强大的快速处理能力来分析大型数据集，这有助于他们收集和转换用户信息。

字典提供了一种直观的数据存储方式，让用户能更容易地找到特定信息。我们可以用一个生活中的例子来理解：使用一本普通的纸质字典（不是数据结构，而是真实的书籍）时，你查找一个单词，找到它，然后阅读其定义。Python字典本质上也是如此：你查找一个键，从而访问与该键关联的值。这就是“键值对”的含义。

一个简单的例子 🐘

假设我们有一个动物园，园内有不同的围栏，里面饲养着不同的动物。我们可以用一个字典来存储这些信息，其中围栏编号作为键，动物作为值。

我们可以用这个字典来查询每个围栏里有哪些动物。例如，如果我们想知道2号围栏里有什么动物，我们可以这样操作：

# 定义一个动物园字典
zoo = {1: '狮子', 2: '斑马', 3: '大象'}

# 查询2号围栏的动物
animal_in_pen_2 = zoo[2]
print(animal_in_pen_2)  # 输出：斑马

以这种方式访问字典时，程序总是在键中搜索，并返回对应键的值。这个过程是单向的，不能反向操作。例如，你不能通过索引来搜索“斑马”并找出它所在的围栏号，那样会导致 KeyError，因为“斑马”不是字典中的一个键。

如何创建字典？

字典主要有两种创建方式。

第一种方式是使用花括号 {}。 在这种方法中，每个键和它的值之间用冒号 : 分隔，每个键值对之间用逗号 , 分隔。

# 使用花括号创建字典
zoo = {1: '狮子', 2: '斑马', 3: '大象'}

第二种方式是使用 dict() 函数。 使用 dict() 函数时，语法略有不同。当键是字符串时，你可以将它们作为关键字参数输入。

# 使用dict()函数创建字典
zoo = dict(pen1='狮子', pen2='斑马', pen3='大象')

请注意，上次我们用花括号创建字典时，使用了引号来表示键是字符串。而在这里，作为关键字参数，我们不需要引号。同时，键和值之间使用的是等号 = 而不是冒号 :。

无论使用花括号还是 dict() 函数，字典的查找方式都是相同的。dict() 函数在使用上更加灵活。例如，我们还可以通过传递一个列表的列表、元组的列表或列表的元组作为参数来创建同一个字典。

# 使用列表的列表创建字典
zoo_list = [[1, '狮子'], [2, '斑马'], [3, '大象']]
zoo_from_list = dict(zoo_list)

# 使用元组的元组创建字典
zoo_tuple = ((1, '狮子'), (2, '斑马'), (3, '大象'))
zoo_from_tuple = dict(zoo_tuple)

它们都会得到相同的结果。

字典的核心特性

上一节我们介绍了如何创建和访问字典，本节中我们来看看字典的几个重要特性。

1. 添加新的键值对
如果想向现有字典中添加新的键值对，例如将鳄鱼放入4号围栏，可以像下面这样直接赋值：

zoo[4] = '鳄鱼'

2. 键必须是不可变的
字典的键必须是不可变对象。不可变键的类型包括但不限于：整数、浮点数、元组和字符串。列表、集合和其他字典不属于此类，因为它们是可变的。

3. 字典是无序的
这意味着你不能通过位置索引来访问它们。如果你尝试用索引 2 访问我们的 zoo 字典，你会得到一个 KeyError，因为计算机会将 2 解释为一个字典键，而不是一个位置索引。同时，由于字典是无序的，你有时会发现条目的顺序在你操作过程中可能会发生变化。如果你的数据顺序很重要，最好使用像列表这样的有序数据结构。

4. 检查键是否存在
你可以简单地使用 in 关键字来检查某个键是否存在于你的字典中。

# 检查键 2 是否存在
if 2 in zoo:
    print("2号围栏存在")

请注意，这种方法只适用于检查键，不能用于检查值。

总结与展望

本节课中，我们一起学习了Python字典的基础知识。我们了解了字典作为键值对集合的本质，掌握了使用花括号 {} 和 dict() 函数创建字典的两种方法，并探讨了字典的核心特性，如键的不可变性、无序性以及如何检查和添加数据。

字典的功能远不止于此，我们在这里回顾的只是一个开始。接下来，我们将通过更多示例来展示字典的强大功能，并学习一些让字典操作变得轻松便捷的工具。我们下节课再见！

036：字典方法 🗂️

在本节课中，我们将继续学习Python字典，并重点介绍如何将列表数据转换为字典，以及如何使用字典的keys()、values()和items()方法来高效地访问数据。

概述

上一节我们介绍了字典的基本概念和工作原理。本节中，我们将通过一个具体的例子，学习如何将球员信息列表转换为按位置组织的字典，并探索几个关键的字典方法，以便更灵活地操作和访问数据。

从列表到字典的转换

让我们回顾之前使用过的女子篮球队阵容示例。该阵容最初被编码为一个元组列表，每个元组代表一名球员的姓名、年龄和位置。当球队只有首发五人时，这种列表结构是有效的。

如果我们想增加更多球员，字典可以帮助我们根据特定需求组织数据。例如，如果我们希望按位置查找球员，可以创建一个字典，其中键是位置，值是球员信息（以包含姓名和年龄的元组表示）。

我们可以手动重新输入或复制粘贴信息来创建字典，但更好的方法是编写代码来自动转换。考虑到如果数据量很大（例如整个联盟的球员），手动操作将非常低效。

以下是将列表转换为字典的步骤：

  1. 实例化一个空字典。
  2. 遍历原始列表中的每个元组。
  3. 提取位置作为字典的键。
  4. 提取球员的姓名和年龄，组成元组，作为该键对应的值（值将是一个包含多个元组的列表）。

以下是实现此转换的代码：

# 原始球员列表（姓名， 年龄， 位置）
roster = [
    ("Alice", 22, "Guard"),
    ("Bob", 24, "Forward"),
    ("Cathy", 23, "Center"),
    ("Diana", 25, "Guard"),
    ("Eva", 21, "Forward")
]

# 步骤1：创建空字典
new_team = {}

# 步骤2：遍历列表并填充字典
for name, age, position in roster:
    # 步骤3和4：检查位置是否已存在，然后添加球员信息
    if position in new_team:
        # 如果位置键已存在，将球员元组追加到对应的列表中
        new_team[position].append((name, age))
    else:
        # 如果位置键不存在，创建新键并初始化列表
        new_team[position] = [(name, age)]

# 检查结果
print(new_team)

运行这段代码后，new_team字典将按位置组织所有球员，每个位置键对应一个球员信息元组的列表。这种方式在数据分析中非常常见，掌握它能使你成为更高效的数据专业人士。

实用的字典方法

创建字典后，我们需要有效访问其中的数据。以下是三个核心方法：

keys() 方法

如果你直接遍历字典，循环只会访问键，而不是值。但你不必每次都写循环来获取键，这正是keys()方法的作用。它返回字典中所有键的视图。

# 获取字典的所有键
positions = new_team.keys()
print(positions)  # 输出类似 dict_keys(['Guard', 'Forward', 'Center'])

values() 方法

类似地，values()方法让你能检索字典中所有的值。对于我们的new_team字典，值是由元组组成的列表，因此调用此方法会返回一个“列表的列表”。

# 获取字典的所有值
players_info = new_team.values()
print(players_info)  # 输出所有球员信息列表

items() 方法

如果你想同时访问键和其对应的值，可以使用items()方法。它返回一个包含（键， 值）对元组的视图。为了更清晰地查看输出，我们通常配合循环使用。

# 使用items()方法遍历键值对
for position, players in new_team.items():
    print(f"位置: {position}")
    for player in players:
        print(f"  - 球员: {player[0]}, 年龄: {player[1]}")

总结

本节课中，我们一起学习了如何将列表数据转换为更有组织的字典结构，并掌握了三个强大的字典方法：keys()、values()和items()。字典使得数据的存储和检索变得快速而高效。

请继续探索字典的更多功能，随着时间推移，你会发现它已成为你数据分析工具箱中不可或缺的重要工具。

037：集合简介 📚

在本节课中，我们将要学习Python中的一种重要数据结构——集合。集合用于存储无序且唯一的元素，在数据处理中非常有用，例如去除重复项或进行数学集合运算。

什么是集合？ 🧩

上一节我们介绍了列表和元组，本节中我们来看看集合。集合是Python中的一种数据结构，它包含无序且不可重复的元素。

集合可以通过 set() 函数或非空花括号 {} 来创建。集合中的每个元素必须是唯一且不可变的，但集合本身是可变的。

在数据表中存储混合数据，或需要确保大量元素中每个只出现一次时，集合非常有价值。由于集合是可变的，因此不能用作字典的键。

如何创建集合？ 🛠️

创建集合主要有两种方法。

方法一：使用 set() 函数

set() 函数接受一个可迭代对象作为参数，并返回一个新的集合对象。

以下是使用列表、元组和字符串创建集合的示例：

# 从列表创建集合
my_list = ["foo", "bar", "baz", "foo"]
set_from_list = set(my_list)
print(set_from_list)  # 输出可能是 {'foo', 'bar', 'baz'}，注意第二个'foo'被去除了

# 从元组创建集合
my_tuple = (1, 2, 2, 3)
set_from_tuple = set(my_tuple)
print(set_from_tuple)  # 输出 {1, 2, 3}

# 从字符串创建集合
my_string = "hello"
set_from_string = set(my_string)
print(set_from_string)  # 输出可能是 {'e', 'h', 'l', 'o'}，字母无序且唯一

set() 函数会将可迭代对象拆分为单个元素，并仅保留其中唯一的元素。

方法二：使用花括号 {}

使用花括号可以直接创建集合，但花括号内必须有内容。空的花括号 {} 会被Python解释为空字典，而不是空集合。

# 创建非空集合
my_set = {"apple", "banana", "cherry"}
print(my_set)

# 创建仅包含一个字符串的集合
single_set = {"python"}
print(single_set)  # 输出 {'python'}

注意：定义空集合或新建集合时，最好使用 set() 函数。仅当集合非空且要赋值给变量时，才使用花括号。

此外，由于集合元素是无序的，因此无法通过索引或切片来访问集合中的元素。

集合的常用操作 🔧

集合支持多种数学集合运算。以下是几个核心操作及其对应的方法和运算符。

交集

交集用于找出两个集合共有的元素。

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}

# 使用方法
intersection_result = set1.intersection(set2)
print(intersection_result)  # 输出 {3, 4}

# 使用运算符 &
intersection_result_operator = set1 & set2
print(intersection_result_operator)  # 输出 {3, 4}

并集

并集用于获取两个集合中所有的元素。

x1 = {"a", "b", "c"}
x2 = {"c", "d", "e"}

# 使用方法
union_result = x1.union(x2)
print(union_result)  # 输出 {'a', 'b', 'c', 'd', 'e'}

# 使用运算符 |
union_result_operator = x1 | x2
print(union_result_operator)  # 输出 {'a', 'b', 'c', 'd', 'e'}

并集是数学中的可交换操作，因此无论变量顺序如何，结果都相同。

差集

差集用于找出存在于第一个集合中，但不在第二个集合中的元素。

set_a = {7, 8, 9, 10}
set_b = {9, 10, 11, 12}

# 使用方法：set_a 减去 set_b
difference_result = set_a.difference(set_b)
print(difference_result)  # 输出 {7, 8}

# 使用运算符 -
difference_result_operator = set_a - set_b
print(difference_result_operator)  # 输出 {7, 8}

# 反向差集：set_b 减去 set_a
reverse_difference = set_b - set_a
print(reverse_difference)  # 输出 {11, 12}

差集不是可交换操作，set_a - set_b 与 set_b - set_a 的结果不同。

对称差集

对称差集用于找出两个集合中互不共有的所有元素。

set_x = {1, 2, 3}
set_y = {3, 4, 5}

# 使用方法
symmetric_diff_result = set_x.symmetric_difference(set_y)
print(symmetric_diff_result)  # 输出 {1, 2, 4, 5}

# 使用运算符 ^
symmetric_diff_operator = set_x ^ set_y
print(symmetric_diff_operator)  # 输出 {1, 2, 4, 5}

总结 📝

本节课中我们一起学习了Python中的集合。

我们了解了集合是存储无序、唯一元素的数据结构，掌握了使用 set() 函数和花括号创建集合的两种方法。我们还深入探讨了集合的四种核心操作：交集、并集、差集和对称差集，并学会了如何使用对应的方法和运算符来执行这些操作。

集合是数据处理中去除重复和进行集合运算的强大工具，为后续更复杂的数据分析工作奠定了重要基础。

038：包的强大功能 📦

在本节课中，我们将要学习Python中用于数据工作和其他科学应用的高级计算能力。这些功能通过库、包和模块来提供，它们能扩展、增强和复用代码，从而节省时间，并提供额外的数据类型用于数据分析或机器学习模型构建。

库与包：可复用的代码集合

上一节我们介绍了Python的基础知识，本节中我们来看看如何通过库和包来扩展Python的功能。

库或包广义上指的是一个可复用的代码集合，它包含相关的模块和文档。在数据工作中，你经常会遇到“库”和“包”这两个术语被互换使用。

以下是数据工作中常用的两个库：

  • Matplotlib：一个用于在Python中创建静态、动画和交互式可视化的综合库。
  • Seaborn：一个基于Matplotlib的数据可视化库，它为处理常见的图表和图形提供了更简单的接口。

证书课程还集成了另外两个常用的数据工作库：NumPy和pandas。

  • NumPy（Numerical Python）是一个核心库，包含多维数组和矩阵数据结构以及操作它们的函数。这个库用于科学计算。
  • pandas（Python Data Analysis）是一个建立在NumPy之上的强大库，用于操作和分析表格数据。

数据专业工作中还有许多其他流行的Python库和包，例如Scikit-learn和Statsmodels。Scikit-learn是一个库，Statsmodels是一个包，它们包含了数据专业人员可以用来测试统计模型性能的函数，被广泛应用于各个科学领域。Scikit-learn和Statsmodels相当高级，因此在本课程中你不会直接使用它们，但在课程项目的其他地方将有机会接触。

再次强调，该领域的不同从业者经常将库和包混用，所以你可能会听到他们以其中一种或两种方式来指代。库和包为数据专业人员提供了必不可少的模块集合。

模块：组织代码的结构化方式

上一节我们了解了库和包，本节中我们来看看构成它们的更小单元——模块。

模块是从包或库中访问的Python文件，包含函数和全局变量的集合。全局变量与其他变量的区别在于，这些变量可以从程序或脚本的任何地方访问。

模块用于以结构化的方式组织函数、类和其他数据。在内部，模块是通过包含这些必要类和函数的独立文件来设置的。当你导入一个模块时，你就是在使用预先编写好的代码组件。每个模块都是一个可执行文件，可以添加到你的脚本中。

以下是数据专业工作中常用的模块：

  • math：提供对数学函数的访问。
  • random：用于生成随机数。这在从列表中随机选择元素、随机打乱元素或进行随机抽样时非常有用，你将在后续课程中探索这些内容。

根据你是想使用整个包还是仅使用单个预定义的函数或功能，有几种导入模块的方法。这为执行专门的操作增加了功能。

总结与后续

关于库、包和模块还有很多需要学习，你可以随时参考课程资源以获取有关安装这些功能的更多信息，并持续增长你的Python知识。但请注意，你无需安装任何东西，因为完成证书课程不同部分所需的一切都已内置在你在Coursera上将使用的Notebook中。

在下一个视频中，我将向你介绍一些库。😊

039：NumPy简介 🐍

在本节课中，我们将要学习NumPy库的基础知识。NumPy是Python中用于科学计算的核心库之一，它提供了高性能的多维数组对象以及处理这些数组的工具。理解NumPy是掌握Python数据分析的关键一步。

NumPy的强大之处：向量化

上一节我们介绍了Python的强大功能部分源于其丰富的包和库。本节中我们来看看其中最重要且广泛使用的库之一：NumPy。

NumPy的核心优势在于向量化。向量化允许对数据对象的多个组成部分同时执行操作。这对于数据专业人员尤其有用，因为他们经常需要处理大量数据。向量化代码计算效率更高，能节省大量时间。

让我们进一步探讨这个概念。假设我们有两个长度相同的列表A和B，我们想创建一个新列表C，它是两个列表的逐元素乘积。

如果尝试直接相乘列表A和B，计算机会报错。为了执行此操作，我们可以编写一个for循环。

以下是使用循环的实现方式：

# 定义列表A和B
A = [1, 2, 3]
B = [4, 5, 6]

# 使用for循环计算逐元素乘积
C = []
for i in range(len(A)):
    C.append(A[i] * B[i])

这种方法可以完成任务，但代码较为繁琐。

使用NumPy进行向量化计算

我们可以使用NumPy将此操作作为向量化计算来执行。

以下是使用NumPy的实现方式：

import numpy as np

# 将列表转换为NumPy数组
A_np = np.array([1, 2, 3])
B_np = np.array([4, 5, 6])

# 使用乘法运算符直接进行向量化计算
C_np = A_np * B_np

两种方法的结果相同，但向量化方法更简单、更易读且执行速度更快。因为for循环一次迭代一个元素，而向量操作在单个语句中同时计算所有元素。

这种效率在处理小数据时可能不明显，但在处理大型数据集时将变得至关重要。此外，向量化操作占用的内存空间更少，这在处理大量数据时是另一个重要因素。

导入语句与别名

你可能注意到，在使用NumPy之前，我们必须先导入它。这称为导入语句。

导入语句使用import关键字将外部库、包、模块或函数加载到你的计算环境中。一旦你将某个内容导入到笔记本中并运行该单元格，除非重启笔记本，否则无需再次导入。

当我们导入NumPy时，通常将其导入为np。这称为别名。别名允许你分配一个备用名称来引用某个对象。在这种情况下，我们将numpy缩写为np。

以下是导入和别名的示例：

import numpy as np

注意下面创建数组的代码中使用了np。如果我们没有给NumPy起别名np，就必须在这里完整地键入numpy才能访问其数组函数。使用np作为别名使代码更短、更易读。请注意，np是标准别名，如果你使用其他名称，其他人在阅读你的代码时可能会感到困惑。

NumPy的广泛影响

除了本身非常有用之外，NumPy还为许多其他Python库（如pandas）提供了动力。因此，理解NumPy的工作原理将帮助你更好地使用这些其他包。

关于NumPy，还有更多内容等待探索。在接下来的课程中，你将学习其核心数据结构和功能。

本节课中我们一起学习了NumPy库的基本概念，包括其向量化计算的优势、如何通过导入语句和别名使用它，以及它在Python数据科学生态系统中的核心地位。掌握这些基础知识是高效进行数据分析的重要一步。

040：基本数组操作 📊

在本节课中，我们将要学习NumPy库中数组的核心概念与基本操作。我们将了解什么是N维数组，如何创建和修改它，以及如何检查其属性和形状。掌握这些基础知识对于后续使用更高级的数据分析库至关重要。

欢迎回来 👋

上一节我们介绍了NumPy如何利用向量化来更快速、高效地处理数据。我演示了NumPy如何通过将列表转换为数组，然后直接相乘，来实现两个列表的逐元素乘法。

现在，我们将继续学习数组以及如何操作它们。

数组：NumPy的核心数据结构 🧱

数组是NumPy的核心数据结构。数据对象本身被称为N维数组，简称ND数组。

ND数组就是一个向量。回顾一下，向量使得许多操作可以在代码执行时同时进行，从而实现更快的运行速度和更少的内存占用。

你可以通过将Python对象传递给np.array函数来创建一个ND数组。

import numpy as np
my_array = np.array([1, 2, 3, 4])

数组的可变性与限制 ⚙️

ND数组是可变的，这意味着你可以改变它们包含的值。

例如，如果我想将数组[‘a1‘， ‘a2‘， ‘a3‘， ‘a4‘]中的最后一个值从‘a4‘改为‘a5‘，可以通过索引号来实现。由于是最后一个值，需要使用索引-1。

my_array = np.array([‘a1‘， ‘a2‘， ‘a3‘， ‘a4‘])
my_array[-1] = ‘a5‘

但是，如果不重新赋值，就无法改变数组的大小。如果尝试在数组末尾添加一个数字，计算机会报错。因此，要改变数组大小，必须重新赋值。

数组的另一个要求是，其所有元素必须是相同的数据类型。

如果我创建一个包含整数1、2和字符串‘coconut‘的数组，NumPy会尝试将所有内容强制转换为相同的数据类型。在本例中，所有内容都变成了字符串（用U21表示，意为Unicode 21）。

mixed_array = np.array([1, 2, ‘coconut‘])
print(mixed_array.dtype) # 输出：<U21

所以在创建数组时，请确保它们包含相同类型的数据，或者这种混合类型是你有意为之且对任务有用的。

检查数组属性 🔍

之前学过，对对象调用type函数会返回该对象的数据类型。对数组使用此函数，会得到numpy.ndarray。

print(type(my_array)) # 输出：<class ‘numpy.ndarray‘>

如果我们想检查数组内容的数据类型，可以使用dtype属性。例如，对于一个整数数组，dtype属性会显示为int。

int_array = np.array([1, 2, 3])
print(int_array.dtype) # 输出：int64

多维数组 📐

顾名思义，ND数组可以是多维的。

对于一维数组，NumPy会接收一个长度为X的类数组对象（如列表），并创建一个形状为(X,)的ND数组。一维数组既不是行也不是列。

我们可以使用shape属性来确认数组的形状，使用ndim属性来确认数组的维数。

arr_1d = np.array([1, 2, 3, 4])
print(arr_1d.shape) # 输出：(4,)
print(arr_1d.ndim)  # 输出：1

数据专业人员经常需要确认数组的形状和维数，例如在尝试将其连接到另一个现有数组时。这些方法也常用于帮助理解代码出错的原因。

二维数组可以从一个列表的列表中创建，其中每个内部列表长度相同。你可以将这些内部列表视为单独的行，因此最终的数组就像一个表格。

arr_2d = np.array([[1, 2], [3, 4], [5, 6], [7, 8]])
print(arr_2d.shape) # 输出：(4, 2)
print(arr_2d.ndim)  # 输出：2

如果二维数组是列表的列表，那么三维数组就是一个包含两个这种结构的列表，即列表的列表的列表。这个数组可以看作是两个表格，每个表格有两行三列，因此它具有三个维度。

arr_3d = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])
print(arr_3d.shape) # 输出：(2, 2, 3)
print(arr_3d.ndim)  # 输出：3

这种维度可以无限扩展。幸运的是，有一些方法可以帮助简化多维数组的操作，你将在以后学到。除非进行非常高级的科学计算，否则通常不会直接处理超过三维的NumPy数组。

重塑数组形状 🔄

NumPy允许我们使用reshape方法重塑数组的形状。

我们的二维数组是4行2列。但如果我们希望这些数据变成2行4列呢？我们只需将这些值填入reshape方法，并将结果重新赋值给变量即可。

arr_2d = np.array([[1, 2], [3, 4], [5, 6], [7, 8]])
arr_reshaped = arr_2d.reshape(2, 4)
print(arr_reshaped)
# 输出：
# [[1 2 3 4]
#  [5 6 7 8]]

重塑数据是数据分析中的常见任务，因此熟悉其含义和工作原理非常重要。

NumPy的其他强大功能 ⚡

可以对数组执行许多其他操作，你将在项目需要时学习它们。但NumPy中还有其他一些你会经常使用的有用函数和方法。

这些包括计算平均值、自然对数等函数，以及分别将数字四舍五入到最近较小和较大整数的向下取整（np.floor）和向上取整（np.ceil）操作，以及许多其他常用的数学和统计运算。

arr = np.array([1.2, 2.7, 3.5])
print(np.mean(arr))   # 输出平均值
print(np.floor(arr))  # 输出向下取整结果
print(np.ceil(arr))   # 输出向上取整结果

NumPy非常强大，你可以用它做很多事情，我们在这里只能简要介绍。

总结与展望 🎯

本节课中，我们一起学习了NumPy数组的基础知识。我们了解了N维数组的概念、如何创建和修改数组、检查其数据类型和形状，以及如何重塑数组。

如你所知，NumPy为许多其他有用的库和包提供支持。在本证书课程中，我们不会直接大量使用NumPy，但会大量使用依赖于它的库——Pandas。理解NumPy的基础知识非常重要，因为它将帮助你在开始使用Pandas时更加得心应手。

随着你数据专业技能的发展，你会发现你会一次又一次地回到NumPy，因为它是高级数据分析不可或缺的一部分。

现在，你对数组有了基本的了解，为后续更复杂的数据操作打下了坚实的基础。下次见！

041：Pandas简介 🐼

在本节课中，我们将要学习一个名为Pandas的Python库。Pandas是数据分析领域的一个核心工具，它极大地简化了表格数据的处理和分析工作。

概述

上一节我们介绍了NumPy及其在高效计算中的重要性。本节中，我们来看看另一个建立在NumPy之上的强大库——Pandas。Pandas专门用于处理和分析表格数据，为数据专业人员提供了直观且强大的接口。

导入Pandas

因为Pandas是一个为Python核心工具集增加功能的库，所以使用前需要先导入它。

通常，我们会同时导入NumPy和Pandas，这主要是为了方便，因为两者经常结合使用。严格来说，使用Pandas并不强制要求导入NumPy，Pandas本身是完全独立可用的。

以下是导入的代码示例：

import numpy as np
import pandas as pd

Pandas的核心功能

Pandas的核心功能是操作和分析表格数据。表格数据是指以行和列的形式组织的数据，电子表格就是一个常见的例子。

虽然NumPy也能实现许多与Pandas相同的功能和操作，但使用起来并不总是那么方便，因为它要求你更抽象地处理数据并跟踪每一步操作。Pandas则提供了一个简单的界面，允许你将数据显示为行和列，这意味着在操作数据时，你总能清楚地看到数据发生了什么变化。

数据框：Pandas的核心数据结构

在Pandas中，表格数据被称为“数据框”。数据框是Pandas的一个核心数据结构。

请注意，数据框由行和列组成，它可以包含许多不同的数据类型，包括整数、浮点数、字符串、布尔值等。

加载与查看数据

首先，你可以轻松地从不同格式的文件中将数据加载到Pandas中，例如逗号分隔值文件、Excel电子表格、数据库等。

以下是一个从网络URL加载CSV文件的示例。该文件包含了泰坦尼克号部分乘客的信息，如姓名、船票等级、年龄、票价和船舱号。

基本数据分析操作

以下是Pandas可以执行的一些基本数据分析操作：

  • 计算平均值：要计算乘客的平均年龄，可以选择“年龄”列并对其调用mean方法。
  • 获取统计值：只需付出最少的努力，就能获得最大值、最小值和标准差。
  • 数据分组统计：可以快速检查每个等级的乘客数量。
  • 生成汇总统计：仅需一行代码即可检查整个数据集的摘要统计信息。此方法会给出每个数值列的行数、均值、标准差、最小值、最大值以及四分位数。

数据筛选

Pandas允许你基于简单或复杂的逻辑进行筛选。

例如，可以筛选出年龄大于60岁的三等舱乘客。

数据操作与转换

除了数据分析工具，Pandas还提供了操作和更改数据的方法。

例如，可以添加一个新列，表示从1912年到2023年经通货膨胀调整后的票价。

数据索引与选择

你可以使用索引从数据中选择行、列或单个单元格。

例如，Florence Briggs Thayer的名字位于第1行、第3列。

数据分组与聚合

Pandas支持更复杂的数据分组和聚合操作。

例如，可以按乘客的等级和性别进行分组，然后计算每个组的平均票价。

总结

本节课中，我们一起学习了Pandas库的基本介绍。我们了解了Pandas的核心功能是处理表格数据，认识了其核心数据结构“数据框”，并演示了如何加载数据、进行基本统计分析、数据筛选、转换以及分组聚合。希望你对开始使用Pandas感到兴奋，这是一个强大且有趣的数据分析工具。

042：Pandas基础 🐼

在本节课中，我们将要学习Pandas库的基础知识。Pandas是数据分析的核心工具，广泛应用于数据科学领域。我们将重点介绍Pandas的两个核心对象类：DataFrame和Series，并学习如何创建、查看和操作它们。

DataFrame：二维表格结构

上一节我们介绍了NumPy的基础，本节中我们来看看Pandas的核心数据结构之一：DataFrame。DataFrame是一个二维的、带标签的数据结构，包含行和列。你可以将其想象成一个电子表格或SQL表，它可以容纳多种不同类型的数据。

我们可以使用pandas.DataFrame()函数来创建DataFrame。这个函数非常灵活，可以将多种数据格式转换为DataFrame对象。

以下是创建DataFrame的两种常见方法：

  1. 从字典创建：字典的每个键代表列名，对应的值是一个列表，列表中的每个元素代表该列在不同行的值。

    import pandas as pd
data = {'Name': ['Alice', 'Bob'], 'Age': [25, 30]}
df = pd.DataFrame(data)

  2. 从NumPy数组创建：数组类似于列表的列表，其中每个子列表代表表格的一行。我们可以使用columns和index参数来命名列和行。

    import numpy as np
array_data = np.array([[1, 2, 3], [4, 5, 6]])
df = pd.DataFrame(array_data, columns=['A', 'B', 'C'], index=['Row1', 'Row2'])

数据从业者经常需要从非Python代码编写的现有数据（如CSV文件）创建DataFrame。CSV（逗号分隔值）是一种纯文本文件，使用逗号分隔不同的值。

Pandas提供了read_csv()函数来读取CSV文件并创建DataFrame。该函数可以从URL或本地硬盘路径读取文件。

# 从URL读取
df = pd.read_csv('https://example.com/data.csv')
# 从本地文件读取
df = pd.read_csv('path/to/your/file.csv')

Series：一维标签数组

现在，让我们讨论Pandas的另一个主要类：Series。Series是一个一维的标签数组。Series对象最常用于表示DataFrame的单个列或行。

我们可以从DataFrame中选择一列或一行，其类型就是pandas.Series。

# 选择一列，得到一个Series
age_series = df['Age']
print(type(age_series))  # 输出：<class 'pandas.core.series.Series'>

与DataFrame类似，Series也可以从各种数据对象创建，包括NumPy数组、字典甚至标量。

操作DataFrame与Series

DataFrame和Series类有许多非常有用的方法和属性，可以简化常见任务。记住，方法是属于类的函数，它对对象执行操作；属性是与类实例关联的值，通常表示实例的特征。两者都使用点号访问，但方法使用括号，而属性不用。

假设我们将泰坦尼克号数据集命名为titanic。

以下是几个常用的属性和方法：

  • .columns属性：返回所有列名的索引。

    print(titanic.columns)

  • .shape属性：返回DataFrame包含的行数和列数。

    print(titanic.shape)  # 输出：(891, 12)

  • .info()方法：提供关于DataFrame的摘要信息，包括行数、列数、列名、每列的数据类型、非空值数量以及内存使用量。

    titanic.info()

关于Pandas术语的两个要点：

  1. 缺失值在Pandas中用NaN（Not a Number）表示。
  2. 如果一个Series对象包含混合或字符串数据类型，其数据类型将显示为object。

数据选择与索引

在Pandas中，最常见任务之一是选择或引用DataFrame的特定部分，这与索引和切片非常相似。

以下是选择数据的不同方式：

  • 选择单列：可以使用括号加列名字符串，或使用点号（仅当列名不含空格时）。

    # 括号表示法（推荐）
name_series = titanic['Name']
# 点号表示法（简单代码可用）
name_series = titanic.Name

  • 选择多列：在括号内传入一个列名列表。

    subset_df = titanic[['Name', 'Age', 'Fare']]

  • 按整数位置选择（.iloc）：iloc用于基于整数位置进行选择。

    # 选择单行（返回Series）
first_row = titanic.iloc[0]
# 选择单行（返回DataFrame）
first_row_df = titanic.iloc[[0]]
# 选择行范围
rows_0_to_2 = titanic.iloc[0:3]  # 选择索引0, 1, 2
# 同时选择行和列的子集
subset = titanic.iloc[0:3, [3, 4]]
# 获取特定行和列的单个值
single_value = titanic.iloc[0, 3]

  • 按标签选择（.loc）：loc用于按行和列的名称进行选择。如果行索引是数字，则使用数字；如果行有命名索引，则使用名称。

    # 选择特定行（索引为数字时）的特定列
subset = titanic.loc[[1, 2, 3], ['Name']]

  • 添加新列：可以通过简单的赋值语句向DataFrame添加新列。

    titanic['New_Column'] = range(len(titanic))

总结与后续

本节课中我们一起学习了Pandas的基础知识。我们介绍了DataFrame和Series这两个核心数据结构，学习了如何从不同来源创建它们，并探索了查看数据摘要、选择特定行和列以及添加新列的基本操作。

Pandas的功能非常丰富，本课仅涵盖了基础部分。在未来的学习中，你可能会遇到本课未明确涵盖的任务。在这种情况下，官方文档始终是你最好的朋友，它几乎总是提供简单的示例来演示如何完成你需要做的事情。

数据分析之旅还在继续，我们下节课再见。

043：布尔掩码 🎭

在本节课中，我们将要学习如何使用布尔掩码来根据数值条件筛选数据框中的数据。这是一种基于数值条件进行数据过滤的强大技术。

概述

上一节我们介绍了基于列名、行索引以及行列组合的数据选择方法。本节中，我们来看看如何根据数值条件来筛选数据。

布尔掩码是一种过滤技术，它将一个布尔值网格覆盖在数据框上，从而只选择数据框中与网格中“真”值对齐的数据。

什么是布尔掩码？

布尔值用于描述只有两种可能值的二元变量：True 或 False。在 pandas 中，布尔掩码是一个 pandas 序列对象，它根据特定条件为数据框中的每个值（通常是行）标记 True 或 False。

核心概念：布尔掩码本质上是一个与数据框索引长度相同的布尔值序列。当将其应用于数据框时，只有对应掩码值为 True 的行会被保留。

创建与应用布尔掩码

假设我们有一个关于行星及其卫星数量的数据框。我们想筛选出卫星数量少于 20 颗的行星。

以下是创建和应用布尔掩码的步骤：

  1. 创建数据框：首先，我们使用 pandas 的 DataFrame 函数从一个预定义的字典创建数据框。

    import pandas as pd
planets = pd.DataFrame({
    'name': ['Earth', 'Mars', 'Jupiter', 'Saturn'],
    'moons': [1, 2, 80, 83],
    'radius_km': [6371, 3389, 69911, 58232]
})

  2. 创建布尔掩码：通过编写一个逻辑语句来创建掩码。我们的目标是保留卫星数少于 20 的行星。

    mask = planets['moons'] < 20

    执行这行代码会生成一个布尔序列 mask，其中每个索引位置的值表示对应行是否满足条件（moons < 20）。

  3. 应用布尔掩码：将掩码放入选择器括号中，应用于原始数据框。

    filtered_planets = planets[mask]

    也可以跳过创建中间变量 mask 的步骤，直接将条件逻辑应用于数据框：

    filtered_planets = planets[planets['moons'] < 20]

重要提示：应用布尔掩码进行条件筛选只会生成数据框的一个过滤视图，并不会永久修改原始数据框。调用 planets 变量仍然会返回完整的数据框。如果需要重复使用筛选结果，可以将其赋值给一个新变量。

使用多个条件进行筛选

有时我们需要基于多个条件来过滤数据。Pandas 使用逻辑运算符来组合条件：

  • & 表示 与
  • | 表示 或
  • ~ 表示 非

以下是使用多个条件的示例：

示例1：选择卫星数少于10颗或多于50颗的行星

# 注意：每个条件必须用括号括起来
mask = (planets['moons'] < 10) | (planets['moons'] > 50)
result = planets[mask]

示例2：选择卫星数大于20颗，但排除恰好有80颗卫星或半径小于50000公里的行星

mask = (planets['moons'] > 20) & ~(planets['moons'] == 80) & ~(planets['radius_km'] < 50000)
result = planets[mask]
# 结果将只留下土星（Saturn），因为它有83颗卫星且半径大于50000公里。

关键点：在编写包含多个条件的复杂逻辑语句时，务必用括号将每个独立的条件括起来，否则代码可能会报错或返回非预期的结果。

总结

本节课中我们一起学习了布尔掩码这一核心的数据筛选技术。我们掌握了：

  1. 布尔掩码的概念：它是一个基于条件判断生成的布尔值序列。
  2. 如何创建单个条件的布尔掩码并将其应用于数据框。
  3. 如何使用逻辑运算符 &、|、~ 来组合多个条件，进行更复杂的筛选。

使用目前学到的基本工具，选择和筛选数据的方法几乎是无限的。要熟练掌握各种选择语句的执行方式，需要大量的练习。请务必收藏你觉得有用的所有参考资料，以便随时查阅。

继续努力，我们下一个视频再见。

044：分组与聚合 📊

在本节课中，我们将要学习如何使用Pandas库对数据进行分组和聚合计算。你已经学会了如何通过名称和位置索引以及布尔掩码来选择和筛选数据，现在是时候进入下一步了。掌握分组与聚合能帮助你发现数据背后的故事。

理解Group By方法 🧩

上一节我们介绍了数据筛选，本节中我们来看看如何将数据分组。Pandas中一个最重要且常用的分组工具是 groupby 方法。

groupby 是Pandas DataFrame的一个方法，它根据一列或多列的值将数据框的行分组，以便对各个组进行进一步分析。为了演示其用法，我们使用一个包含更多信息的行星数据集，新增了行星类型、是否有行星环、平均温度（摄氏度）以及是否有全球磁场等列。

在学习新工具时，从一个简单的例子开始总是有益的，这能帮助你准确理解其运作机制。

首先，让我们看看调用 groupby 方法时发生了什么。当你对一个数据框调用此方法时，它会创建一个 groupby 对象。如果不对该对象进行任何操作，它本身没有太大用处，只会显示一个内存地址。但一旦拥有了这个对象，你就可以用它做很多事情。

基础分组与计算 ➕

以下是 groupby 方法的一些基础应用：

例如，如果我们按 type 列对数据框进行分组，然后对分组对象应用 sum 方法，计算机会返回一个包含三行（每种行星类型一行）和三列（每个数值列一列）的新数据框。只有数值列被返回，因为 sum 方法只对数值数据有效。type 列则成为这个新数据框的索引。这些信息可以解释为每个组在相应列上所有值的总和。

虽然像所有气态巨行星的半径总和为128,143公里这样的信息可能用处不大，但所有卫星的总数可能是我们想要计算的有用指标。

如果你想只针对特定列进行计算，只需在 groupby 语句后的选择括号中插入列名列表即可。

你还可以使用 sum 之外的其他方法，例如 min、max、mean、median、count 等。

多列分组与聚合 🔢

groupby 方法同样适用于多列分组。

当我们向 groupby 方法传入一个包含 type 和 magnetic_field 列的列表，然后对结果应用 mean 方法时，我们会得到一个数据框，其中每一行对应行星类型和磁场状态的唯一组合。同样，各列包含的是每个组在每个数值列上的计算平均值。

分组功能非常有用，因为它能帮助你更好地理解数据，也能为你想要绘制图表的数据进行组织，这一点我们将在后续课程中详细学习。

使用Aggregate方法进行多重聚合 🛠️

另一个用于分组对象的重要方法是 agg 方法，它是“aggregate”（聚合）的缩写。这个方法允许你对数据组应用多种计算。

让我们从一个简单的例子开始。假设我们想按行星类型分组，然后为每个组计算数值列的平均值和中位数。

我们在 groupby 语句后调用 agg 方法。在其参数中，我们输入想要应用于数据的计算列表。如果这些计算是 groupby 对象的现有方法，可以直接以字符串形式输入。

我们可以按多列分组，并对每个组应用多个聚合函数。例如，我们可以按行星类型和是否有磁场进行分组，然后使用 agg 方法计算每组的平均值和最大值。

我们甚至可以定义自己的函数并应用它们。例如，假设我们想计算每个组的第90个百分位数。

我们可以定义一个名为 percentile_90 的函数，该函数对数组使用 quantile 方法并返回第90个百分位数的值。然后，我们可以在聚合中调用这个自定义函数。

请注意，我们可以将 mean 作为字符串输入，因为它是 groupby 对象的现有方法；但我们需要将 percentile_90 函数作为对象输入，因为它是自定义的。

总结 📝

本节课中我们一起学习了 groupby 和 aggregate 这两个强大的工具，它们结合起来可以深入揭示数据所讲述的故事。我们演示的这类计算是几乎所有领域数据专业人员的日常任务。

尽管我们只将它们应用在一个非常小的数据集上，但完全相同的操作也适用于包含银河系所有行星的数据集（如果我们知道所有数据并且有足够的计算能力来执行聚合的话）。

关于 groupby 和 aggregate 还有更多可以探索的功能。希望你通过本课，对如何以及何时应用这些工具有了扎实的理解。

045：数据合并与连接 📊➡️🔗

在本节课中，我们将学习如何使用Pandas库中的concat和merge函数，将多个数据框（DataFrame）合并或连接在一起。这是数据分析中整合不同数据源的常见且关键的任务。

你已经学习了许多关于Pandas的知识，它是一个强大的库，能让处理表格数据变得更简单高效。你学会了如何选择和索引数据框中的数据，如何使用布尔掩码筛选数据，以及如何分组和聚合数据以获取洞察。在本视频中，你将学习如何向现有数据框添加新数据。这是数据专业人员的常见任务，但它并非简单地将两个数据框相加。其中有一些重要的注意事项需要了解。到本课程结束时，你将很好地理解这些注意事项，从而能够就如何最好地为项目添加数据做出明智的决策。

我们将学习两个Pandas函数：concat和merge。这两个函数的功能有相当大的重叠，但最重要的是你要掌握每个的基础知识，因为作为数据专业人员，你会经常遇到它们。

使用 concat 函数进行拼接

我们将从concat函数开始。回想一下，“concatenate”的意思是链接或连接在一起。Pandas的concat函数通过水平添加（为现有行添加新列）或垂直添加（为现有列添加新行）来组合数据。它还能够处理出现的许多数据特定的复杂性，从而允许高度的用户控制。在本视频中，我将演示如何使用concat函数向现有列添加新行。但请记住，如果你需要更多信息，有大量的支持文档可供查阅。

Pandas有一种特定的方式来指示我们希望数据沿哪个方向拼接。我们通过引用“轴”来实现这一点。事实上，许多Pandas和NumPy函数都有一个axis关键字，因此你可以指定是希望函数跨行应用还是沿列应用。数据框的两个轴是：轴0，垂直贯穿行；轴1，水平贯穿列。

我们将使用一个基本的行星数据集来演示concat的工作原理。

这个数据包含四颗行星：半径和卫星数量，但它缺少木星、土星、天王星和海王星的数据。现在，假设我们想添加这些数据，它们存在于一个单独的数据框中。

在合并之前，让我们先检查一下这个包含木星、土星、天王星和海王星信息的第二个数据集。

请注意，此数据的格式与df1数据框中的数据格式相同。它拥有相同的列：planet、radius和moons。要组合这两个数据框，我们希望将df2作为新行添加到df1下方。

以下是拼接两个数据框的步骤：

  1. 调用pd.concat()函数。
  2. 将要拼接的数据框以列表形式传入。
  3. 包含axis关键字参数，以指定拼接方向。
import pandas as pd

# 假设 df1 和 df2 已经定义
combined_df = pd.concat([df1, df2], axis=0)

axis=0指示函数垂直组合数据。换句话说，我们希望通过扩展垂直轴（轴0）来添加新数据。

完美，数据已作为新行添加。请注意，每一行都保留了其原始数据框中的索引号。

如果你想重新开始编号，只需重置索引。

combined_df_reset = combined_df.reset_index(drop=True)

我们可以包含drop=True参数，因为否则会向数据框添加一个新的索引列，而在此情况下我们不需要。现在，行索引的枚举从0到7。

concat函数非常适合处理包含格式完全相同、只需垂直组合的数据框。如果你想水平添加数据，请考虑使用merge函数。

使用 merge 函数进行连接

merge函数是一个将两个数据框连接在一起的Pandas函数。它只通过沿轴1（水平方向）扩展来组合数据。

让我们回到行星数据。现在，我们拥有了所有八颗行星的半径和卫星数量，但假设我们想添加行星类型、是否有光环、平均温度、是否有磁场以及是否存在生命等数据。

也许这些数据存在于一个单独的数据框中，但它缺少水星和金星的数据，并且包含一些来自其他恒星系的最近发现的行星，比如Jansen和Tadmore。没关系，我们仍然可以处理。

首先，让我们概念化两个数据集如何连接才能工作。它们需要共享一个共同的参考点。换句话说，两个数据集都必须有某些方面在每一个中都是相同的。这些被称为“键”。键是不同数据框之间共享的参考点，用于匹配。在我们的例子中，键是行星。每个数据框都包含供我们匹配的行星。

现在，让我们考虑连接这些数据的不同方式。

以下是四种主要的连接类型：

  • 内连接：只包含两个数据框中都存在的键。
  • 外连接：包含两个数据框中所有的键。
  • 左连接：包含左侧数据框中的所有键，即使它们不在右侧数据框中。
  • 右连接：包含右侧数据框中的所有键，即使它们不在左侧数据框中。

让我们看看每种连接类型如何影响我们的行星数据。首先，我们将调用函数，分别输入df3和df4作为左侧和右侧的位置参数。然后，我们包含关键字参数on，它让我们指定用于匹配的键应该是什么。在本例中，我们想使用planet列。

现在，我们还有how关键字参数。这是我们输入所需连接类型的地方。让我们先试试内连接。

inner_merged = pd.merge(df3, df4, on='planet', how='inner')

这将数据合并，并且只保留了同时出现在两个数据框中的行星。这意味着我们丢失了左侧数据框中水星和金星的数据，以及右侧数据框中Jansen和Tadmore的数据。

现在，让我们尝试外连接。

outer_merged = pd.merge(df3, df4, on='planet', how='outer')

与预期一样，这产生了一个包含两个初始数据框中所有键的数据框。请注意，因为Jansen和Tadmore不在左侧数据框中，它们没有半径和卫星的信息，所以这些列被填充为NaN。同样，因为水星和金星不在右侧数据框中，它们在最终表格中也缺少一些信息，用NaN表示。

接下来，我们将进行左连接。同样，函数语法相同，只是how参数设置为left。

left_merged = pd.merge(df3, df4, on='planet', how='left')

这产生了一个保留左侧数据框中所有键，并且只包含右侧数据框中那些也存在于左侧数据框中的键的数据框。因此，Jansen和Tadmore被排除在外。

最后，我们将执行右连接。

right_merged = pd.merge(df3, df4, on='planet', how='right')

正如预期，结果是一个拥有右侧数据框中所有键，但不包含左侧数据框中那些不在右侧数据框中的键的数据框。因此，水星和金星被排除在外。

做得好。现在你了解了基本原理，你可以使用这些Pandas工具来完成最常见的数据连接类型，这对于各种各样的数据项目都将非常有用。随着你职业生涯的发展，你会发现更多关于数据连接的知识，以及它如何变得非常复杂。这些工具将对你大有帮助。你已经走了很长的路，我们现在已经准备好开始像真正的数据专业人员一样使用Pandas来探索你的数据了。下次见。

046：第四部分总结 🎯

在本节课中，我们将回顾并总结《Python入门》课程的第四部分内容。本节重点介绍了数据专业人士如何利用Python的数据结构和工具来高效地存储、访问和组织数据，为后续的数据分析工作打下坚实基础。

第四部分内容回顾 📚

上一节我们介绍了Python的基础语法和编程概念，本节中我们来看看数据专业人士如何运用特定的数据结构和工具来处理数据。

这是Python课程第四部分的结尾。

现在，你已经掌握了坚实的Python技能基础，可以在未来作为数据专业人士的职业生涯中持续构建。

在本节课程中，你学习了数据专业人士如何使用数据结构来存储、访问和组织他们的数据。

理解哪种数据结构适合你的特定任务是数据工作的关键部分，并将帮助你快速高效地分析数据。

我们回顾了对数据专业人士极为有用的基本数据结构。

以下是这些核心数据结构：

  • 列表（Lists）
  • 元组（Tuples）
  • 字典（Dictionaries）
  • 集合（Sets）
  • 数组（Arrays）

我们还讨论了两种在高级数据分析中应用最广泛且最重要的Python工具。

第一个是NumPy，数据专业人士因其强大的计算能力而使用它。

你学习了NumPy如何帮助你快速处理大量数据并执行有用的计算。

你学习的第二个Python工具是pandas。

它是一个用于分析表格数据的强大工具。

你学习了pandas如何帮助你执行关键任务，例如筛选、分组和合并数据。

数据专业人士经常处理表格数据。你将在证书课程的其余部分以及未来的职业生涯中使用pandas。

接下来，你将有一个分级评估。为了准备，请复习列出了你所学所有新术语的阅读材料，并随时重新观看视频、阅读材料和其他涵盖关键概念的资源。

祝贺你取得的所有进步，干得漂亮。

核心概念与工具总结 🔧

本节课中我们一起学习了Python中用于数据处理的核心数据结构和两大关键库。

核心数据结构包括：

  • 列表：有序、可变的元素集合，例如 my_list = [1, 2, 3]
  • 元组：有序、不可变的元素集合，例如 my_tuple = (1, 2, 3)
  • 字典：键值对的集合，例如 my_dict = {'key': 'value'}
  • 集合：无序、不重复元素的集合，例如 my_set = {1, 2, 3}
  • 数组：通常通过NumPy库实现，用于高效的数值计算，例如 np.array([1, 2, 3])

关键数据分析工具：

  1. NumPy：提供强大的多维数组对象和数学函数，是科学计算的基础。
  2. pandas：构建于NumPy之上，提供了DataFrame等数据结构，专门用于表格数据的操作和分析。

总结与展望 🚀

在本节课中，我们总结了《Python入门》第四部分的核心内容。你不仅掌握了列表、元组、字典、集合和数组这些基本数据结构，还初步了解了NumPy和pandas这两个在数据科学领域不可或缺的强大工具。理解并熟练运用这些知识，将显著提升你处理和分析数据的效率与能力。

请利用提供的资源充分准备接下来的评估，并带着这些坚实的技能基础，自信地迈向后续更深入的数据分析学习之旅。

047：模块5 欢迎与项目介绍 🎯

在本节课中，我们将学习如何将本课程所学的Python技能应用于一个实际的组合项目。这个项目旨在帮助你构建专业作品集，为未来的求职面试做好准备。

大家好，很高兴再次与大家见面。你可能在上一个课程中认识我。我是Tiffany，负责谷歌负责任AI项目管理团队。我回来是为了更多地与大家讨论你们的组合项目，以及如何在求职中运用它们。

既然我们已经花了一些时间探索Python，我很高兴能帮助你们完成一个可以添加到专业作品集的项目。随着我们完成课程的这一部分，你将有机会开始展示你的编程技能。

组合项目的价值 💼

上一节我们介绍了组合项目的背景，本节中我们来看看这个项目的具体价值。

这个组合项目是培养你面试技能的宝贵机会。当潜在雇主评估你作为候选人时，他们可能会要求你提供过去如何应对编码挑战的具体例子。你可以利用你的作品集来讨论你解决过的实际问题。

此外，一些雇主可能会在面试中要求你加载、清理和构建数据，以证明你的熟练程度。通过练习创建数据库结构来解决数据驱动项目，意味着你将为此类情况做好准备。

实践学习与项目目标 🎯

以下是关于实践学习和项目目标的说明。

你已经了解了体验式学习，即通过实践来理解的理念。这个组合项目是一个绝佳的机会，让你真正发现组织如何使用Python管理数据，并练习你在这门课程中学到的技能。

为了完成组合项目，你将获得一些商业案例详情和一些非结构化数据文件。选择一个商业场景，并根据该场景，使用说明在你的薪酬策略文档中完成一个新条目。

你的任务是加载、清理和构建数据，使你的最终产品成为一个整洁的数据集。数据整理是指构建数据集以促进分析。整洁的数据集易于操作、建模和可视化，并具有特定的结构。

每个变量是一列。每个观测值是一行，每种观测单位类型是一个表格。

项目成果与后续步骤 📈

以下是完成项目后你将获得的成果。

完成这个项目后，你将拥有一个结构化的数据集，可用于下一个课程的组合项目。在你的薪酬策略文档中，你还将记录你所采取的步骤，这些记录可用于向未来的招聘经理解释你的工作和思考过程。

此时，你即将完成本课程，这意味着你已经掌握了作为一名数据专业人士持续发展所需的一切知识。项目的这一部分将侧重于展示对数据操作的掌握，并理解数据专业人士如何使用Python通过自定义函数探索和提取信息。

准备好了吗？那么让我们开始吧。

本节课总结

本节课中我们一起学习了第五模块的组合项目介绍。我们明确了该项目的目标是创建一个可用于求职作品集的整洁数据集，理解了数据整理的核心原则（每个变量是一列，每个观测值是一行），并认识到完成此项目对于展示技能和准备技术面试的重要性。接下来，我们将开始具体的项目实践。

048：《Python入门》课程期末作品项目介绍 🎯

在本节课中，我们将要学习课程期末作品项目的整体介绍与目标。此前我们已经介绍了Python的优势、基础语法、循环、字符串、数据结构和面向对象编程。本节中，我们将了解如何将这些知识应用于一个实际的组合项目，以展示数据专业能力。

在课程中，你已经学习了Python的优势与简洁性，以及基础的Python语法、循环、字符串、数据结构和面向对象编程。

现在，是时候迈出令人兴奋的下一步：将所有这些知识应用于你的组合项目。

在之前的课程中，你了解了数据专业职业的灵活性，以及沟通如何直接影响数据驱动型工作。

你还练习了像数据专业人士一样思考，评估业务场景，并在你的薪酬策略文档中记录项目考量。

这些技能也将适用于这个新项目。

在课程的这一部分，你将获得一些非结构化数据文件。你的目标是加载、清理并结构化这些数据，形成一个整洁的数据集，并针对特定的业务场景。

接下来，你将开始探索在本项目的其他部分中，成为一名数据专业人士意味着什么。

你将致力于发展更多技能，以帮助你在数据职业领域取得成功。

关于数据可视化、统计学、模型和机器学习，还有更多内容需要学习。

通过本项目学习和强化的技能，将帮助你在完成未来的数据项目时成为更好的协作者。

学习如何使用和驾驭Python，也将使你成为数据专业职位的理想候选人。

作为一名数据专业人士，你工作的很大一部分涉及处理数据，以帮助你的团队和组织中的其他人形成关键见解，最终推动业务决策。

通常，数据量非常庞大，需要像Python这样的工具来成功完成日常工作。

组合项目的这一部分是一个绝佳的机会，可以向潜在雇主展示你能够做到这一点：处理非结构化数据，并进行清理、组织和管理，以实现一个可操作的目标。

请记住，培养你作为数据专业人士的技能是一个迭代的过程。

因此，当你有了新想法或学到新东西时，可以持续改进。

本节课中，我们一起学习了期末作品项目的目标：应用所学的Python技能处理非结构化数据，将其转化为整洁、可用的数据集，以解决特定业务问题。这是一个展示你数据清理、组织和管理能力的实践机会，也是你迈向数据专业职业的重要一步。

049：期末项目总结与职业持续成功建议 📊

在本节课中，我们将对已完成的期末项目进行总结，并探讨如何将项目经验转化为职业优势，为未来的面试和工作做好准备。

你已经完成了大量的工作。你在薪资策略文档中完成了两项记录，并开始编写自己的代码。

随着你继续完善你的作品集项目，你需要考虑如何记录你的工作过程，并能在未来的面试中向潜在雇主和招聘经理清晰地解释你所做的工作。

强调可迁移技能 🔄

首先，重要的是要认识到，作为一名数据专业人士，你可能需要学习和适应新的工具。市场上有许多优秀的工具，不同的企业会根据自身需求有不同的偏好。

在求职时，请记住，你已经学到了许多可迁移的技能，这些技能可以应用于不同的组织和行业。例如，在你刚刚完成的作品集项目中，你使用 Python 构建了一个整洁的数据库，专注于解决一个以数据为核心的业务场景。

# 示例：使用Python进行数据处理的核心技能
import pandas as pd
# 数据清洗、整合与分析是可迁移的核心能力
data = pd.read_csv('business_data.csv')
cleaned_data = data.dropna()

Python 是一个强大的工具，掌握它是一项重要的技能。但更重要的是，你学会了思考数据专业人士的工作如何为商业决策和战略洞察做出贡献。你学到了沟通的重要性、可用工具的价值，以及如何使用 Python 管理大型数据集。这些都是在工作面试中值得强调的技能，无论职位要求使用什么工具。

这个作品集项目是展示这些可迁移技能的绝佳方式，它能让面试官深入了解你解决问题的方法、你的思维过程以及你做出某些决定的原因。

考虑你的受众 🎯

除了确保在谈论你的作品集项目时突出可迁移技能，你还需要确保考虑到你的受众。

正如你在整个课程中所学到的，你经常需要与不同类型、拥有不同技术水平的相关方合作。当你与他们沟通技术流程时，你需要记住你的受众是谁、他们的目标是什么、他们已经知道什么以及他们需要知道什么。

当你与面试官讨论你的作品集项目时，这一点同样重要。通常，参与或主持你面试的人不一定都是数据专业人士。例如，招聘经理可能不像你那样对数据流程有详细的理解。

为了让你的陈述对他们保持相关性，请尝试记住关于受众的那些关键问题。你的面试官面临着一个业务挑战，就像数据项目中的相关方一样。他们有一个需要填补的职位空缺。

思考他们需要了解你的哪些信息，才能做出解决该挑战的决定。

下一步：用数据讲故事 📖

接下来，你将全面学习如何用数据讲故事。然后，你将有机会进行一些探索性数据分析并创建数据可视化图表。

到本课程结束时，你将拥有一个强大的作品集。

本节课总结

在本节课中，我们一起学习了如何对期末项目进行职业化的总结与呈现。核心要点包括：

  1. 识别并强调可迁移技能，如问题解决、业务思维和工具应用能力。
  2. 在沟通中始终考虑受众，根据面试官的角色和背景调整你的表达方式。
  3. 认识到作品集项目是展示你综合能力的窗口，而不仅仅是技术代码的堆砌。

通过有策略地展示你的项目，你可以更有效地在求职过程中脱颖而出，为持续的职业成功奠定基础。

050：《Python入门》课程总结 🎉

在本节课中，我们将回顾并总结《Python入门》课程的核心内容。你已经完成了最终的课程项目，现在拥有了一个可以向未来雇主展示的具体成果，这证明了你的Python熟练程度。

课程核心技能回顾 📚

上一节我们完成了课程项目，本节中我们来系统回顾一下在整个课程中学到的重要Python技能。

以下是你在本课程中掌握的核心Python技能：

  • 变量与数据类型：你学会了如何使用变量来存储和标记数据，以及如何转换和组合不同的数据类型，例如整数（int）和浮点数（float）。
  • 函数与运算符：你学会了如何调用函数来对数据执行有用的操作，并使用运算符来比较值。
  • 条件语句：你学会了如何编写条件语句（如 if-elif-else），以指示计算机如何根据你的指令做出决策。
  • 代码规范：你练习了编写清晰、易于其他数据专业人士理解和复用的整洁代码。
  • 循环结构：你发现了如何使用循环（如 for 循环和 while 循环）来自动化重复性任务。
  • 字符串操作：你学会了如何通过切片、索引和格式化来操作字符串。
  • 数据结构：你探索了基本的数据结构，例如列表（list）、元组（tuple）、字典（dict）、集合（set）和数组。
  • 数据分析工具：最后，你学习了两个在高级数据分析中最广泛使用和最重要的Python工具：NumPy 和 pandas。

下一步学习方向 🚀

掌握了如何创建系统来为利益相关者准备数据之后，接下来你将迎来更令人兴奋的发现。现在是时候开始思考如何呈现这些数据，并使其对决策制定产生价值了。

总结与展望 🌟

本节课中，我们一起学习了Python编程的基础与核心技能。你现在已经拥有了坚实的Python技能基础，可以在未来作为数据专业人士的职业生涯中持续构建。

所以，请做好准备，继续你的学习之旅吧。

posted @ 2026-03-26 12:28  布客飞龙III  阅读(5)  评论(0)    收藏  举报