宾夕法尼亚大学-Python-与-Java-入门笔记-全-

宾夕法尼亚大学 Python 与 Java 入门笔记（全）

001：关于讲师-Brandon-Krakowsky 👨‍🏫

在本节课中，我们将认识本编程与科技课程的讲师Brandon Krakowsky，了解他的专业背景和个人经历。

我的名字是Brandon Krakowsky，我是这门编程语言与科技课程的讲师。

关于我的背景，我最初是一名音乐家，随后在无线电广播和音频制作领域工作。

我的编程经验始于Adobe Flash。

我曾使用这个工具为一家大型制药公司开发了一个实时网络会议平台。

我获得了宾夕法尼亚大学的计算机与信息技术硕士学位，并曾在宾夕法尼亚大学设计学院担任程序员。

之后，我在沃顿商学院计算部门担任应用开发人员。

我与教职员工合作，构建技术以推进多个学生项目。

在此期间，我创立了自己的公司Bak LLC。

为多家公司提供编程和自由职业应用开发服务。

我后来转向数据与分析领域，并成为沃顿定制分析公司的研究与教育总监。

负责管理来自世界各地的学生和学术研究人员参与的大规模研究项目。

最近，我成为了宾夕法尼亚大学工程学院的讲师。

关于我个人，我弹奏贝斯。

我喜欢我的狗，并且我是一个重视家庭的人。

本节课中我们一起学习了本课程讲师Brandon Krakowsky的职业发展路径，他从音乐和音频领域起步，逐步转型为经验丰富的程序员、应用开发者、数据分析项目管理者，并最终成为大学讲师。他的多元化背景为这门编程入门课程带来了独特的视角。

002：本课程学习预期

在本节课中，我们将了解这门课程的目标受众、学习投入要求以及你将掌握的核心编程技能。这有助于你判断课程是否适合自己，并明确学习方向。

课程目标受众

这门课程面向几乎没有或完全没有计算经验的学生和专业人士，也适用于没有接受过编程或计算机科学正式培训的人群。

它同样适合离开学术界一段时间后重返校园的求学学生，以及正在开始或推进信息技术领域职业生涯的专业人士。

总的来说，这门课程是希望学习编程基础知识且从未编程过的人的绝佳入门课。

它也是曾经编程过但已有一段时间未使用该技能的人的优秀复习课程。

学习投入与课程结构

在课程工作量方面，这门课程每周大约需要4到6小时，持续约四周。

除了观看制作好的音视频内容，每周都会有计分的编程作业。

课程还包含用于评估你对课程材料理解程度的定期测验，以及用于建立你作为程序员信心的实践编码练习。

你将学到的核心内容

在本课程中，你将学习使用Python进行编程，包括以下方面：

以下是Python编程的核心组成部分：

• 语言语法：即构成有效Python代码的规则。
• 代码风格：编写清晰、易读代码的惯例。
• 编程技巧：解决问题和实现功能的方法。
• 编码规范：行业内广泛接受的代码编写标准。

你还将学习以下重要概念：

以下是成为优秀程序员的关键实践：

• 最佳实践与良好的代码设计：如何构建高效、可维护的程序。
• 代码和程序文档：如何为代码添加说明，使其易于理解和使用。
• 计算思维：像计算机科学家一样分析和解决问题的方法。

---

本节课中，我们一起了解了这门编程入门课程的适用人群、需要投入的时间以及涵盖的核心学习内容。明确这些预期将帮助你更好地规划学习，为接下来的编程之旅做好准备。

003：为什么从Python开始 🐍

在本节课中，我们将要学习这门课程选择Python作为入门编程语言的原因。我们将探讨Python作为第一门编程语言的优势，以及它如何帮助我们更顺畅地开启编程学习之旅。

---

为什么从Python开始

Python是一门优秀的入门语言。它能让你非常快速地上手并开始运行程序。通常，你可以在几分钟内就开始编写代码。

与Java相比，Python的学习难度要低得多。这使你能够将更多时间用于思考编程逻辑和算法，而不必担心学习复杂的代码语法。

上一节我们介绍了课程的整体安排，本节中我们来看看选择Python作为起点的具体考量。

---

Python作为第一语言的优势

以下是Python作为初学者第一门编程语言的几个关键优势：

• 快速上手：安装和配置环境简单，可以迅速进入编码实践。
• 语法简洁：代码结构清晰，更接近自然语言，降低了初学者的认知负担。
• 专注于逻辑：减少在复杂语法规则上的精力消耗，让学习者能更集中于问题解决和算法设计。

---

与Java的初步对比

虽然本课程后续也会学习Java，但以Python开始有一个重要目的：建立编程思维。Python简洁的语法就像一副“训练轮”，帮助你在掌握平衡（编程逻辑）时，不必同时费力地蹬车（记忆复杂语法）。

例如，一个简单的“Hello World”程序，在两种语言中的区别直观体现了语法的简繁：

Python代码示例:

print("Hello, World!")

Java代码示例:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

通过对比可以看出，Python允许初学者用更直观的代码表达意图。

---

本节课中我们一起学习了选择Python作为编程入门起点的原因。我们了解到Python因其易于安装、语法简洁而能帮助初学者快速建立信心，并专注于核心的编程逻辑与算法思维，为后续学习Java等更复杂的语言打下坚实基础。

004：Python编程入门模块介绍 🐍

在本节课中，我们将要学习Python编程的第一个模块。这个模块将引导你完成编程环境的搭建，并介绍Python语言的基础知识，包括基本数据类型、数学运算、变量定义以及程序流程控制。

下载与安装工具

我们将从下载和安装必要的编程工具开始。这是编写和运行Python代码的第一步。

以下是需要完成的步骤：

• 下载并安装Python解释器。
• 选择一个代码编辑器或集成开发环境（IDE）。
• 验证安装，确保可以在命令行或终端中运行Python。

打印输出与基础数据类型

上一节我们介绍了如何搭建编程环境，本节中我们来看看如何与程序进行最基本的交互——打印信息到控制台，并认识Python中的基础数据类型。

完成环境配置后，你将学习如何使用print()函数向控制台输出信息。同时，你将了解Python中的几种基本数据类型。

以下是几种核心的数据类型：

• 整数：表示没有小数部分的数字，例如 42。
• 浮点数：表示带有小数点的数字，例如 3.14。
• 字符串：表示文本信息，用单引号或双引号包围，例如 'Hello World'。
• 布尔值：表示逻辑真或假，即 True 或 False。

基础数学运算

认识了数据类型之后，我们可以使用它们进行基础的数学运算。Python支持所有常见的算术操作。

你可以在Python中直接执行加、减、乘、除等运算。

以下是基本的算术运算符示例：

• 加法：1 + 2 结果为 3
• 减法：5 - 3 结果为 2
• 乘法：4 * 2 结果为 8
• 除法：9 / 3 结果为 3.0（得到一个浮点数）

创建脚本与使用变量

掌握了基础运算，我们就可以开始编写更完整的程序了。本节将指导你创建第一个Python脚本，并学习如何使用变量来存储和操作数据。

接下来，你将创建自己的第一个Python脚本文件（通常以.py结尾）。在脚本中，你将学习如何定义变量来存储数据，并使用条件语句（如if、elif、else）来控制程序的执行流程。

定义变量的语法很简单：

variable_name = value

例如：

age = 25
name = "Alice"

获取用户输入与错误检查

程序不仅仅是单向输出，与用户互动同样重要。本节我们将学习如何从用户那里获取输入，并对其进行最基本的检查。

最后，你将学习如何使用input()函数获取用户的键盘输入。我们还会初步探讨如何对输入进行非常基础的验证，以确保程序的健壮性。

获取用户输入的代码如下：

user_input = input("请输入一些内容：")

---

本节课中我们一起学习了Python编程的入门步骤。我们从环境搭建开始，逐步学习了如何打印输出、理解基础数据类型、进行数学运算、创建脚本、定义变量、控制程序流程，以及如何获取并初步验证用户输入。这些是构建更复杂程序的基石。

005：什么是编程 🖥️

在本节课中，我们将学习编程的核心概念。我们将探讨程序的定义、编程的本质以及不同编程语言之间的关键区别。

概述

程序是一系列指令的集合，当被执行时，它能完成一个特定的任务或一组任务。编程则是规定或编写这些指令的方式。

编程语言的关键维度

不同的编程语言在许多方面存在差异。以下是几个核心的考量维度。

语法

语法指的是语言的结构或文法规则。它规定了代码应该如何被正确地书写和组织。

语义

语义指的是代码的含义，即当我运行这段代码时，它具体会做什么。

性能

性能关注代码的运行速度，即代码执行得快还是慢。

内存管理

内存管理指的是计算机在运行代码时，如何高效地管理其资源。

总结

本节课我们一起学习了编程的基本定义。我们了解到，程序是执行特定任务的指令集合，而编程是创建这些指令的过程。我们还探讨了评估编程语言的几个关键方面：语法、语义、性能和内存管理。理解这些概念是学习任何编程语言的第一步。

006：客户端与服务器端编程

在本节课中，我们将要学习客户端编程与服务器端编程的基本概念。理解这两者的区别是理解现代应用程序如何工作的基础。

客户端编程

上一节我们介绍了编程的基本概念，本节中我们来看看什么是客户端编程。

客户端程序运行在客户端设备上。客户端编程主要涉及用户与用户界面的交互。

例如，一个网页就是一个运行在Web浏览器（即客户端）中的客户端程序。

以下是常见的客户端编程语言：

• HTML
• CSS
• JavaScript

服务器端编程

了解了客户端编程后，接下来我们探讨与之相对的服务器端编程。

服务器端程序运行在服务器或远程计算机上。服务器端编程主要涉及用户界面与服务器上程序之间的交互。

例如，一个网页向服务器上的程序发送消息或请求，该程序处理用户输入并与数据库进行交互。

以下是常见的服务器端编程语言：

• Python
• Java
• PHP
• ASP.NET

核心概念与交互模型

为了更清晰地理解两者的协作关系，我们可以用一个简单的公式来描述典型的Web交互流程：

用户操作 -> 客户端代码（如JavaScript） -> 网络请求 -> 服务器端代码（如Python/Java） -> 数据库 -> 返回数据 -> 客户端更新界面

这个过程就像一个点餐系统：顾客（用户）在菜单（客户端界面）上选择菜品，服务员（客户端代码）将订单送到厨房（服务器），厨师（服务器端程序）根据订单烹饪并备餐（处理数据），最后服务员将做好的菜送回给顾客。

总结

本节课中我们一起学习了客户端与服务器端编程的核心区别。客户端程序在用户设备上运行，负责展示界面和收集用户输入；而服务器端程序在远程服务器上运行，负责处理业务逻辑、计算和数据存储。两者通过网络协同工作，共同构成了我们日常使用的各种网络应用。

007：核心编程概念入门 🚀

在本节课中，我们将要学习Python和Java等面向对象编程语言中一些共通的核心概念。这些概念是构建程序的基础，理解它们对于后续的学习至关重要。

数据结构 📊

上一节我们介绍了编程语言中的共通性，本节中我们来看看第一个核心概念：数据结构。

数据结构是存储相关数据集合的方式。例如，一个有序的项目列表或序列。

在代码中，一个简单的列表可以这样表示：

my_list = [1, 2, 3, 4, 5]

流程控制 🔄

了解了如何存储数据后，我们来看看如何控制程序的执行流程。

流程控制是控制和改变程序流程的方式。这包括条件语句，它允许我们根据逻辑条件做出决策并执行相应的代码。

一个典型的条件语句结构如下：

if condition:
    # 执行某些操作
else:
    # 执行其他操作

循环 🔁

除了条件分支，另一种控制流程的重要方式是循环。

循环允许我们重复执行代码或多次执行某个操作。

以下是循环的一个基本示例：

for item in my_list:
    print(item)

变量 📦

现在，我们来看看程序中用于存储和引用信息的基本单元：变量。

变量是值或信息片段的符号名称或引用。

你可以使用变量来存储各种数据。例如：

name = “Alice”
age = 25

函数 ⚙️

最后，我们来认识一下函数，它是组织程序逻辑的关键。

函数是组织好、可重复使用的代码块，用于执行一个单一的相关操作。

定义一个简单函数的代码如下：

def greet(name):
    return f“Hello, {name}!”

---

本节课中我们一起学习了编程中的几个核心概念：数据结构用于组织数据，流程控制（包括条件语句和循环）用于决定程序的执行路径，变量用于存储和引用信息，以及函数用于封装可重用的代码块。掌握这些概念是学习任何编程语言的第一步。

008：什么是Python

在本节课中，我们将要学习Python编程语言的基本概念，包括它的起源、特点以及它为何如此受欢迎。

概述

Python是一种广泛使用的高级编程语言。它以简洁的语法和强大的功能而闻名，非常适合初学者入门，同时也被专业开发者用于各种复杂的项目。

Python的命名起源

Python的命名灵感来源于一部名为《蒙提·派森的飞行马戏团》的电视节目。虽然这部喜剧节目本身与编程无关，但其名字为这门语言带来了一个独特而有趣的标识。

Python作为高级编程语言

上一节我们了解了Python的命名，本节中我们来看看它的核心特性之一：它是一种高级编程语言。

高级编程语言意味着它在程序员和计算机硬件之间提供了一层抽象。它封装了与计算机底层（如内存管理、硬件操作）通信的复杂细节，使得程序员能够使用更接近人类语言的指令来编写程序。

因此，Python代码通常更直观、更易于阅读和理解。例如，打印“Hello World”的代码非常简单：

print("Hello World")

Python作为面向对象语言

理解了Python的高级特性后，我们接下来探讨它的另一个重要范式：面向对象编程。

Python是一种面向对象的编程语言。这意味着它的设计核心是围绕“对象”而非“动作”来组织代码。对象是数据和相关操作的封装体。以下是定义一个简单“汽车”类的示例：

class Car:
    def __init__(self, brand):
        self.brand = brand

    def honk(self):
        print(f"The {self.brand} car says: Beep Beep!")

my_car = Car("Toyota")
my_car.honk()

这种范式有助于构建模块化、可重用和易于维护的大型程序。

Python的主要特点

基于以上概念，以下是Python语言的一些关键特点，这些特点共同造就了它的流行：

• 语法简洁清晰：Python使用缩进来定义代码块，强制要求代码格式整洁，这大大增强了可读性。
• 解释型语言：Python代码由解释器逐行执行，无需像C或Java那样先进行编译。这使得开发和调试过程更快速。
• 强大的标准库和丰富的第三方库：Python自带功能丰富的标准库，并且拥有一个庞大的第三方库生态系统（如NumPy用于科学计算，Django用于Web开发），几乎可以应用于任何领域。
• 跨平台：Python可以在Windows、macOS、Linux等多种操作系统上运行。
• 社区活跃：Python拥有一个庞大且活跃的开发者社区，这意味着初学者可以轻松找到大量的学习资源、教程和问题解答。

总结

本节课中我们一起学习了Python编程语言的基础。我们了解了它有趣的命名起源，认识了它作为高级编程语言和面向对象语言的核心特性，并列举了其语法简洁、解释执行、库资源丰富等主要优点。这些特性使得Python成为一门既强大又友好的编程语言，是开始编程之旅的绝佳选择。

009：Python是解释型语言 🐍

在本节课中，我们将要学习Python作为一种解释型编程语言的核心特性，并将其与Java等编译型语言进行对比，同时探讨解释型语言在调试方面的特点。

解释型语言与编译型语言

上一节我们介绍了编程语言的基本概念，本节中我们来看看Python语言的执行方式。

Python是一种解释型编程语言。这意味着Python代码不需要被编译或从一种语言转换为另一种语言才能执行。Python解释器会直接读取源代码，并逐行解释和执行。

相比之下，Java是一种编译型编程语言。Java源代码需要先被编译成一种称为字节码的中间格式，然后由Java虚拟机（JVM）执行。

以下是两种语言执行流程的核心区别：

• Python（解释型）：源代码 -> Python解释器 -> 直接执行。
• Java（编译型）：源代码 -> 编译器 -> 字节码 -> JVM -> 执行。

Python解释器与调试

由于Python代码由解释器逐行执行，这有时会使调试程序变得困难。错误可能直到解释器运行到有问题的代码行时才会被发现。

因此，在编写Python代码时，遵循一个良好的实践至关重要：不要一次性编写大段代码而不进行任何测试。😡

正确的做法是采用增量开发和测试的方法。以下是推荐的步骤：

1. 编写少量代码：每次只添加或修改一小部分功能。
2. 立即运行测试：运行程序，检查当前代码是否按预期工作。
3. 重复过程：如果代码工作正常，再继续添加下一小部分功能并测试。

这种方法可以帮助你快速定位和修复错误，因为问题很可能就出在你刚刚新增或修改的那几行代码中。

总结

本节课中我们一起学习了Python作为解释型语言的特点。我们了解了它无需编译、由解释器直接执行的特性，并将其执行流程与Java的编译过程进行了对比。同时，我们也认识到解释型语言在调试上的潜在挑战，并掌握了通过“编写少量代码并立即测试”的增量方法来有效应对这一挑战的核心实践。

010：为什么选择Python 🐍

在本节课中，我们将探讨Python编程语言的主要特点与优势，了解它为何成为初学者入门和众多应用领域的首选。

---

Python是一种开源编程语言，这意味着它是免费的。

---

上一节我们了解了Python的免费特性，本节中我们来看看它的其他核心优势。Python功能强大、灵活且直观。网上有大量可用的库和资源。此外，Python的语法与英语非常相似。

以下是Python语法直观性的一个例子：

# 判断一个数字是否为正数
if number > 0:
    print("这是一个正数。")

---

Python非常适合初学者，并且是学习其他编程语言的绝佳基础。

---

理解了Python对初学者友好的特点后，我们来看看它的广泛应用领域。Python可以用于人工智能、机器学习、自然语言处理、Web开发、数据分析和可视化、游戏编程、桌面图形用户界面开发以及许多其他用途。

以下是Python应用领域的一些核心概念：

• 人工智能/机器学习：常用库如 scikit-learn, TensorFlow, PyTorch。
• Web开发：常用框架如 Django, Flask。
• 数据分析：核心库包括 pandas, NumPy。
• 数据可视化：常用库如 Matplotlib, Seaborn。

---

本节课中我们一起学习了选择Python的几个关键理由：它是一门免费的开源语言，拥有强大、灵活且类似英语的直观语法，非常适合编程初学者，并能作为学习其他语言的坚实基础。同时，Python在人工智能、Web开发、数据分析等众多现代技术领域都有广泛应用，这使得学习Python是一项极具价值的投资。

Python编程入门：1.1：下载与安装Python 🐍

在本节课中，我们将学习如何下载和安装Python编程语言，这是本课程将使用的主要工具。

我们将在本课程中使用 Python 3。如果你已经安装了 Python 2，请升级到 Python 3。

上一节我们明确了所需的Python版本，本节中我们来看看具体的下载与安装步骤。

要下载并安装Python，请访问Python官方网站并下载最新版本。此下载和安装包捆绑了 IDLE，即Python的集成开发与学习环境。

它包含一个交互式Python解释器和一个脚本编辑器。我们最终将使用IDLE来编写和运行Python脚本。

以下是下载和安装的核心步骤列表：

1. 访问Python官方网站。
2. 下载适用于你操作系统的最新Python 3版本安装程序。
3. 运行安装程序，并在安装过程中勾选“Add Python to PATH”选项。
4. 完成安装后，你可以在开始菜单或应用程序中找到IDLE。

本节课中我们一起学习了如何下载和安装Python 3，并了解了其自带的集成开发环境IDLE。这是开始编写Python程序的第一步。

Python与Java编程入门：1-2：下载与安装Jupyter Notebook

在本节课中，我们将学习如何设置Jupyter Notebook，这是一个用于编写和运行Python代码的便捷工具。

Jupyter Notebook是一个基于浏览器的应用程序，它集成了交互式Python解释器和脚本编辑器，允许你以“笔记本”的形式组织代码、文本和可视化结果。

为了开始使用Jupyter Notebook，我们需要先安装它。一个简单的方法是下载并安装Anaconda，这是一个集成了Python和众多科学计算库的数据科学平台。Anaconda会一次性安装好Python和Jupyter Notebook。

以下是安装步骤：

1. 访问Anaconda官方网站，下载适用于你操作系统（Windows、macOS或Linux）的安装程序。
2. 运行下载的安装程序，并按照提示完成安装过程。

安装完成后，有多种方式可以启动Jupyter Notebook。

第一种方法是通过命令行启动。在macOS上打开“终端”（Terminal），或在Windows上打开“命令提示符”（Command Prompt），然后输入命令 jupyter notebook 并按下回车键。

第二种方法是通过图形界面启动。你可以打开Anaconda Navigator（一个随Anaconda安装的应用程序），在其中找到Jupyter Notebook的图标并点击启动。

无论使用哪种方式启动，你的默认网页浏览器都会自动打开，显示Jupyter Notebook的文件浏览器界面，从这里你就可以创建新的笔记本或打开已有的项目了。

本节课中，我们一起学习了Jupyter Notebook的基本概念，并通过安装Anaconda一次性获取了Python和Jupyter Notebook环境。我们还介绍了通过命令行和Anaconda Navigator两种启动Jupyter Notebook的方法。现在，你的编程环境已经准备就绪。

013：使用Jupyter Notebook 📓

在本节课中，我们将学习如何启动、创建和操作Jupyter Notebook，这是运行Python代码的交互式环境。我们将涵盖从启动Notebook到编写、运行代码以及管理代码单元的基本操作。

启动Jupyter Notebook

下载并安装Anaconda后，可以通过几种方式启动Jupyter Notebook。

最简单的方法是打开电脑上的Anaconda Navigator，然后点击启动按钮来启动Jupyter Notebook。

这将在你的默认浏览器中启动Jupyter Notebook。你可以导航到想要创建和保存Notebook文件的文件夹。

创建与重命名Notebook

要创建一个Notebook，请点击右上角的“New”按钮，并选择最新版本的Python（通常是Python 3）。

这将创建你的第一个Notebook文件。要重命名它，请点击顶部的标题。

输入一个名称，然后点击“Rename”。

编写与运行代码

你将在代码单元（cell）内编写和运行Python代码。

例如，输入以下代码：

print("Hello, world")

要运行代码，可以按 Control + Return。这将在当前单元中运行代码，本例中会将“Hello, world”打印到控制台。

或者，可以按 Shift + Return。这将在运行当前单元代码后，在其下方创建一个新的代码单元。

按 Shift + Return 后，代码再次运行，将“Hello, world”打印到控制台，并在下方创建一个新单元。

管理代码单元

以下是管理代码单元的基本操作。

要手动创建新单元，可以点击单元左侧选中它，然后按键盘上的 A 键。A 键会在上方插入一个单元。

选中一个单元后，按 B 键会在下方插入一个单元。

要删除一个单元，点击单元左侧选中它，然后按两次 D 键（即 D D）即可删除。

保存与退出

Notebook文件会自动保存，但如需手动保存，可以点击左侧的保存按钮。

要退出Jupyter Notebook，可以关闭你的Notebook文件。

然后点击右上角的“Quit”按钮。

这将停止服务器并退出Jupyter Notebook。

总结

本节课中我们一起学习了Jupyter Notebook的基本使用。我们了解了如何启动Notebook、创建和重命名文件、在单元中编写并运行Python代码（如 print("Hello, world")），以及如何使用快捷键（A、B、D D）来插入和删除单元。最后，我们还学习了如何保存工作和安全退出Notebook环境。

014：如何编写Python代码 🐍

在本节课中，我们将要学习Python编程中最基础但至关重要的部分：如何使用print函数向控制台输出信息。我们将从最简单的用法开始，逐步探索其更高级的功能。

使用print函数输出内容

让我们从最基本的Python print命令开始，它用于向控制台输出信息。

print函数的功能是将指定的消息打印到屏幕上。

以下是print函数的基本用法示例：

print("Hello, World!")

字符串的引号与连接

在print函数中，你可以使用双引号或单引号来定义字符串，两者效果相同。

你还可以使用print命令来连接（或链接）字符和字符串。

以下是字符串连接的一个例子：

print("Hello" + " " + "World!")

修改print语句的结束符

默认情况下，print语句以换行符（\n）结束，这意味着每次调用print后输出会换到新的一行。

但是，我们可以通过为print命令添加end参数来覆盖这个默认行为。

例如，以下代码将多个print语句的输出打印在同一行：

print("Hello", end=" ")
print("World!")

指定print参数之间的分隔符

通常，传递给print函数的多个参数之间会用一个空格分隔。

我们可以通过为print命令添加sep参数来指定不同的分隔符。

例如，以下代码使用连字符而非空格来分隔参数：

print("2023", "10", "27", sep="-")

---

本节课中我们一起学习了Python print函数的核心用法。我们掌握了如何输出基本文本、连接字符串，以及通过end和sep参数灵活控制输出的格式。这些是构建更复杂程序的基础。

015：打印输出 📝

在本节课中，我们将要学习Python中最基础的功能之一：使用 print 命令向控制台输出信息。我们将从最简单的打印开始，逐步了解如何控制输出的格式。

---

基础打印命令

让我们从最基本的Python print 命令开始，向控制台输出信息。

我将输入 print 和一个消息。

print("Hello")

运行这段代码。我按下 Shift + Return 来执行代码。它将这条消息打印到了控制台。

我也可以使用单引号。

print('Hello')

Python以相同的方式处理它，并将该消息打印到控制台。

双引号或单引号都可以使用。

---

连接字符串

上一节我们介绍了如何打印单个字符串，本节中我们来看看如何将多个字符串连接在一起。

我可以使用 print 命令连接或链接字符和字符串。

以下是具体方法：在 print 函数中，用逗号分隔多个字符串。

print("Hello", "World")

如果我运行它，Python会将它们并排打印在一起，即连接或链接在一起。

输出结果为：Hello World。

---

控制行尾字符

我可以改变 print 语句的结束符。

例如，输入：

print("Good morning", end=" ")
print("Brandon")

这里，我指定了 end 参数为一个空格字符 " "。

这将打印 Good morning，后面跟着一个空格。然后我打印 Brandon。

所以最终输出是：Good morning Brandon。

---

指定分隔符

我还可以为 print 命令的参数指定分隔符。

以下是具体方法：使用 sep 参数来定义参数之间的分隔符。

print("Good night", "Brandon", sep=", ")

这里，分隔符 sep 被设置为 ", "（逗号加空格）。

所以它会打印 Good night，后面跟着 ", "，然后是 Brandon。

输出结果为：Good night, Brandon。

---

总结

本节课中我们一起学习了Python的 print 函数。我们从最基本的打印字符串开始，学会了如何使用双引号和单引号。接着，我们探索了如何通过逗号分隔来连接多个字符串。然后，我们学习了如何使用 end 参数来控制打印结束后的字符，以及如何使用 sep 参数来定义多个参数之间的分隔符。这些是控制程序输出的基础且重要的技能。

016：016_01_03_基本数据类型 📊

在本节课中，我们将要学习Python中的基本数据类型。理解数据类型是编程的基础，它决定了我们可以对数据进行何种操作。我们将从整数和浮点数开始，并学习如何使用type()命令来确认数据的类型。

整数类型 (int) 🔢

在Python中，每个值都有一个与之关联的类型。让我们从整数（int）开始。整数是正或负的、没有小数点的完整数字。

例如，8是一个整数。

-1也是一个整数。

我们可以进行一些简单的数学运算。2 + 3，将两个整数相加，得到整数5。

5 - 6，得到-1，同样是一个整数。

2 * 3，得到6，也是一个整数。

稍微复杂一点的运算：3 + 5 - 2 * 6。根据运算顺序，我们得到-4。

记住运算顺序，我们可以使用括号：(3 + 5 - 2) * 6，得到36，这也是一个整数。

我们可以使用type()命令来确认一个值是什么类型。在这种情况下，type(99)会告诉我们99是一个整数。

浮点数类型 (float) 🌊

上一节我们介绍了整数，本节中我们来看看浮点数。浮点数是包含小数点的正数或负数。

例如，1.3是一个浮点数。

23.0是一个浮点数。

-5.1也是一个浮点数。

2 * 3.5，一个整数乘以一个浮点数，结果是浮点数7.0。

7 / 2.0，结果是浮点数3.5。

如果我们想查看一个对象的类型，可以再次使用type()命令。type(0.1)会显示0.1是一个浮点数。

---

本节课中我们一起学习了Python中的两种基本数据类型：整数（int）和浮点数（float）。我们了解了它们的定义，并通过示例学习了如何对它们进行数学运算。我们还掌握了使用type()函数来检查任何值的类型，这是编程中一个非常有用的调试和验证工具。理解这些基础是后续学习更复杂数据类型和操作的关键。

Python编程入门：1-2：算术运算符 🧮

在本节课中，我们将要学习Python编程语言中的算术运算符。这些运算符用于执行基础的数学运算，是编写任何涉及计算的程序的基础。

上一节我们介绍了编程的基本概念，本节中我们来看看如何让计算机进行数学计算。

算术运算符用于执行数学运算。加号 + 表示加法，减号 - 表示减法。

星号 * 用于乘法，而正斜杠 / 用于除法。

以下是除法运算符的示例：

result = 10 / 2  # result 的值为 5.0

双斜杠 // 用于整数除法。它执行除法运算，但只返回商的整数部分，丢弃小数部分。

以下是整数除法运算符的示例：

result = 3 // 2  # result 的值为 1

双星号 ** 用于幂运算，即计算一个数的另一个数次方。

以下是幂运算符的示例：

result = 2 ** 3  # result 的值为 8

百分号 % 表示取模运算。它执行除法运算，但返回的是余数，而不是商。

以下是取模运算符的示例：

result = 7 % 5  # result 的值为 2

本节课中我们一起学习了Python的六种基本算术运算符：加法+、减法-、乘法*、除法/、整数除法//、幂运算**和取模%。理解这些运算符是进行更复杂编程的第一步。

018：关于除法运算 🧮

在本节课中，我们将要学习Python中的三种除法运算：普通除法、整数除法和取模运算。理解这些运算的区别对于进行精确的数值计算至关重要。

普通除法

首先，我们来看最基础的除法运算，它使用单个正斜杠 / 作为运算符。这种除法会返回一个精确的结果，包括小数部分。

以下是几个普通除法的例子：

• 3 / 2 的结果是 1.5。
• 3.1 / 2 的结果是 1.55。

整数除法

上一节我们介绍了返回精确结果的普通除法，本节中我们来看看整数除法。整数除法使用两个连续的正斜杠 // 作为运算符。它的作用是进行除法运算后，返回结果的整数部分，直接舍弃小数部分。

以下是整数除法的运算示例：

• 3 // 2 的结果是 1。因为2只能整除3一次。
• 3.1 // 2 的结果同样是 1。即使被除数是浮点数 3.1，运算结果也只会保留整数部分 1。

取模运算

了解了返回商的整数除法后，我们再来学习取模运算。取模运算使用百分号 % 作为运算符。它的作用是进行除法运算后，返回余数部分。

以下是取模运算的示例：

• 3 % 2 的结果是 1。因为 3 除以 2 等于 1，余数为 1。
• 4 % 2 的结果是 0。因为 4 可以被 2 整除，没有余数。
• 3.1 % 2 的结果是 1.1。因为 3.1 除以 2 等于 1，余数为 1.1。

总结

本节课中我们一起学习了Python中的三种除法运算：

1. 普通除法 (/)：返回包含小数的精确结果。
2. 整数除法 (//)：返回商的整数部分，舍弃小数。
3. 取模运算 (%)：返回除法运算后的余数。

掌握这些运算将帮助你在程序中更灵活地处理数值计算。

019：019_01_06_布尔值 🔢

在本节课中，我们将要学习Python中的布尔值。布尔值是一种表示“真”或“假”的数据类型，它是编程中进行逻辑判断和决策的基础。我们将通过具体的例子来理解布尔值是如何工作的，以及如何通过比较运算得到布尔值。

---

什么是布尔值？ 🤔

布尔值（Boolean）是一个表示“真”（True）或“假”（False）的值。在Python中，我们可以通过比较运算来得到布尔值。

例如，我们可以问：1等于2吗？

1 == 2

这个表达式的值是 False。

---

数值比较与布尔值

上一节我们介绍了布尔值的基本概念，本节中我们来看看如何使用比较运算符来生成布尔值。

以下是几个数值比较的例子：

• 1 < 2 的结果是 True。
• 1.2 <= 1.2 的结果是 True，因为1.2等于1.2。

---

字符串比较与布尔值

除了数字，我们也可以比较字符串。字符串的比较会同时考虑类型和值。

以下是几个字符串比较的例子：

• ‘car’ == ‘car’ 的结果是 True，因为类型相同，值也相同。
• ‘Car’ == ‘car’ 的结果是 False，因为虽然类型相同，但值不同（大小写不同）。
• ‘1’ == 1 的结果是 False，因为类型不同（一个是字符串，一个是整数）。

我们还可以使用“不等于”运算符 != 进行比较：

• ‘1’ != 1 的结果是 True，因为它们确实不相等。

---

对象的布尔值

在Python中，每个对象都有一个内在的布尔值。这意味着我们可以直接测试一个对象在逻辑上是“真”还是“假”。

以下是测试不同对象布尔值的例子：

• bool(False) 的值是 False。
• bool(True) 的值是 True。
• bool(7) 的值是 True。
• bool(0) 的值是 False。通常，任何非零数值的布尔值都是 True，而零的布尔值是 False。
• bool(7 == 0) 的值是 False，因为 7 == 0 这个比较表达式本身的结果是 False。

---

总结

本节课中我们一起学习了Python中的布尔值。我们了解到布尔值是 True 或 False，可以通过比较运算符（如 ==， !=， <， <=）来获得。我们还学习了Python中每个对象都有一个内在的布尔值，例如非零数字为 True，零为 False。理解布尔值是掌握程序流程控制（如 if 语句）的关键第一步。

020：比较运算符 🔍

在本节课中，我们将要学习Python中的比较运算符。比较运算符用于比较两个值，并判断它们之间的关系，其运算结果是一个布尔值（True 或 False）。掌握比较运算符是编写条件判断语句的基础。

相等与不相等比较

上一节我们介绍了变量的概念，本节中我们来看看如何比较两个值是否相等。

使用双等号 == 可以测试两个值是否相等。使用感叹号加等号 != 可以测试两个值是否不相等。

以下是这两种运算符的示例：

• 5 == 5 的结果是 True。
• 5 == 3 的结果是 False。
• 5 != 3 的结果是 True。
• 5 != 5 的结果是 False。

大小比较

除了判断相等，我们还可以比较数值的大小关系。

使用小于号 < 可以测试一个值是否小于另一个值。使用大于号 > 可以测试一个值是否大于另一个值。

以下是这两种运算符的示例：

• 3 < 5 的结果是 True。
• 5 < 3 的结果是 False。
• 7 > 2 的结果是 True。
• 2 > 7 的结果是 False。

包含等值的大小比较

有时我们需要判断一个值是否“小于或等于”或“大于或等于”另一个值。

小于等于号 <= 测试一个值是否小于或等于另一个值。同理，大于等于号 >= 测试一个值是否大于或等于另一个值。

以下是这两种运算符的示例：

• 5 <= 5 的结果是 True。
• 4 <= 5 的结果是 True。
• 6 <= 5 的结果是 False。
• 5 >= 5 的结果是 True。
• 6 >= 5 的结果是 True。
• 4 >= 5 的结果是 False。

本节课中我们一起学习了Python的六种基本比较运算符：==（等于）、!=（不等于）、<（小于）、>（大于）、<=（小于等于）和 >=（大于等于）。它们用于比较两个值并返回布尔结果，是构建程序逻辑判断的核心工具。

021：代码练习-判断奇偶数 🧮

在本节课中，我们将通过一个简单的代码练习来学习如何使用取模运算符判断一个整数是奇数还是偶数。我们将从理解奇偶数的数学定义开始，然后将其转化为编程逻辑。

概述

判断一个数字是奇数还是偶数是编程中的基础任务。其核心原理基于一个简单的数学运算：取模运算。取模运算返回两个数相除后的余数。对于判断奇偶性，我们关心的是这个数字除以2后的余数。

判断奇偶性的原理

一个整数如果能被2整除，即除以2的余数为0，那么它就是偶数。反之，如果除以2的余数不为0（通常为1），那么它就是奇数。这个逻辑可以用取模运算符 % 来表示。

以下是判断逻辑的公式化描述：

• 偶数：number % 2 == 0
• 奇数：number % 2 != 0 或 number % 2 == 1

上一节我们介绍了判断奇偶性的基本原理，本节中我们来看看如何应用这些原理进行具体的判断练习。

代码练习解析

让我们通过两个具体的数字来实践这个判断过程。

示例一：判断50002是否为偶数

我们取数字50002，计算它除以2的余数，并检查余数是否等于0。

50002 % 2 == 0

计算结果是 True。因为50002除以2没有余数，所以它是偶数。

示例二：判断50003是否为奇数

接下来，我们取数字50003，计算它除以2的余数。

50003 % 2

余数大于或等于1（实际上就是1）。因为除以2有余数，所以它一定是奇数。

总结

本节课中我们一起学习了如何使用取模运算符 % 来判断一个整数的奇偶性。关键点在于检查 number % 2 的结果：如果等于0，则是偶数；如果不等于0（或等于1），则是奇数。这是将基础数学概念转化为编程逻辑的一个经典且实用的例子。

022：字符串基础 🧵

在本节课中，我们将要学习Python编程中一个非常基础且重要的概念：字符串。字符串是构成文本数据的基本单位，理解其定义和基本操作是编写程序的第一步。

什么是字符串？

字符串是由单引号或双引号括起来的一系列字符。

例如，'nice' 是一个字符串。

同样，"nice" 也是一个字符串。

在Python中，用单引号和双引号定义的字符串是等价的。这意味着 'nice' 和 "nice" 是相同类型、相同值的字符串。

字符串的连接

我们可以使用加号 + 来连接（或链接）字符和字符串。

例如，‘so’ + ‘ ‘ + ‘wow’ 的结果是 ‘so wow’。‘Python is so cool’ 也是一个字符串连接的例子。

当我们写下 ‘so’ + ‘ ‘ + ‘wow’ 时，Python知道我们试图将这三个字符串片段连接在一起。

检查数据类型

我们可以检查一个对象是否是字符串。使用 type() 函数可以查看对象的类型。

例如，type(‘yes’) 的返回值是 str，表示这是一个字符串。

同样，type(“1.03”) 的返回值也是 str，因为它是一个由数字字符组成的字符串。

作为对比，type(1.03) 的返回值是 int（或 float，取决于具体实现），因为它是一个数字。

打印字符串

我们可以使用 print() 函数输出多个字符串。print() 函数会将所有传入的参数依次打印出来，并默认用空格分隔。

例如，print(‘name’, ‘Brandon’, ‘Krakowski’) 会输出 name Brandon Krakowski。

我们也可以先使用加号 + 将字符串连接成一个整体，然后再打印。

例如，print(‘name’ + ‘ ‘ + ‘Brandon’ + ‘ ‘ + ‘Krakowski’)。

这行代码在 print() 命令内部将字符串 ‘name’、空格、‘Brandon’、空格和 ‘Krakowski’ 连接起来，然后打印整个结果。其输出与直接打印多个参数的结果看起来完全相同。

转义字符

最后，我们学习如何在字符串中使用特殊字符。在Python字符串中，反斜杠 \ 是一个特殊字符，也称为转义字符。

例如，我们想打印：Brandon’s last name is Krakowski。如果直接写 ‘Brandon’s last name is Krakowski’，Python会误认为第二个单引号是字符串的结束，从而导致语法错误。

正确的写法是使用转义字符：print(“Brandon\’s last name is Krakowski”)。

运行这行代码，会正确输出 Brandon’s last name is Krakowski。这里的反斜杠 \ 是一个转义字符，它告诉Python紧随其后的单引号应被视为普通字符，而不是用于界定字符串的符号。

---

本节课中我们一起学习了Python字符串的基础知识。我们了解了字符串的定义方式（单引号或双引号）、如何使用加号进行连接、如何用 type() 函数检查类型、如何使用 print() 函数输出字符串，以及如何利用转义字符 \ 在字符串中表示特殊符号。掌握这些概念是进行后续文本处理和更复杂编程的基础。

023：类型转换 🔄

在本节课中，我们将要学习Python中的类型转换。类型转换是指将数据从一种类型转换为另一种类型，例如将浮点数转换为整数，或将数字转换为字符串。掌握类型转换对于处理不同类型的数据和避免程序错误至关重要。

---

从浮点数转换为整数

上一节我们介绍了基本的数据类型，本节中我们来看看如何在它们之间进行转换。首先，我们来看一个将浮点数转换为整数的例子。

在Python中，你可以使用内置的 int() 函数进行转换。例如，计算 1237 / 62 会得到一个浮点数结果。

result = 1237 / 62
print(result)  # 输出: 19.925925925925927

这是一个浮点数。如果我们想将其转换为整数，可以使用 int() 函数。

int_result = int(1237 / 62)
print(int_result)  # 输出: 19

需要注意的是，int() 函数会向下取整到最接近的整数。因此，19.925... 被转换成了19。

---

使用 round() 函数进行四舍五入

如果你希望将一个浮点数四舍五入到最接近的整数，而不是简单地向下取整，应该使用Python内置的 round() 函数。

rounded_result = round(1237 / 62)
print(rounded_result)  # 输出: 20

这样，19.925... 就被正确地四舍五入为20。

---

从字符串转换为整数

类型转换不仅限于数字之间。你也可以将字符串转换为整数，前提是字符串的内容是有效的数字。

number_from_string = int("1")
print(number_from_string)  # 输出: 1

---

打印与字符串拼接

在编程中，我们经常需要将数字和文本一起打印出来。以下是几种不同的方法。

首先，可以直接打印一个数学表达式的结果。

print(4 / 2)  # 输出: 2.0

其次，可以使用逗号分隔的方式，在同一行 print 函数中打印字符串和数字。

print("4 mod 2 equals", 4 % 2)  # 输出: 4 mod 2 equals 0

然而，如果你尝试使用加号 + 来拼接字符串和数字，Python会报错，因为它不知道如何将这两种不同类型的数据连接在一起。

# 这行代码会引发 TypeError 错误
# print("4 mod 2 equals" + 4 % 2)

---

使用 str() 函数解决拼接问题

要解决上述问题，我们需要使用 str() 函数将数字显式地转换为字符串，然后再进行拼接。

以下是正确的做法：

print("4 mod 2 equals" + str(4 % 2))  # 输出: 4 mod 2 equals 0

通过 str(4 % 2)，我们将计算结果 0 转换成了字符串 "0"，从而可以安全地与前面的文本进行拼接。

---

打印布尔值

同样的原则也适用于布尔值。布尔值也需要先转换为字符串，才能与其他字符串拼接。

print("Is 4 even? " + str(4 % 2 == 0))  # 输出: Is 4 even? True

在这里，表达式 4 % 2 == 0 的结果是布尔值 True。我们使用 str() 函数将其转换为字符串 "True"，然后完成拼接。

---

本节课中我们一起学习了Python中的类型转换。我们了解了如何使用 int()、round() 和 str() 等内置函数在不同数据类型（如整数、浮点数、字符串和布尔值）之间进行转换。记住，在进行字符串拼接时，确保所有操作数都是字符串类型，这是避免 TypeError 的关键。

024：如何使用Coursera实验环境-理解自动评分输出 🧑‍💻

在本节课中，我们将学习如何在Coursera的实验环境中完成编程作业，理解自动评分系统的输出信息，并掌握解决常见问题的方法。

启动与界面介绍

上一节我们介绍了课程背景，本节中我们来看看如何开始第一个作业。

打开作业后，你会看到一个名为Jupyter Notebook的界面。这是一个非常方便的工具，它为我们提供了编写代码的环境和作业说明。这意味着你无需在本地电脑上安装任何软件或担心系统依赖问题，无论你使用的是Mac、Windows还是Linux系统，都不会影响你的编程学习。这为我们提供了一个极佳的入门Python编程的方式。

理解变量初始化与执行代码单元

在作业的顶部，有一个关于变量初始化的说明。强烈建议你仔细阅读并确保完全理解这部分内容，因为它对于成功完成本次作业以及未来的作业都至关重要。

我们需要做的第一件事是执行顶部的代码单元。代码单元就是Notebook中这些灰色的方框，它们是可运行的代码块，你可以在其中编写和修改代码。其中一些单元可能是只读的，例如用于测试的单元或作业正常运行所必需的部分。

运行一个单元最简单的方法是点击顶部的运行按钮。然而，使用键盘快捷键通常更方便。你可以按住Shift或Control键再按Enter键。根据你按住的键不同，执行后你可能会停留在当前单元，也可能会跳转到下一个单元。

例如，如果我按住Control再按Enter，单元执行后我仍停留在该单元。如果我按住Shift再按Enter，单元执行后我会跳转到下一个单元。同样，你可以使用方向键在单元间导航，也可以通过按Enter键进入单元进行编辑。这是一个只读单元，所以我无法修改它，但我可以进入单元并移动光标。

当一个单元执行时，你会看到一个旋转的星号。在这个方括号里它转得很快，但在课程后期执行一些复杂的代码块时，可能需要几秒钟才能完成。

完成第一道题目与理解测试

现在，我们来看第一道题目。题目要求我们计算3.93乘以4901的结果，并将其保存在一个名为Q1的变量中。

观察代码，我们发现已有的打印语句已经引用了Q1变量，因此我们很清楚这里需要做什么。让我们创建一个名为Q1的变量，并为其赋值3.93 * 4901。

Q1 = 3.93 * 4901

如果我在这里按住Control并按Enter，我可以在执行代码块的同时保持在该单元内。

接下来，我将运行测试单元。我们会看到，当我运行这个单元时，它打印出了“success”，因为我们的计算是正确的。但为了演示，让我们在这个单元中故意制造一个错误。我通过点击上箭头键导航回这个单元，然后按Enter开始输入。我们将把乘数改为4而不是3.93。

Q1 = 4 * 4901  # 错误的示例

你会注意到输出略有变化，但我们更感兴趣的是测试结果。当我们运行这个测试时，会收到一条错误信息。这条信息可能很长，看起来有点吓人，但一旦你见过几次，就能很快掌握要领。

最重要的部分是底部显示的内容：AssertionError。这个断言错误基本上是说这两个数字不匹配，系统期望它们相等，但实际并不相等。

观察实际的测试用例，我们可以看到assertEqual语句，它比较了我们刚刚创建的变量Q1和解决方案中的版本S.Q1。这些测试的工作原理是，我们有一个作业的解决方案版本，并将其存储在其他地方。然后，在需要时提取这些值，以确认你计算的值与我们期望的解决方案值是否一致。

修正错误与继续作业

为了修正这个错误，我们可以直接回到出错的地方，将乘数改回3.93。我们按住Shift并按Enter跳转到下一个单元，然后按住Control并按Enter执行这个单元，现在我们就得到了“success”信息。

成功通过Q1的测试后，我们使用方向键向下移动，继续处理Q2。在这个例子中，我们将进行一个类似的计算操作，并将结果赋值给一个名为Q2的变量。

同样，我们可以执行这个单元，看到打印语句返回我们期望的值。但再次，通过一个错误来演示会更有趣。让我们稍微修改一下这个计算。

当我们执行测试时，我们会再次跳到这里查看断言错误，因为它提供了最重要的信息。从这里我们可以看出数字不匹配。如果我们仔细查看这条更长的信息，实际上可以开始理解发生了什么。在最顶部，这个绿色箭头指向了assert语句，该语句基本上是在比较我们创建的变量和解决方案变量。

这看起来很熟悉，因为它实际上就包含在这个单元里。我们知道43.0也很熟悉，因为我们刚刚在这个单元中打印过。因此，如果我们将其修正为正确的值35.83，就可以通过这个测试并看到“success”信息。

让我们再做一个例子。Q3是一个类似的问题，我们需要将3 / 0.3的结果赋值给Q3。之后我们打印出值，然后继续到测试用例，这次我们通过了。

使用验证按钮与提交作业

现在，让我们尝试用一种稍微不同的方法来检查测试用例。顶部的“Validate”按钮是一个很好的方式，可以验证你是否通过了Notebook中的所有测试，而不仅仅是你当前所在的这个测试单元。

当我点击它时，系统会计算每一个测试。你会注意到很多测试都失败了，但这很正常，因为我们还没有真正完成整个作业。如果我们查看最顶部，会看到第一个失败的测试是关于Q4的，这再次说明我们尚未完成Q4。

现在，如果我们修改Q3使其失败，然后返回并再次验证，我们应该会在顶部看到Q3失败。因此，“Validate”按钮是快速确保你通过所有测试的好方法。

如果我们再次修正Q3并运行单元，现在我们就通过了前三个测试。

一旦你验证了你的工作，并且确信已经通过了足够多的测试，你就可以提交这份作业了。提交后，你随时可以回来重新提交。提交后不久，你应该会在作业页面上看到成绩。但如果你没有得到期望的成绩，你随时可以回来再次尝试。

总结

本节课中我们一起学习了如何在Coursera的Jupyter Notebook环境中完成编程作业。我们了解了如何执行代码单元、理解并修正自动评分系统给出的错误信息，以及如何使用“Validate”按钮全面检查作业。希望这些内容对你有所帮助，如果在学习过程中有任何后续问题，请在论坛上发帖提问。祝你在课程中学习顺利！

025：下载与安装IDLE 🐍

在本节课中，我们将学习如何获取并安装Python的官方集成开发与学习环境——IDLE。这是你开始Python编程之旅的第一步。

概述

IDLE是随Python一同捆绑分发的官方开发环境。它集成了交互式解释器和脚本编辑器，为编写和运行Python代码提供了一个便捷的工具。

下载与安装步骤

上一节我们了解了IDLE的基本概念，本节中我们来看看如何具体获取和安装它。

要下载并安装IDLE，你需要访问Python官方网站的下载页面。因为IDLE是随Python主程序一同分发的，所以安装Python的同时就会自动安装IDLE。

以下是具体的操作步骤：

1. 访问Python官方网站（python.org）。
2. 导航至“Downloads”（下载）页面。
3. 选择适合你操作系统的Python版本进行下载。
4. 运行下载的安装程序，并按照提示完成安装。

安装过程结束后，你的系统中将同时拥有Python解释器和IDLE开发环境。

IDLE的核心组件

安装完成后，让我们认识一下IDLE包含的两个核心工具，它们对学习和开发至关重要。

IDLE主要包含两个组件，其功能可以通过以下伪代码描述其关系：

IDLE 环境包含：
    - 交互式Python解释器 (用于即时执行代码)
    - 脚本编辑器 (用于编写和保存程序文件)

以下是每个组件的简要说明：

• 交互式Python解释器：这是一个可以立即执行单行Python命令的窗口，非常适合快速测试代码片段和学习语法。
• 脚本编辑器：这是一个用于编写完整Python程序（脚本）的文本编辑器。你可以在这里编写多行代码，将其保存为 .py 文件，并运行整个程序。

总结

本节课中我们一起学习了Python官方开发环境IDLE的下载与安装方法。我们了解到IDLE随Python一同安装，并且它包含了交互式解释器和脚本编辑器这两个核心工具，为后续的编程学习打下了基础。下一节，我们将开始探索如何使用IDLE来编写你的第一个Python程序。

026：使用IDLE交互式环境 🐍

在本节课中，我们将要学习如何使用IDLE（Python自带的集成开发与学习环境）的交互式环境。我们将了解如何启动IDLE，在Python Shell中直接输入并运行代码，以及执行一些基本的操作，如打印输出和进行数学运算。

---

启动IDLE与Python Shell

IDLE包含一个交互式的Python解释器和一个脚本编辑器。我们将主要使用其交互式环境来即时运行代码。

当你首次启动IDLE时，你会看到Python Shell窗口。你可以直接在这个Shell中输入Python代码并立即看到执行结果。

---

在Shell中运行代码

在Python Shell中，代码是逐行解释执行的。让我们从最经典的示例开始：向控制台打印输出。

要打印“Hello, world”，只需输入以下代码并按回车键执行：

print("Hello, world")

执行后，Shell会立即显示输出结果。

接下来，我们可以打印更长的句子：

print("today is a good day")

同样，按下回车键后，这句话就会显示在控制台上。

---

执行数学与逻辑运算

除了打印文本，Python Shell还是一个强大的计算器。你可以直接进行数学运算和逻辑比较。

例如，进行加法运算：

2 + 3

执行乘法运算：

2 * 3

你还可以进行更复杂的运算，比如：

2 * 3.5

对于逻辑判断，Python使用比较运算符。例如，判断1是否等于2：

1 == 2

这个表达式会返回布尔值 False，因为1不等于2。

再判断1是否小于2：

1 < 2

这个表达式会返回 True。

最后，判断1.2是否大于或等于1.2：

1.2 >= 1.2

这个表达式同样会返回 True。

---

总结

本节课中，我们一起学习了IDLE交互式环境的基本用法。我们了解了如何启动IDLE并在Python Shell中直接输入代码，包括使用 print() 函数输出文本，以及执行基础的数学运算和逻辑比较。这个交互式环境是快速测试代码片段和熟悉Python语法的绝佳工具。在接下来的课程中，我们将学习如何使用IDLE的脚本编辑器来编写更复杂的程序。

027：运行Python脚本 🐍

在本节课中，我们将学习如何在集成开发环境（IDE）中创建、保存和运行一个Python脚本文件。这是将代码转化为可执行程序的第一步。

创建脚本文件

首先，我们需要在IDE中创建一个新的文件来编写我们的Python代码。

以下是创建新文件的步骤：

1. 在IDE的菜单栏中，点击 File（文件）。
2. 在下拉菜单中，选择 New File（新建文件）。

保存脚本文件

创建新文件后，必须将其保存到计算机上，才能运行其中的代码。保存时，请确保文件扩展名为 .py，例如 my_script.py。

以下是保存文件的步骤：

1. 在菜单栏中，点击 File（文件）。
2. 选择 Save（保存）或 Save As（另存为）。
3. 在弹出的对话框中，为文件命名（例如 hello.py），并选择保存位置。
4. 点击保存。

编写与运行代码

文件保存后，你可以在其中输入Python代码。例如，输入一个简单的打印语句：

print("Hello, World!")

要执行脚本文件中的代码，你需要运行它。

以下是运行脚本的方法：

• 在菜单栏中，点击 Run（运行），然后选择 Run Module（运行模块）。
• 或者，直接使用快捷键：在Windows/Linux系统上按 F5，在Mac系统上按 Fn + F5。

运行脚本后，代码的输出结果（例如“Hello, World!”）将显示在IDE下方的控制台（Console）窗口中。

---

本节课中，我们一起学习了Python脚本从创建到运行的完整流程：在IDE中新建文件、将其保存为 .py 格式、编写代码，最后通过菜单或快捷键运行脚本并查看结果。掌握这些基本操作是开始Python编程实践的基础。

Python编程入门：1-2：为Python脚本添加注释 📝

在本节课中，我们将要学习如何在Python脚本中添加注释。注释是代码中不会被Python解释器执行的文本，它们的主要作用是向阅读代码的人（包括未来的你自己）解释代码的功能和逻辑。添加注释是编写清晰、可维护代码的重要习惯。

---

单行注释

你可以使用井号 # 来为单行文本添加注释。井号之后直到行尾的所有内容都会被Python视为注释而忽略。

以下是单行注释的示例：

# 这是一个单行注释
print("Hello, World!")  # 这行代码会打印一条问候语

---

多行注释

上一节我们介绍了单行注释，本节中我们来看看如何一次性注释多行文本。你可以使用三个双引号 """ 或三个单引号 ''' 来包裹多行文本，从而创建多行注释。

以下是多行注释的示例：

"""
这是一个
多行注释
可以跨越多行
"""
print(1)
print(2)
print(3)

---

注释的重要性

为脚本添加注释能使你的代码结构清晰、易于阅读。注释通常用于：

• 解释复杂代码块的逻辑。
• 记录函数或类的用途。
• 标记待完成的任务（TODO）或需要注意的问题（FIXME）。

至少，你应该为所有非显而易见的代码行添加注释。

以下是我的打印语句，它们将输出数字1、2、3：

print(1)  # 输出数字 1
print(2)  # 输出数字 2
print(3)  # 输出数字 3

当你运行脚本时，Python会完全忽略所有注释，只执行有效的代码语句。

---

本节课中我们一起学习了Python中注释的两种主要写法：使用 # 进行单行注释，以及使用 """ 或 ''' 进行多行注释。记住，良好的注释习惯是成为一名优秀程序员的关键，它能极大地提升代码的可读性和可维护性。

029：代码练习-注释问候用户程序 📝

在本节课中，我们将学习如何编写一个包含注释的Python程序。注释是代码中用于解释程序功能的文本，它不会被计算机执行，但对程序员理解代码至关重要。我们将通过一个简单的“问候用户”程序来实践这一概念。

概述

我们将创建一个程序，它首先请求用户输入姓名，然后将输入的姓名存储在一个变量中，最后打印出一条包含该姓名的问候语。在整个过程中，我们会使用注释来描述每一步代码的作用。

编写带注释的程序

上一节我们了解了注释的基本概念，本节中我们来看看如何在实际代码中应用它。

以下是我们将要编写的程序的核心步骤：

1. 提示用户输入姓名：程序会显示一个问题，等待用户输入。
2. 存储用户输入：将用户输入的信息保存到一个变量中，以便后续使用。
3. 输出问候信息：将存储的姓名与问候语结合，并打印到屏幕上。

现在，让我们用代码来实现这些步骤，并为每一行关键代码添加注释。

# 提示用户输入姓名，并将输入结果存储在变量‘name’中
name = input("What is your name? ")

# 打印一条包含用户姓名的问候信息
print("Hello, " + name)

代码解析

在上一部分，我们写好了完整的代码。本节中我们来详细解析每一行代码及其注释的作用。

以下是代码中两个核心部分的解释：

• 第一行代码：name = input(“What is your name? “)
  • input() 是一个函数，它会在屏幕上显示括号内的文本（这里是”What is your name? “），并等待用户在命令行中输入信息。
  • 用户输入的内容（例如”Alice”）会被赋值给等号左边的变量 name。变量就像一个标签，指向存储的数据。
• 第二行代码：print(“Hello, ” + name)
  • print() 函数用于将内容输出到屏幕。
  • 我们使用加号 + 将字符串 ”Hello, “ 和变量 name 中存储的值连接起来，形成完整的问候语，例如 ”Hello, Alice”。

运行程序

代码编写并添加注释后，下一步就是运行它，看看实际效果。

保存文件（例如 greeting.py）并运行。程序会首先在命令行中显示提示：

What is your name?

当你输入姓名（例如“Bob”）并按下回车后，程序会输出：

Hello, Bob

整个过程清晰地展示了从获取用户输入到处理并输出结果的数据流。

总结

本节课中我们一起学习了如何为一个简单的Python程序添加注释。我们编写了一个交互式的问候程序，它使用 input() 函数获取用户输入，用变量存储数据，最后用 print() 函数输出个性化问候。通过为关键代码行添加注释（以 # 开头），我们使程序的功能一目了然，这对于代码的维护和与他人协作非常重要。记住，清晰的注释是优秀编程习惯的重要组成部分。

030：变量赋值 📝

在本节课中，我们将要学习编程中的一个核心概念——变量。我们将了解什么是变量，如何为变量赋值，以及Python语言中变量的一些重要特性。

什么是变量？ 🔍

变量是值的符号名称或引用。当你为变量赋值时，变量就获得了该值的类型。你可以使用变量来存储各种数据。

变量的命名规则 📛

以下是关于变量命名的一些关键规则：

• 变量名可以包含字母、数字和下划线。
• 变量名不能以数字开头。
• 变量名区分大小写。

Python的动态类型特性 🔄

Python是一种动态类型语言。这意味着如果你在代码的后续部分为同一个变量赋予一个不同的值，该变量会更新为新的值及其类型。

例如，你可以先写 x = 5，然后稍后写 x = “hello”。变量 x 的类型会从整数变为字符串。

变量的运算与更新 ➕➖

变量可以参与运算，并且其值可以被更新。

上一节我们介绍了变量的基本概念，本节中我们来看看如何对变量进行运算。

这里我们将 x 增加1，其写法等同于 x = x + 1。

x += 1

同样地，我们将 y 减少1，其写法等同于 y = y - 1。

y -= 1

变量类型的改变 🧩

正如之前提到的，在Python中，变量的类型可以改变。

例如，将 x 设置为字符串 ”5″，会将 x 的类型从整数更改为字符串。

x = “5” # 此时x的类型是字符串（str），而不是整数（int）

本节课中我们一起学习了变量的定义、命名规则、Python动态类型的特性以及如何对变量进行运算和重新赋值。理解变量是编写任何程序的基础，请务必掌握这些核心概念。

031：布尔运算符 🔍

在本节课中，我们将要学习编程中的布尔运算符。布尔运算符是用于比较值并得出“真”或“假”结果的逻辑工具，它们是构建程序决策逻辑的基础。

布尔运算符概述 📋

布尔运算符用于比较值。它们将表达式计算为布尔值，最终返回“真”或“假”。

逻辑运算符详解

有三种主要的逻辑运算符用于比较值。

与运算符 (and)

上一节我们介绍了布尔运算符的基本概念，本节中我们来看看第一个运算符：and。

and 运算符用于判断两个表达式是否同时为真。

例如，在Python中，我们可以这样使用：

x = 5
print(x > 3 and x < 5)  # 输出：False

另一种常见的写法是 3 < x < 5，其结果同样为 False。

或运算符 (or)

了解了“与”运算后，我们来看看“或”运算。or 运算符用于判断至少一个表达式是否为真。

以下是使用示例：

y = 2
print(y < 3 or y == 3)  # 输出：True

这等价于判断 y <= 3。

非运算符 (not)

最后，我们来学习 not 运算符。not 运算符返回一个值的相反布尔值。如果原值为真，则返回假；反之亦然。

请看以下示例：

res = y <= x  # 假设 y=2, x=5，此表达式为 True
print(not res)  # 输出：False

我们知道 res 是 True，所以 not res 的结果就是 False。

总结

本节课中我们一起学习了三种核心的布尔运算符：and、or 和 not。我们了解了它们各自的功能：and 要求所有条件为真，or 要求至少一个条件为真，而 not 则对布尔值进行取反。掌握这些运算符是编写条件判断和复杂逻辑表达式的重要一步。

032：变量替换 🔄

在本节课中，我们将要学习如何在Python中进行变量替换。变量替换是编程中的基础操作，它允许我们在表达式中使用已赋值变量的值，从而进行计算、逻辑判断和字符串操作。

在数学表达式中替换变量

上一节我们介绍了变量的基本赋值，本节中我们来看看如何在数学表达式中使用这些变量。

你可以在数学表达式中替换变量。例如，我们可以同时为两个变量赋值，并在计算中使用它们。

以下是具体的代码示例：

x = y = 10

这行代码将 x 和 y 的值都设置为 10。

z = 2 * x + y

这行代码计算 z 的值，公式为 2 * x + y。由于 x 和 y 都是 10，所以 z 等于 2*10 + 10。

print(z)

打印 z 的值，结果是 30。

在布尔表达式中替换变量

理解了数学运算后，我们来看看变量在逻辑判断中的应用。

你同样可以在布尔表达式中进行变量替换。布尔表达式的结果是 True 或 False。

以下是具体的代码示例：

x = 42
b = 15 < x / 2 < 25

这行代码首先将 x 赋值为 42，然后判断 x/2 的值是否在 15 和 25 之间。因为 42/2 = 21，所以表达式 15 < 21 < 25 为真。

print(b)
print(type(b))

打印 b 的值和它的数据类型。b 是 True，其类型是 bool（布尔型）。

变量在乘法运算中的替换

最后，我们探讨一个关键点：变量类型如何影响运算结果。不同类型的变量（如整数和字符串）在相同操作下会有不同行为。

你可以替换变量进行乘法运算。但请注意，操作的结果取决于变量的数据类型。

以下是具体的代码示例：

x = 42
y = str(x)

这行代码将整数 x 转换为字符串，并赋值给 y。现在 y 是字符串 "42"。

x *= 2
y *= 2

x *= 2 等同于 x = x * 2，对整数 x 进行数值乘法。
y *= 2 等同于 y = y * 2，对字符串 y 进行重复连接操作。

print(x)
print(y)

打印 x 和 y 的值。

• x 是 84。因为 42 * 2 = 84。
• y 是 "4242"。因为字符串 "42" 重复连接两次，变成了 "4242"。

本节课中我们一起学习了Python中的变量替换。我们掌握了如何在数学表达式和布尔表达式中使用变量值，并理解了数据类型（如整数和字符串）对乘法这类操作结果的直接影响。这是构建更复杂程序逻辑的重要基石。

033：变量组合 🔗

在本节课中，我们将要学习如何组合变量，特别是如何将字符串变量连接起来，以创建新的、更复杂的字符串。

概述

上一节我们介绍了变量的基本概念和赋值操作。本节中我们来看看如何将不同的变量值组合在一起。这在编程中非常常见，例如，将用户的名字和问候语组合成一句完整的欢迎信息。

教程内容

你可以组合变量。让我们先存储一些字符串值。

以下是定义两个字符串变量的代码：

fave_movie = "Justin Bieber's Believe"
fave_singer = "Justin Bieber"

然后，让我们将它们组合起来，创建一个新的字符串变量。

以下是将变量与固定文本组合的代码：

faves = "Your favorite movie is " + fave_movie + " and your favorite singer is " + fave_singer

最后，让我们打印 faves 变量的值。

print(faves)

运行以上代码，输出结果将是：

Your favorite movie is Justin Bieber's Believe and your favorite singer is Justin Bieber

总结

本节课中我们一起学习了如何组合字符串变量。我们通过 + 操作符将多个字符串片段（包括存储在变量中的文本和直接书写的文本）连接在一起，从而生成一个新的、更长的字符串。这是构建动态文本输出的基础技能。

034：代码练习-猫狗数量统计 🐱🐶

在本节课中，我们将通过一个简单的代码练习来学习如何在Python中定义变量、进行字符串拼接，并最终打印出结果。这个练习将帮助我们巩固变量赋值和字符串操作的基础知识。

概述

我们将按照以下步骤编写一个简单的Python程序：

1. 定义两个变量，分别代表“猫”和“狗”。
2. 使用字符串拼接，将这两个变量组合成一个完整的句子。
3. 打印出这个句子。

变量定义

首先，我们需要定义两个变量。在Python中，我们可以使用等号 = 来为变量赋值。

以下是具体的赋值操作：

• x = “cats”：将变量 x 的值设置为字符串“cats”。
• y = “dogs”：将变量 y 的值设置为字符串“dogs”。

字符串拼接

上一节我们定义了变量，本节中我们来看看如何将它们组合起来。我们将创建一个新的变量 s，它的值是一个完整的句子。这个句子由多个部分拼接而成。

在Python中，我们可以使用加号 + 来连接（拼接）字符串。

以下是构建变量 s 的代码：

• s = “It’s raining “ + x + “ and “ + y + “.”

这段代码的含义是：将字符串 ”It’s raining “、变量 x 的值、字符串 ” and “、变量 y 的值以及字符串 ”.” 依次连接起来，并将最终结果赋值给变量 s。

打印结果

最后，我们需要将结果输出到屏幕上。在Python中，我们使用 print() 函数来实现这个功能。

以下是打印结果的代码：

• print(s)

执行这行代码后，程序会输出变量 s 中存储的完整字符串。

完整代码与输出

将以上所有步骤组合起来，就得到了我们的完整程序。

x = “cats”
y = “dogs”
s = “It’s raining “ + x + “ and “ + y + “.”
print(s)

运行这段代码，你将在控制台看到以下输出：

It’s raining cats and dogs.

总结

本节课中我们一起学习了Python编程的基础操作。我们通过一个“猫狗数量统计”的练习，实践了如何定义变量（x 和 y）、如何进行字符串拼接（使用 + 运算符），以及如何使用 print() 函数输出结果。这些是构建更复杂程序的基石。

035：获取用户输入 🎯

在本节课中，我们将要学习如何在Python程序中获取用户的输入。这是创建交互式程序的基础，能让程序根据用户提供的信息动态运行。

概述

上一节我们介绍了变量的赋值和字符串格式化。本节中我们来看看如何让程序与用户进行交互，即获取用户在程序运行时输入的信息。

使用 input() 函数

要获取用户输入，可以使用 input() 函数。这个函数会暂停程序执行，等待用户在控制台输入内容，并将输入的内容作为字符串返回。

以下是 input() 函数的基本用法：

input("提示信息")

例如，我们可以用 input() 来询问用户最喜欢的电影：

input("What is your favorite movie?")

运行这段代码时，程序会首先在控制台打印提示信息 “What is your favorite movie?”，然后等待用户输入。用户输入的内容（例如 “Believe”）会被函数返回。

将输入存储到变量中

你可以根据用户输入动态地设置变量。例如，我们可以创建两个变量来分别存储用户最喜欢的电影和歌手。

以下是实现此功能的代码示例：

fave_movie = input("What is your favorite movie?")
fave_singer = input("Who is your favorite singer?")

运行这段代码，程序会依次询问两个问题，并将用户的回答分别存储在 fave_movie 和 fave_singer 变量中。

组合输入信息

获取用户输入后，我们通常需要处理或展示这些信息。我们可以像之前学习的那样，使用字符串格式化来组合这些变量。

以下是如何将用户输入组合成一句完整的话：

faves = "Your favorite movie is {} and your favorite singer is {}.".format(fave_movie, fave_singer)
print(faves)

在这段代码中，花括号 {} 是占位符，.format() 方法会将 fave_movie 和 fave_singer 的值依次插入到对应的位置。

运行完整的程序，效果如下：

1. 程序询问 “What is your favorite movie?”，用户输入 “Believe”。
2. 程序接着询问 “Who is your favorite singer?”，用户输入 “Justin Bieber”。
3. 程序最后输出组合后的句子：“Your favorite movie is Believe and your favorite singer is Justin Bieber.”

处理数值输入

默认情况下，input() 函数返回的数据类型是字符串。这在处理年龄、数量等数值信息时需要注意。

请看以下代码：

age = input("How old are you?")
print(type(age))

即使用户输入了数字 “23”，age 变量的类型仍然是字符串。如果我们尝试进行数学计算：

print(age + 3)

程序会报错，因为我们试图将一个字符串和一个整数相加。

为了解决这个问题，我们需要进行类型转换。可以使用 int() 函数将字符串转换为整数。

以下是修正后的代码：

age = int(input("How old are you?"))  # 将输入转换为整数
print(type(age))  # 现在类型是 
print("In three years, you'll be", age + 3)

现在，程序可以正确计算并输出：“In three years, you'll be 26.”

总结

本节课中我们一起学习了Python中获取用户输入的核心方法。
我们首先介绍了 input() 函数的基本用法，它用于接收用户的文本输入。
接着，我们学习了如何将输入存储到变量中，并利用字符串格式化来组合和展示这些信息。
最后，我们探讨了 input() 函数默认返回字符串的特性，并学习了如何使用 int() 函数进行类型转换以处理数值计算。
掌握用户输入是创建交互式程序的关键一步。

036：代码练习-计算账单总额 💰

在本节课中，我们将编写一个Python程序，用于计算餐厅消费的总账单。程序将引导用户输入餐费、销售税百分比和小费百分比，然后计算出包含税和小费后的总金额，并格式化为两位小数输出。

概述

我们将创建一个程序，其核心逻辑是：总账单 = 餐费 + 税额 + 小费。其中，税额基于餐费计算，而小费则基于“餐费+税额”后的总额计算。这是餐厅账单的常见计算方式。

分步实现

以下是实现该功能的详细步骤。

第一步：获取用户输入

首先，我们需要从用户那里获取三个关键信息：餐费、税率和小费率。Python的 input() 函数可以获取用户输入，但返回的是字符串类型，因此我们需要将其转换为浮点数（float）以便进行数学计算。

bill = float(input("How much is the meal? "))
tax = float(input("What is the sales tax as a percentage? "))
tip = float(input("How much of a tip as a percentage? "))

第二步：计算税额并加到账单上

上一节我们获取了原始数据，本节中我们来看看如何计算税额。税额的计算公式是：税额 = 餐费 × (税率 / 100)。计算出税额后，将其与原始餐费相加，得到含税总额。

tax_amount = bill * (tax / 100)
total = bill + tax_amount

第三步：计算小费并加到总账单上

在得到含税总额后，接下来我们需要计算小费。小费的计算基于当前的含税总额，公式为：小费金额 = 含税总额 × (小费率 / 100)。然后将小费金额加到总账单中。

tip_amount = total * (tip / 100)
total = total + tip_amount

第四步：格式化并输出最终结果

所有计算完成后，我们需要将总金额四舍五入到两位小数，并以清晰的格式打印出来。Python内置的 round() 函数可以完成四舍五入。为了输出更美观，我们可以使用 print() 函数的 sep 参数来控制输出分隔符。

total = round(total, 2)
print("The total bill is", total, sep=" ")

完整代码示例

将以上所有步骤组合起来，就得到了完整的程序。

# 获取用户输入
bill = float(input("How much is the meal? "))
tax = float(input("What is the sales tax as a percentage? "))
tip = float(input("How much of a tip as a percentage? "))

# 计算税额并加到账单上
tax_amount = bill * (tax / 100)
total = bill + tax_amount

# 计算小费并加到总账单上
tip_amount = total * (tip / 100)
total = total + tip_amount

# 格式化并输出最终结果
total = round(total, 2)
print("The total bill is", total, sep=" ")

运行示例

运行上述程序，并按照提示输入数据，程序将输出最终的总账单金额。

How much is the meal? 30
What is the sales tax as a percentage? 6
How much of a tip as a percentage? 18
The total bill is 37.52

总结

本节课中我们一起学习了如何构建一个实用的餐厅账单计算器。我们掌握了以下关键技能：

1. 使用 input() 获取用户输入，并用 float() 进行类型转换。
2. 按照“先税后小费”的顺序进行数学计算。
3. 使用 round() 函数对结果进行格式化。
4. 使用 print() 函数的 sep 参数控制输出格式。

这个练习涵盖了变量、输入输出、类型转换和基本算术运算，是巩固Python基础知识的绝佳示例。

037：条件语句 if-elif-else 🧠

在本节课中，我们将要学习Python中用于程序决策的核心工具——条件语句。通过if、elif和else，我们可以让程序根据不同的情况执行不同的代码块。

概述

条件语句允许我们基于逻辑判断来决定执行哪一部分代码。这是实现程序“智能”和交互性的基础。我们将从最简单的if语句开始，逐步扩展到更复杂的if-elif-else结构。

---

if 语句

if语句是最基本的条件判断结构。它检查一个条件是否为真，如果为真，则执行其下方缩进的代码块。

代码块通过缩进（通常是4个空格或一个制表符）来定义。

基本语法公式：

if condition:
    # 如果条件为真，则执行这里的语句

让我们看一个例子。首先，我们获取用户输入2+2的结果，并将其转换为整数。然后，我们判断这个值是否不等于4。

以下是具体步骤：

1. 获取用户输入并转换为整数。
2. 使用if语句判断该值是否不等于4。
3. 如果条件成立，则执行缩进的代码块，打印“try again”。

x = int(input(“2 + 2 = “))
if x != 4:
    print(“try again”)

---

if-else 语句

上一节我们介绍了if语句，它只在条件为真时执行代码。但很多时候，我们希望在条件为假时执行另一段代码。这时就需要用到if-else语句。

如果if的条件为真，则执行if代码块中的语句；否则（else），执行else代码块中的语句。

基本语法公式：

if condition:
    # 条件为真时执行的语句
else:
    # 条件为假时执行的语句

在下面的例子中，我们同样获取2+2的答案。如果答案等于4，我们打印“basic arithmetic holds”；否则，打印“try again”。

x = int(input(“2 + 2 = “))
if x == 4:
    print(“basic arithmetic holds”)
else:
    print(“try again”)

---

if-elif-else 语句

当我们需要在多个条件中进行选择时，if-elif-else结构就派上用场了。elif是“else if”的缩写，用于检查额外的条件。

程序会按顺序检查每个if和elif的条件。一旦某个条件为真，就执行对应的代码块，然后跳过整个结构的其余部分。如果所有if和elif的条件都为假，则执行else块。

基本语法公式：

if condition1:
    # 条件1为真时执行
elif condition2:
    # 条件2为真时执行
else:
    # 以上条件都不为真时执行

假设我们询问用户的年龄，并根据不同年龄段给出不同的回应。

以下是判断逻辑：

1. 如果年龄小于100岁，执行if块。
2. 如果年龄等于100岁，执行elif块。
3. 如果以上都不满足（即年龄大于100岁），执行else块。

age = int(input(“Please enter your age: “))
if age < 100:
    print(“You are young!”)
elif age == 100:
    print(“You are exactly one century old!”)
else:
    print(“You are wise beyond your years!”)

---

多个 elif 条件

你可以根据需要使用任意数量的elif条件来构建更精细的判断逻辑。程序会从上到下依次检查每个条件。

扩展语法公式：

if condition1:
    # 语句
elif condition2:
    # 语句
elif condition3:
    # 语句
# ... 可以有更多 elif
else:
    # 语句

让我们扩展年龄判断的例子，增加更多分类。

以下是更详细的年龄分类：

• 如果年龄为0岁，打印一条特殊消息。
• 如果年龄小于100岁，打印“You are young!”。
• 如果年龄等于100岁，打印“You are exactly one century old!”。
• 如果以上条件均不满足（年龄大于100岁），则执行else块。

age = int(input(“Please enter your age: “))
if age == 0:
    print(“Welcome to the world!”)
elif age < 100:
    print(“You are young!”)
elif age == 100:
    print(“You are exactly one century old!”)
else:
    print(“You are wise beyond your years!”)

---

总结

本节课中我们一起学习了Python条件语句的核心结构。

• if语句：用于执行单一条件判断。
• if-else语句：提供了条件为假时的备选执行路径。
• if-elif-else语句：允许我们在多个互斥的条件中进行选择，是构建复杂程序逻辑的基石。

记住，代码块的界定完全依赖于缩进，这是Python语法的一个重要特点。通过熟练运用这些条件语句，你已经可以让你的程序根据不同的输入做出不同的反应了。

038：代码练习-数字成绩转字母等级 📊

在本节课中，我们将编写一个程序，提示用户输入一个数字成绩，然后程序会根据成绩范围打印出对应的字母等级。

概述

我们将通过以下步骤完成这个练习：

1. 获取用户输入的数字成绩。
2. 将输入转换为整数。
3. 使用流程控制语句测试成绩的范围。
4. 根据范围打印出对应的字母等级。

例如，如果用户输入的成绩在90到100之间，程序将输出“A”。

编写程序

首先，我们需要创建一个变量来存储用户的成绩。

以下是实现该功能的核心代码步骤：

# 获取用户输入
grade = input("Enter your grade: ")

# 将输入转换为整数
grade = int(grade)

# 测试成绩范围并打印字母等级
if grade >= 90:
    print("A")
elif grade >= 80:
    print("B")
elif grade >= 70:
    print("C")
elif grade >= 60:
    print("D")
else:
    print("F")

代码逻辑详解

上一节我们介绍了代码的整体结构，本节中我们来看看每一部分的具体作用。

1. 获取输入：使用 input() 函数提示用户输入，并将结果存储在变量 grade 中。
2. 类型转换：使用 int() 函数将字符串类型的输入转换为整数类型，以便进行数值比较。
3. 条件判断：使用 if-elif-else 语句链来检查成绩所处的范围。
   • 第一个条件 if grade >= 90: 检查成绩是否大于等于90。如果是，则打印“A”。
   • 如果第一个条件不满足，程序会检查下一个 elif 条件 grade >= 80:，依此类推。
   • 如果所有 if 和 elif 条件都不满足，则执行 else: 分支，打印“F”。

运行示例

让我们运行一下代码，看看它的实际效果。

• 当输入 91 时，输出为 A。
• 当输入 65 时，输出为 D。
• 当输入 59 时，输出为 F。

程序能够正确地将数值成绩映射到对应的字母等级。

总结

本节课中我们一起学习了如何编写一个将数字成绩转换为字母等级的程序。我们实践了从用户获取输入、进行类型转换以及使用 if-elif-else 流程控制语句进行多条件判断的核心编程概念。这个练习巩固了如何根据不同的条件执行不同的代码分支。

039：多重条件判断 📊

在本节课中，我们将要学习如何在程序中设置多个独立的if条件判断语句。我们将通过一个具体的例子，演示如何依次检查用户输入的数字是否满足一系列条件，并理解每个条件是如何被独立测试的。

概述

我们可以使用多个if条件语句，这意味着每个条件都会被单独测试。首先，程序会要求用户输入一个整数。在编程中，一个良好的实践是在将字符串转换为整数之前，先确认输入是否为数字。为此，我们可以使用字符串的.isnumeric()方法。

检查输入是否为数字

在将用户输入转换为整数之前，我们需要验证输入是否由纯数字字符组成。以下是实现此功能的代码：

user_input = input("请输入一个整数：")
if user_input.isnumeric():
    number = int(user_input)
    # 后续的条件判断将在这里进行
else:
    print("输入无效，请输入一个数字。")

.isnumeric()方法会检查字符串中的所有字符是否都是数字字符。如果是，则返回True，我们便可以安全地将其转换为int类型。

执行多重条件判断

在确认输入是数字并完成类型转换后，我们可以运行一系列独立的if条件测试。每个条件都会按顺序被评估。

以下是多个独立if语句的示例：

if number > 20:
    print(f"数字大于20: {number}")

![](https://github.com/OpenDocCN/cs-notes-zh/raw/master/docs/upenn-py-java-intro/img/a0bdadb1d76870811c20a62f9d276b5f_6.png)

if number > 10:
    print(f"数字大于10: {number}")

if number > 0:
    print(f"数字大于0: {number}")

请注意，这些条件是独立的。一个数字如果大于20，它同样也会满足大于10和大于0的条件，因此所有相关的打印语句都会执行。

处理非数字输入

如果用户的输入未能通过最初的.isnumeric()测试，程序将跳转到else分支，并打印一条友好的错误信息。

else:
    print("抱歉，您输入的不是一个有效的正整数。")

重要注意事项

需要特别注意的是，.isnumeric()方法仅对正整数有效。它无法识别负号（“-”）或小数点（“.”），因此不能用于检查负数或浮点数。

总结

本节课中我们一起学习了多重条件判断。我们了解了如何使用多个独立的if语句来依次测试不同条件，并掌握了在类型转换前使用.isnumeric()方法验证用户输入是否为数字的良好实践。记住，每个if语句都是独立执行的，并且.isnumeric()仅适用于检查正整数。

Python和Java编程入门1-2：040_01_01：验证用户输入 🔍

在本节课中，我们将要学习如何在Python程序中验证用户的输入，特别是如何安全地将用户输入的字符串转换为整数，并优雅地处理可能出现的错误。

---

上一节我们讨论了直接转换用户输入可能带来的问题。本节中我们来看看如何使用 try...except 结构来更稳健地处理输入验证。

如果不检查输入是否为数字就直接尝试进行类型转换，例如，如果用户的输入是字符串 "22"，尝试将其转换为整数 int 时，程序会正常运行。但如果输入是类似 "hello" 这样的非数字字符串，直接转换就会导致程序出错并抛出异常。

但我们可以捕获这类错误。以下是一种在转换前检查输入是否为整数的更好方法。

首先，我们获取用户输入，并尝试在一个 try 代码块中将其转换为整数。如果在此过程中发生错误，即该值无法被转换为整数，我们将捕获引发的异常。

我们通过编写一个 except 代码块来实现这一点，并将特定的错误信息存储在一个变量（例如 e）中。

然后，我们可以打印一条友好的提示信息，或者访问并打印出具体的错误信息。😡

反之，如果没有发生错误，则意味着输入已成功转换为整数，此时我们打印出该值本身。

以下是我们重构后的原始代码，它要求用户输入一个整数来进行求值。😡

请注意，else 子句是可选的，在此处并非必需，因此我们将其省略。

---

本节课中我们一起学习了如何使用 try...except 语句来验证用户输入，从而避免因无效输入导致的程序崩溃。这种方法使得程序更加健壮和用户友好。

041：常见Python错误解析与处理 🐍

在本节课中，我们将学习Python编程中几种常见的错误类型，理解它们的含义，并掌握如何诊断和修复这些错误。我们将通过具体的代码示例来演示错误的发生场景以及正确的解决方法。

---

变量名大小写错误

首先，我们来看一个由变量名大小写不一致引发的错误。

A = 2
print(a)

运行这段代码会得到一个 NameError，提示 name 'a' is not defined。错误发生在第2行。这是因为我们定义变量时使用的是大写字母 A，但在打印时却试图访问小写字母 a。Python是区分大小写的语言，A 和 a 被视为两个不同的变量。

解决方法：确保变量名在定义和使用时保持大小写一致。将打印语句改为 print(A) 即可修复。

---

函数名大小写错误

接下来，我们看看调用内置函数时，因大小写错误导致的问题。

B = 3
Print(B)

运行这段代码会得到另一个 NameError，提示 name 'Print' is not defined。错误发生在第2行。这是因为Python的内置函数 print 必须全部小写，我们错误地将其首字母大写了。

解决方法：将函数调用更正为小写的 print(B)。

---

类型错误：字符串与数字比较

在处理用户输入时，一个常见的错误是忘记进行类型转换。用户输入默认是字符串类型。

age = input("Enter your age: ")
print("Are you older than 26?")
print(age > 26)

运行代码并输入 25 后，会得到一个 TypeError，提示 '>' not supported between instances of 'str' and 'int'。这是因为我们不能直接用字符串 "25" 和整数 26 进行比较。

解决方法：在比较之前，使用 int() 函数将字符串转换为整数。

age = int(input("Enter your age: "))
print("Are you older than 26?")
print(age > 26)

---

类型错误：字符串与数字运算

类似的类型错误也会发生在算术运算中。

age = input("Enter your age again: ")
print("How old will you be in one year?")
print(age + 1)

运行代码并输入 25 后，会得到 TypeError，提示 can only concatenate str (not "int") to str。这是因为 + 运算符对字符串是连接操作，不能直接将字符串 "25" 和整数 1 相加。

解决方法：同样，需要先将字符串转换为整数再进行计算。

age = int(input("Enter your age again: "))
print("How old will you be in one year?")
print(age + 1)

---

处理无效输入：ValueError

然而，直接转换用户输入存在风险。如果用户输入的不是有效的数字（例如输入了单词 "twenty-five"），int() 函数会抛出一个 ValueError。

以下是处理这种情况的方法，使用 try...except 语句来捕获并优雅地处理错误。

try:
    age = int(input("Enter your age again: "))
    print("How old will you be in one year?")
    print(age + 1)
except ValueError:
    print("The given age is not valid.")

代码解释：

• try: 块中包含可能引发错误的代码。
• except ValueError: 块专门用于捕获 ValueError 类型的异常。
• 如果用户输入无法转换为整数，程序不会崩溃，而是执行 except 块中的代码，打印出友好的错误提示信息。

---

总结

本节课中，我们一起学习了Python编程中几种典型的错误及其处理方法：

1. NameError：通常由未定义的变量名或错误大小写的函数名引起。解决方法是检查拼写和大小写。
2. TypeError：在尝试对不兼容的数据类型进行操作时发生，例如字符串与数字比较或运算。解决方法是使用 int()、float() 或 str() 等函数进行正确的类型转换。
3. ValueError：当函数接收到类型正确但值不合理的参数时引发，例如 int("abc")。解决方法是使用 try...except 语句来捕获异常并提供备用处理逻辑。

理解这些错误并学会如何调试，是成为一名熟练Python程序员的重要一步。记住，遇到错误时，仔细阅读错误信息，它通常会明确指出问题所在的行和原因。

Python与Java编程入门：1-2：编程演示 - 创建成绩转换函数 🎯

在本节课中，我们将学习如何将一个简单的成绩转换程序重构为使用用户自定义函数。我们将从一段接收用户输入并打印对应字母成绩的代码开始，逐步将其转换为更模块化、可重用的函数形式。

---

上一节我们回顾了基础的成绩转换逻辑。本节中，我们来看看如何将这些代码封装到一个用户自定义函数中。

首先，我们有一段原始代码。这段代码的功能是：提示用户输入一个数字成绩，将其转换为整数，然后根据数值范围打印出对应的字母成绩。

以下是原始代码的逻辑步骤：

1. 获取用户的数字成绩输入。
2. 将输入值转换为整数。
3. 测试数字的范围并打印相应的字母成绩。

现在，我们将所有这些代码放入一个用户自定义函数中。

def numeric_to_letter_grade():
    grade = input("Enter a numeric grade: ")
    grade = int(grade)

    if grade >= 90:
        print("A")
    elif grade >= 80:
        print("B")
    elif grade >= 70:
        print("C")
    elif grade >= 60:
        print("D")
    else:
        print("F")

定义好函数后，我们可以通过调用它来运行函数体内的所有代码。

numeric_to_letter_grade()

运行这段代码，输入 87，程序会输出 B。这里，我们调用了上面定义的 numeric_to_letter_grade 函数，它执行了函数体内的所有逻辑。

---

上面我们创建了一个无参数的函数。另一种更灵活的方法是定义一个带有参数的函数。

让我们修改函数，使其接受一个名为 grade 的参数，并移除函数内部获取用户输入的代码。

def numeric_to_letter_grade(grade):
    if grade >= 90:
        print("A")
    elif grade >= 80:
        print("B")
    elif grade >= 70:
        print("C")
    elif grade >= 60:
        print("D")
    else:
        print("F")

现在，我们可以向函数传递一个具体的数值来转换为字母成绩。例如，我们可以这样传递数值 87：

numeric_to_letter_grade(87)

运行这个函数调用，会得到输出 B。

我们也可以结合用户输入来使用这个函数。以下是具体做法：

# 获取用户输入
user_grade = input("Enter a numeric grade: ")
user_grade = int(user_grade)

# 将输入值作为参数传递给函数
numeric_to_letter_grade(user_grade)

再次运行代码，输入 92，程序会输出 A。在这个过程中，我们获取用户输入，将其转换为整数，然后将这个值作为参数传递给函数。函数执行时，会接收这个给定的参数，并运行函数体内的代码进行判断和输出。

---

本节课中我们一起学习了如何将过程式代码重构为函数式代码。我们首先创建了一个无参数函数来封装整个流程，然后将其改进为带参数的函数，使逻辑更清晰且更具复用性。通过定义函数，我们可以将特定功能的代码块模块化，便于多次调用和代码管理。

043：模块介绍

在本节课中，我们将要学习Python编程中的一个重要模块。我们将从列表这一基础数据结构开始，然后探讨如何使用循环来重复执行代码，最后学习如何创建和使用函数来组织代码。我们还将了解如何为代码编写文档，以便于他人理解和使用。

列表简介

我们将以Python中最常用的数据结构之一——列表的简要介绍来开启本模块。

列表是一种有序的集合，可以存放任意类型的元素。在Python中，列表用方括号 [] 表示，元素之间用逗号分隔。

以下是列表的一个基本示例：

my_list = [1, 2, 3, 'hello', True]

循环入门

上一节我们介绍了列表，本节中我们来看看如何使用循环来重复执行某个过程或多次运行一段代码。

循环是编程中用于重复执行代码块的结构。Python中主要有两种循环：for 循环和 while 循环。for 循环通常用于遍历序列（如列表），而 while 循环则在条件为真时重复执行代码块。

以下是 for 循环遍历列表的一个简单示例：

for item in my_list:
    print(item)

函数详解

在掌握了循环之后，我们将深入探讨函数。函数是用于执行单一相关操作的有组织代码块。

Python提供了许多内置函数，如 print() 和 len()。我们也可以创建自己的用户定义函数，作为程序中的构建模块。

定义一个函数的基本语法如下：

def function_name(parameters):
    # 函数体
    return result

代码文档最佳实践

最后，我们将学习为代码编写文档的最佳实践。好的文档服务于两类受众：使用我们代码并希望从高层次理解它的用户，以及阅读代码并想知道其工作原理的程序员。

以下是编写文档时需要考虑的几个要点：

• 用户文档：解释函数或模块的用途、输入参数和返回值。
• 代码注释：在代码内部解释复杂的逻辑或算法。
• 文档字符串：使用三引号在函数定义下方编写详细的说明。

本节课中我们一起学习了Python编程的基础模块：列表的创建与使用、利用循环进行迭代操作、如何定义和调用函数来组织代码，以及编写清晰文档的重要性。掌握这些概念是构建更复杂程序的重要基石。

044：创建列表 📝

在本节课中，我们将要学习Python中一种非常重要的数据结构——列表。我们将了解列表是什么，它的核心特性，以及如何创建和访问列表中的元素。

---

什么是列表？ 🤔

列表是Python中的一种数据结构。列表是最常用的序列类型。

列表是可变的，这意味着一旦列表被定义，其中的单个元素可以被更改。

---

如何创建列表？ 🛠️

上一节我们介绍了列表的基本概念，本节中我们来看看如何创建一个列表。

要创建一个列表，需要在方括号 [] 内指定用逗号分隔的值。

创建列表的通用语法如下：

my_list = [value1, value2, value3, ...]

以下是创建列表时需要注意的几个要点：

• 列表中可以包含不同类型的值。
• 列表中的每个项目都被分配一个索引值，索引从 0 开始。

---

总结 📚

本节课中我们一起学习了Python列表的基础知识。我们了解到列表是一种可变且常用的序列数据结构。我们学会了使用方括号和逗号来创建列表，并知道了列表可以包含混合类型的数据，其元素通过从0开始的索引进行访问。掌握列表的创建是使用Python进行数据组织和处理的第一步。

045：更新列表 📝

在本节课中，我们将要学习如何创建Python列表，以及如何访问、修改和检查列表中的元素。列表是Python中一种非常基础且强大的数据结构，用于存储一系列有序的元素。

创建与查看列表

首先，我们可以创建一个包含若干随机元素的列表，并将其存储在一个变量中。

list1 = [1, 2, 3, 4]

我们可以打印这个列表来查看其内容。同时，我们可以使用Python内置的 len() 函数来获取并打印列表的长度。

print(list1)
print(len(list1))

len(list1) 返回的是列表的长度，即列表中包含的元素个数。

访问列表元素

我们可以获取列表中的特定元素。例如，通过使用方括号 [] 和索引 1，我们可以获取并打印列表中的第二个元素。

print(list1[1])

需要记住的是，列表元素的索引从 0 开始。因此，索引 1 对应的是列表中的第二个元素。

如果我们尝试获取列表中不存在的元素，例如第五个元素，Python会报错。

print(list1[4])  # 这将导致错误

由于我们的列表 list1 总共只有四个元素，索引 4 指向的第五个元素并不存在。在这种情况下，Python会抛出一个“列表索引超出范围”的错误。

修改列表内容

上一节我们介绍了如何访问列表元素，本节中我们来看看如何修改列表。你可以使用 append() 方法向列表末尾添加新元素，或者使用 pop() 方法从列表中移除元素。

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

list1.append(5)

如果使用 pop() 方法时不提供索引参数，它将移除列表中的最后一个元素。

list1.pop()

如果使用 pop() 方法时提供了索引参数，它将移除该特定索引位置上的元素。例如，以下代码会移除列表中的第二个元素（索引为1）。

list1.pop(1)

检查元素是否存在

最后，我们可以检查某个特定元素是否存在于列表中。以下是检查元素是否存在的方法：

print(3 in list1)

本节课中我们一起学习了Python列表的基本操作：包括创建列表、获取列表长度、通过索引访问元素、向列表添加元素、从列表中移除元素，以及检查某个元素是否在列表中。掌握这些操作是使用Python进行数据处理的基础。

046：循环类型 🔄

在本节课中，我们将要学习编程中一个非常基础且强大的概念——循环。循环允许我们重复执行一段代码，从而高效地处理重复性任务。我们将重点介绍两种主要的循环类型：for循环和while循环，并理解它们各自的工作原理和适用场景。

什么是循环？ 🔁

循环用于重复一个过程、一段代码块，或者多次执行某个操作。通过使用循环，我们可以避免编写大量重复的代码，使程序更加简洁和高效。

循环的两种主要类型

上一节我们介绍了循环的基本概念，本节中我们来看看两种具体的循环类型。理解它们的区别是掌握循环的关键。

以下是两种主要的循环类型：

• for循环：这种循环会运行一段代码指定的次数。它通常在我们提前知道需要重复多少次时使用。
• while循环：这种循环会持续地运行一段代码，只要某个条件被满足。它通常在我们不确定需要重复多少次，但知道何时应该停止时使用。

for循环详解

for循环的核心思想是“遍历”。它常用于遍历一个序列（如列表、字符串）或执行固定次数的操作。

在Python中，for循环的基本语法如下：

for 变量 in 序列:
    # 要重复执行的代码块

例如，遍历一个数字列表并打印每个数字：

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

这段代码会依次将列表中的每个数字赋值给变量number，然后执行print(number)，总共执行5次。

while循环详解

while循环的核心是“条件”。只要条件为真，循环体内的代码就会一直执行。

在Python中，while循环的基本语法如下：

while 条件:
    # 要重复执行的代码块

例如，当计数器小于5时，持续打印并增加计数器的值：

count = 0
while count < 5:
    print(count)
    count = count + 1

这段代码会先检查count < 5是否为真。如果为真，则执行打印和增加count的操作，然后再次检查条件，直到count不再小于5为止。

总结

本节课中我们一起学习了编程中的循环结构。我们了解到，循环用于重复执行代码。我们重点探讨了两种循环：for循环用于执行指定次数的重复，而while循环则在满足条件时持续重复。理解何时使用for循环，何时使用while循环，是编写高效、清晰代码的重要一步。

047：指定次数执行代码 🔄

在本节课中，我们将要学习如何使用 for 循环来让一段代码执行指定的次数。这是编程中实现重复任务的基础方法。

使用列表进行迭代

上一节我们介绍了循环的概念，本节中我们来看看如何具体使用 for 循环。一种常见的方法是迭代一个列表。

以下是一个定义数字列表并存储到变量中的例子：

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

for 循环的结构

for 语句表明我们正在遍历列表，或者说，会依次处理列表中的每一个元素。

代码的逻辑可以理解为：对于列表中的每一个项目，执行缩进代码块中的操作。

以下是 for 循环的基本语法结构：

for item in list:
    # 执行的操作

循环体与迭代变量

在这个例子中，我们执行的操作是打印出当前的项目本身。

在 for 语句中，我们使用 number 来指代列表中的每一个项目，这被称为迭代变量或哑变量。

这是一种指代我们当前正在处理的列表元素的方式。需要注意的是，这个迭代变量的名称可以是任何有效的标识符，例如 nu 或 n。

for nu in numbers:
    print(nu)

循环的执行过程

这个循环会遍历整个列表，并运行其内部的代码块10次（因为列表有10个元素）。如果我们运行这段代码，将会看到它依次打印出列表中的每一个数字。

本节课中我们一起学习了如何使用 for 循环遍历列表来执行指定次数的代码。我们了解了循环的基本结构、迭代变量的作用，以及如何通过遍历列表元素来控制代码的执行次数。这是自动化重复任务的第一步。

048：遍历列表

在本节课中，我们将要学习如何遍历列表，并在此过程中筛选出特定的元素（例如偶数），同时学习如何统计筛选出的元素数量。

遍历列表与筛选元素

上一节我们介绍了列表的基本概念。本节中我们来看看如何遍历列表中的所有元素，并对它们进行条件判断。

我们可以遍历同一个列表，并找出其中的偶数。首先，定义一个包含数字的列表。

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

列表中的每一项都是一个数字。以下代码展示了如何遍历这个列表：

for number in numbers:
    print(number)

如果只想找出其中的偶数，我们需要创建一个新的列表来存储它们。

even_numbers = []  # 定义一个空列表来存储偶数

以下是筛选偶数的逻辑：在遍历原始列表时，测试每个数字是否为偶数。如果是，则将其添加到 even_numbers 列表中。

判断一个数是否为偶数的条件是：该数除以2的余数为0。在Python中，可以使用取模运算符 % 来实现。

for number in numbers:
    if number % 2 == 0:          # 检查数字是否为偶数
        even_numbers.append(number) # 如果是偶数，则添加到列表中

最后，打印出偶数列表。

print(even_numbers)

运行上述代码，输出结果为：[2, 4, 6, 8, 10]。

统计元素数量

除了筛选，我们常常还需要知道筛选出的元素有多少个。有两种方法可以实现。

方法一：使用计数器变量
在遍历和筛选的同时，递增一个计数器。

even_count = 0  # 初始化偶数计数器
even_numbers = []

![](https://github.com/OpenDocCN/cs-notes-zh/raw/master/docs/upenn-py-java-intro/img/547b82bf0866d34b0a9197702411f6eb_10.png)

for number in numbers:
    if number % 2 == 0:
        even_numbers.append(number)
        even_count += 1  # 计数器加一

![](https://github.com/OpenDocCN/cs-notes-zh/raw/master/docs/upenn-py-java-intro/img/547b82bf0866d34b0a9197702411f6eb_12.png)

print(even_numbers)
print(f"There are {even_count} numbers in the even list.")

运行代码，会先输出偶数列表，然后输出：There are 5 numbers in the even list.。

方法二：使用 len() 函数
更简单的方法是直接使用Python内置的 len() 函数来获取列表的长度。

even_numbers = [number for number in numbers if number % 2 == 0] # 列表推导式，后续课程会详细讲解
print(even_numbers)
print(f"There are {len(even_numbers)} numbers in the even list.")

这段代码同样会输出偶数列表和数量：There are 5 numbers in the even list.。

---

本节课中我们一起学习了如何遍历列表、使用条件语句筛选元素（如偶数），以及使用两种方法统计筛选出的元素数量。这些是处理列表数据的基础且重要的操作。

049：代码练习-查找最小值 📝

在本节课中，我们将学习如何编写代码来查找一组数字中的最小值。我们将不使用Python内置的min函数，而是通过手动遍历列表并比较数值来实现这一功能。

概述

我们将从一个包含多个数字的列表开始，通过遍历列表中的每个元素，并与一个初始设定的“最小值”进行比较，从而找出列表中的实际最小值。这个过程将帮助我们理解循环和条件判断在编程中的基本应用。

定义数字列表

首先，我们需要定义一个包含数字的列表。我们将使用以下数值：5, 3, 8, -1, -2, 2, 0。

numbers = [5, 3, 8, -1, -2, 2, 0]

初始化最小值变量

在开始遍历列表之前，我们需要一个变量来记录当前找到的最小值。一个常见的做法是先将列表的第一个元素设为初始最小值。

min_number = numbers[0]

这里，我们将min_number初始化为列表的第一个元素，即数字5。

遍历列表并查找最小值

接下来，我们将遍历列表中的每一个数字。对于列表中的每个元素，我们都会检查它是否小于当前记录的min_number。如果是，我们就更新min_number为这个更小的值。

以下是遍历和比较的逻辑：

for number in numbers:
    if number < min_number:
        min_number = number

在这段代码中，for循环会依次将numbers列表中的每个值赋给变量number。然后，if语句会判断当前的number是否小于min_number。如果条件为真，min_number的值就会被更新为当前的number。

打印最终结果

在完成整个列表的遍历后，min_number变量中存储的就是列表中的最小值。最后，我们将其打印出来。

print(min_number)

运行上述完整代码，输出结果将是-2，因为它是列表[5, 3, 8, -1, -2, 2, 0]中最小的数字。

总结

本节课中，我们一起学习了如何在不使用内置函数的情况下，通过编写代码来查找列表中的最小值。我们首先定义了一个数字列表，然后初始化了一个变量来跟踪最小值。接着，我们使用for循环遍历列表，并通过if条件语句比较和更新最小值。最后，我们打印出了找到的最小值。这个过程清晰地展示了循环和条件判断这两个基础编程概念的实际应用。

050：遍历字符串列表 🌟

在本节课中，我们将学习如何使用Python的for循环来遍历一个字符串列表，并根据条件执行不同的操作。我们将通过一个具体的例子来演示这个过程。

概述

我们将创建一个包含多个行星名称的列表，然后遍历这个列表。在遍历过程中，我们会检查每个元素，并根据其值打印出不同的信息。这有助于我们理解如何在实际编程中处理列表和条件判断。

教程内容

首先，我们定义一个名为planets的列表，其中包含几个字符串元素："Sun"、"Mercury"、"Venus"、"Earth"和"Mars"。

planets = ["Sun", "Mercury", "Venus", "Earth", "Mars"]

接下来，我们使用for循环来遍历这个列表。对于列表中的每一个元素（我们称之为planet），我们将执行一系列的条件判断。

以下是循环和条件判断的代码结构：

for planet in planets:
    if planet == "Sun":
        print(planet, "is not a planet")
    else:
        print(planet, "is a planet")
    if planet == "Mercury":
        print(planet, "is closest to the sun")

在上面的代码中，我们首先检查当前planet是否等于"Sun"。如果是，我们打印一条信息表明它不是行星；否则，我们打印一条信息表明它是行星。此外，如果当前planet是"Mercury"，我们还会额外打印一条信息，说明它是最靠近太阳的行星。

执行结果

当运行上述代码时，控制台将输出以下结果：

Sun is not a planet
Mercury is a planet
Mercury is closest to the sun
Venus is a planet
Earth is a planet
Mars is a planet

从输出中可以看到，程序正确地识别了太阳不是行星，而其他元素都是行星，并且特别指出了水星是最靠近太阳的行星。

总结

在本节课中，我们一起学习了如何使用for循环遍历字符串列表，并结合if-else条件语句根据元素值执行不同的操作。通过这个例子，我们掌握了列表遍历和条件判断的基本用法，这是Python编程中非常基础和重要的技能。

051：字符串迭代 🔄

在本节课中，我们将学习如何遍历字符串。字符串是由字符组成的序列，我们可以像遍历列表一样，逐个访问其中的每个字符。

---

上一节我们介绍了循环的基本概念，本节中我们来看看如何将循环应用于字符串。

遍历字符串

我们可以直接对字符串本身进行迭代。这意味着我们可以使用 for 循环来逐个访问字符串中的每一个字符。

以下是具体步骤：

1. 首先，定义一个字符串变量。
2. 然后，使用 for 循环遍历这个字符串变量。
3. 在循环体内，处理或打印每一个字符。

让我们通过一个例子来理解这个过程。

示例：拼写单词

我们定义一个变量 month，并将其赋值为 "February"。

month = "February"

首先，我们打印月份本身，并加上提示语 “is spelled”。

print(month, "is spelled")

接下来，我们遍历 month 字符串。在每次循环中，变量 x 会依次代表字符串中的一个字符。

for x in month:
    print(x)

运行这段代码，输出结果如下：

February is spelled
F
e
b
r
u
a
r
y

程序首先打印了 “February is spelled”，然后依次打印了月份中的每个字符，每个字符独占一行。

在同一行打印字符

如果我们希望所有字符打印在同一行，并以空格分隔，可以修改 print 函数的 end 参数。默认情况下，print 函数会在输出末尾添加换行符。我们可以将其改为一个空格。

for x in month:
    print(x, end=' ')

再次运行代码，输出变为：

February is spelled F e b r u a r y

现在，所有的字符都打印在了同一行，并且用空格分隔开来。

---

本节课中我们一起学习了字符串的迭代。我们了解到，字符串是可迭代对象，可以使用 for 循环轻松访问其中的每一个字符。通过控制 print 函数的 end 参数，我们可以灵活地控制输出的格式，例如将所有字符打印在同一行。这是处理文本数据的一项基础且重要的技能。

052：代码练习-遍历姓名 ✍️

在本节课中，我们将通过一个简单的代码练习来学习如何使用 for 循环遍历字符串，并在这个过程中统计字符串的长度。我们将编写一个程序，提示用户输入他们的名字，然后逐个字母地打印出来，并最终统计名字中的字母总数。

概述

我们将创建一个程序，其核心功能包括：

1. 获取用户输入的名字。
2. 使用 for 循环遍历名字中的每个字母。
3. 在遍历过程中打印每个字母并统计字母总数。
4. 最后输出统计结果。

分步教程

第一步：获取用户输入

首先，我们需要从用户那里获取他们的名字。我们将使用 Python 的 input() 函数来实现这一点，并将用户输入的值存储在一个变量中。

以下是获取用户输入的代码：

name = input("What is your first name? ")

这段代码会在屏幕上显示提示信息 “What is your first name?”，并等待用户输入。用户输入的内容将被赋值给变量 name。

第二步：初始化计数器

为了统计名字中的字母数量，我们需要一个计数器变量。在开始遍历之前，我们将这个计数器初始化为 0。

初始化计数器的代码如下：

letter_count = 0

变量 letter_count 将用于记录我们遍历到的字母数量。

第三步：打印初始信息并开始遍历

在开始遍历之前，我们先打印一条消息，告知用户程序即将开始拼写他们的名字。

接着，我们使用 for 循环来遍历名字 name 中的每一个字符。在循环中，变量 x 会依次代表名字中的每一个字母。

以下是打印初始信息和 for 循环的代码：

print(name, "is spelled:")
for x in name:

现在，我们已经准备好了循环结构。在下一节中，我们将看看在循环内部需要执行哪些操作。

第四步：循环内的操作

在 for 循环内部，我们需要完成三件事：

1. 打印当前字母 x。
2. 在打印的字母后面添加一个空格，使输出更清晰。
3. 将计数器 letter_count 的值增加 1，以记录这个字母。

以下是循环体内的代码：

    print(x, end=" ")
    letter_count += 1

这里，print(x, end=" ") 中的 end=" " 参数确保每个字母打印在同一行，并用空格分隔。letter_count += 1 是 letter_count = letter_count + 1 的简写，用于递增计数器。

第五步：输出最终结果

当 for 循环遍历完名字中的所有字母后，我们会退出循环。此时，我们需要输出最终的统计结果。

首先，我们打印一个空行，让输出更美观。然后，我们打印出统计到的字母总数以及用户的名字。

以下是输出最终结果的代码：

print()
print("That is", letter_count, "letters in the name", name)

print() 会输出一个空行。第二行 print 语句将计数器 letter_count 的值和变量 name 的值一起输出，形成完整的句子。

完整代码与运行示例

将以上所有步骤组合起来，就得到了完整的程序代码：

name = input("What is your first name? ")
letter_count = 0

print(name, "is spelled:")
for x in name:
    print(x, end=" ")
    letter_count += 1

print()
print("That is", letter_count, "letters in the name", name)

当你运行这段代码时，程序会与你进行如下交互（假设用户输入的名字是 “Brandon”）：

What is your first name? Brandon
Brandon is spelled:
B r a n d o n
That is 7 letters in the name Brandon

总结

在本节课中，我们一起学习并完成了一个 Python 编程练习。我们掌握了如何使用 for 循环来遍历字符串中的每一个字符，并在循环过程中进行打印和计数操作。关键步骤包括：使用 input() 获取输入，初始化变量，利用 for x in name: 进行遍历，在循环体内处理每个字符，最后格式化输出结果。这个练习巩固了循环和字符串处理的基本概念。

053：使用range函数的for循环 🚀

在本节课中，我们将要学习如何使用Python中的range函数来创建for循环。range函数可以生成一个数字序列，它常被用来替代列表，以便重复执行某段代码特定次数。

概述

上一节我们介绍了使用列表进行for循环迭代。本节中我们来看看如何使用range函数来实现类似的功能。range函数的基本格式如下：

range(start, stop, step)

其中：

• start 是序列的起始值（可选，默认为0）。
• stop 是序列的结束值（不包含该值本身）。
• step 是步长，即每次递增的值（可选，默认为1）。

需要注意的是，range函数的参数必须是整数，不能是浮点数。

基础用法示例

以下是range函数在不同参数下的几种基础用法。

示例1：默认起始值

当只提供一个参数时，它被视为stop值。循环将从0开始，到stop-1结束。

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

这段代码会打印数字0到9。

示例2：指定起始值

我们可以同时指定start和stop值。

for x in range(0, 10):
    print(x)

这段代码同样会打印数字0到9。

示例3：生成特定范围的序列

通过调整start和stop值，我们可以生成任意整数区间。

for x in range(1, 7):
    print(x)

这段代码会打印数字1到6。

示例4：使用步长（step）

step参数允许我们控制序列中数字的间隔。

for x in range(0, 30, 7):
    print(x)

这段代码会打印：0, 7, 14, 21, 28。它以7为步长，从0递增到30（不包含30）。

示例5：反向迭代

通过设置负的step值，我们可以实现反向迭代。

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

这段代码会倒序打印数字5到0：5, 4, 3, 2, 1, 0。

实际应用：筛选奇数

现在，让我们结合条件判断，利用range函数解决一个实际问题：找出1到1200之间的所有奇数。

以下是实现此功能的步骤：

1. 创建一个空列表odd_numbers用于存储结果。
2. 使用range(1, 1201)生成1到1200的数字序列。
3. 在循环中，使用取模运算符%判断每个数字是否为奇数（即number % 2 != 0）。
4. 如果是奇数，则使用append()方法将其添加到列表中。
5. 循环结束后，打印整个列表。

odd_numbers = []
for number in range(1, 1201):
    if number % 2 != 0:
        odd_numbers.append(number)
print(odd_numbers)

运行这段代码，你将得到一个包含1到1200之间所有奇数的列表。

总结

本节课中我们一起学习了range函数在for循环中的强大用途。我们掌握了其三种参数（start, stop, step）的用法，并通过多个示例演示了如何生成正向、反向以及带有特定步长的数字序列。最后，我们通过一个筛选奇数的实例，将range循环与条件判断结合起来，解决了实际问题。range函数是控制循环次数和生成数字序列的利器，在后续编程中会经常用到。

054：基于条件重复执行代码 🔄

在本节课中，我们将要学习一种重要的编程结构——while循环。它允许我们基于一个条件来重复执行一段代码。理解while循环的工作原理对于编写动态和灵活的程序至关重要。

什么是while循环？

while循环是一种控制流语句，它会重复执行其内部的代码块，只要指定的条件为真。

其基本语法结构可以用以下伪代码表示：

while (条件为真) {
    // 要重复执行的代码块
}

上一节我们介绍了循环的基本概念，本节中我们来看看while循环的具体工作机制和注意事项。

循环条件与潜在风险

while循环的执行完全依赖于其条件。如果条件始终为真，循环将永远不会停止，这被称为无限循环。

以下是使用while循环时必须注意的关键点：

• 如果循环条件永远无法被满足（即始终为真），循环将变成无限循环。
• 无限循环会导致程序无法继续执行后续代码，并可能最终导致程序崩溃。

因此，在设计while循环时，确保循环条件最终能变为假至关重要。

while循环示例：递减计数

让我们通过一个简单的例子来理解while循环。下面的代码会打印变量 a 的值，直到它变为0。

a = 5
while a > 0:
    print(a)
    a = a - 1

在这个例子中：

1. 我们首先将变量 a 初始化为 5。
2. 只要 a 大于零，while 循环后的代码块就会执行。
3. 每次执行代码块时，我们都会打印 a 的当前值，然后将 a 的值减1。
4. 当 a 不再大于零时，程序会退出while循环。

执行上述代码，输出结果将是：

5
4
3
2
1

while循环示例：倍增数值

现在，我们来看另一个例子。这个程序从数字4开始，不断将变量 x 乘以2，直到达到上限128。

x = 4
while x < 128:
    x = x * 2
    print(x)

在这个例子中：

1. 我们首先将变量 x 初始化为 4。
2. 只要 x 小于128，while 循环后的代码块就会执行。
3. 每次执行代码块时，我们先将 x 乘以2，然后打印 x 的当前值。
4. 当 x 不再小于128时，程序会退出while循环。

执行上述代码，输出结果将是：

8
16
32
64
128

请注意，循环在打印出128后停止，因为此时 x < 128 的条件已不再为真。

总结

本节课中我们一起学习了 while循环 的核心概念。我们了解到while循环用于基于条件重复执行代码，其关键在于循环条件必须在某次迭代后变为假，以避免程序陷入无限循环。我们通过递减计数和倍增数值两个实例，具体分析了while循环从初始条件判断、执行循环体到更新变量、再次判断条件的完整执行流程。掌握while循环是控制程序逻辑的重要一步。

055：等待用户输入 🎯

在本节课中，我们将学习如何使用 while 循环来创建一个持续运行的程序，直到接收到特定的用户输入为止。这是一种常见的交互式编程模式。

---

使用 while 循环等待特定输入

上一节我们介绍了 while 循环的基本结构。本节中我们来看看它的一个典型应用场景：等待用户输入特定内容。

while 循环的一个常见用途是编写需要持续运行并等待某些事件发生的程序，例如，等待特定的用户输入。

以下是一个程序示例，它会一直运行，直到用户输入单词 “Hello”。

# 首先，获取用户输入并将其存储在变量 inp 中
inp = input("Please enter something: ")

# 当 inp 不等于 "Hello" 时，循环继续
while inp != "Hello":
    # 重新提示用户输入，并将新结果存储在 inp 中
    inp = input("That's not the right word. Try again: ")

通过这种方式，每次提示用户输入新内容时，变量 inp 都会被更新。

---

循环结束与后续操作

一旦 inp 的值确实等于 “Hello”，程序就会退出 while 循环。

退出循环后，程序可以继续执行后续的代码。例如，打印一条消息：

print("It's about time!")

---

总结

本节课中我们一起学习了如何利用 while 循环来等待并验证用户的输入。我们掌握了以下核心流程：

1. 使用 input() 函数获取初始输入。
2. 使用 while 循环和条件判断（如 inp != "Hello"）来持续检查输入。
3. 在循环体内更新输入变量，为下一次条件检查做准备。
4. 当条件满足时退出循环，并执行后续代码。

这种模式对于创建需要与用户进行特定交互的程序非常有用。

056：代码练习-密码验证 🔐

在本节课中，我们将学习如何使用 while 循环来编写一个密码验证程序。程序会持续要求用户输入密码，直到输入正确为止。

概述 📋

我们将创建一个程序，其核心功能是验证用户输入的密码。程序会使用一个 while 循环来反复提示用户输入，直到输入的密码与预设的密码匹配。如果密码错误，程序会提示用户重新输入；如果密码正确，则输出欢迎信息并结束循环。

程序设计与实现

上一节我们介绍了循环的基本概念，本节中我们来看看如何应用 while 循环来解决一个实际问题——密码验证。

首先，我们需要初始化一个变量来存储用户输入的密码。由于在首次进入循环前用户尚未输入，我们将其设置为空字符串。

password = ""

接下来，我们设置循环条件。只要 password 变量的值不等于正确的密码 “secret”，循环就会继续执行。

while password != "secret":

在循环体内，我们需要做以下几件事：
以下是循环体内需要执行的步骤列表：

1. 提示用户输入密码。
2. 获取用户的输入并存储到 password 变量中。
3. 判断输入的密码是否正确。
4. 根据判断结果输出相应的信息。

让我们将这些步骤转化为代码。在循环中，我们使用 input 函数获取用户输入。

    password = input("Please, enter the password: ")

获取输入后，我们使用 if 语句进行判断。如果密码正确，则打印欢迎信息。

    if password == "secret":
        print("Welcome.")

如果密码不正确，则需要提示用户输入有误，并请其再次尝试。随后，循环条件会再次被检查，由于 password 仍不等于 “secret”，循环将再次执行，重新提示用户输入。

    else:
        print("Sorry, the password you entered is incorrect. Please try again.")

将以上所有部分组合起来，就构成了完整的密码验证程序。

代码示例与运行

以下是完整的程序代码：

password = ""
while password != "secret":
    password = input("Please, enter the password: ")
    if password == "secret":
        print("Welcome.")
    else:
        print("Sorry, the password you entered is incorrect. Please try again.")

程序运行逻辑：

1. 程序启动，password 为空字符串，满足 while 循环条件。
2. 进入循环，提示用户输入。
3. 用户输入后，程序立即判断。
   • 若输入为 ”secret”，则打印 ”Welcome.”，循环条件不再满足，程序结束。
   • 若输入错误，则打印错误提示，循环继续，回到步骤2。

注意事项：此程序对密码的大小写敏感。输入 ”Secret” 或 ”SECRET” 都会被判定为错误密码。

总结 🎯

本节课中我们一起学习了如何利用 while 循环构建一个交互式的密码验证程序。我们掌握了以下关键点：

• 使用 while 循环实现重复执行，直到满足特定条件。
• 使用 input() 函数获取用户输入。
• 使用 if-else 语句根据条件执行不同的代码分支。
• 理解了程序对字符串大小写的敏感性。

通过这个练习，你将 while 循环、条件判断和用户输入结合运用，解决了实际问题，这是编程中非常重要的基础技能。

057：使用break退出循环 🔄

在本节课中，我们将要学习如何使用 break 语句来提前退出循环。这是一种控制循环流程的强大工具，允许我们在满足特定条件时立即停止循环的执行。

概述

循环是编程中用于重复执行代码块的结构。然而，有时我们可能需要在循环正常结束之前，根据某个条件提前终止它。break 语句正是为此目的而设计的。

break语句的工作原理

break 命令会立即终止其所在的整个循环，并将程序控制权转移到循环之后的语句。它通常与条件判断语句（如 if）结合使用。

其核心逻辑可以用以下伪代码描述：

while 条件:
    # 执行一些代码
    if 特定条件满足:
        break  # 立即退出循环
    # 循环的其他代码

上一节我们介绍了循环的基本概念，本节中我们来看看如何使用 break 来主动控制循环的退出。

代码示例与分析

让我们通过一个具体的例子来理解 break 的用法。我们将初始化一个变量 x 为 1，然后在一个 while 循环中递增它，并在 x 等于 5 时使用 break 退出。

以下是实现此逻辑的Python代码步骤：

1. 将变量 x 初始化为 1。
2. 设置一个 while 循环，条件是 x 小于或等于 10。
3. 在循环内部，检查 x 是否等于 5。
4. 如果 x 等于 5，则执行 break 语句。
5. 否则，打印 x 的当前值，然后将 x 的值增加 1。

对应的代码如下：

x = 1
while x <= 10:
    if x == 5:
        break
    print(x)
    x += 1

执行流程与输出

现在，我们来逐步分析这段代码的执行过程：

• x 从 1 开始。
• 进入 while 循环，因为 1 <= 10 为真。
• x 不等于 5，所以打印 1，然后 x 变为 2。
• 循环继续，打印 2，x 变为 3。
• 循环继续，打印 3，x 变为 4。
• 循环继续，打印 4，x 变为 5。
• 当 x 等于 5 时，if 条件成立，执行 break 语句。
• 循环被立即终止，程序跳出 while 循环。

因此，这段代码的输出结果是：

1
2
3
4

代码打印了 1、2、3、4，然后当 x 变为 5 时，它跳出了 while 循环，程序结束。

总结

本节课中我们一起学习了 break 语句的用法。break 是一个重要的流程控制关键字，它允许我们在循环内部满足某个条件时，立即并完全地退出当前循环。这为编写更灵活、高效的循环逻辑提供了可能。记住，break 只影响它所在的最内层循环。

058：使用continue跳过循环 🔄

在本节课中，我们将要学习Python循环控制中的另一个重要关键字：continue。我们将了解它与break的区别，并通过一个具体的例子来掌握如何使用它来跳过循环中的特定迭代。

概述

continue语句用于改变程序的控制流，它会立即结束当前循环的本次迭代，并跳转到循环的下一次迭代开始处。这与break语句不同，break会完全终止整个循环。

continue语句的工作原理

上一节我们介绍了使用break来终止循环。本节中我们来看看continue，它提供了一种更精细的控制方式。

当程序在循环体内执行到continue语句时，它会跳过本次迭代中continue之后的所有代码，直接回到循环的顶部，并根据循环条件决定是否开始下一次迭代。

代码示例：打印特定奇数

让我们通过一个具体的编程任务来理解continue的用法。我们的目标是编写代码，打印出1到20之间的所有奇数，但需要跳过那些同时是3的倍数的数字。

以下是实现此逻辑的步骤：

1. 使用for循环遍历1到20的数字。
2. 判断当前数字是否为奇数。
3. 如果当前数字是奇数，再判断它是否是3的倍数。
4. 如果它同时是3的倍数，则使用continue跳过打印。
5. 否则，打印这个数字。

对应的Python代码如下：

for number in range(1, 21):
    # 测试是否为奇数
    if number % 2 != 0:
        # 测试是否为3的倍数
        if number % 3 == 0:
            # 如果是3的倍数，则跳过本次迭代
            continue
        # 打印符合条件的奇数
        print(number)

代码解析：

• range(1, 21) 生成从1到20的整数序列。
• number % 2 != 0 是判断奇数的条件。%是取模运算符，number % 2的结果为0表示number是偶数，不为0则表示是奇数。
• number % 3 == 0 是判断是否为3的倍数的条件。
• 当两个条件都满足（即是奇数又是3的倍数）时，执行continue，程序会直接跳转到for循环的下一个number，不会执行最后的print(number)语句。

运行这段代码，输出结果为：

1
5
7
11
13
17
19

可以看到，数字3、9、15虽然也是奇数，但因为它们是3的倍数，所以在执行continue后被跳过了，没有打印出来。

总结

本节课中我们一起学习了continue语句的用法。我们了解到：

• continue用于跳过当前循环的本次迭代，立即开始下一次迭代。
• 它与break的关键区别在于：break会终止整个循环，而continue只跳过当前一次循环。
• 通过结合条件判断，我们可以使用continue灵活地控制循环中哪些代码需要执行，哪些需要跳过，从而编写出更清晰、高效的循环逻辑。

059：嵌套循环 🔄

在本节课中，我们将要学习嵌套循环的概念。嵌套循环是指一个循环结构内部包含另一个循环结构。理解嵌套循环的执行顺序对于处理多维数据（如表格、矩阵）和复杂逻辑至关重要。

嵌套循环的概念

嵌套循环是一个循环内部包含另一个循环。对于外层循环的每一次迭代，它都会完整地执行一遍内层循环。

这个概念可以用以下伪代码来描述：

for (外层循环的每次迭代) {
    // 执行外层循环体
    for (内层循环的每次迭代) {
        // 执行内层循环体
    }
}

代码示例分析

上一节我们介绍了嵌套循环的基本概念，本节中我们来看看一个具体的代码示例，并分析它的执行流程。

以下代码会打印出什么内容？

for i in range(1, 4):
    print(i)
    for j in range(1, 3):
        print("\t", j)

以下是代码执行的逐步分析：

1. 进入外层循环的第一次迭代，此时 i 的值为 1。程序首先打印出 1。
2. 接着，程序进入内层循环。对于内层循环的每一次迭代，它打印出当前的 j 值，并在前面加上一个制表符（\t）。因此，它会依次打印出 \t 1 和 \t 2。
3. 内层循环执行完毕后，程序返回到外层循环，开始第二次迭代，此时 i 的值为 2。程序打印出 2。
4. 然后，程序再次进入内层循环，并完整地执行其所有迭代，再次打印出 \t 1 和 \t 2。
5. 最后，程序进行外层循环的最后一次迭代，此时 i 的值为 3。程序打印出 3。
6. 接着，程序最后一次运行内层循环的所有迭代，打印出 \t 1 和 \t 2。

因此，这段代码的完整输出结果是：

1
    1
    2
2
    1
    2
3
    1
    2

本节课中我们一起学习了嵌套循环的工作原理。我们了解到，外层循环每执行一步，内层循环都会从头到尾完整地执行一遍。掌握这种执行顺序是编写复杂循环逻辑的基础。

Python与Java编程入门：1-2：代码练习-乘法表

在本节课中，我们将编写一个程序来巩固对乘法表的理解。我们将使用嵌套的for循环来生成一个从1到10的完整乘法表。

概述

我们将通过两层循环来遍历乘数和被乘数，并打印出每一个乘法算式及其结果。这有助于我们熟悉循环结构在解决实际问题中的应用。

核心概念与代码实现

程序的核心是使用两个嵌套的for循环。外层循环变量i代表乘法表中的第一个数字（乘数），内层循环变量j代表第二个数字（被乘数）。

以下是实现乘法表打印的Python代码：

for i in range(1, 11):
    for j in range(1, 11):
        result = i * j
        print("{} times {} equals {}".format(i, j, result))

代码解析

上一节我们概述了程序的目标，本节中我们来详细解析代码的每一部分。

1. 外层循环：for i in range(1, 11):

   • 这行代码创建了一个循环。变量i会依次取值为1到10（range(1, 11)生成的序列包含1，但不包含11）。

2. 内层循环：for j in range(1, 11):

   • 对于外层循环的每一个i值，都会执行一次完整的内层循环。变量j也会依次取值为1到10。

3. 计算与打印：
   • result = i * j：计算当前i和j的乘积。
   • print("{} times {} equals {}".format(i, j, result))：使用字符串的format方法，将变量i、j和result的值填充到占位符{}中，并打印出格式化的算式。

运行结果

当运行上述代码时，控制台将输出从 1×1 到 10×10 的所有乘法算式，例如：

1 times 1 equals 1
1 times 2 equals 2
...
10 times 9 equals 90
10 times 10 equals 100

总结

本节课中我们一起学习了如何使用嵌套的for循环来生成乘法表。我们掌握了range()函数的基本用法，以及如何利用字符串格式化来清晰地输出结果。这个练习巩固了循环结构的知识，并展示了如何将逻辑分解为简单的重复步骤。

061：编程演示-平均值计算程序 📊

在本节课中，我们将学习如何编写一个Python程序，该程序会持续向用户请求输入整数，并计算这些输入数字的平均值。程序允许用户输入 -1 来退出循环并计算平均值。

概述与思路

我们将创建一个程序，其核心逻辑是：持续接收用户输入，将输入的数字存储起来，直到用户输入特定的退出指令（-1）。然后，程序会计算所有已输入数字的总和与平均值。

为了实现这个功能，我们需要使用一个循环来反复获取输入，并使用一个列表来存储所有输入的数字。同时，我们需要一个计数器来记录输入了多少个数字，以便后续计算平均值。

程序实现步骤

以下是构建此程序的具体步骤。

1. 初始化变量

首先，我们需要初始化几个关键的变量：

• num_list：一个空列表，用于存储用户输入的所有数字。
• count：一个计数器，初始值为 0，用于记录输入了多少个数字。
• playing：一个布尔值标志，初始为 True，用于控制循环是否继续执行。

num_list = []
count = 0
playing = True

2. 设置循环获取输入

接下来，我们使用一个 while 循环来反复请求用户输入。只要 playing 变量的值为 True，循环就会继续执行。

while playing:
    # 获取用户输入
    num_input = int(input(“Enter an int: “))

3. 处理用户输入

在循环内部，我们需要对用户的输入进行判断和处理。这里有两种情况：

1. 如果用户输入 -1，则将 playing 标志设为 False，以便在下一次循环迭代前退出。
2. 否则，将输入的数字添加到列表中，并增加计数器。

    if num_input == -1:
        playing = False
    else:
        num_list.append(num_input)
        count += 1

请注意：if-else 结构确保了退出指令 -1 不会被添加到数字列表中，也不会被计入总数。

4. 计算并输出平均值

当用户输入 -1 退出循环后，程序将执行循环之后的代码。我们需要计算列表中所有数字的总和，然后用总和除以数字的个数来得到平均值。

以下是计算和输出的代码：

# 计算总和
num_sum = 0
for num in num_list:
    num_sum += num

# 计算平均值
num_average = num_sum / count

# 输出结果
print(“Average:”, num_average)

核心公式：平均值 = 总和 / 数量，即 average = sum / count。

完整代码与运行示例

将以上所有步骤组合起来，就得到了完整的程序。

# 1. 初始化变量
num_list = []
count = 0
playing = True

# 2. 循环获取输入
while playing:
    num_input = int(input(“Enter an int: “))

    # 3. 处理输入
    if num_input == -1:
        playing = False
    else:
        num_list.append(num_input)
        count += 1

# 4. 计算并输出平均值
num_sum = 0
for num in num_list:
    num_sum += num

num_average = num_sum / count
print(“Average:”, num_average)

运行示例：

Enter an int: 3
Enter an int: 3
Enter an int: 3
Enter an int: -1
Average: 3.0

Enter an int: 1
Enter an int: 2
Enter an int: 3
Enter an int: -1
Average: 2.0

总结

本节课中，我们一起学习并实现了一个交互式的平均值计算程序。我们掌握了以下几个关键点：

1. 使用 while 循环和布尔标志来控制程序的持续运行。
2. 使用 if-else 语句对不同的用户输入（正常数字 vs 退出指令）进行分支处理。
3. 使用列表来动态存储数据，并使用 for 循环遍历列表以计算总和。
4. 应用 average = sum / count 这个基本公式来计算平均值。

这个程序是理解循环控制、条件判断和基础数据处理的经典示例。你可以尝试修改它，例如计算输入数字的最大值、最小值，或者允许用户输入小数。

062：编程演示-单词反转 🔄

在本节课中，我们将学习如何编写一个Python程序来反转一个单词。我们将通过一个具体的例子，逐步讲解如何从后向前遍历字符串，并将字符拼接起来形成反转后的单词。

---

概述

我们的目标是编写一个程序，将一个给定的单词进行反转。例如，将单词 “pastor” 反转为 “rotsap”。我们将使用循环和字符串索引来实现这个功能。

---

程序实现步骤

以下是实现单词反转的具体步骤。

1. 初始化变量

首先，我们定义原始单词和一个用于存储反转结果的空字符串。

word = "pastor"
rev = ""

2. 设计循环结构

接下来，我们需要遍历原始单词，但是顺序是从后向前。我们将使用 range 函数来生成一个递减的索引序列。

for j in range(len(word) - 1, -1, -1):

公式解释：

• len(word) - 1：这是循环的起始索引，即单词的最后一个字符的位置。
• -1：这是循环的结束条件，表示索引大于 -1 时循环继续，即索引为 0 时仍会执行。
• -1：这是步长，表示每次循环索引 j 减少 1。

3. 拼接字符

在循环体内，我们根据当前索引 j 获取单词中的字符，并将其拼接到 rev 字符串的前面。

    rev = rev + word[j]

代码解释：

• word[j]：获取 word 字符串中索引为 j 的字符。
• rev + word[j]：将当前字符连接到 rev 字符串的末尾。

4. 输出结果

循环结束后，rev 字符串中存储的就是反转后的单词。我们将其打印出来。

print(rev)

---

完整代码示例

将以上所有步骤组合起来，就得到了完整的单词反转程序。

word = "pastor"
rev = ""

for j in range(len(word) - 1, -1, -1):
    rev = rev + word[j]

print(rev)

运行这段代码，控制台将输出：

rotsap

---

总结

本节课中，我们一起学习了如何用Python实现单词反转。核心要点包括：

1. 使用 range 函数生成反向索引序列。
2. 通过字符串索引 word[j] 访问特定位置的字符。
3. 利用字符串拼接操作逐步构建反转后的结果。

通过这个简单的例子，我们掌握了循环和字符串处理的基本配合方式，这是编程中非常常见的模式。

063：什么是函数 👨‍💻

在本节课中，我们将要学习编程中一个非常核心的概念：函数。理解函数是编写高效、可维护代码的关键一步。

概述

函数是组织好的、可重复使用的代码块，用于执行一个单一相关的操作。函数为你的应用程序提供了更好的模块化特性，并实现了高度的代码重用。

函数的基本概念

上一节我们概述了函数的重要性，本节中我们来看看函数的具体定义和作用。

函数是一个有组织的、可重用的代码块，它被用来执行一个单一相关的操作。这意味着你可以将一段完成特定任务的代码打包起来，给它起一个名字，然后在需要的时候反复调用它，而无需重复编写相同的代码。

函数的好处

了解了函数是什么之后，我们来看看使用函数能带来哪些具体的好处。

使用函数主要有两大优势：

• 更好的模块化：函数将复杂的程序分解成一个个小的、功能明确的模块。这使得代码结构更清晰，更容易理解和维护。
• 高度的代码重用：一旦定义了一个函数，你就可以在程序的任何地方多次调用它。这避免了代码重复，提高了开发效率。

Python中的函数

我们已经讨论了函数的通用概念，现在让我们聚焦到Python语言中，看看函数是如何实现的。

Python本身提供了许多内置函数，这些是核心语言的一部分，例如 print()、len() 等，你可以直接使用它们。

同时，Python也允许你定义自己的函数，这是你构建复杂程序的基础。定义函数的语法通常如下：

def 函数名(参数):
    # 函数体：执行操作的代码
    return 返回值 #（可选）

总结

本节课中我们一起学习了函数的概念。我们了解到函数是一个用于执行特定任务的可重用代码块，它能带来模块化和代码重用的好处。我们还知道了Python既提供了内置函数，也允许我们自定义函数来构建程序。

掌握函数是编程旅程中的一个重要里程碑，它将帮助你写出更优雅、更强大的代码。

064：内置函数 📚

在本节课中，我们将要学习Python中的内置函数。你已经使用过一些内置函数，例如用于打印字符串的print函数和用于获取用户输入的input函数。本节将系统地介绍其他几个常用的内置函数，帮助你更高效地处理数据。

已使用的内置函数回顾

在之前的课程中，你已经接触过几个核心的内置函数。

以下是几个你已经熟悉的内置函数示例：

• print(): 用于向控制台输出信息。

  print("Hello, World!")
  

• input(): 用于从用户那里获取输入。

  name = input("请输入你的名字：")
  

• int(): 用于将其他数据类型（如字符串）转换为整数。

  num_str = "10"
  num_int = int(num_str)  # 结果是整数 10
  

更多内置函数介绍

上一节我们回顾了已学的函数，本节中我们来看看其他几个非常有用的内置函数。

float() 函数

float()函数用于将给定的字符串或整数转换为浮点数（即小数）。

result = float("3.14")  # 结果是浮点数 3.14

round() 函数

round()函数用于对给定的浮点数进行四舍五入。你可以指定要保留的小数位数。

rounded_num = round(3.14159, 2)  # 结果是 3.14

max() 与 min() 函数

max()函数用于获取给定参数中的最大值。

maximum = max(5, 1, 8, 3)  # 结果是 8

类似地，min()函数用于获取给定参数中的最小值。

minimum = min(5, 1, 8, 3)  # 结果是 1

len() 函数

len()函数用于获取给定对象的长度或其中包含的项目数量。它常用于字符串、列表等。

length = len("Python")  # 结果是 6

总结

本节课中我们一起学习了Python的几个重要内置函数。我们回顾了print()、input()和int()，并新学习了float()用于类型转换、round()用于数值舍入、max()和min()用于找最值，以及len()用于获取长度。熟练运用这些内置函数是进行有效Python编程的基础。

Python与Java编程入门：1-2：用户自定义函数

在本节课中，我们将要学习如何在Python中创建和使用用户自定义函数。函数是组织代码、实现代码复用的核心工具。我们将了解函数的基本结构、参数与返回值，并通过简单的例子来掌握其用法。

---

Python允许你创建自己的用户自定义函数。

以下是定义函数时需要遵循的一些约定：函数名应基于其功能来命名，代码中的空白（缩进）非常重要。函数体，即代码块或语句组，必须通过四个空格或一个制表符进行缩进。

---

上一节我们提到了函数的基本结构，本节中我们来看看函数如何接收输入。

有时函数需要接收输入，这些输入被称为参数。当你调用或使用函数时，你需要传递实参来满足这些参数。

---

了解了函数的输入后，我们再来看看函数的输出。

有时函数会产生一个输出，这被称为函数的返回值。

你使用 def 关键字来定义一个函数，后面跟上函数名和一对圆括号。

圆括号内包含可选的参数，函数将这些参数视为变量来处理。

函数内部包含具体的功能代码，最后可以跟一个可选的返回值。

---

本节课中我们一起学习了用户自定义函数的基础知识。我们了解了如何使用 def 关键字定义函数，认识了参数（输入）和返回值（输出）的概念，并知道了代码缩进在定义函数体时的重要性。掌握这些是编写模块化和可重用代码的第一步。

066：函数定义与调用

在本节课中，我们将学习如何定义一个简单的函数，并调用它来计算一个数字的平方。我们将通过一个具体的例子来理解函数的参数、返回值以及执行流程。

概述

我们将定义一个名为 square 的函数，它接收一个数字作为参数，计算该数字的平方，并返回结果。之后，我们会调用这个函数，传入数字10，并打印出计算结果。

函数定义

首先，我们来定义函数。函数定义使用 def 关键字，后跟函数名和括号内的参数列表。

以下是定义 square 函数的步骤：

1. 使用 def 关键字开始定义函数。
2. 函数名为 square。
3. 它接收一个参数，我们将其命名为 x。
4. 在函数体内，我们计算 x 乘以 x 的结果，并将其赋值给变量 y。
5. 最后，使用 return 语句将 y 的值作为函数的结果返回。

对应的代码如下：

def square(x):
    y = x * x
    return y

在这个函数中，x 是输入参数，y 被赋值为 x 的平方（即 x * x），然后函数返回 y 的值。

函数调用与结果输出

定义好函数后，我们就可以调用它了。调用函数意味着执行函数体内的代码。

以下是调用函数并处理结果的步骤：

1. 我们调用 square 函数，并传入数字 10 作为实际参数。
2. 函数执行后返回的结果（即100），我们将其存储在一个变量中（例如 result）。
3. 最后，我们使用 print 函数将这个结果输出到屏幕上。

对应的代码如下：

result = square(10)
print(result)

当我们调用 square(10) 时，函数开始执行。参数 x 被赋值为10，然后计算 y = 10 * 10，得到 y = 100。函数返回100，这个值被赋给变量 result。执行 print(result) 语句后，控制台将输出 100。

总结

本节课中，我们一起学习了Python函数的基础知识。我们定义了一个名为 square 的函数来计算平方，理解了参数 x 如何接收输入值，以及 return 语句如何输出结果。随后，我们通过 square(10) 调用了这个函数，并将返回值打印出来，最终得到了正确的结果100。这个过程清晰地展示了函数从定义、执行到返回值的完整流程。

067：代码练习-比较大小 🔍

在本节课程中，我们将学习如何定义一个函数来比较两个数字的大小。我们将创建一个名为 greater_than 的函数，它接收两个数字作为参数，并返回一个布尔值，指示第一个参数是否大于第二个参数。

函数定义与逻辑

首先，我们定义函数 greater_than。它接收两个参数 x 和 y。在函数内部，我们使用条件语句来判断 x 是否大于 y。如果是，函数返回 True；否则，返回 False。

以下是函数的代码实现：

def greater_than(x, y):
    if x > y:
        return True
    else:
        return False

函数调用与结果输出

定义好函数后，我们需要调用它来测试其功能。我们将使用两个变量 a 和 b 分别存储数字 2 和 3，然后将它们作为参数传递给 greater_than 函数。

以下是调用函数并输出结果的代码：

a = 2
b = 3
result = greater_than(a, b)
print("{} is greater than {}: {}".format(a, b, result))

运行结果分析

运行上述代码后，控制台将输出比较结果。由于 2 不大于 3，所以输出为 False。

总结

在本节课中，我们一起学习了如何定义一个比较两个数字大小的函数。我们掌握了函数的基本结构、参数传递、条件判断以及结果的返回与输出。通过这个简单的练习，我们加深了对函数和条件语句的理解，为后续更复杂的编程任务打下了基础。

068：文档字符串 📝

在本节课中，我们将要学习如何为函数编写文档字符串。文档字符串是代码中用于解释函数或类功能的重要部分，它能帮助其他开发者理解和使用你的代码。

---

什么是文档字符串？

上一节我们介绍了函数的基本概念，本节中我们来看看如何为函数添加说明。你可以并且应该为你的函数提供一个文档字符串。

文档字符串描述了函数或类的操作。它是为那些使用你的函数并想从高层次了解其功能的人准备的。

这与注释不同。注释是为可能阅读你的代码并想了解其工作原理细节的程序员准备的。

---

如何创建文档字符串？

要创建文档字符串，需要在函数定义中，将一段字符串作为第一个语句。

以下是创建文档字符串的代码示例：

def greet(name):
    """
    向指定的人打招呼。

    参数:
    name (str): 要打招呼的人的名字。

    返回:
    str: 包含问候语的字符串。
    """
    return f"Hello, {name}!"

---

如何访问文档字符串？

文档字符串可以通过两种方式被用户访问。

首先，可以通过使用 help() 命令来获取函数的帮助信息。

其次，可以直接通过引用特殊的 __doc__ 变量来访问。请注意，__doc__ 在单词“doc”前后各有两个下划线。

以下是访问文档字符串的示例：

# 使用 help() 命令
help(greet)

# 直接访问 __doc__ 属性
print(greet.__doc__)

---

总结

本节课中我们一起学习了文档字符串。我们了解了文档字符串的定义、它与注释的区别、如何创建文档字符串，以及如何通过 help() 函数和 __doc__ 属性来访问它。编写清晰的文档字符串是编写可维护和易用代码的关键一步。

069：代码练习-获取因数

在本节课中，我们将学习如何编写一个Python函数，用于找出任意给定整数的所有因数。我们将从定义函数开始，逐步讲解其实现逻辑，并通过一个具体例子来演示其用法。

概述

我们将创建一个名为 get_factors 的函数。该函数接收一个整数作为参数，并返回一个列表，其中包含该整数的所有因数。因数的定义是能够整除给定整数且没有余数的所有正整数。

函数定义与逻辑

首先，我们定义函数。函数名为 get_factors，它接受一个参数 x，代表我们要寻找因数的目标整数。

def get_factors(x):
    # 函数体将在这里实现

函数的目标是返回一个列表。因此，我们首先在函数内部创建一个空列表，用于存储找到的因数。

    factors = []

寻找因数的过程

接下来，我们需要找出所有能整除 x 的数。根据定义，一个数的因数包括1和它本身，以及所有能整除它的正整数。因此，我们需要检查从1到 x 本身（包括 x）的所有整数。

我们使用一个 for 循环来遍历这个范围。在Python中，range(1, x+1) 会生成从1到 x（包含）的整数序列。

    for i in range(1, x + 1):

在循环内部，我们需要判断当前的数字 i 是否是 x 的因数。判断方法是检查 x 除以 i 的余数是否为0。在Python中，我们使用取模运算符 % 来计算余数。

条件判断如下：
if x % i == 0:

如果条件为真，说明 i 能整除 x，那么 i 就是 x 的一个因数。我们将其添加到 factors 列表中。

        if x % i == 0:
            factors.append(i)

返回结果并测试

循环结束后，factors 列表中就包含了 x 的所有因数。最后，函数返回这个列表。

    return factors

现在，让我们用一个例子来测试这个函数。我们将调用 get_factors(21) 并打印结果。

result = get_factors(21)
print(result)

运行这段代码，输出应该是 [1, 3, 7, 21]。这表示数字21的因数有1、3、7和21本身。

完整代码示例

以下是 get_factors 函数的完整代码：

def get_factors(x):
    factors = []
    for i in range(1, x + 1):
        if x % i == 0:
            factors.append(i)
    return factors

# 测试函数
print(get_factors(21))

总结

在本节课中，我们一起学习了如何编写一个寻找整数因数的Python函数。我们定义了函数 get_factors，它通过遍历从1到目标数本身的所有整数，并使用取模运算来检查整除性，从而收集所有因数并返回一个列表。通过调用 get_factors(21)，我们验证了函数能正确找出21的因数：1、3、7和21。这个练习巩固了函数定义、循环和条件判断等基础编程概念。

070：代码练习-唯一值列表 📝

在本节课中，我们将学习如何编写一个名为 unique_list 的函数。这个函数接收一个数字列表作为参数，并返回一个仅包含原列表中唯一值的新列表。我们将通过逐步构建代码来理解其逻辑。

概述

我们的目标是创建一个函数，它能过滤掉输入列表中的重复数字，只保留每个数字的第一次出现。我们将通过遍历输入列表，并检查每个元素是否已存在于新列表中来实现这一功能。

函数定义与逻辑

首先，我们来定义函数。函数名为 unique_list，它接收一个参数 L，这个参数是一个数字列表。

def unique_list(L):

在函数内部，我们需要创建一个新的空列表，用于存放最终的唯一值。

    X = []

接下来，我们需要遍历输入列表 L 中的每一个元素。

    for a in L:

在遍历过程中，对于每一个元素 a，我们需要判断它是否已经存在于新列表 X 中。如果不存在，我们才将它添加到 X。

        if a not in X:
            X.append(a)

遍历完成后，新列表 X 就包含了所有唯一的元素。最后，我们返回这个列表。

    return X

代码整合与调用

现在，让我们将以上代码片段整合成一个完整的函数，并调用它来测试结果。

def unique_list(L):
    X = []
    for a in L:
        if a not in X:
            X.append(a)
    return X

# 调用函数并打印结果
result = unique_list([1, 2, 3, 3, 3, 3, 3, 4, 5])
print(result)

当我们运行这段代码时，函数会处理输入列表 [1, 2, 3, 3, 3, 3, 3, 4, 5]。它会遍历每个数字，并将尚未出现在新列表中的数字添加进去。

执行结果

执行上述代码后，我们得到的输出应该是：

[1, 2, 3, 4, 5]

正如我们所期望的，重复的数字 3 只在结果列表中出现了一次。

总结

本节课中，我们一起学习了如何编写一个 unique_list 函数来获取列表中的唯一值。我们掌握了以下关键步骤：

1. 定义一个接收列表参数的函数。
2. 创建一个空列表来存储结果。
3. 使用 for 循环遍历输入列表。
4. 在循环内使用 if 条件判断和 not in 运算符来检查元素是否已存在于新列表中。
5. 使用 append() 方法将不重复的元素添加到新列表。
6. 最后返回这个包含唯一值的新列表。

通过这个练习，你不仅学会了如何去除列表中的重复项，也巩固了函数定义、列表操作和循环控制等基础编程概念。

071：执行顺序

在本节课中，我们将要学习Python程序执行的基本顺序，理解代码是如何被解释器一步步运行的。这对于编写和调试程序至关重要。

程序执行的基本顺序

当你加载并运行一个Python模块或文件时，文件中的语句和定义会按照它们出现的顺序依次执行。

函数定义与函数执行

上一节我们介绍了程序执行的顺序，本节中我们来看看函数定义与函数调用的区别。

执行一个 def 语句会定义一个函数。它并不会运行该函数。

函数只有在被调用时才会运行。

程序的常见结构

理解了函数定义与调用的区别后，我们来看看程序通常是如何组织的。

一个非常小的程序可能根本不定义任何函数，而仅仅是一系列要执行的语句。

大多数程序由许多函数定义组成，可能还包含一些顶层语句（即不在函数内的语句）。

程序的起点

通常，一个特定的函数是程序的起点。按照惯例，这个函数被称为 main。我们将会看到，在Java中这实际上是强制性的。

---

本节课中我们一起学习了Python程序的执行顺序。我们了解到代码是按顺序执行的，def 语句用于定义而非执行函数，函数需要被调用才会运行。我们还探讨了简单程序和典型程序的结构差异，并知道了 main 函数作为程序起点的惯例。理解这些概念是构建更复杂程序的基础。

072：__name__变量与main函数 🐍

在本节课中，我们将要学习Python中一个非常重要的概念：__name__变量。理解这个概念，能帮助我们控制代码的执行方式，区分一个Python文件是作为主程序运行，还是被其他文件导入为模块。

概述

在Python中，每个模块（即一个.py文件）都有一个内置的变量叫做__name__。Python解释器在执行一个文件之前，会自动为这个变量赋值。这个值决定了代码的执行路径，是编写可复用、可测试代码的关键。

__name__变量的作用

在模块或文件执行代码之前，Python会定义几个特殊的变量。__name__就是其中之一。

作为主程序运行

如果Python解释器将该文件作为主程序运行，它会将特殊变量__name__的值设置为"__main__"。

作为模块被导入

如果该文件是从另一个模块导入的，__name__将被设置为该模块或文件的名称。

如何使用if __name__ == "__main__"

为了在Python解释器首次读取文件时指导其行为，我们可以在脚本底部添加一个条件判断。

以下是其标准写法：

if __name__ == "__main__":
    main()

这段代码的作用是：如果文件作为主程序加载，则运行main()函数。

请注意：__name__在name前后各有两个下划线，__main__在main前后也各有两个下划线。正确的写法是__name__和__main__。

实践意义

通过使用if __name__ == "__main__":这个结构，我们可以实现：

1. 直接运行：当直接运行该脚本时，执行特定的启动代码（通常是调用一个main()函数）。
2. 模块导入：当该脚本被其他文件导入时，不会执行那些启动代码，而只提供其中定义的函数、类等供调用。这使得代码既可以直接运行，又可以作为一个功能库被其他程序使用。

总结

本节课中我们一起学习了Python中__name__变量的核心机制。我们了解到，通过检查__name__是否等于"__main__"，可以智能地控制代码的执行流程。这是编写专业、结构清晰的Python程序的基石。记住这个简单的模式，它能让你的代码更加灵活和强大。

073：编程演示-元音单词计数器 🧮

在本节课中，我们将学习如何编写一个Python程序，该程序能够统计字符串中的元音字母数量以及句子中的单词数量。我们将从创建两个独立的功能开始，然后通过代码重构将它们合并到一个更通用的函数中，以提高代码的复用性和清晰度。

创建元音计数器函数

首先，我们创建一个名为 vowel_counter 的函数，用于统计给定字符串中的元音字母（A, E, I, O, U）数量。

以下是实现步骤：

1. 初始化一个计数器变量。
2. 遍历字符串中的每一个字符。
3. 检查当前字符是否为元音字母。
4. 如果是元音字母，则计数器加一。
5. 函数返回最终的计数结果。

def vowel_counter(given_string):
    vowel_count = 0
    for character in given_string:
        if character in "AEIOUaeiou":
            vowel_count += 1
    return vowel_count

创建主函数循环

接下来，我们创建一个 main 函数。该函数包含一个无限循环，允许用户重复输入字符串进行元音计数，直到输入特定的退出指令（例如 -1）为止。

def main():
    while True:
        input_string = input("Enter a string: ")
        if input_string == "-1":
            break
        count = vowel_counter(input_string)
        print(f"{count} vowels in '{input_string}'")

为了在直接运行此脚本时执行 main 函数，我们使用 Python 的特殊变量 __name__。

if __name__ == "__main__":
    main()

创建单词计数器函数

上一节我们介绍了如何统计元音，本节中我们来看看如何统计句子中的单词数量。我们假设单词之间由单个空格分隔。

以下是实现步骤：

1. 使用 strip() 方法去除句子首尾的空白字符。
2. 初始化一个空格计数器。
3. 遍历句子中的每个字符，检查它是否为空格。
4. 单词数量等于空格数量加一。

def word_counter(sentence):
    sentence = sentence.strip()
    space_count = 0
    for char in sentence:
        if char == " ":
            space_count += 1
    word_count = space_count + 1
    return word_count

创建完成后，我们可以修改 main 函数，调用 word_counter 来测试其功能。

代码重构：创建通用计数函数

观察 vowel_counter 和 word_counter 函数，我们发现它们具有相似的结构：都是遍历一个字符串，并统计其中符合特定条件的字符数量。

为了提高代码的复用性，我们可以创建一个通用的函数 count_instance_of_str。

这个函数接收两个参数：string1 和 string2。它的功能是统计 string1 中有多少个字符也出现在 string2 中。

def count_instance_of_str(string1, string2):
    count = 0
    for character in string1:
        if character in string2:
            count += 1
    return count

现在，我们可以利用这个通用函数来重写（重构）之前的两个专用函数。

以下是重构后的 vowel_counter 函数：

def vowel_counter(given_string):
    vowel_count = count_instance_of_str(given_string, "AEIOUaeiou")
    return vowel_count

以下是重构后的 word_counter 函数。注意，我们统计的是空格的数量，因此 string2 参数是一个空格字符 " "。

def word_counter(sentence):
    sentence = sentence.strip()
    space_count = count_instance_of_str(sentence, " ")
    word_count = space_count + 1
    return word_count

最后，更新 main 函数以同时或分别调用这两个功能，程序的核心逻辑就完成了。

总结

本节课中我们一起学习了如何构建一个具有交互功能的字符串处理程序。我们从编写独立的元音计数器和单词计数器开始，然后通过识别代码中的重复模式，创建了一个通用的字符计数函数 count_instance_of_str 来重构代码。这个过程展示了函数封装和代码重构的基本思想，它们能让程序变得更简洁、更易于维护和扩展。

074：PyCharm与数据结构入门 🚀

在本模块中，我们将开始使用PyCharm——一个用于编写和运行Python代码的集成开发环境。它的增强功能远超IDLE的有限能力，并且是行业标准工具。

在回顾列表（包括这一常用序列的更高级用法）之后，我们将深入探讨另外两种非常重要的数据结构：集合和元组。我们将学习如何利用它们来存储和操作信息。

虽然我们已经有一些使用字符串的经验，但本模块将探索字符串的复杂性和更强大的功能。

---

3.1：PyCharm介绍 💻

上一节我们概述了本模块的学习目标，本节中我们来看看我们将要使用的新工具：PyCharm。

PyCharm是一个功能强大的集成开发环境，用于编写和运行Python代码。它提供了代码自动补全、调试、项目管理等远超IDLE的增强功能，是软件开发行业的常用工具。

---

3.2：回顾与深入：列表 📋

在开始学习新的数据结构之前，我们先巩固一下列表的知识。列表是Python中最常用的序列类型之一。

以下是列表的一些基础与进阶操作示例：

# 创建一个列表
my_list = [1, 2, 3, 'hello']

# 列表推导式 - 一种创建列表的简洁方法
squares = [x**2 for x in range(10)]

# 列表切片
sub_list = my_list[1:3]

---

3.3：探索集合 🔗

现在，让我们转向第一种新的数据结构：集合。集合是一个无序且元素唯一的容器。

集合的核心特性可以通过以下公式和代码来理解：

• 唯一性：集合中不允许重复元素。
• 无序性：集合中的元素没有固定顺序。

# 创建一个集合
my_set = {1, 2, 3, 3, 4}  # 结果将是 {1, 2, 3, 4}

# 集合的常用操作：并集、交集、差集
set_a = {1, 2, 3}
set_b = {3, 4, 5}
union_set = set_a | set_b          # 并集: {1, 2, 3, 4, 5}
intersection_set = set_a & set_b   # 交集: {3}
difference_set = set_a - set_b     # 差集: {1, 2}

---

3.4：探索元组 📦

接下来，我们学习元组。元组与列表类似，但有一个关键区别：元组是不可变的。这意味着一旦创建，其内容就不能被修改。

以下是元组的关键概念和应用：

# 创建一个元组
my_tuple = (1, 2, 'apple', 'banana')

# 尝试修改元组会导致错误
# my_tuple[0] = 10  # 这行代码会引发 TypeError

# 元组常用于表示固定的一组值，例如坐标
point = (10, 20)

---

3.5：字符串的进阶功能 🔤

我们已经熟悉了字符串的基础操作，现在让我们探索字符串更强大和复杂的功能。字符串在Python中同样是不可变序列，但拥有丰富的方法来处理文本。

以下是字符串处理的一些高级技巧：

text = "Hello, World! Welcome to Python."

# 字符串分割
words = text.split()  # 按空格分割: ['Hello,', 'World!', 'Welcome', 'to', 'Python.']
parts = text.split(',') # 按逗号分割: ['Hello', ' World! Welcome to Python.']

# 字符串连接
new_text = "-".join(words)  # 用‘-’连接列表中的单词

# 字符串格式化 (f-string)
name = "Alice"
age = 25
greeting = f"My name is {name} and I am {age} years old."

---

总结 📝

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

1. 如何使用功能强大的PyCharm IDE进行开发。
2. 回顾并深化了对列表的理解，包括列表推导式等高级用法。
3. 掌握了两种新的核心数据结构：集合（无序、唯一）和元组（有序、不可变），并了解了它们的特性和应用场景。
4. 探索了字符串更强大的处理功能，如分割、连接和格式化。

这些工具和数据结构是构建更复杂Python程序的基础，熟练掌握它们将极大提升你的编程效率。

075：关于PyCharm 🐍

在本节课中，我们将要学习什么是PyCharm，并了解它作为Python集成开发环境（IDE）的核心功能。

什么是PyCharm？

PyCharm是一个专为Python设计的集成开发环境。它由一家名为JetBrains的公司开发。

上一节我们介绍了PyCharm的基本定义，本节中我们来看看它具体包含哪些强大的功能。

PyCharm的核心功能

PyCharm拥有众多功能，包括但不限于代码辅助和分析。

以下是PyCharm提供的一些关键辅助功能：

• 代码补全
• 语法和错误高亮显示
• 快速代码修复

总结

本节课中我们一起学习了PyCharm。我们了解到PyCharm是JetBrains公司开发的Python集成开发环境，它通过代码补全、语法高亮和快速修复等功能，为开发者提供了强大的代码辅助与分析能力。

076：下载安装PyCharm 🛠️

在本节课中，我们将学习如何下载并安装PyCharm的免费开源版本，这是开始Python编程的重要一步。

概述

PyCharm是一款功能强大的集成开发环境（IDE），专为Python开发设计。为了使用其免费的开源版本，我们需要从官方网站下载社区版。本节将指导你完成下载和安装过程。

下载PyCharm社区版

要使用PyCharm的免费开源版本，请从PyCharm下载页面获取社区版。

以下是下载步骤：

1. 访问PyCharm官方网站的下载页面。
2. 在版本选择区域，找到并点击“Community”（社区版）的下载链接。
3. 根据你的操作系统（如Windows、macOS或Linux），选择对应的安装包进行下载。

安装PyCharm

上一节我们介绍了如何下载PyCharm社区版，本节中我们来看看如何安装它。

安装过程通常很简单。以下是基本步骤：

1. 运行你下载的安装程序。
2. 跟随安装向导的指示进行操作。在大多数情况下，你可以接受默认的安装设置。
3. 完成安装后，启动PyCharm。

总结

本节课中我们一起学习了如何为Python编程准备开发环境。我们首先从官方网站下载了PyCharm的免费社区版，然后完成了安装步骤。现在你已经拥有了一个强大的工具，可以开始编写和运行Python代码了。

077：运行代码 🚀

在本节课中，我们将学习如何在PyCharm集成开发环境中创建项目、编写Python脚本并运行代码。我们将从打开PyCharm开始，逐步完成创建项目、新建Python文件、编写代码以及执行脚本的完整流程。

---

创建新项目

上一节我们介绍了PyCharm的安装，本节中我们来看看如何创建一个新的项目。

下载并安装PyCharm后，打开IDE并创建一个新项目。操作路径为：File -> New Project。

为项目命名。

点击“Create”。你可以选择将项目附加到当前窗口。

---

在项目中创建Python文件

成功创建项目后，下一步是在项目中创建Python脚本文件。

在左侧选中项目，然后依次点击 File -> New -> Python File。接着为你的Python文件命名。

按下回车键。这将在项目中创建一个Python文件，你可以在左侧的项目导航器中看到你的项目及其包含的文件。

---

编写并运行代码

现在我们已经有了项目结构，接下来看看如何编写和运行Python代码。

在PyCharm中运行代码，首先需要将代码输入到脚本文件中并保存。以下是运行脚本的步骤：

1. 在创建的Python文件中输入代码。
2. 保存该文件。
3. 要运行脚本，可以点击菜单栏的 Run -> Run。
4. 或者，使用键盘快捷键 Control + Option + R（在Mac上；Windows/Linux上通常是 Ctrl + Shift + F10 或 Shift + F10）。
5. 选择要运行的文件。

随后，你将在IDE底部看到代码的输出结果。

---

本节课中我们一起学习了在PyCharm中创建项目、新建Python文件以及运行代码的基本操作。掌握这些步骤是开始Python编程实践的第一步。

078：列表复习 📝

在本节课中，我们将要学习Python中一个非常重要的数据结构——列表。我们将回顾列表的基本概念、创建方法以及常用的操作。

概述

列表是Python中最常用的序列类型之一。它是一种可变的数据结构，这意味着在列表被定义之后，其中的单个元素可以被修改。

列表的创建

要创建一个列表，需要在方括号 [] 内指定用逗号分隔的值。

my_list = [1, 2, 3, 4]

列表中的值不必都是相同的数据类型。你可以在同一个列表中混合使用不同的数据类型。例如，下面的列表包含三个字符串和一个整数。

mixed_list = [‘cat‘, ‘dog‘, 5, ‘bird‘]

列表索引

列表中的每个项目都被分配了一个索引值，索引从零开始。

animals = [‘cat‘, ‘dog‘, ‘bird‘]

这里，在方括号内使用索引 1，我们可以得到列表中的第二个项目。

print(animals[1])  # 输出: dog

如果我们尝试使用索引 4 来打印列表中的第五个项目呢？

print(animals[4])

这个项目不存在，所以我们会得到一个索引错误，因为索引超出了范围。

查找项目索引

我们可以使用Python内置的 list.index() 方法来查找列表中特定值的索引。

animals = [‘cat‘, ‘dog‘, ‘bird‘]
index_of_dog = animals.index(‘dog‘)
print(index_of_dog)  # 输出: 1

这里我们得到了列表中 ‘dog‘ 项目的索引，即 1。

列表的常用操作

上一节我们介绍了如何访问列表元素，本节中我们来看看如何修改列表。

以下是向列表中添加项目的方法。

你可以使用 append() 方法向列表添加项目。这个方法会将一个项目添加到列表的末尾。

animals = [‘cat‘, ‘dog‘, ‘bird‘]
animals.append(‘fish‘)
print(animals)  # 输出: [‘cat‘, ‘dog‘, ‘bird‘, ‘fish‘]

---

以下是获取列表长度的方法。

使用Python内置的 len() 函数获取列表的长度。

animals = [‘cat‘, ‘dog‘, ‘bird‘]
length = len(animals)
print(length)  # 输出: 3

这会返回列表中项目的数量。

---

以下是移除列表中项目的方法。

使用 pop() 方法从列表中移除项目。

animals = [‘cat‘, ‘dog‘, ‘bird‘]
animals.pop()  # 移除最后一个项目
print(animals)  # 输出: [‘cat‘, ‘dog‘]

这会移除列表中的最后一个项目。通过在 pop() 方法中指定索引 1，可以移除列表中的第二个项目。

animals = [‘cat‘, ‘dog‘, ‘bird‘]
animals.pop(1)  # 移除索引为1的项目
print(animals)  # 输出: [‘cat‘, ‘bird‘]

---

以下是在列表中特定位置插入项目的方法。

通过指定索引 2 和要插入的字符串，可以在列表的第三个位置插入一个项目。

animals = [‘cat‘, ‘dog‘, ‘bird‘]
animals.insert(2, ‘fish‘)
print(animals)  # 输出: [‘cat‘, ‘dog‘, ‘fish‘, ‘bird‘]

---

以下是检查特定项目是否在列表中的方法。

animals = [‘cat‘, ‘dog‘, ‘bird‘]
print(‘dog‘ in animals)  # 输出: True
print(‘elephant‘ in animals)  # 输出: False

总结

本节课中我们一起学习了Python列表的基础知识。我们回顾了如何创建列表、理解列表索引、以及执行添加、获取长度、移除、插入和检查成员等常见操作。列表是Python编程中不可或缺的工具，掌握这些基本操作是进行更复杂数据处理的第一步。

079：更多列表操作 📝

在本节课中，我们将学习Python中关于列表的两种重要操作：列表的加法与乘法。这些操作能帮助我们高效地组合或重复列表中的元素。

上一节我们介绍了列表的基本索引和切片操作，本节中我们来看看如何对列表进行拼接和重复。

列表的加法 ➕

列表的加法操作可以将两个列表连接起来，生成一个包含两个列表所有元素的新列表。新列表的元素顺序是第一个列表的元素在前，第二个列表的元素在后。

以下是列表加法的示例：

Ls1 = [2, 3, 4]
Ls2 = [7, 8, 9]
Ls3 = Ls1 + Ls2
print(Ls3)  # 输出: [2, 3, 4, 7, 8, 9]

在这个例子中，Ls3 是一个新列表，它包含了 Ls1 的所有元素（2, 3, 4），后面紧跟着 Ls2 的所有元素（7, 8, 9）。

列表的乘法 ✖️

列表的乘法操作可以将一个列表重复指定的次数，从而生成一个包含多个重复序列的新列表。

以下是列表乘法的示例：

Ls3 = [2, 3, 4, 7, 8, 9]
Ls4 = Ls3 * 3
print(Ls4)  # 输出: [2, 3, 4, 7, 8, 9, 2, 3, 4, 7, 8, 9, 2, 3, 4, 7, 8, 9]

在这个例子中，Ls4 是一个新列表，它由 Ls3 的内容重复三次组成。

本节课中我们一起学习了Python列表的两种便捷操作：使用 + 运算符进行列表拼接，以及使用 * 运算符进行列表重复。这些操作是构建和操作数据序列的基础工具。

080：列表函数 📋

在本节课中，我们将要学习Python列表的一个重要内置函数——extend()。这个函数用于将一个列表中的所有元素添加到另一个列表的末尾，并直接修改原列表。

概述

上一节我们介绍了列表的基本操作，本节中我们来看看如何使用extend()函数来合并两个列表。与使用加号+连接列表不同，extend()函数会直接更新调用它的列表。

extend()函数详解

你可以使用extend()函数来扩展列表。这里定义了两个列表：ls1是[2, 3, 4]，ls2是[7, 8, 9]。

接下来，我将输入ls1.extend(ls2)。这个操作类似于列表相加，但它会实际更新ls1，并将ls2中的值追加到ls1的末尾。

以下是代码示例：

ls1 = [2, 3, 4]
ls2 = [7, 8, 9]
ls1.extend(ls2)

现在，我将遍历ls1来查看其中的元素。

以下是遍历并打印列表的代码：

for l in ls1:
    print(l)

我们将看到ls1中的值：2, 3, 4, 7, 8, 9。所以，ls2中的值被追加到了ls1的末尾。

总结

本节课中我们一起学习了extend()函数。我们了解到，list1.extend(list2)会将list2中的所有元素添加到list1的尾部，并直接改变list1的内容。这是一种高效合并列表的方法。

081：列表切片操作指南 📋

在本节课中，我们将要学习Python中一个非常实用且强大的功能——列表切片。通过切片，我们可以轻松地获取列表的一部分，或者创建列表的副本，甚至批量更新列表中的元素。

切片基础语法

列表切片通过在方括号内使用冒号来实现。其基本语法如下：

list_name[start_index:end_index]

其中，start_index 是切片开始位置的索引（包含该索引对应的元素），end_index 是切片结束位置的索引（不包含该索引对应的元素）。起始索引和结束索引都是可选的。

为了更直观地理解，让我们通过一个例子来演示。

切片操作演示

首先，我们创建一个列表。

my_list = ['B', 'A', 'N', 'A', 'N', 'A', 'S']

获取指定范围的切片

现在，让我们获取索引2到4的元素（即第3到第5个元素）。

print(my_list[2:5])

运行结果是 ['N', 'A', 'N']。它包含了索引为2、3、4的元素。索引5是结束索引，所以不被包含在内。

获取从某索引到列表末尾的切片

如果我们想获取从索引4开始到列表末尾的所有元素，但不知道列表的确切长度，可以省略结束索引。

print(my_list[4:])

这将输出 ['N', 'A', 'S']，即第5、6、7个元素。

获取整个列表的切片

要获取整个列表的切片，可以同时省略起始索引和结束索引。

print(my_list[:])

这等同于 my_list[0:len(my_list)]，会输出完整的列表 ['B', 'A', 'N', 'A', 'N', 'A', 'S']。

使用负索引进行切片

切片也支持负索引，负索引表示从列表末尾开始倒数。

print(my_list[:-4])

这里，结束索引是 -4。代码会输出从开头到倒数第4个元素（不包含）之间的所有元素，即 ['B', 'A', 'N']。

利用切片创建列表副本

上一节我们介绍了如何获取列表的一部分，本节中我们来看看切片另一个重要的用途：创建列表的独立副本。

通过获取包含所有元素的切片，我们可以得到原列表的一个“浅拷贝”。这意味着新列表和原列表是两个独立的对象。

copy_my_list = my_list[:]

以下是验证副本独立性的方法：

print(copy_my_list is my_list)  # 检查是否是同一个对象，输出 False
print(copy_my_list == my_list)  # 检查值是否相等，输出 True

第一行代码检查两个变量是否指向内存中的同一个列表对象，结果为 False，说明它们是独立的。第二行代码检查两个列表包含的值是否完全相同，结果为 True。

通过切片更新列表元素

我们不仅可以用索引更新单个列表元素，还可以使用切片来一次性更新多个元素。

首先，定义一个列表（虽然它目前包含的都是偶数）。

odd_numbers = [2, 4, 6, 8]

更新单个元素

使用索引来更新第一个元素，使其变为奇数。

odd_numbers[0] = 1
print(odd_numbers)  # 输出：[1, 4, 6, 8]

使用切片更新多个元素

现在，我们使用切片一次性将索引1到3的元素（即第2、3、4个元素）更新为奇数。

odd_numbers[1:4] = [3, 5, 7]
print(odd_numbers)  # 输出：[1, 3, 5, 7]

请注意，我们指定的结束索引是4，虽然原列表索引4并不存在（列表最大索引是3），但Python会将其解释为“直到列表末尾”，因此这个操作是有效的。

总结

本节课中我们一起学习了Python列表的切片操作。我们掌握了使用 list[start:end] 语法来获取列表的子集，了解了起始和结束索引的规则。我们还学习了如何利用 list[:] 来创建列表的独立副本，以及如何使用切片语法高效地批量更新列表中的多个元素。切片是处理列表数据时不可或缺的工具，熟练掌握它将大大提高你的编程效率。

082：字符串与列表对比

在本节课中，我们将要学习Python中两个重要的数据类型：字符串和列表。我们将重点探讨它们的相似之处与关键区别，特别是字符串的不可变性。

字符串与列表的相似性

上一节我们介绍了列表的基本概念，本节中我们来看看字符串。字符串可以被视为一个字符序列。从这个角度看，字符串与列表非常相似。你可以想象字符串就是一个由字符组成的列表。

例如，我们可以像访问列表元素一样，使用方括号和索引来访问字符串中的单个字符。

my_restaurant_choice = "pizza"
first_character = my_restaurant_choice[0]  # 获取第一个字符 'p'

字符串与列表的关键区别：不可变性

虽然字符串和列表在访问元素上很相似，但它们有一个根本性的区别：字符串是不可变的。这意味着一旦一个字符串被创建，你就无法修改其中的单个字符。

相比之下，列表是可变的，我们可以轻松地更新列表中的元素。

以下是展示这一区别的核心示例：

对于列表，我们可以进行读取和更新操作：

my_menu_choices = [“pizza”, “burger”, “salad”]
# 1. 读取元素
first_item = my_menu_choices[0]  # 获取 ‘pizza’
# 2. 更新元素
my_menu_choices[0] = “pasta”     # 将第一个元素改为 ‘pasta’，这是允许的

然而，对于字符串，我们只能进行读取操作，尝试更新会导致错误：

my_restaurant_choice = “pizza”
# 1. 读取字符
first_char = my_restaurant_choice[0]  # 获取 ‘p’，这是允许的
# 2. 尝试更新字符（这将导致错误）
my_restaurant_choice[0] = “P”         # 错误！字符串不可变

尝试执行上述字符串更新代码会引发 TypeError，因为Python不允许直接修改字符串的某个部分。

如何“改变”字符串

既然字符串不可变，我们该如何修改它们呢？方法不是直接修改原字符串，而是创建一个新的字符串。

以下是几种常见的操作：

• 替换字符或子串：使用 .replace() 方法会返回一个新的字符串。

  new_string = my_restaurant_choice.replace(‘p’, ‘P’)  # 得到 ‘Pizza’，原字符串不变
  

• 拼接字符串：使用 + 运算符或 .join() 方法创建新字符串。

  greeting = “Hello” + “ “ + “World”  # 创建新字符串 “Hello World”
  

• 转换大小写：使用 .upper(), .lower(), .title() 等方法也会返回新字符串。

  loud_string = my_restaurant_choice.upper()  # 得到 ‘PIZZA’
  

本节课中我们一起学习了字符串和列表的核心异同。我们了解到字符串可以像列表一样通过索引访问，但其不可变性是它与列表最本质的区别。记住，任何看似“修改”字符串的操作，实际上都是创建了一个全新的字符串对象。理解这一点对于避免程序错误和编写高效的Python代码至关重要。

083：字符串切片 🧩

在本节课中，我们将要学习字符串切片。字符串切片允许我们从一个字符串中获取一部分，这被称为子字符串。其操作方式与列表切片非常相似。

字符串切片基础

与列表类似，我们可以从字符串中获取一个切片。这被称为子字符串。

你可以使用相同的冒号语法。其格式为：[起始索引:结束索引]。

• 起始索引是切片中包含的第一个字符的索引。
• 结束索引是切片中不包含的最后一个字符的索引。

为了更直观地理解，请看下图：

切片操作示例

上一节我们介绍了切片的基本语法，本节中我们通过一个具体的例子来看看如何操作。

例如，让我们创建一个字符串：

S = "Hello World"

现在，我想获取这个字符串的一部分，即一个子字符串。

我将使用切片来实现。所以我们要打印 S[ ]。

我想获取前五个字符。起始索引将是0。我们可以省略它，它会默认为0。结束索引将是5。这将给我们索引为0到4的字符。

以下是代码：

print(S[0:5])

运行这段代码。我们得到的结果是“Hello”。

总结

本节课中我们一起学习了字符串切片。我们了解到，字符串切片使用 [起始索引:结束索引] 的语法来获取原字符串的一部分（子字符串），其中起始索引包含在结果内，而结束索引不包含在结果内。这是处理字符串中特定片段的一个强大工具。

084：代码练习-姓名子字符串 👨‍💻

在本节课中，我们将学习如何使用Python的字符串索引和切片功能，从一个包含全名的字符串中提取出姓氏。我们将通过一个具体的练习来掌握这些概念。

---

概述

我们将创建一个变量来存储姓名，然后通过找到姓名中空格的位置，来提取出姓氏部分。核心在于使用字符串的.index()方法和切片操作。

---

练习步骤

1. 创建姓名变量

首先，我们需要创建一个变量来存储姓名。这个姓名应包含名和姓，中间用一个空格分隔。

name = "Brrandon Krarkowski"

2. 定位空格索引

接下来，我们需要找到姓名中空格字符的索引位置。这个位置将作为我们切片的终点。

first_space = name.index(" ")

这里，name.index(" ")会返回字符串中第一个空格字符的索引值。

3. 提取姓氏

现在，我们使用字符串切片来提取姓氏。切片从字符串的开头（索引0）开始，到我们刚刚找到的空格索引位置结束。

first_name = name[0:first_space]
print(first_name)

运行以上代码，将只输出名字“Brrandon”。

---

总结

在本节课中，我们一起学习了如何从全名字符串中提取姓氏。我们首先创建了姓名变量，然后使用.index()方法找到空格的位置，最后通过字符串切片提取出姓氏部分。这个方法在处理文本数据时非常有用。

085：字符串的分割与连接

在本节课中，我们将要学习Python中两个非常实用的字符串方法：split（分割）和join（连接）。它们能帮助我们在字符串和列表之间进行灵活的转换，是处理文本数据的基础。

使用 split 方法分割字符串

split 是一个有用的字符串方法，用于将一个字符串分割成一个由多个字符串组成的列表。

例如，我们定义一个变量 colors 并存储一个字符串。由于该字符串中包含逗号，我们可以使用 split 方法，以逗号字符作为分隔符，将字符串分割成一个字符串列表。

以下是具体操作步骤：

1. 定义一个包含逗号分隔颜色的字符串。
2. 调用 split 方法并指定分隔符为逗号。
3. 结果 colors_list 将是一个字符串列表。

colors = "red,green,blue"
colors_list = colors.split(",")
# 现在 colors_list 是 ['red', 'green', 'blue']

列表中第三个字符串（即颜色）将是 “green”。

使用 join 方法连接列表

与分割相反，join 方法能从多个字符串组成的列表中创建一个单一的字符串。

这里，我们使用定义为逗号字符的分隔符来连接字符串列表。

以下是具体操作步骤：

1. 准备一个字符串列表。
2. 在分隔符字符串（如逗号）上调用 join 方法，并将列表作为参数传入。
3. 结果 new_colors 将是一个包含所有三个颜色的字符串。

colors_list = ['red', 'green', 'blue']
new_colors = ",".join(colors_list)
# 现在 new_colors 是 "red,green,blue"

结合使用以修改字符串

在之前的例子中，我们曾尝试直接更新字符串中的某个字符，但这是行不通的，因为字符串在Python中是不可变的。

我们可以先将字符串转换为一个真正的列表。但是，使用空字符串调用 split 函数会引发错误，所以 split("") 这个方法不可行。

正确的做法是使用Python内置的 list 函数将字符串转换为字符列表。

以下是修改字符串中特定字符的完整流程：

1. 使用 list() 将字符串转换为列表。
2. 在列表中更新目标位置的字符。
3. 使用 join 方法将列表转换回字符串。

my_string = "hello"
# 1. 转换为列表
my_list = list(my_string)  # ['h', 'e', 'l', 'l', 'o']
# 2. 更新第三个字母（索引为2）
my_list[2] = 'x'
# 3. 转换回字符串
new_string = "".join(my_list)  # "hexlo"

本节课中我们一起学习了字符串的 split 和 join 方法。split 用于将字符串按指定分隔符拆分为列表，而 join 则用于将列表中的元素合并为一个字符串。通过结合使用 list() 和 join()，我们可以巧妙地修改原本不可变的字符串。掌握这些方法是进行文本处理的关键步骤。

Python和Java编程入门1-2：086_03_01：创建元组 🧱

在本节课中，我们将要学习Python中一个重要的数据结构——元组。我们将了解元组的定义、特性以及如何创建它。

---

什么是元组？

元组是一个不可变的值序列。一旦定义，你就无法更改其中的单个元素。

这与可变的列表不同。

与列表类似，元组中包含的值不必是同一类型。

---

如何创建元组？

创建元组非常简单，只需将逗号分隔的值用圆括号括起来即可。

以下是一个包含四个值的元组示例，其类型是 tuple。

my_tuple = (1, 2, 'hello', 3.14)
print(type(my_tuple))  # 输出: <class 'tuple'>

实际上，即使不使用圆括号，仅用逗号分隔值，也能创建元组。其类型依然是 tuple。

another_tuple = 1, 2, 'world'
print(type(another_tuple))  # 输出: <class 'tuple'>

---

使用内置函数创建元组

你还可以使用Python内置的 tuple() 函数，从字符串或列表等可迭代对象创建元组。

以下是将字符串转换为元组的示例，其中每个字符成为元组中的一个独立项。

tuple_from_string = tuple('Python')
print(tuple_from_string)  # 输出: ('P', 'y', 't', 'h', 'o', 'n')

---

元组的不可变性

如果你尝试更新元组中的元素，将会得到一个错误。因此，以下操作是无效的。

my_tuple[0] = 100  # 这会导致 TypeError

同样，以下操作也是无效的。

my_tuple.append(5)  # 元组没有 append 方法，这会导致 AttributeError

---

元组的应用场景

我们将看到，当你希望从一个函数中一次性返回多个值时，元组会变得极其有用。

---

总结

本节课中我们一起学习了Python元组。我们了解到元组是一个不可变的序列，可以通过圆括号或逗号直接创建，也可以使用 tuple() 函数从其他对象转换而来。元组的不可变性保证了数据的安全性，使其在需要返回多个值的函数等场景中非常实用。

087：代码练习-最大值最小值函数 📊

在本节课中，我们将学习如何编写一个函数，该函数接收一个列表，并返回一个包含该列表中最大值和最小值的元组。我们将使用Python内置的max()和min()函数，并探索两种不同的方法来处理函数返回的元组。

---

概述

我们将创建一个名为max_and_min的函数。这个函数接受一个列表作为参数，使用Python内置的max()和min()函数找出列表中的最大值和最小值，然后将这两个值作为一个元组返回。之后，我们将在主函数中调用它，并学习如何从返回的元组中提取值。

---

创建最大值最小值函数

首先，我们定义max_and_min函数。该函数接收一个列表，并返回一个包含该列表最大值和最小值的元组。

def max_and_min(given_list):
    """
    返回一个包含给定列表最大值和最小值的元组。
    """
    max_value = max(given_list)  # 使用内置max函数获取最大值
    min_value = min(given_list)  # 使用内置min函数获取最小值
    return (max_value, min_value)  # 返回包含这两个值的元组

函数内部，我们使用max(given_list)获取列表的最大值，使用min(given_list)获取列表的最小值。通过将这两个值放在括号()内，我们创建并返回了一个元组。

---

编写主函数进行测试

为了测试我们的函数，我们需要编写一个主函数。在主函数中，我们将创建一个列表，调用max_and_min函数，并打印结果。

上一节我们介绍了max_and_min函数的定义，本节中我们来看看如何在主程序中使用它。

以下是主函数的实现步骤：

1. 创建一个测试列表。
2. 调用max_and_min函数，并将返回的元组赋值给一个变量。
3. 打印该变量的类型以确认它是元组。
4. 通过索引从元组中提取最大值和最小值并打印。

def main():
    # 1. 创建一个测试列表
    list1 = [10, -1, -34, 56]

    # 2. 调用函数并将返回的元组赋值给变量
    max_min_tuple = max_and_min(list1)

    # 3. 打印返回值的类型
    print(type(max_min_tuple))  # 输出：<class 'tuple'>

    # 4. 通过索引从元组中提取值
    max_value = max_min_tuple[0]  # 获取元组的第一个元素（最大值）
    min_value = max_min_tuple[1]  # 获取元组的第二个元素（最小值）

    print(f"最大值: {max_value}")  # 输出：最大值: 56
    print(f"最小值: {min_value}")  # 输出：最小值: -34

运行上述代码，我们可以看到函数正确返回了元组(56, -34)，并且我们成功通过索引提取了这两个值。

---

使用元组解包赋值

除了通过索引访问元组元素，Python还提供了一种更简洁的方法，称为“元组解包”或“多重赋值”。这种方法允许我们将元组中的值直接赋值给多个变量。

上一节我们通过索引手动提取了元组中的值，本节中我们来看看一种更高效的赋值方法。

以下是使用元组解包的步骤：

1. 在调用函数时，直接将返回的元组解包到两个变量中。
2. 这两个变量会分别被赋值为元组中的第一个和第二个元素。

def main():
    list1 = [10, -1, -34, 56]

    # 使用元组解包直接赋值
    max_val_2, min_val_2 = max_and_min(list1)

    print(f"最大值 (方法二): {max_val_2}")  # 输出：最大值 (方法二): 56
    print(f"最小值 (方法二): {min_val_2}")  # 输出：最小值 (方法二): -34

通过max_val_2, min_val_2 = max_and_min(list1)这行代码，我们一次性完成了函数调用和值提取两个步骤，代码更加简洁易读。

---

总结

本节课中我们一起学习了如何完成一个关于元组的代码练习。我们主要掌握了以下内容：

1. 定义函数：创建了max_and_min函数，它利用内置的max()和min()函数计算列表的极值，并以元组形式返回。
2. 处理返回值：学会了如何调用函数，并通过索引（如tuple[0]）从返回的元组中提取特定值。
3. 使用元组解包：掌握了更高效的元组解包技巧，可以直接将函数返回的元组元素赋值给多个变量，简化了代码。

这个练习巩固了函数定义、返回值以及元组操作的基本概念，这些都是Python编程中的重要基础。

088：集合的创建与特性 🧩

在本节课中，我们将要学习Python中一个重要的数据结构——集合。我们将了解集合的基本特性，并掌握创建集合的几种不同方法。

---

什么是集合？ 🤔

集合是一个无序的集合。顺序无关紧要，也无法指定。

集合不支持像索引这样的操作。集合不允许重复的元素。

集合中包含的值不需要全部是同一类型。集合是可变的，这意味着一旦定义，其中的元素可以被改变。

---

如何创建集合？ 🛠️

上一节我们介绍了集合的基本概念，本节中我们来看看如何实际创建一个集合。

方法一：使用花括号

要创建一个集合，可以在花括号内放置一个用逗号分隔的值列表。

代码示例：

my_set = {1, 2, 3, 'hello'}

方法二：使用 set() 函数从字符串创建

你也可以使用Python内置的set函数从一个字符串创建集合。

这会创建一个包含字符串中唯一字母的集合。字符串中的每个字符将成为集合中的一个元素。

代码示例：

set_from_string = set("banana")
# 结果：{'b', 'a', 'n'}

方法三：使用 set() 函数从列表创建

同样，你也可以使用set函数从一个列表创建集合。

这会创建一个包含列表中唯一数字的集合。列表中的每个数字将成为集合中的一个元素。

代码示例：

list_b = [1, 2, 2, 3, 4, 4]
set_from_list = set(list_b)
# 结果：{1, 2, 3, 4}

方法四：创建空集合

例如，为了稍后添加项目，你可以使用不带参数的set函数来创建一个空集合。

代码示例：

empty_set = set()

---

总结 📝

本节课中我们一起学习了Python中集合的创建与特性。我们了解到集合是一个无序、不重复且可变的容器。我们掌握了四种创建集合的方法：

1. 使用花括号 {} 直接定义。
2. 使用 set() 函数将字符串转换为字符集合。
3. 使用 set() 函数将列表转换为唯一元素集合。
4. 使用 set() 函数创建空集合以备后续使用。

Python与Java编程入门：第3章第2节：遍历与更新集合 🔄

在本节课中，我们将要学习如何遍历集合中的元素，以及如何向集合中添加或移除元素。这些操作是管理和使用集合数据的基础。

---

上一节我们介绍了集合的基本概念和创建方法。本节中我们来看看如何访问集合中的每一个元素。

你可以遍历一个集合，以获取其中的每一个独立元素。

以下是遍历集合 A 并打印每个元素的代码示例：

for item in A:
    print(item)

---

同样地，我们也可以遍历另一个集合 B。

以下是遍历集合 B 并打印每个元素的代码示例：

for item in B:
    print(item)

---

遍历集合让我们能够查看所有内容。接下来，我们将学习如何动态地修改集合的内容。

这里，我们向集合 A 中添加一个字符串元素。操作如下：

A.add("new_string")

---

集合的修改也包括移除元素。

这里，我们从集合 B 中移除一个整数元素。操作如下：

B.remove(some_integer)

---

通过以上操作，我们可以灵活地管理集合中的数据。

本节课中我们一起学习了遍历集合的两种方法，以及如何使用 add 和 remove 方法来更新集合中的元素。掌握这些操作是有效使用集合类型的关键。

090：模块介绍

在本节课中，我们将学习Python中加载和存储数据的多种方式。我们将重点介绍字典这一数据结构，并学习如何与外部文件进行交互。

Python提供了多种加载和存储数据的方式。

信息可以保存在字典中。字典是一种数据结构，对于存储单个事物的多个属性或数据点极为有用。

数据也可以存储在外部的文件中，然后加载到Python中。

本模块将使我们能够以多种方式使用字典，并通过打开、读取和写入外部文件来与本地文件系统进行交互。

掌握了这些新增技能后，你将开始更好地理解Python的动态能力，以及它如何能轻松地与其他系统集成。

---

上一节我们概述了本模块的学习目标，本节中我们来看看具体的数据存储方式。

以下是两种主要的数据处理方式：

• 使用字典：字典用于存储键值对，非常适合组织具有多个属性的数据。
  • 核心概念示例：student = {"name": "Alice", "age": 20, "major": "Computer Science"}
• 使用外部文件：数据可以保存在文本文件（如.txt）、CSV文件或JSON文件中，程序可以读取这些文件或将数据写入其中。
  • 核心操作示例：

    # 打开并读取文件
    with open('data.txt', 'r') as file:
        content = file.read()
    # 写入文件
    with open('output.txt', 'w') as file:
        file.write('Hello, World!')
    

---

本节课中我们一起学习了Python中两种核心的数据管理方法：使用字典在内存中结构化数据，以及通过文件操作与外部存储系统进行数据交换。这些技能是构建更复杂、能处理现实世界数据的Python应用程序的基础。

091：创建字典 📚

在本节课中，我们将要学习Python中一种新的数据结构——字典。我们将了解字典是什么，它与列表和集合有何不同，以及如何创建和使用它。

---

什么是字典？

上一节我们介绍了列表和集合，本节中我们来看看字典。字典是另一种存储数据的方式，但它以无序的键值对形式存储数据。

一个字典由一组键和其对应的值组成。在其他编程语言中，字典也被称为哈希映射或关联数组，例如在Java中。

字典非常有用。一个典型的应用场景是存储单个事物的多个属性或数据点。

---

如何创建字典？

要创建一个字典，需要使用花括号 {}，并在其中放置用逗号分隔的键值对。

以下是创建字典的基本语法：

my_dict = {key1: value1, key2: value2, ...}

键通常是简单的数据类型，如字符串或整数，但值可以是任何类型的数据。

---

字典的特性

字典是可变的。这意味着一旦字典被定义，其中的元素可以被修改、添加或删除。

---

总结

本节课中我们一起学习了Python字典的基础知识。我们了解到字典是一种存储键值对的无序数据结构，它非常适用于存储具有多个属性的对象信息。我们还学习了使用花括号和键值对来创建字典的基本方法。

092：字典（键值对）📚

在本节课中，我们将要学习Python中一个非常重要的数据结构——字典。字典用于存储键值对，它允许我们通过一个唯一的“键”来快速查找和访问对应的“值”。

字典的基本概念

上一节我们介绍了列表和元组等序列类型，本节中我们来看看字典。字典是一种映射类型，它存储的是键（key）和值（value）之间的关联关系。

一个字典由花括号 {} 定义，其中包含多个用逗号分隔的 键: 值 对。

以下是一个关于个人信息的字典示例：

person = {
    "name": "Alice",
    "age": 30,
    "city": "New York"
}

访问字典中的值

创建字典后，我们通常需要根据键来获取对应的值。Python提供了两种主要方法。

使用方括号 [] 访问

最直接的方式是使用方括号，并在其中放入键名。

print(person["name"])  # 输出: Alice

使用 .get() 方法访问

另一种更安全的方式是使用字典内置的 .get() 方法。它的优势在于当查找的键不存在时，可以避免程序崩溃。

以下是 .get() 方法的几种使用情况：

• 键存在时：返回对应的值。

  print(person.get("age"))  # 输出: 30
  

• 键不存在时（默认）：返回 None（空值）。

  print(person.get("state"))  # 输出: None
  

• 键不存在时（指定默认值）：可以指定一个默认返回值。

  print(person.get("state", "PA"))  # 输出: PA
  

相比之下，如果使用方括号 [] 去访问一个不存在的键，Python会直接抛出一个 KeyError 错误，导致程序中断。

print(person["state"])  # 会引发 KeyError

课程总结

本节课中我们一起学习了Python字典的核心用法。我们了解到字典是一种高效的键值对存储结构，并通过方括号 [] 和 .get() 方法掌握了访问其中数据的技巧。特别需要注意的是，使用 .get() 方法能更安全地处理键可能不存在的情况，是更推荐的实践方式。

093：更新字典 📝

在本节课中，我们将要学习如何更新Python字典。字典是可变的数据结构，这意味着我们可以修改、添加或删除其中的元素。我们将通过具体的操作来掌握这些核心技能。

更新与添加元素 🔄

上一节我们介绍了字典的基本结构，本节中我们来看看如何修改字典的内容。字典是可变的，因此其中的元素可以被更新或添加。

• 通过键名更新值：直接为已存在的键赋予新值。

  my_dict['name'] = 'New Name'
  

• 通过键名增加值：例如，将键 age 对应的值加1。

  my_dict['age'] += 1
  

• 添加新的键值对：为字典中不存在的键赋值，即可添加新元素。

  my_dict['college'] = 'University of Pennsylvania'
  my_dict['city'] = 'Philadelphia'
  

检查与删除元素 ❌

在修改字典时，有时需要先检查某个键是否存在，或者删除不需要的元素。

• 检查键是否存在：使用 in 关键字可以判断一个键是否存在于字典中。

  if 'age' in my_dict:
      print("键‘age’存在")
  

• 删除元素：使用 del 关键字可以删除字典中指定的键值对。

  del my_dict['city']
  

嵌套数据结构 🧩

字典的值不仅可以是基本数据类型，还可以是其他复杂的数据结构，例如列表或其他字典。

• 值为列表：可以为字典的键分配一个列表作为值。

  my_dict['siblings'] = ['Alice', 'Bob']
  

• 修改嵌套列表：可以像操作普通列表一样，对字典中的列表进行修改，例如使用 .append() 方法添加元素。

  my_dict['siblings'].append('Charlie')
  

合并字典 🤝

有时我们需要将两个字典的内容合并到一起。除了逐一添加键值对，还有一个更高效的方法。

• 使用 .update() 方法：这个方法可以将一个字典中的所有键值对添加到另一个字典中。如果键已存在，则其值会被覆盖。

  dict1 = {'a': 1, 'b': 2}
  dict2 = {'b': 3, 'c': 4}
  dict1.update(dict2)
  # 现在 dict1 是 {'a': 1, 'b': 3, 'c': 4}
  

本节课中我们一起学习了如何更新Python字典。我们掌握了修改现有值、添加新键值对、检查键是否存在、删除元素、处理嵌套的列表值以及使用 .update() 方法合并字典等核心操作。理解这些操作是灵活运用字典这一强大数据结构的关键。

094：代码练习-成绩考勤簿 📚

在本节课中，我们将通过一个综合练习来巩固对Python字典的理解。我们将创建一个用于管理学生成绩和出勤情况的“成绩考勤簿”。这个练习将涉及创建嵌套字典、访问数据、遍历字典以及进行简单的计算。

---

创建学生字典

首先，我们需要为每个学生创建一个字典。每个学生的字典将包含三个键值对：name（姓名）、grades（成绩列表）和attendance（出勤情况列表）。

以下是三个学生的数据：

• Billy:

  • 姓名："Billy"
  • 成绩：[100, 80, 67, 100, 89]
  • 出勤：[True, True, True, True, True]（全勤）

• Sarah:

  • 姓名："Sarah"
  • 成绩：[0, 99, 0, 100]
  • 出勤：[True, False, True, False, True]

• Ben:

  • 姓名："Ben"
  • 成绩：[60, 82, 71, 92, 100]
  • 出勤：[False, False, False, False, False]（全缺勤）

在代码中，我们这样创建它们：

billy = {
    "name": "Billy",
    "grades": [100, 80, 67, 100, 89],
    "attendance": [True, True, True, True, True]
}

![](https://github.com/OpenDocCN/cs-notes-zh/raw/master/docs/upenn-py-java-intro/img/503acde6669ea7ded2286aff59887689_5.png)

sarah = {
    "name": "Sarah",
    "grades": [0, 99, 0, 100],
    "attendance": [True, False, True, False, True]
}

ben = {
    "name": "Ben",
    "grades": [60, 82, 71, 92, 100],
    "attendance": [False, False, False, False, False]
}

---

构建主学生字典

上一节我们为每个学生创建了独立的字典。本节中，我们将把这些学生字典组织到一个主字典中，以便统一管理。我们将使用唯一的字符串ID（如"1", "2", "3"）作为键，对应的学生字典作为值。

students = {
    "1": billy,
    "2": sarah,
    "3": ben
}

---

访问字典信息

现在我们已经有了结构化的数据，接下来看看如何从中获取信息。

获取学生总数

我们可以使用len()函数获取主字典中键的数量，即学生总数。

num_students = len(students)
print(f"There are {num_students} students.")
# 输出：There are 3 students.

获取所有学生ID

有两种方法可以获取所有学生ID（即主字典的所有键）。

方法一：使用 .keys() 方法
.keys()方法返回一个包含所有键的视图对象。

student_ids = students.keys()
print(student_ids)  # 输出：dict_keys(['1', '2', '3'])

方法二：直接遍历字典
直接遍历字典会默认遍历其键。

for key in students:
    print(key)
# 输出：
# 1
# 2
# 3

获取特定学生的信息

我们可以通过键来访问嵌套字典中的值。

获取Billy的出勤记录：

billy_info = students["1"]  # 获取ID为“1”的学生字典
billy_attendance = billy_info["attendance"] # 从该字典中获取“attendance”键的值
print(billy_attendance)  # 输出：[True, True, True, True, True]

获取Sarah的成绩：

sarah_grades = students["2"]["grades"] # 链式访问
print(sarah_grades)  # 输出：[0, 99, 0, 100]

获取一个学生的所有信息

要获取一个学生字典中的所有键值对，可以使用.items()方法。它返回一个包含(键, 值)元组的视图对象。

以下是获取Ben所有信息的代码：

ben_info = students["3"]  # 获取Ben的字典
ben_items = ben_info.items() # 获取该字典的所有键值对

for key, value in ben_items:
    print(f"{key}: {value}")
# 输出：
# name: Ben
# grades: [60, 82, 71, 92, 100]
# attendance: [False, False, False, False, False]

---

计算所有学生的平均成绩

上一节我们学习了如何访问单个学生的数据。本节中，我们将遍历所有学生，计算他们所有成绩的平均分。这里介绍两种方法。

方法一：遍历并收集所有成绩
思路是创建一个空列表，然后遍历每个学生，将他们的成绩列表中的每一项逐个添加到总列表中。

grades = []  # 用于存放所有成绩的空列表

# 遍历主字典的所有键值对（学生ID和对应的学生字典）
for student_id, student_dict in students.items():
    # 遍历当前学生字典中“grades”键对应的列表
    for grade in student_dict["grades"]:
        grades.append(grade) # 将每个成绩添加到总列表

# 计算平均分：总和 / 数量
average_grade = sum(grades) / len(grades)
print(f"Average grade for all assignments is {round(average_grade)}")
# 输出：Average grade for all assignments is 69

方法二：直接拼接成绩列表
这种方法更简洁。我们同样创建一个空列表，但在内层循环中，我们不是遍历成绩再添加，而是直接将整个成绩列表“拼接”到总列表的末尾。

grades_concatenated = []  # 用于存放所有成绩的空列表

for student_id, student_dict in students.items():
    # 直接将当前学生的成绩列表整体添加到总列表末尾
    grades_concatenated += student_dict["grades"]

average_grade = sum(grades_concatenated) / len(grades_concatenated)
print(f"Average grade for all assignments is {round(average_grade)}")
# 输出：Average grade for all assignments is 69

---

总结

本节课中我们一起完成了一个综合练习，创建并操作了一个“成绩考勤簿”。我们实践了以下核心操作：

1. 创建嵌套字典：构建了学生字典 -> 主字典的两层结构。
2. 访问数据：使用键来获取特定学生的信息，如students["1"]["attendance"]。
3. 遍历字典：使用.keys()、.items()方法和for循环来获取键、值或键值对。
4. 数据计算：通过遍历所有学生，收集并计算了全体学生的平均成绩。

这个练习很好地展示了字典在组织和管理结构化数据方面的强大能力。

095：01 打开文件 📂

在本节课中，我们将要学习如何在Python中打开文件。这是进行文件读写操作的第一步，理解这个过程对于后续处理文件数据至关重要。

概述

在Python中打开文件，本质上需要完成三个步骤：打开文件、使用文件（即读取、写入或追加内容）以及关闭文件。

打开文件

要打开一个文件，需要使用Python内置的 open() 函数。其基本语法如下：

file_object = open(path_to_file, mode)

其中，path_to_file 是一个指定文件路径的字符串，mode 则指定了访问文件的类型。

文件路径

path_to_file 可以是以下几种形式：

• 如果文件与程序在同一目录下，可以直接使用文件名。
• 也可以使用指向该文件的绝对路径或相对路径。

访问模式

要对文件进行读取或写入，mode 参数可以是以下值之一：

• 'r'：表示你只想读取文件。
• 'w'：表示你想写入文件。
• 'a'：表示你想向一个已存在文件的末尾追加内容。
• 'r+'：表示你想同时对文件进行读取和写入。

总结

本节课中我们一起学习了Python中打开文件的基础知识。我们了解了打开文件需要调用的 open() 函数，并详细解释了其两个关键参数：文件路径和访问模式。掌握这些是后续进行文件内容读取、写入和操作的基础。

Python和Java编程入门1-2：04：文件打开方法模式详解 📂

在本节课中，我们将要学习Python中文件操作的核心概念——文件打开模式。理解不同的模式是正确读写文件数据的基础。

上一节我们介绍了文件操作的基本概念，本节中我们来看看几种核心的文件打开模式及其具体行为。

---

读取模式 ‘r’

‘r’ 代表读取模式，这也是 open() 函数的默认模式。该模式用于打开一个已存在的文件以读取其内容。

其基本格式如下：

open(‘文件路径’, ‘r’)

此模式会打开文件用于读取。如果指定的文件不存在，程序将返回一个错误。由于这是默认模式，你也可以省略 ‘r’ 参数，直接写成 open(‘文件路径’)。

---

写入模式 ‘w’

‘w’ 代表写入模式。该模式用于向文件写入数据。

其基本格式如下：

open(‘文件路径’, ‘w’)

此模式会打开文件用于写入，并具有两个关键特性：

1. 如果文件已存在，则会清空该文件中的所有旧数据。
2. 如果文件不存在，则会创建一个新文件。

---

追加模式 ‘a’

‘a’ 代表追加模式。当你需要在文件末尾添加新内容，而不影响原有数据时，应使用此模式。

其基本格式如下：

open(‘文件路径’, ‘a’)

此模式会打开文件用于在末尾追加数据。与写入模式类似，如果文件不存在，它也会创建一个新文件。

---

读写模式 ‘r+’

‘r+’ 代表读写模式。这是一种组合模式，允许你对同一个文件既进行读取又进行写入操作。

其基本格式如下：

open(‘文件路径’, ‘r+’)

此模式会打开文件同时用于读取和写入。它有两个重要特点：

1. 如果文件不存在，程序将返回一个错误。
2. 它不会像 ‘w’ 模式那样自动清空文件的旧有数据。

---

本节课中我们一起学习了Python中四种基本的文件打开模式：读取模式‘r’、写入模式‘w’、追加模式‘a’和读写模式‘r+’。理解每种模式何时创建文件、是否清空数据以及是否允许读写，是安全有效进行文件操作的关键。

097：读取文件 📖

在本节课中，我们将要学习如何使用Python读取文件。我们将介绍三种不同的读取方法，并了解如何正确地打开和关闭文件流。

---

概述

文件操作是编程中的一项基本技能。通过读取文件，程序可以处理存储在外部文件中的数据。本节将详细介绍三种从文件中读取内容的方法。

---

使用流从文件中读取行

你可以使用一个流（stream）来从文件中逐行读取内容。流是程序与文件之间进行数据交换的通道。

---

读取文件的三种方法

以下是三种主要的文件读取方法，每种方法适用于不同的场景。

read() 方法

read() 方法将整个文件的内容作为一个字符串读取。

file_content = file_object.read()

此方法读取文件中的所有文本。

---

readline() 方法

上一节我们介绍了如何一次性读取整个文件，本节中我们来看看如何逐行读取。readline() 方法每次读取文件的一行，并将该行作为字符串返回。

single_line = file_object.readline()

此方法读取文件中的一行。

---

readlines() 方法

readlines() 方法将文件中的所有行读取为一个列表（list）。列表中的每个元素都是文件中的一行，并且是一个字符串。

all_lines = file_object.readlines()

此方法将文件中的所有行读取为一个列表。

---

重要注意事项

在使用所有读取方法后，必须记住在操作完成时关闭流。这是一个良好的编程习惯，可以释放系统资源。

file_object.close()

此操作关闭文件对象。

---

总结

本节课中我们一起学习了Python中读取文件的三种核心方法：read()、readline()和readlines()。我们了解了每种方法的特点和适用场景，并强调了在文件操作完成后关闭文件流的重要性。掌握这些基础操作是进行更复杂文件处理的第一步。

098：处理文件中的换行符 📄

在本节课中，我们将要学习如何处理从文件中读取文本时遇到的换行符。换行符是文本文件中的一个特殊字符，它表示一行的结束。在Python中，当我们从文件读取行时，这个字符通常会被包含进来，有时我们需要将其移除以便于后续处理。

什么是换行符？

从文件中读取的每一行，其末尾都包含一个换行符，在代码中表示为 \n。

这个字符虽然不可见，但它是文本行结构的一部分。如果不进行处理，它可能会影响字符串的比较、拼接或输出格式。

如何使用 rstrip() 方法移除换行符

为了移除行末的换行符以及其他可能的空白字符（如空格、制表符），我们可以使用字符串的 rstrip() 方法。

上一节我们介绍了换行符的存在，本节中我们来看看如何清理它。

以下是使用 readline() 方法读取单行文本后，移除末尾空白字符（包括换行符）的示例：

代码描述：

line = file.readline().rstrip()

这行代码首先从文件中读取一行，然后立即调用 rstrip() 方法去除该行右侧（末尾）的所有空白字符。

在迭代文件流时处理换行符

更常见的情况是，我们直接迭代文件对象来逐行处理内容。同样，我们可以在处理每一行时移除其末尾的换行符。

以下是迭代文件流并清理每一行的示例：

代码描述：

with open('filename.txt', 'r') as file:
    for line in file:
        cleaned_line = line.rstrip()
        # 接下来处理 cleaned_line

在这段代码中，for 循环会遍历文件的每一行。在循环体内，我们对每一行 line 调用 rstrip() 方法，得到清理后的字符串 cleaned_line，然后可以对其进行任何需要的操作。

总结

本节课中我们一起学习了文件操作中一个重要的细节——换行符的处理。我们了解到：

1. 从文件读取的行包含末尾的换行符 \n。
2. 使用字符串的 rstrip() 方法可以方便地移除行末的换行符及其他空白字符。
3. 无论是使用 readline() 读取单行，还是通过迭代直接处理多行，rstrip() 都是清理数据的有效工具。

掌握这个方法能让你更干净地处理文本数据，为后续的字符串操作或数据分析打下良好基础。

099：04_05_写入文件 📝

在本节课中，我们将学习如何使用Python将数据写入文件。我们将介绍两种核心方法：write和writelines，并理解文件流操作的基本流程。

使用流将数据写入文件

上一节我们介绍了如何从文件中读取数据。本节中我们来看看如何将数据写入文件。与读取类似，我们同样需要使用“流”来操作文件。

你可以使用一个流（stream）将文本行写入文件。

写入单个字符串：write 方法

write方法用于向文件写入一个单独的字符串。

以下是使用write方法的基本步骤：

• 打开一个文件流，并指定模式为写入（如 'w'）。
• 调用流的 write() 方法，传入要写入的字符串。
• 完成写入后，关闭文件流以释放资源。

其核心操作可以用以下代码描述：

file_stream.write("要写入的字符串")

写入字符串列表：writelines 方法

而 writelines 方法用于将一个字符串列表写入文件。

以下是使用writelines方法需要注意的要点：

• 它接收一个可迭代对象（如列表），其中的每个元素都应是字符串。
• 该方法不会在写入的每个字符串后自动添加换行符，如果需要换行，必须在每个字符串元素中自行包含 \n。

其核心操作可以用以下代码描述：

lines_list = ["第一行\n", "第二行\n"]
file_stream.writelines(lines_list)

再次强调，使用这些写入方法时，操作完成后必须记得关闭流。

本节课中我们一起学习了如何向文件写入数据。我们掌握了write方法用于写入单个字符串，以及writelines方法用于写入一个字符串列表。关键是要记住，完成文件操作后，务必关闭文件流以确保数据被正确保存且释放系统资源。

100：关闭文件 📂

在本节课中，我们将要学习一个在文件操作中至关重要的概念：如何正确地关闭文件。理解并实践这一点，能确保你的程序稳定运行，并避免数据丢失或损坏。

概述

处理文件时，完成操作后关闭文件是一个必须养成的好习惯。不关闭文件可能导致无法重新打开该文件，或者写入的数据不完整。虽然操作系统有时会自动关闭未处理的文件，但这并非绝对可靠。因此，为了安全起见，我们应该始终显式地关闭文件。

关闭文件的方法

有两种主要的方法可以确保文件被正确关闭。下面我们将逐一介绍。

方法一：显式调用 .close() 方法

这是一种直接的方法。首先，我们使用 open() 函数打开文件，并将返回的文件对象存储在一个变量中（通常称为“流”）。完成所有文件操作后，我们调用该文件对象的 .close() 方法来关闭它。

以下是具体的代码示例：

stream = open("myfile.txt", "r")
# ... 在这里进行文件读取或写入操作 ...
stream.close()

在这段代码中，stream.close() 这一行执行后，文件对象就被关闭了。

方法二：使用 with 语句

这是一种更现代、更推荐的方法，因为它能自动管理文件的关闭。with 语句会创建一个上下文管理器，在代码块执行完毕后，无论是否发生异常，它都会自动关闭文件。

以下是使用 with 语句的代码示例：

with open("myfile.txt", "r") as stream:
    # ... 在这里进行文件读取或写入操作 ...
    # 当代码块执行完毕后，文件会自动关闭

使用这种方法，你无需手动调用 .close()。一旦程序退出 with 语句的缩进代码块，文件就会自动被安全地关闭。

总结

本节课中我们一起学习了关闭文件的两种方法。第一种是传统的手动调用 .close() 方法，第二种是使用更简洁安全的 with 语句。记住，养成及时关闭文件的好习惯，是编写健壮程序的重要一环。在后续的文件操作中，请务必实践这一点。

101：编程演示-打开并读取文件 📂

在本节课中，我们将学习如何编写一个Python函数来打开、读取并打印文本文件的内容。我们将通过一个具体的编程演示，逐步讲解文件操作的核心步骤。

概述

我们将创建一个名为 open_read_file 的函数。该函数接收一个文件名作为参数，执行以下操作：以读取模式打开文件，逐行读取内容并打印到控制台，同时统计文件的总行数，最后安全地关闭文件。通过这个练习，你将掌握Python中处理文件的基本方法。

函数定义与文件打开

首先，我们定义 open_read_file 函数。它使用Python内置的 open() 函数来打开指定的文件。

def open_read_file(filename):
    f = open(filename, 'r')

在这里，open(filename, 'r') 是关键。filename 是我们要打开的文件名，'r' 参数表示以“读取”模式打开。这个操作会返回一个文件流对象，我们将其赋值给变量 f。

为了确认文件已成功打开并查看流对象的类型，我们可以添加一行打印语句：

    print(type(f))

逐行读取与内容处理

成功打开文件后，下一步是读取其中的内容。我们将使用一个循环来逐行读取文件。

以下是实现这一过程的核心代码逻辑：

1. 初始化一个计数器 count 为0，用于统计行数。
2. 使用 f.readline() 方法读取第一行。
3. 进入一个 while 循环，只要读取到的行不是空字符串（表示文件末尾），就继续执行。
4. 在循环体内，打印当前行，然后读取下一行，并将计数器加1。

对应的代码如下：

    count = 0
    line = f.readline()
    while line:
        print(line)
        line = f.readline()
        count += 1

循环结束后，我们打印出文件的总行数。

    print(f"There are {count} lines in the file.")

关闭文件与程序执行

文件操作完成后，非常重要的一步是关闭文件，以释放系统资源。这通过文件流对象的 .close() 方法实现。

    f.close()

为了运行这个函数，我们定义一个 main 函数来调用它，并传入一个位于同一目录下的文件名（例如 news.txt）。

def main():
    open_read_file('news.txt')

if __name__ == "__main__":
    main()

运行程序后，控制台将依次输出：

1. 文件流对象的类型（例如 <class ‘_io.TextIOWrapper’>）。
2. 文件 news.txt 的每一行内容。
3. 文件的总行数统计（例如 “There are 10 lines in the file.”）。

总结

本节课我们一起学习了Python中基本的文件操作。我们创建了一个完整的函数，演示了如何安全地打开文件、读取其内容、处理数据（打印和计数）以及最终关闭文件。理解并掌握 open()、readline() 和 close() 这些方法是进行任何文件处理任务的基础。

102：编程演示-打开读取并追加到新文件 📂

在本节课中，我们将学习如何编写一个Python函数。这个函数会打开并读取一个文件的内容，将其中的文本行顺序反转，然后将反转后的内容追加到另一个文件中。

概述

我们将创建一个名为 open_read_append_new_file 的函数。该函数接收两个参数：一个用于读取的源文件路径和一个用于写入（追加）的目标文件路径。函数的核心任务是读取源文件的所有行，反转这些行的顺序，然后将反转后的行追加到目标文件的末尾。

函数定义与逻辑

首先，我们来定义这个函数。以下是函数的基本框架和逻辑步骤：

def open_read_append_new_file(file_to_read, file_to_write):
    # 函数逻辑将在这里实现

上一节我们介绍了函数的目标，本节中我们来看看如何一步步实现它。以下是实现该功能的具体步骤：

1. 打开并读取源文件：使用 with 语句以读取模式打开第一个文件，并将其所有行读入一个列表。
2. 反转列表顺序：对包含文件行的列表调用 .reverse() 方法。
3. 打开并写入目标文件：使用 with 语句以追加模式打开第二个文件，并将反转后的列表写入该文件。
4. 自动关闭文件：利用 with 语句的特性，文件会在代码块执行完毕后自动关闭，无需手动调用 .close() 方法。

代码实现详解

现在，让我们将上述步骤转化为完整的Python代码。

def open_read_append_new_file(file_to_read, file_to_write):
    # 步骤1：打开并读取源文件
    with open(file_to_read, 'r') as fin:
        lines_list = fin.readlines()

    # 步骤2：反转列表顺序
    lines_list.reverse()

    # 步骤3：打开并追加到目标文件
    with open(file_to_write, 'a') as fout:
        fout.writelines(lines_list)

代码解释：

• with open(file_to_read, 'r') as fin:：这行代码使用 with 上下文管理器打开 file_to_read 指定的文件。模式 'r' 表示读取。文件对象被赋值给变量 fin。with 语句确保文件在代码块结束后会被正确关闭。
• lines_list = fin.readlines()：readlines() 方法读取文件的所有行，并将每一行作为一个字符串元素，返回一个列表。这个列表被存储在变量 lines_list 中。
• lines_list.reverse()：这是列表对象的一个方法，它会原地反转列表中元素的顺序。执行后，lines_list 中的第一行变成最后一行，最后一行变成第一行。
• with open(file_to_write, 'a') as fout:：同样使用 with 语句打开 file_to_write 指定的文件。模式 'a' 表示追加。如果文件不存在，Python会自动创建它。文件对象被赋值给变量 fout。
• fout.writelines(lines_list)：writelines() 方法接收一个字符串列表作为参数，并将列表中的所有字符串写入文件。由于我们是以追加模式打开的，新内容会被添加到文件原有内容的末尾。

调用函数

函数定义好后，我们需要从程序的主入口（例如 main 函数或脚本的顶层代码）调用它。

假设我们有一个名为 news.txt 的源文件，并希望将反转后的内容输出到 news_out.txt 文件。

# 调用我们定义的函数
open_read_append_new_file('news.txt', 'news_out.txt')

运行这段程序后，你会在当前目录下发现一个新文件 news_out.txt。打开它，你会看到其内容正是 news.txt 中所有行的反向排列。

总结

本节课中我们一起学习了如何操作文件。我们创建了一个 open_read_append_new_file 函数，它完整演示了文件的读取、数据处理（反转行顺序）和写入（追加）的流程。关键点在于：

1. 使用 with open(...) as ...: 语句可以安全、自动地管理文件对象的打开和关闭。
2. readlines() 方法用于将文件所有行读入列表。
3. 列表的 .reverse() 方法用于反转列表元素顺序。
4. 使用 'a'（追加）模式打开文件进行写入，如果文件不存在则会自动创建。
5. writelines() 方法用于将一个字符串列表写入文件。

通过这个练习，你掌握了Python中进行基础文件I/O操作的核心方法。

Python与Java编程入门1-2：103：编程演示 - 打开、读取并追加到原文件 📄

在本节课程中，我们将学习如何创建一个函数，该函数能够打开一个文件，读取其内容，并向同一个文件追加新的内容。我们将使用Python的文件操作模式来实现这一功能。

---

上一节我们介绍了基本的文件读写操作，本节中我们来看看如何对同一个文件进行读取和追加写入。

现在，让我们创建一个名为 open_read_append_same_file 的函数，它用于打开并读取一个文件，然后向同一个文件追加内容。

首先，我们定义这个函数。它接收一个文件名作为参数。

def open_read_append_same_file(filename):

此函数将执行以下操作：打开指定文件，将所有行读取到一个列表中，然后向同一个文件追加内容。

由于我们需要对同一个文件进行读取和写入，因此我们使用 ‘r+’ 模式来打开文件。这个模式允许我们同时进行读取和写入操作。

    f = open(filename, ‘r+’)

接下来，我们将文件的所有行读取到一个列表中。

    lst = f.readlines()

在将内容追加回原文件之前，我们可以先对这个列表进行一些修改。例如，我们可以在列表的开头插入一些新的文本行。

以下是修改列表的步骤：

    lst.insert(0, ‘\n‘)  # 在列表开头插入一个空行
    lst.insert(0, ‘Here is some new text.\n‘)  # 在列表开头插入一行新文本
    lst.insert(0, ‘\n‘)  # 再插入一个空行，作为分隔

现在，列表已经更新完毕。接下来，我们需要将修改后的列表内容写回原文件。由于我们是以 ‘r+’ 模式打开的文件，写入操作将从文件末尾开始，从而实现追加的效果。

    f.writelines(lst)

最后，不要忘记关闭文件，这是一个良好的编程习惯。

    f.close()

函数定义完成后，我们需要在主函数中调用它来测试效果。

def main():
    open_read_append_same_file(‘news.txt‘)

运行这段代码。然后，如果我们打开 news.txt 文件，将会看到文件的开头已经追加了我们插入的新文本行和空行。每次运行此函数，都会在文件开头再次追加相同的内容。

---

本节课中我们一起学习了如何创建一个函数来打开、读取并向同一个文件追加内容。我们使用了 ‘r+’ 文件模式，并演示了如何通过修改读取到的列表来更新文件内容。记住，在完成文件操作后，务必关闭文件。

104：编程演示-打开读取并写入新文件 📄

在本节课中，我们将学习如何编写一个Python函数，该函数能够打开一个文件、读取其内容，并将这些内容完整地复制到另一个新文件中。这是文件操作的基础技能。

---

上一节我们介绍了文件操作的基本概念，本节中我们来看看如何具体实现一个文件复制函数。

现在，让我们创建一个名为 open_read_write_new_file 的函数，它的功能是将一个文件中的文本复制到另一个文件。

以下是创建该函数的步骤：

1. 打开第一个文件用于读取：我们使用 with 关键字和 open() 函数，以默认的读取模式打开第一个文件。这确保了文件在使用后会被正确关闭。

   with open(file1) as fin:
   

2. 读取文件全部内容：我们使用文件对象的 .read() 方法，将文件中的所有行读取为一个单独的字符串。

   text = fin.read()
   

3. 打开第二个文件用于写入：我们再次使用 open() 函数，但这次指定模式为写入模式 (‘w’)。如果目标文件不存在，此操作会自动创建它。

   with open(file2, ‘w’) as fout:
   

4. 将内容写入第二个文件：我们使用文件对象的 .write() 方法，将之前读取的字符串 text 写入到第二个文件中。

   fout.write(text)
   

将以上步骤组合起来，就构成了我们的函数。以下是完整的函数定义：

def open_read_write_new_file(file1, file2):
    # 打开第一个文件并读取全部内容
    with open(file1) as fin:
        text = fin.read()
    # 打开（或创建）第二个文件并写入内容
    with open(file2, ‘w’) as fout:
        fout.write(text)

---

函数定义完成后，我们需要调用它来执行复制操作。

让我们调用这个函数，将 news.txt 文件的内容复制到一个名为 news_copy.txt 的新文件中。

open_read_write_new_file(‘news.txt‘, ‘news_copy.txt‘)

运行这段代码后，你会在当前目录下发现一个新文件 news_copy.txt。打开这个文件，你会看到它的内容与原始的 news.txt 文件完全一致，证明复制操作成功。

---

本节课中我们一起学习了如何编写一个完整的文件复制函数。我们掌握了使用 with open() as ... 语句安全地打开文件，使用 .read() 方法读取内容，以及使用 .write() 方法将内容写入新文件。这是处理文本文件的基础且重要的操作。

105：编程演示-文件转字典

在本节课中，我们将学习如何编写代码，从一个文本文件中读取数据，并将其内容整理成一个字典。我们将处理一个包含用户及其消费金额的文件，目标是计算每个用户的总消费额。

概述

我们将创建一个名为 import_and_create_dictionary 的函数。该函数接收一个文件名作为参数，读取文件内容，并返回一个字典。字典的键是用户名，值是该用户的总消费金额。文件中的每一行格式应为 用户名, 消费金额。我们的代码需要能够处理空行、缺失金额或无效金额的情况，并忽略这些行。

代码实现步骤

上一节我们介绍了任务目标，本节中我们来看看具体的实现步骤。

以下是创建字典的核心步骤：

1. 初始化空字典：首先，我们创建一个空的字典来存储结果。

   expenses = {}
   

2. 读取文件：打开指定的文件，并将其所有行读取到一个列表中。

   f = open(filename, 'r')
   lines = f.readlines()
   

3. 处理每一行：遍历列表中的每一行。

   for line in lines:
   

4. 清理和分割：移除每行首尾的空白字符，然后根据逗号 , 进行分割。

   lst = line.strip().split(',')
   

5. 检查数据完整性：检查分割后的列表长度。如果长度小于等于1，说明该行缺少消费金额，应跳过。

   if len(lst) <= 1:
       continue
   

6. 提取键和值：从列表中提取用户名（键）和消费金额字符串（值），并再次清理首尾空格。

   key = lst[0].strip()
   value = lst[1].strip()
   

7. 转换数值：尝试将消费金额字符串转换为浮点数。如果转换失败（例如遇到非数字字符），则跳过该行。

   try:
       value = float(value)
   except ValueError:
       continue
   

8. 更新字典：在字典中查找该用户当前的总消费额（如果不存在则默认为0），加上新的消费金额，然后更新回字典。

   expenses[key] = expenses.get(key, 0) + value
   

9. 关闭文件并返回结果：处理完所有行后，关闭文件并返回构建好的字典。

   f.close()
   return expenses
   

运行示例

现在，让我们创建一个主函数来测试我们的代码。

我们将调用 import_and_create_dictionary 函数处理名为 expenses.txt 的文件，并打印结果字典。

def main():
    expenses = import_and_create_dictionary('expenses.txt')
    print(expenses)

if __name__ == '__main__':
    main()

运行程序后，输出结果如下：

{'Brandon': 443.0, 'Ted': 938.21, 'Barbara': 102.0, 'Betsy': 864.31}

这个字典准确地反映了每个用户的总消费额。例如，用户 Brandon 在文件中有两笔有效消费（342 和 101），总和为 443，与我们的计算结果一致。

总结

本节课中我们一起学习了如何从文件创建字典。我们实现了一个函数，它能读取格式化的文本文件，处理可能出现的异常数据（如空行、格式错误），并最终汇总生成一个以用户名为键、总消费额为值的字典。这个练习涵盖了文件操作、字符串处理、异常捕获和字典更新等核心编程概念。

106：在线银行系统介绍 💻

在本作业中，你将实现一个在线银行系统。用户可以在系统中注册、登录、更改密码和删除账户。他们还可以更新自己的银行账户余额，并向其他用户的银行账户转账。

概述 📋

上一节我们介绍了作业的整体目标。本节中，我们将深入探讨实现该系统所需的具体功能，特别是与文件输入输出和字典操作相关的部分。

你需要实现与文件I/O和字典相关的函数。其中两个函数要求你导入文件并创建字典。用户信息将从 user.txt 文件导入，账户信息将从 bank.txt 文件导入。其余函数要求你使用或修改从这些文件创建的两个字典。

查看数据文件 📂

在开始编码之前，让我们先查看程序将要导入的文件。以下是这些文件的内容和格式说明。

用户文件 (user.txt)

此文件包含用户账户信息。你的程序将导入此文件，并根据其中包含的信息创建一个用户账户字典。

文件中的每一行都包含一个用户账户的信息。每行的格式应相同：用户名，后跟一个空格、一个连字符、另一个空格，然后是用户密码。你的程序将读取此文件中的每一行，并在用户账户字典中创建一个账户。

请注意，文件中某些行可能缺少密码或包含无效密码。你的代码在导入文件时必须考虑这些情况。

银行账户文件 (bank.txt)

此文件包含银行账户信息。你的程序将导入此文件，并根据其中包含的信息创建一个银行账户字典。

文件中的每一行都包含特定用户银行账户的初始存款金额。每行的格式应相同：用户名，后跟一个冒号，然后是初始存款金额。你的程序将从此文件加载每一行，并计算特定用户的总初始存款金额。

请注意，文件中某些行可能包含无效的存款金额、缺少存款金额，或者完全是空行。你的代码在导入文件时需要考虑到这些不同类型的行。

实现 import_and_create_bank 函数 🛠️

现在，让我们开始编写一些代码。我们将要编写的第一个函数是 import_and_create_bank。该函数将接收一个给定的文件名，并从该文件创建一个银行账户字典。我们将要读取的文件是 bank.txt。

以下是该函数的基本框架和实现步骤：

def import_and_create_bank(filename):
    bank = {}
    # 打开文件并读取所有行
    f = open(filename, 'r')
    lines = f.readlines()
    # 遍历每一行
    for line in lines:
        # 去除行首尾空白字符，并按冒号分割
        lst = line.strip().split(':')
        # 如果分割后的列表长度小于2，跳过该行
        if len(lst) <= 1:
            continue
        # 提取键（用户名）和值（存款金额）
        key = lst[0].strip()
        value = lst[1].strip()
        # 尝试将存款金额转换为数值
        try:
            value = float(value)
        except:
            # 如果转换失败，跳过该行
            continue
        # 将存款金额累加到该用户的账户余额中
        bank[key] = bank.get(key, 0) + value
    # 关闭文件
    f.close()
    # 返回创建的字典
    return bank

代码步骤详解

1. 打开文件并读取：使用 open 函数以读取模式打开文件，并使用 readlines 方法获取所有行的列表。
2. 处理每一行：遍历列表中的每一行。
3. 分割和清理：使用 strip 方法去除行首尾的空白字符，然后使用 split(':') 按冒号将行分割成列表。
4. 有效性检查：检查分割后的列表长度。如果长度小于等于1（意味着缺少冒号分隔符或冒号后没有内容），则使用 continue 跳过该行。
5. 提取键值对：从列表中提取索引0和1的元素，分别作为键（用户名）和值（存款金额），并再次使用 strip 去除可能存在的多余空格。
6. 数值转换：将存款金额字符串尝试转换为浮点数。如果转换失败（例如，值是“XYZ”），则跳过该行。
7. 更新字典：使用 bank.get(key, 0) 获取该用户当前的账户余额（如果不存在则默认为0），然后加上新的存款金额，并更新回字典中。
8. 关闭文件并返回：处理完所有行后，关闭文件并返回创建好的银行账户字典。

测试函数

运行该函数后，我们可以打印出创建的字典并进行测试。例如，对于示例数据，用户“Brandon”的账户余额应为115.5（5 + 10 + 100.5）。对于文件中不存在的用户（如“Joel”），查询其余额应返回 None（或通过 .get 方法返回默认值）。

总结 📝

本节课中，我们一起学习了作业4“在线银行系统”的概述和第一个核心函数的实现。我们了解了需要处理的两个数据文件（user.txt 和 bank.txt）的格式，并详细实现了 import_and_create_bank 函数，该函数负责从文件导入数据并构建一个银行账户余额字典。我们重点掌握了文件读取、字符串分割与清理、异常处理以及字典的更新操作。

下一节，我们将继续实现导入用户账户信息的函数以及其他系统功能。

107：课程介绍

在本节课中，我们将要学习一门关于使用Python进行基础数据科学分析的入门课程。课程将介绍核心的数据处理概念，并指导我们如何加载、检查和分析真实世界的数据，以回答基本的数据问题。

课程概述 📋

本课程介绍使用Python进行基础数据科学分析的技术。

它引入了核心概念，例如数据框，这是一个二维的、带标签的数据结构，以及数据连接，即将多个数据框合并为单一结构。

学习目标 🎯

本模块将概述如何加载、检查和查询真实世界的数据，以及如何回答关于这些数据的基本问题。

你将掌握数据聚合与汇总，以及数据可视化的技能。此外，你将获得使用数据分析库的经验，例如 Pandas、NumPy 和 Matplotlib。

核心概念与工具 🔧

以下是本课程将涉及的核心概念与工具：

• 数据框：一个二维的、带标签的数据结构，是数据分析的核心。在Python中，我们通常使用Pandas库的DataFrame对象来处理。

  import pandas as pd
  df = pd.DataFrame(data)
  

• 数据连接：将多个数据框基于某些共同字段合并的操作。例如，使用Pandas的merge函数。

  merged_df = pd.merge(df1, df2, on='key_column')
  

• 数据分析库：课程将重点使用三个强大的Python库：
  • Pandas：用于数据操作和分析。
  • NumPy：支持大型多维数组和矩阵运算。
  • Matplotlib：用于创建静态、交互式和动画可视化的综合库。

总结 📝

本节课中，我们一起学习了这门数据科学入门课程的整体框架。我们了解到，课程将围绕数据框和数据连接等核心概念展开，并指导我们使用Pandas、NumPy和Matplotlib等工具来完成数据加载、检查、聚合、汇总和可视化等一系列任务，最终目标是能够分析和回答关于真实数据的问题。

108：讲师介绍 🧑‍🏫

在本节课中，我们将认识本课程的讲师Brandon Krakowsky，了解他的专业背景和个人经历。

大家好，我是Brandon Krakowsky，我是这门编程语言与技术课程的讲师。

关于我的背景，我最初是一名音乐家，之后在无线电广播和音频制作领域工作。

我的编程经验始于Adobe Flash。我曾使用这个工具为一家大型制药公司开发了一个实时网络会议平台。

我获得了宾夕法尼亚大学的计算机与信息技术硕士学位，并曾在宾夕法尼亚大学设计学院担任程序员。

之后，我在沃顿商学院计算部门担任应用开发人员，与教职员工合作构建技术，以推进多个学生项目。

在此期间，我创立了自己的公司Bak LLC，为多家公司提供编程和自由职业应用开发服务。

后来我转向数据与分析领域，成为沃顿客户分析部门的研究与教育总监，负责管理来自世界各地的学生和学术研究人员参与的大规模研究项目。

最近，我成为了宾夕法尼亚大学工程学院的讲师。关于我个人，我弹奏贝斯，喜欢我的狗，并且重视家庭。

本节课中我们一起学习了本课程讲师Brandon Krakowsky的职业发展路径和个人兴趣。他的经历展示了从艺术到技术，再到教育与创业的多元化跨界旅程。

109：下载与安装Jupyter Notebook 📓

在本节课中，我们将要学习如何下载和安装Jupyter Notebook，这是一个用于编写和运行Python代码的强大工具。

概述

Jupyter Notebook是一个基于浏览器的交互式计算环境。它集成了Python解释器和脚本编辑器，允许你创建包含代码、文本和可视化的文档。本节将指导你完成安装过程。

下载与安装Anaconda

为了开始使用Jupyter Notebook，我们首先需要安装它。最简单的方法是下载Anaconda，这是一个集成了Python、Jupyter Notebook以及其他众多数据科学工具的平台。Anaconda会一次性安装好所有必需的组件。

以下是安装步骤：

1. 访问Anaconda官方网站。
2. 根据你的操作系统（Windows、macOS或Linux）下载对应的安装程序。
3. 运行下载的安装程序，并按照提示完成安装。

启动Jupyter Notebook

安装完成后，你有两种主要方式来启动Jupyter Notebook。

方法一：通过命令行启动

你可以通过系统的命令行工具来启动Jupyter Notebook。

• 在macOS上，打开“终端”（Terminal）应用程序。
• 在Windows上，打开“命令提示符”（Command Prompt）。

在打开的命令行窗口中，输入以下命令并按回车键：

jupyter notebook

执行此命令后，你的默认浏览器会自动打开，显示Jupyter Notebook的主界面。

方法二：通过Anaconda Navigator启动

如果你更喜欢图形化界面，可以使用Anaconda Navigator来启动。

1. 在你的应用程序列表中找到并打开“Anaconda Navigator”。
2. 在Navigator的主界面中，找到Jupyter Notebook的图标。
3. 点击该图标下方的“Launch”（启动）按钮。

总结

本节课中我们一起学习了Jupyter Notebook的安装与启动。我们了解到Jupyter Notebook是一个在浏览器中运行的交互式编程环境。我们通过安装Anaconda平台一次性获得了Python和Jupyter Notebook。最后，我们掌握了两种启动Jupyter Notebook的方法：通过系统命令行输入 jupyter notebook 命令，或者通过Anaconda Navigator的图形界面进行启动。现在你的编程环境已经准备就绪，可以开始编写和运行Python代码了。

110：使用Jupyter Notebook 📓

在本节课中，我们将学习如何启动、创建和操作Jupyter Notebook文件，这是编写和运行Python代码的便捷环境。

概述

Jupyter Notebook是一个交互式编程环境，允许你在“单元格”中编写和运行代码，非常适合学习和快速原型开发。本节将指导你完成从启动到基本操作的完整流程。

启动Jupyter Notebook

下载并安装Anaconda后，你可以通过几种方式启动Jupyter Notebook。

最简单的方法是打开电脑上的Anaconda Navigator，然后点击Jupyter Notebook旁边的“启动”按钮。

这将在你的默认浏览器中启动Jupyter Notebook。

创建与保存笔记本

你可以导航到想要创建和保存笔记本文件的文件夹。

要创建一个新笔记本，请点击右上角的“新建”按钮，然后选择最新版本的Python（通常是Python 3）。

这将创建你的第一个笔记本文件。

要重命名它，请点击顶部的标题，输入新名称，然后点击“重命名”。

编写与运行代码

你将在单元格内编写和运行Python代码。

例如，输入以下代码：

print("Hello, world")

要运行代码，你可以按 Control + Return。这将在当前单元格中运行代码，本例中会将“Hello, world”打印到控制台。

或者，你可以按 Shift + Return。这也会运行单元格中的代码，并在下方创建一个新的单元格。

管理单元格

如果你想手动创建新单元格，可以点击单元格左侧选中它，然后按键盘上的 A 键。A 键会在上方插入一个单元格。

如果选中一个单元格后按 B 键，则会在下方插入一个单元格。

要删除一个单元格，点击单元格左侧选中它，然后按两次 D 键（即 D, D）。

保存与退出

笔记本文件会自动保存，但如果你想手动保存，可以点击左侧的保存按钮。

要退出Jupyter Notebook，你可以关闭笔记本文件标签页。

然后，点击右上角的“退出”按钮。这将停止服务器并退出Jupyter Notebook。

总结

本节课中，我们一起学习了Jupyter Notebook的基本操作：如何启动程序、创建和重命名笔记本、在单元格中编写并运行Python代码、以及如何管理单元格和保存工作。掌握这些是使用Jupyter Notebook进行高效编程的第一步。

111：导入与读取文件-使用CSV模块 📂

在本节课中，我们将要学习如何使用Python内置的功能来读取和写入文件，特别是如何使用csv模块来处理CSV格式的文件。我们将从打开文件的基本操作开始，逐步深入到使用csv.DictReader类来读取数据。

打开文件

在读取文件之前，必须先打开文件。Python提供了内置的open()函数来完成这个操作。

其格式如下：

open(fname, access_mode)

其中，fname是文件名，包括文件路径。access_mode是一个可选参数，用于指定文件的打开模式，例如“只读”或“写入”。默认模式是“只读”（'r'）。

例如，以下代码以只读模式打开位于my_file_path路径下的一个CSV文件：

file = open('my_file_path/my_file.csv', 'r')

这行代码会为my_file.csv文件创建一个文件对象，并设置为只读模式。

文件访问模式

打开文件时，可以指定以下几种访问模式：

• 'r'：以只读模式打开文件。这是默认模式。
• 'w'：以只写模式打开文件。如果文件已存在，则覆盖它；如果文件不存在，则创建新文件。
• 'a'：以追加模式打开文件。光标位于文件末尾，如果文件不存在则创建新文件。
• 'r+'：以读写模式打开文件。

使用CSV模块读取文件

csv模块提供了用于读写CSV（逗号分隔值）文件的类。其中，csv.DictReader类非常有用，它能将CSV文件中的信息读取并映射到一个字典对象中。

以下是使用csv.DictReader的基本步骤：

1. 导入csv模块。
2. 使用open()函数以只读模式打开目标文件。
3. 调用csv.DictReader()并传入文件对象，它会返回一个可用于读取文件中数据的reader对象。

示例代码如下：

import csv
file = open('data.csv', 'r')
reader = csv.DictReader(file)

关闭文件

文件读取完毕后，应当将其关闭。可以使用内置的close()函数。这个操作会刷新所有未写入的信息并关闭文件对象。文件关闭后，就无法再进行读取或写入操作。养成使用close()函数关闭文件的习惯是良好的编程实践。

例如：

import csv
file = open('data.csv', 'r')
reader = csv.DictReader(file)
# ... 处理数据的其他操作 ...
file.close()  # 关闭文件对象

使用with语句自动管理文件

为了确保文件总能被正确关闭，可以使用with语句。它能在代码块执行完毕后自动关闭文件，无需手动调用close()。

以下是使用with语句的示例：

import csv
with open('data.csv', 'r') as csv_file:
    reader = csv.DictReader(csv_file)
    # ... 处理数据的其他操作 ...
# 当代码块执行完毕，文件会自动关闭

总结

本节课中我们一起学习了Python文件操作的基础知识。我们了解了如何使用open()函数以不同模式打开文件，重点介绍了如何使用csv模块的DictReader类来方便地读取CSV文件数据。我们还强调了使用close()函数手动关闭文件的重要性，并学习了使用with语句来自动管理文件资源，这是一种更安全、更简洁的做法。掌握这些内容是进行数据处理和分析的重要第一步。

112：编码演示-分析史上最伟大的500张专辑 🎵

在本节课中，我们将学习如何使用Python的CSV模块来加载和分析一个数据集。我们将以《滚石》杂志评选的“史上最伟大的500张专辑”列表为例，学习如何读取CSV文件、查看数据结构、提取特定信息以及使用列表推导式进行高效的数据筛选。

概述数据集

我们将分析的数据集是《滚石》杂志2012年评选的“史上最伟大的500张专辑”列表，其中包含了专辑的流派信息。数据文件包含以下列：

• number：专辑在榜单上的排名。
• year：专辑的发行年份。
• album：专辑的名称。
• artist：艺术家的名称。
• genre：专辑的主要流派名称。
• subgenre：一个由逗号分隔的子流派名称列表。

加载和读取CSV文件

首先，我们需要导入csv模块并使用它来读取我们的数据文件。

以下是加载和读取CSV文件的基本步骤：

1. 导入csv模块。
2. 使用with语句和open()函数以读取模式打开文件。
3. 使用csv.DictReader()将文件内容读取为一个字典阅读器。

import csv

with open(‘album_list.csv‘, ‘r‘) as csv_file:
    reader = csv.DictReader(csv_file)
    print(type(reader))
    print(reader.fieldnames)

运行这段代码后，我们会看到reader的类型是csv.DictReader，并且打印出了文件的所有列标题。

遍历并打印数据行

上一节我们介绍了如何加载文件，本节中我们来看看如何查看文件中的具体数据。我们可以使用for循环来遍历字典阅读器并打印每一行数据。

with open(‘album_list.csv‘, ‘r‘) as csv_file:
    reader = csv.DictReader(csv_file)
    for row in reader:
        print(row)

这段代码会打开文件，将其加载到阅读器中，然后遍历并打印文件中的每一行。每一行数据都会以一个有序字典的形式显示，其中包含列名和对应的值。

重要提示：默认情况下，csv.DictReader对象只能被迭代一次。这是因为它是直接从文件流中读取数据，而不是将整个数据集加载到内存中。目前，最简单的解决方案是每次需要使用时都重新加载文件。

打印前100行数据

有时我们只需要查看数据集的一部分。以下是如何使用循环和控制语句来打印前100行数据。

with open(‘album_list.csv‘, ‘r‘) as csv_file:
    reader = csv.DictReader(csv_file)
    rows_to_print = 100
    for row in reader:
        rows_to_print -= 1
        if rows_to_print >= 0:
            print(row)
        else:
            break

这段代码会重新加载文件，设置一个计数器，然后遍历阅读器。每打印一行，计数器减1。当计数器小于0时，循环终止。这样我们就只看到了前100行数据。

将数据复制到列表

为了更方便地进行后续分析，避免反复读取文件，我们可以将数据从字典阅读器复制到一个Python列表中。

以下是具体步骤：

1. 打开文件并加载到阅读器。
2. 创建一个空列表。
3. 遍历阅读器，将每一行数据（字典）添加到列表中。

albums = []
with open(‘album_list.csv‘, ‘r‘) as csv_file:
    reader = csv.DictReader(csv_file)
    for row in reader:
        albums.append(row)

print(f“Number of albums: {len(albums)}“)

运行后，我们会看到列表albums的长度是500，与文件中的行数一致。现在，我们可以直接使用albums列表进行后续的所有分析。

使用列表推导式筛选数据

列表推导式是Python中一种优雅且简洁的创建新列表的方法。它由一个表达式和一个for循环组成，放在方括号内。其含义是：为循环的每一次迭代执行某个操作，并将结果添加到新列表中。

让我们使用列表推导式来找出所有在1974年发行的专辑。

albums_1974 = [row for row in albums if row[‘year‘] == ‘1974‘]
print(f“Number of albums in 1974: {len(albums_1974)}“)

这段代码会遍历albums列表中的每一行（row），检查其year字段是否等于字符串‘1974‘，如果是，则将该行添加到新列表albums_1974中。最后打印出新列表的长度。

结果显示有14张专辑在1974年发行。我们可以进一步打印这些专辑的详细信息：

for album in albums_1974:
    print(album[‘album‘], “by“, album[‘artist‘])

如果我们只想查看1974年专辑列表中的前10张，可以在列表推导式的结果上使用切片操作：

first_10_1974 = [row for row in albums if row[‘year‘] == ‘1974‘][:10]
print(first_10_1974)

进行复杂条件筛选

现在，让我们进行一个更复杂的筛选：找出所有主要流派（genre）为“Rock”，并且子流派（subgenre）列表中包含“Pop Rock”或“Fusion”的专辑。

这需要我们检查列表类型的字段。以下是实现方法：

rock_albums = []
for row in albums:
    if row[‘genre‘] == ‘Rock‘ and (‘Pop Rock‘ in row[‘subgenre‘] or ‘Fusion‘ in row[‘subgenre‘]):
        rock_albums.append(row)

for album in rock_albums:
    print(album[‘album‘], album[‘artist‘], album[‘genre‘], album[‘subgenre‘])

这段代码的逻辑是：遍历albums列表中的每一行，如果该行的genre字段等于‘Rock‘，并且其subgenre字段（一个字符串）中包含子串‘Pop Rock‘或‘Fusion‘，则将该行添加到rock_albums列表中。最后，遍历并打印出筛选结果中每张专辑的名称、艺术家、流派和子流派。

请注意：原描述中subgenre是“逗号分隔的列表”，在CSV文件中通常作为一个字符串读取（例如“Pop Rock, Blues Rock“）。因此，代码中使用in操作符检查子字符串是否存在于这个字符串中。如果subgenre字段在读取时已被正确解析为Python列表，则应使用‘Pop Rock‘ in row[‘subgenre‘]的语法。

总结

本节课中我们一起学习了使用Python csv模块进行数据分析的基础操作。我们掌握了如何加载CSV文件、查看其结构和内容、将数据转换为更易操作的列表形式，以及使用for循环和列表推导式根据特定条件（如年份、流派）来筛选数据。这些技能是处理表格数据并进行初步探索性分析的核心。通过分析“史上最伟大的500张专辑”这个有趣的数据集，我们实践了从数据加载到信息提取的完整流程。

113：编码演示-捕获数据错误与排序 🐍

在本节课中，我们将学习如何处理数据集中的错误数据，并探索如何使用Lambda函数对数据进行排序。我们将从一个包含专辑信息的数据集开始，目标是找出其中最早的发行年份，并学习如何按艺术家姓名对专辑列表进行排序。

概述

我们将首先尝试从数据集中提取发行年份并找出最小值，但会遇到非数值数据导致的错误。为了解决这个问题，我们将编写一个函数来安全地验证和转换数据。之后，我们将介绍Lambda函数的概念，并演示如何使用它作为sorted函数的参数来对数据进行自定义排序。

处理数据错误

首先，我们的目标是找出数据集中所有专辑的最早发行年份。我们尝试创建一个包含所有发行年份的整数列表。

以下是创建发行年份列表的初始代码：

release_years = []
for row in albums:
    if row['year']:
        release_years.append(int(row['year']))

运行这段代码时，我们遇到了一个ValueError，提示“invalid literal for int() with base 10”。这意味着year列中的某个值不是有效的数字字符串，无法转换为整数。

与其手动查找这个无效值，我们更合理的做法是编写代码来处理这种异常情况。我们将定义一个函数，通过捕获ValueError来安全地检查一个字符串是否能被转换为整数。

定义验证函数

我们定义一个名为is_valid_year的函数。在Python中，我们使用def关键字来定义函数。

def is_valid_year(year_string):
    try:
        year = int(year_string)
        return year
    except ValueError:
        return False

这个函数尝试将输入的字符串转换为整数。如果转换成功，则返回该整数；如果引发ValueError异常，则返回False，表示提供的年份无效。

使用验证函数过滤数据

现在，我们使用这个is_valid_year函数来生成一个只包含有效年份的列表。我们使用列表推导式来简化代码。

release_years = [int(row['year']) for row in albums if is_valid_year(row['year'])]
print(release_years)

运行代码后，我们得到了一个有效的发行年份列表。

接着，我们打印出最小的发行年份：

print(min(release_years))

输出结果是1399。然而，1399年对于我们的数据集来说并不是一个合理的年份。这表明我们的验证逻辑还需要加强。

完善验证逻辑

我们需要修改is_valid_year函数，使其不仅检查能否转换为整数，还要检查年份是否大于一个合理的阈值（例如1400年）。

def is_valid_year(year_string):
    try:
        year = int(year_string)
        if year > 1400:
            return year
        else:
            return False
    except ValueError:
        return False

现在，一个有效的年份必须能转换为整数并且大于1400。我们重新运行生成列表和查找最小值的代码，得到了更合理的结果1955。

上一节我们介绍了如何捕获和处理数据错误，确保我们只处理有效的数据。接下来，我们将看看如何对处理后的数据进行排序。

使用Lambda函数进行排序

为了对数据进行灵活的排序，Python提供了sorted函数和一个强大的工具——Lambda函数。

理解Lambda函数

Lambda函数是一种匿名、单行的迷你函数，可以即时定义和使用。它适用于需要一个简单函数作为参数的场景。

以下是一个将数字加倍的常规函数定义：

def double(x):
    return x * 2
print(double(4))  # 输出 8

使用Lambda函数可以实现相同的功能：

double_l = lambda x: x * 2
print(double_l(4))  # 输出 8

Lambda函数特别适合作为参数传递给其他高阶函数，例如sorted函数的key参数。

对专辑列表进行排序

sorted函数接受一个可选的key参数，该参数指定一个函数，用于从每个元素中提取比较键。

假设我们想按艺术家（artist）的名字对albums列表进行排序。我们可以向sorted函数传递一个Lambda函数作为key。

albums_sorted = sorted(albums, key=lambda x: x['artist'])

在这行代码中：

• sorted(albums, ...) 对albums列表进行排序。
• key=lambda x: x[‘artist’] 定义了一个Lambda函数，它接收一个参数x（代表列表中的每一行数据），并返回该行的artist字段的值。sorted函数将根据这个返回值来排列列表中的元素。

运行这行代码后，albums_sorted就是一个按艺术家名字字母顺序排列的新列表。

总结

本节课中我们一起学习了两个重要的编程技巧。
首先，我们学习了如何处理数据集中的异常值。通过定义is_valid_year函数并使用try-except块捕获ValueError，我们能够安全地过滤掉无效的年份数据，并在此基础上计算出合理的最早发行年份。
其次，我们介绍了Lambda函数，这是一种简洁的定义匿名函数的方式。我们演示了如何将Lambda函数作为sorted函数的key参数，从而实现对数据列表的自定义排序，例如按艺术家姓名对专辑进行排序。
掌握错误处理和Lambda函数的使用，将使你能够更稳健、更灵活地处理和分析数据。

114：编码演示-计算最大值与最小值 🎯

在本节课中，我们将学习如何使用Python从数据集中找出最新的专辑。我们将通过过滤无效数据、使用max()函数以及lambda表达式来实现这一目标。

概述与数据准备

首先，我们需要从数据集中找出发行年份最晚的专辑，并输出其专辑名、艺术家和发行年份。由于部分专辑的发行年份数据可能无效，我们的第一步是过滤掉这些无效数据。

以下是具体步骤：我们将创建一个名为valid_albums的列表，其中只包含发行年份有效的专辑。我们使用列表推导式来实现这一点，对albums列表中的每一行数据，调用is_valid_year函数检查其年份是否有效。

valid_albums = [row for row in albums if is_valid_year(row[‘year’])]

计算最新专辑

上一节我们介绍了如何过滤出有效的专辑数据。本节中，我们来看看如何从这些有效数据中找到发行年份最晚的专辑。

我们使用Python内置的max()函数来完成这个任务。max()函数可以接受一个key参数，该参数允许我们指定一个函数来决定比较的依据。在这里，我们使用lambda表达式来告诉函数，应该根据专辑的“year”字段来寻找最大值。

album_max = max(valid_albums, key=lambda x: x[‘year’])

输出结果

在找到最新的专辑后，我们需要将其信息打印出来。

以下是需要打印的信息项：

• 专辑标题
• 艺术家
• 发行年份

对应的代码如下：

print(album_max[‘title’])
print(album_max[‘artist’])
print(album_max[‘year’])

运行代码后，我们得到的结果是：数据集中最新的专辑是The Beach Boys在2011年发行的《The Smile Sessions》。

总结

本节课中我们一起学习了如何从数据集中计算最大值。我们首先过滤了无效的发行年份数据，然后利用max()函数配合lambda表达式作为key参数，成功地找出了发行年份最晚的专辑，并输出了它的详细信息。

115：09_02_01_Pandas模块 📊

在本节课中，我们将学习如何使用Python的Pandas模块进行基础的数据分析操作。Pandas是一个强大的工具，它允许我们连接数据库、读写Excel文件，并以一种结构化的方式处理数据。

---

什么是Pandas模块？ 🤔

Pandas模块提供了多种数据分析工具的访问接口。它可以连接并与数据库交互，也能读写Excel文件。

导入Pandas模块后，我们就可以使用一个非常有用的read_excel方法。这个方法可以将一个Excel文件读取到一个称为“数据框”的结构中。

---

理解数据框 📈

数据框是一个二维的、带标签的数据结构。你可以把它想象成一个电子表格或数据库表。

Pandas模块还提供了一个有用的ExcelFile类，它带有一个parse方法。这个方法可以读取Excel文件中的单个工作表。我们将使用这个类来加载我们的数据。

---

核心概念与操作 🛠️

以下是Pandas中几个核心概念和操作的介绍。

1. 导入Pandas模块

要使用Pandas，首先需要导入它。在Python中，我们通常使用pd作为Pandas的别名。

import pandas as pd

2. 读取Excel文件

使用pd.read_excel()方法可以将整个Excel文件读入一个数据框。

df = pd.read_excel('文件名.xlsx')

3. 使用ExcelFile类读取特定工作表

如果你想更精细地控制，例如只读取某个特定的工作表，可以使用ExcelFile类。

xls = pd.ExcelFile('文件名.xlsx')
df_sheet1 = xls.parse('Sheet1')  # 读取名为‘Sheet1’的工作表

---

总结 📝

本节课中，我们一起学习了Pandas模块的基础知识。我们了解到Pandas是一个用于数据分析的强大工具，它可以处理数据库和Excel文件。我们重点介绍了数据框这个核心概念，它是一个类似于电子表格的二维数据结构。同时，我们学习了两种读取Excel文件的方法：使用pd.read_excel()直接读取，以及使用pd.ExcelFile()类来解析特定的工作表。掌握这些基础操作是进行后续数据分析的第一步。

116：加载数据 📂

在本节课中，我们将学习如何加载和分析Yelp数据集。我们将了解数据文件的结构，识别其中的关键数据列，并理解不同数据表之间的关系。

---

在开始之前，请确认你已经下载了Yelp数据文件。该文件包含了美国宾夕法尼亚州和内华达州13个城市的本地商户信息。此数据来源于Yelp数据集挑战赛。

---

数据文件结构

数据文件包含三个主要的数据表：Yelp data、Cities和States。下面我们将逐一介绍每个表的结构。

Yelp Data 表

Yelp data 表包含以下数据列：

• name：商户的名称。
• category0：用户分配的第一个商户类别。
• category1：用户分配的第二个商户类别。在我们的数据中，这两个是最高级别的商户类别。
• takeout：一个布尔标志（true或false），指示该商户是否提供外卖服务。
• review count：该商户收到的评论数量。
• stars：该商户的整体星级评分。
• city ID：引用商户所在城市的标识符。此ID可以与Cities表中的ID列进行匹配。
• state ID：引用商户所在州的标识符。此ID可以与States表中的ID列进行匹配。

---

Cities 表

上一节我们介绍了主数据表，本节中我们来看看辅助的Cities表。它包含以下两列数据：

• ID：城市的唯一标识符。
• city：城市的名称。

---

States 表

类似地，States表也包含两列数据：

• ID：州的唯一标识符。
• state：州的名称。

---

本节课中我们一起学习了Yelp数据集的基本结构。我们了解了主数据表（Yelp data）中的关键信息，如商户名称、类别、评分等，以及如何通过city ID和state ID与Cities、States这两个辅助表进行关联，从而获取更完整的地理位置信息。理解这种表间关系是进行后续数据分析的重要基础。

117：检查数据 📊

在本节课中，我们将学习如何使用Pandas库加载和初步检查一个数据集。我们将以Yelp数据文件为例，介绍如何读取数据、查看数据结构、获取统计信息以及处理重复项。

---

加载和读取Yelp数据文件

首先，我们需要导入Pandas库，并使用其ExcelFile类来加载整个Yelp Excel文件。

import pandas as pd
yelp_file = pd.ExcelFile('yelp_data.xlsx')

---

读取数据到DataFrame

上一节我们加载了文件，本节中我们来看看如何将特定的工作表读取到一个DataFrame中。我们使用parse方法来完成这个操作。

df = yelp_file.parse('Yelp Data')

我们可以看到df的类型是一个DataFrame。

---

查看数据的基本信息

我们可以获取数据框的行数，并通过访问shape属性来获取行和列的数量。

row_count = len(df)
rows, columns = df.shape

以下是获取每列中非空值数量的方法：

value_counts = df.count()

你可以通过访问columns属性来查看列标题。

column_headers = df.columns

通过访问dtypes属性，可以获取每列存储的数据类型。

data_types = df.dtypes

---

获取数据的统计摘要

describe方法为数据框中的数值提供了各种汇总统计信息。

summary_statistics = df.describe()

---

查看数据的前几行

head方法默认显示数据的前五行。如果你提供一个参数，它将显示给定数量的行。例如，以下代码显示前100行数据。

first_100_rows = df.head(100)

---

删除数据中的重复项

你可以使用drop_duplicates方法从数据框中删除重复项。默认情况下，此方法会查看所有列以识别并删除数据中的重复行。

df_no_duplicates = df.drop_duplicates()

---

本节课中我们一起学习了如何使用Pandas进行数据检查。我们涵盖了从加载Excel文件、读取工作表到DataFrame，再到查看数据维度、统计信息、样本以及处理重复数据的基本步骤。这些是进行任何数据分析前至关重要的准备工作。

118：查询数据

在本节课中，我们将要学习如何使用Pandas库从数据集中查询特定的数据列。我们将重点介绍如何选择单列、多列以及如何查看数据的前几行。

选择特定数据列

上一节我们介绍了数据框的基本结构，本节中我们来看看如何从中提取我们感兴趣的列。要选择特定的数据列，需要在方括号内指定列的名称。

例如，如果我们有一个名为 businesses 的数据框，其中包含 name、city_id、state_id 等列。

选择单列数据

以下是选择单列数据的方法。要仅选择企业的名称，可以使用 name 属性。

代码示例：

businesses['name']

选择多列数据

有时我们需要同时查看多个相关的列。要查询前100家企业的位置信息，我们需要创建一个包含所需列名的列表。

以下是创建列名列表的步骤：

1. 确定需要的列，例如 city_id 和 state_id。
2. 将这些列名放入一个Python列表中。

代码示例：

columns_to_select = ['city_id', 'state_id']

获取数据子集

创建好列名列表后，就可以用它来获取数据的子集了。然后将该列表放入方括号中，并通过调用参数为100的 head 方法来获取前100条记录。

代码示例：

businesses[columns_to_select].head(100)

执行以上操作将只显示每个城市和州的ID。

关联数据获取实际值

但是，我们想要看到实际的城市和州名称，而不仅仅是ID。那么，如何才能获取实际的值呢？

我们需要将这个数据集与其他数据集进行关联（Join）。例如，可能存在一个独立的 cities 数据框，其中 city_id 对应着具体的城市名。通过合并这两个数据框，我们就可以用有意义的名称替换掉ID。这将是后续课程中要深入探讨的内容。

本节课中我们一起学习了如何从Pandas数据框中查询单列和多列数据，以及如何使用 head 方法查看数据的前几行。我们还了解到，当数据通过ID关联时，需要连接其他数据集才能获得可读的实际值。

119：数据连接 🔗

在本节课中，我们将要学习如何将来自不同表格的数据连接（Join）在一起。这是数据分析中一个非常核心的操作，它允许我们基于共同的字段，将分散的信息整合成一个更完整的数据集。

上一节我们介绍了数据清洗的基本概念，本节中我们来看看如何将清洗后的数据进行合并。

数据连接的需求

我们手头有三份数据：一份是Yelp的主要业务数据表，另外两份分别是城市信息表和州信息表。Yelp数据表中只包含了城市和州的ID编号，而没有具体的名称。

我们需要根据这些ID，在城市表和州表中查找出对应的城市名和州名。

然后，将这些查找到的名称与Yelp主数据表中的其他信息结合起来。

连接的工作原理

实现这个目标的方法，是通过每个数据集中共有的字段或标识符来连接它们。

这种连接表格的过程，与我们在关系型数据库中对表进行的操作非常相似。

具体来说，连接操作依赖于“键”（Key）：

• Yelp数据表中的“城市ID”将与“城市”表中的“ID”进行连接。
• Yelp数据表中的“州ID”将与“州”表中的“ID”进行连接。

内连接（Inner Join）

最常用的连接类型称为内连接。

它的工作原理是基于一个连接键或公共标识符来合并数据框（DataFrame），并返回一个新的数据框。这个新数据框只包含那些连接键的值在两个原始表格中都存在的行。

用公式可以这样理解其逻辑：
结果表 = 表A ∩ 表B （基于连接键）

或者用伪代码描述其核心过程：

result = []
for row_a in table_a:
    for row_b in table_b:
        if row_a[key] == row_b[key]:  # 连接条件
            result.append( combine(row_a, row_b) )

上图直观地展示了内连接的效果：只有两个表格中ID匹配的行才会被保留并合并到最终结果中。

---

本节课中我们一起学习了数据连接的核心概念。我们了解到，为了整合分散在不同表格中的信息，可以使用基于共同字段的连接操作。其中，内连接是最基础且最常用的连接类型，它确保最终结果只包含两个数据源中都存在的匹配项。掌握数据连接是进行复杂数据分析的关键一步。

120：代码练习-连接数据 📊

在本节课中，我们将要学习如何使用Pandas库来连接（或合并）多个数据表。我们将从一个包含Yelp商家数据的Excel文件开始，然后分别加载城市和州的信息工作表，最后通过“连接”操作将这些信息整合到一个统一的数据集中。

---

准备与数据加载

在开始连接数据之前，我们需要导入必要的库并加载数据。

首先，导入Pandas库，并为其设置一个简短的别名 pd。

import pandas as pd

接下来，使用 pd.ExcelFile 方法加载包含多个工作表的Excel文件。我们将文件命名为 Yelp.xlsx，它位于与当前Jupyter笔记本文件相同的目录中。

xls = pd.ExcelFile('Yelp.xlsx')

xls 变量现在是一个代表整个Excel文件的对象。要访问其中的特定工作表，我们使用 parse 方法。首先，我们解析名为 Yelp data 的工作表，并将其存储在一个名为 df 的DataFrame中。

df = xls.parse('Yelp data')

为了确认数据已正确加载，我们可以使用 head() 方法查看前五行数据。

df.head()

---

连接城市数据

上一节我们加载了主要的Yelp商家数据。本节中，我们来看看如何将城市信息连接到这个主数据集上。

首先，我们需要从同一个Excel文件中加载城市信息。使用 parse 方法解析名为 cities 的工作表，并将其存储在 df_cities 变量中。

df_cities = xls.parse('cities')

同样，我们可以查看这个新DataFrame的前几行，以了解其结构。

df_cities.head()

可以看到，df_cities 包含两列：ID 和 city。

现在，我们使用Pandas的 merge 函数来连接数据。以下是执行连接的关键参数：

• left: 左侧的DataFrame（主数据集 df）。
• right: 右侧的DataFrame（城市数据集 df_cities）。
• how: 连接类型，这里使用 'inner' 表示内连接。
• left_on: 左侧DataFrame中用于匹配的列名（city ID）。
• right_on: 右侧DataFrame中用于匹配的列名（ID）。

df = pd.merge(left=df, right=df_cities, how='inner', left_on='city ID', right_on='ID')

执行后，新的 df 包含了来自 df_cities 的 city 信息。再次使用 df.head() 查看，可以确认城市名称已成功添加。

---

连接州数据

我们已经成功地将城市信息合并到了数据集中。接下来，我们将以同样的方式添加州的信息。

首先，从Excel文件中加载州信息工作表。

df_states = xls.parse('states')
df_states.head()

df_states 工作表包含 ID 和 state 两列。

现在，我们再次使用 merge 函数。这次，将主数据集 df 与州数据集 df_states 进行连接。连接键是 df 中的 state ID 列和 df_states 中的 ID 列。

df = pd.merge(left=df, right=df_states, how='inner', left_on='state ID', right_on='ID')

连接完成后，我们可以检查数据形状，确认列数增加了。

df.shape

使用 df.head() 查看数据，可以看到 state 列也已成功添加。

---

查看与清理数据

现在，我们已经拥有了一个包含商家名称、城市和州信息的完整数据集。让我们来查看一下具体内容，并做一些清理工作。

首先，创建一个我们感兴趣的列名列表，然后使用这个列表从DataFrame中选取数据。

atts = ['name', 'city', 'state']
df[atts].head(100)

这段代码将显示前100家商家的名称、所在城市和州。

在查看结果时，你可能会注意到数据中多出了一些多余的列，例如 ID_x 和 ID_y。这些是连接操作后产生的重复列。以下是删除它们的方法：

del df['ID_x']
del df['ID_y']

删除后，再次查看数据，这些多余的列就消失了。现在，数据集中只保留了原始的 city ID 和 state ID 列，以及我们通过连接添加的 city 和 state 信息列。

---

总结

本节课中我们一起学习了如何使用Pandas进行数据连接操作。我们主要完成了以下步骤：

1. 导入库与加载数据：使用 pd.ExcelFile 和 parse 方法加载Excel文件中的多个工作表。
2. 执行连接：使用 pd.merge() 函数，通过指定连接键（left_on, right_on）和连接方式（how='inner'），将城市和州的信息表连接到主数据集。
3. 查看与清理：选取特定列查看结果，并使用 del 关键字删除连接后产生的重复列。

通过这个练习，你掌握了将分散在不同表格中的相关信息整合到一个统一视图中的基本方法，这是数据分析中一项非常实用的技能。

121：数据框切片操作

在本节课中，我们将要学习如何使用切片（Slicing）操作来获取Pandas数据框（DataFrame）中的特定部分数据。切片是一种高效的数据选取方法，允许我们通过索引范围来提取数据的子集。

切片的基本格式

你可以通过使用冒号来获取数据框的一个切片。其基本格式如下：

dataframe[start_index:end_index]

在方括号内，你需要提供一个起始索引、一个冒号和一个结束索引。起始索引是切片中包含的第一个值的索引，而结束索引是切片中不包含的最后一个值的索引。这两个值都是可选的。

获取指定范围的切片

上一节我们介绍了切片的基本语法，本节中我们来看看如何获取数据中第二组100个企业的信息。

以下是具体步骤：

1. 从数据框中获取一个切片。
2. 起始索引设为100，结束索引设为200。
3. 执行此操作。

运行后，我们可以看到切片的起始索引是100，这是第一条记录。切片会一直延伸到索引199，因为索引200不包含在切片内。

获取最后一条记录

了解了如何获取中间范围的数据后，我们来看看如何定位并获取数据框中的最后一条记录。

以下是两种实现方法：

方法一：通过计算长度获取

1. 首先，获取数据框中最后一条记录的索引。这可以通过计算数据框的长度减1得到。
2. 然后，使用这个索引值作为起始索引来获取切片。在方括号中，起始索引就是我们上一步保存的最后一个索引值，后面跟着冒号。
3. 省略可选的结束索引，这样切片会从提供的起始索引一直延伸到数据框的末尾。
4. 将这个切片存储在变量中，例如 last_business。
5. 最后，从这个切片中提取出“名称”字段。

结果显示，数据框中的最后一个企业是“Sunrise Towing”，其索引是599。

方法二：使用负索引
另一种更简洁的方法是使用负索引。

1. 直接从数据框获取切片，使用 -1 作为起始索引。-1 会从末尾开始计数，代表数据框的最后一个索引。
2. 同样省略结束索引，让切片延伸到末尾。
3. 然后直接从结果中获取“名称”字段。

这样也能得到相同的结果：“Sunrise Towing”，索引599。

---

本节课中我们一起学习了数据框的切片操作。我们掌握了切片的基本语法 dataframe[start:end]，并实践了如何获取指定范围的数据行，以及两种获取最后一条记录的方法：通过计算长度和使用负索引。切片是处理数据框子集的重要工具。

122：使用布尔索引查询数据 🎯

在本节课中，我们将要学习如何使用布尔索引（Boolean Indexing）来筛选和查询Pandas数据框（DataFrame）中的数据。这是一种非常强大且直观的数据过滤方法。

概述

布尔索引的核心思想是：首先创建一个布尔序列（Series），其中每个元素的值是True或False。然后，将这个布尔序列与数据框进行比较，从而筛选出满足条件的记录。接下来，我们将通过几个具体的例子来详细讲解这个过程。

创建布尔条件序列

要使用布尔索引筛选数据框，首先需要创建一个一维的布尔序列。

这个序列中的每个元素都对应数据框中的一条记录，其值为True或False。

布尔索引会将这个布尔序列中的每个值与数据框中的每条记录进行比较。

例如，我们想筛选出所有位于匹兹堡（Pittsburgh）的企业。

以下是创建条件序列的步骤：

# 创建一个条件：城市等于“Pittsburgh”
pits = df['city'] == 'Pittsburgh'

运行这行代码后，pits变量中存储了一个布尔序列。我们可以查看它的类型和内容。

# 查看类型
type(pits)  # 输出：pandas.core.series.Series

# 查看内容
pits  # 输出：一个由True和False值组成的序列

应用布尔索引筛选数据

现在，我们想用这个布尔序列来过滤数据框本身。

为此，我们可以在数据框名称后的方括号中放入这个条件。

# 使用布尔序列筛选数据框
df[pits]

这段代码会根据pits序列中的True/False值来过滤数据框。执行后，我们只会看到城市为“匹兹堡”的记录。

查询特定信息

假设我们想查询“The Dragon Chinese Cuisine”这家餐厅是否提供外卖（takeout）服务。

我们需要先筛选出名称为“The Dragon Chinese Cuisine”的企业。

以下是具体步骤：

# 创建条件：名称为“The Dragon Chinese Cuisine”
condition = df['name'] == 'The Dragon Chinese Cuisine'

# 使用条件筛选数据框
df[condition]

执行后，我们看到只有一家企业符合条件，并且其takeout列的值为True，表示提供外卖服务。

如果我们只想查看takeout这一列，可以这样做：

# 筛选后只获取‘takeout’列
df[condition]['takeout']

输出结果为True，确认了该餐厅提供外卖。

组合多个条件进行筛选

接下来，让我们尝试更复杂的查询。例如，我们想筛选出数据集中所有的酒吧（bars）。

我们将使用用户定义的business category列来创建条件。

以下是具体步骤：

# 条件1：category0列等于‘bars’
cat0_bars = df['category0'] == 'bars'

# 条件2：category1列等于‘bars’
cat1_bars = df['category1'] == 'bars'

# 组合条件：满足条件1 或 条件2
df[cat0_bars | cat1_bars]

这段代码会返回那些category0或category1中任意一列被标记为“bars”的企业。

现在，我们想进一步筛选出位于卡内基市（Carnegie）的酒吧。

我们需要添加第三个条件。

以下是具体步骤：

# 条件3：城市等于‘Carnegie’
carnegie = df['city'] == 'Carnegie'

# 组合所有条件：满足（条件1 或 条件2）并且 满足条件3
df[(cat0_bars | cat1_bars) & carnegie]

这段代码会返回那些category0或category1为“bars”，并且城市为“Carnegie”的企业。

使用列表进行多值匹配

最后，我们想筛选出卡内基市（Carnegie）中所有被归类为“酒吧”或“餐厅”的企业。

我们可以使用.isin()函数来检查列中的值是否在一个给定的列表中。

以下是具体步骤：

# 创建一个包含目标类别的列表
target_categories = ['bars', 'restaurants']

# 条件1：category0列的值在目标列表中
cat0_in_list = df['category0'].isin(target_categories)

# 条件2：category1列的值在目标列表中
cat1_in_list = df['category1'].isin(target_categories)

# 条件3：城市等于‘Carnegie’
carnegie = df['city'] == 'Carnegie'

# 组合所有条件
df[(cat0_in_list | cat1_in_list) & carnegie]

这段代码会返回那些category0或category1为“bars”或“restaurants”，并且城市为“Carnegie”的企业。

总结

本节课中，我们一起学习了如何使用布尔索引在Pandas数据框中进行高效的数据查询。我们掌握了以下核心技能：

1. 创建布尔条件序列：通过比较数据框的列与特定值来生成True/False序列。
2. 应用单个条件筛选：使用df[condition]的语法来过滤数据。
3. 组合多个条件：使用逻辑运算符|（或）和&（与）来构建复杂的查询逻辑。
4. 使用.isin()函数：便捷地检查列值是否属于一个预定义的列表。

布尔索引是数据分析中筛选和提取目标数据的强大工具，理解并掌握它将为后续的数据处理工作打下坚实基础。

123：代码练习 - 拉斯维加斯潜水酒吧推荐 🍸

在本节课中，我们将学习如何使用Python进行数据筛选和随机选择。我们将通过一个具体案例——从数据集中找出拉斯维加斯所有评分至少为4星的潜水酒吧，并随机推荐一家——来实践这些技能。

---

上一节我们介绍了数据筛选的基本概念，本节中我们来看看如何将这些概念应用于一个具体的练习。

我们的目标是：首先，统计拉斯维加斯共有多少家潜水酒吧；其次，从这些酒吧中筛选出评分至少为4星的；最后，从符合条件的酒吧中随机推荐一家。

以下是实现此目标的具体步骤：

1. 筛选拉斯维加斯的潜水酒吧
   我们首先需要从数据集中找出所有位于拉斯维加斯且被归类为“潜水酒吧”的行。这需要组合多个条件。

2. 统计总数
   在得到筛选后的数据框后，我们可以通过获取其长度来得知潜水酒吧的总数。

3. 筛选高评分酒吧
   接着，我们在上一步的结果中，进一步筛选出评分（stars列）大于或等于4.0的酒吧。

4. 随机推荐
   最后，我们从高评分酒吧的列表中，随机选择一家进行推荐。

---

步骤一：筛选拉斯维加斯的潜水酒吧

我们首先定义三个筛选条件：

• lv：城市为“Las Vegas”。
• cat0_bars：category0列为“Dive Bars”。
• cat1_bars：category1列为“Dive Bars”。

然后，我们将这些条件组合起来，创建一个新的数据框 dive_bars_lv。这个数据框包含所有满足“城市是拉斯维加斯”并且“category0或category1是潜水酒吧”条件的行。

# 定义筛选条件
lv = df['city'] == 'Las Vegas'
cat0_bars = df['category0'] == 'Dive Bars'
cat1_bars = df['category1'] == 'Dive Bars'

# 组合条件，创建包含拉斯维加斯所有潜水酒吧的新数据框
dive_bars_lv = df[lv & (cat0_bars | cat1_bars)]

步骤二：统计潜水酒吧总数

现在，我们可以通过计算 dive_bars_lv 数据框的长度来得到总数。

# 获取潜水酒吧的总数
total_dive_bars = len(dive_bars_lv)
print(f"拉斯维加斯共有 {total_dive_bars} 家潜水酒吧。")

步骤三：筛选高评分酒吧

接下来，我们在 dive_bars_lv 的基础上，增加一个评分条件，创建另一个数据框 dive_bars_lv_4star，它只包含评分至少为4星的酒吧。

# 在潜水酒吧中筛选评分>=4.0的
stars_condition = dive_bars_lv['stars'] >= 4.0
dive_bars_lv_4star = dive_bars_lv[stars_condition]
print(f"其中，有 {len(dive_bars_lv_4star)} 家评分至少为4星。")

步骤四：随机推荐一家酒吧

为了随机推荐，我们需要生成一个随机索引。首先导入 random 模块，然后生成一个介于0和数据框最大索引之间的随机整数。我们介绍两种方法来获取对应的行。

方法一：使用切片

import random

# 生成一个随机索引
r_int = random.randint(0, len(dive_bars_lv_4star) - 1)

# 使用切片获取该索引对应的行
rand_dive_bar = dive_bars_lv_4star[r_int:r_int+1]
print("随机推荐的潜水酒吧是（切片法）:")
print(rand_dive_bar)

方法二：使用 .iloc 方法

.iloc 方法通过整数位置选择行，这是更直接的方式。

import random

# 生成一个随机索引
r_int = random.randint(0, len(dive_bars_lv_4star) - 1)

# 使用.iloc通过整数位置获取行
rand_dive_bar = dive_bars_lv_4star.iloc[r_int]
print("随机推荐的潜水酒吧是（.iloc法）:")
print(rand_dive_bar)

每次运行上述代码块，你可能会看到不同的酒吧被推荐，例如“Huntridge Tavern”或“Moondogies”。

---

本节课中我们一起学习了如何组合多个条件对数据进行筛选，如何计算筛选结果的数量，以及如何使用 random 模块实现随机选择。通过“拉斯维加斯潜水酒吧推荐”这个练习，我们实践了从数据查询到结果输出的完整流程，这是数据分析中非常实用的基础技能。

124：使用sum函数计算数据总和 🧮

在本节课中，我们将要学习如何使用sum函数来计算数据行中数值的总和。这是一个非常实用的功能，可以帮助我们快速获取特定条件下的数据总量。

概述

为了计算数据行中数值的总和，我们可以使用sum函数。这个函数能够对满足特定条件的行中的指定列进行求和。

上一节我们介绍了数据筛选的基本概念，本节中我们来看看如何结合筛选条件与求和函数。

计算亨德森市美甲沙龙的总评论数

我们的目标是计算位于亨德森市的所有美甲沙龙的总评论数。

首先，我们需要查询数据并筛选出亨德森市的所有美甲沙龙。

以下是构建筛选条件的步骤：

1. 创建第一个条件：测试category0字符串值是否包含“nail salon”。

   condition1 = df['category0'].str.contains('nail salon')
   

2. 创建第二个条件：测试category1字符串值是否包含“nail salon”。

   condition2 = df['category1'].str.contains('nail salon')
   

   在我们的数据中，用户可能将“美甲沙龙”这个业务类别分配给category0或category1，因此我们需要同时考虑这两种情况。

3. 创建第三个条件：筛选城市为“Henderson”的行。

   condition3 = df['city'] == 'Henderson'
   

最后，我们将所有三个条件组合起来，并计算review_count列的总和。

total_reviews = df[ (condition1 | condition2) & condition3 ]['review_count'].sum()

这段代码返回的是满足以下条件的行的总评论数：category0包含“nail salon”或category1包含“nail salon”，并且城市是“Henderson”。

总结

本节课中我们一起学习了如何使用sum函数对满足复杂条件的数据行进行求和。关键步骤包括：构建多个逻辑条件（使用|表示“或”，&表示“且”），然后应用sum()函数到目标列上。这种方法可以高效地计算数据子集的总和。

125：计算平均值 📊

在本节课中，我们将学习如何使用Python的Pandas库来计算匹兹堡市汽车维修店的平均星级评分。我们将通过数据筛选和聚合操作来完成这个任务。

上一节我们介绍了数据筛选的基本概念，本节中我们来看看如何应用这些概念来计算特定条件下的平均值。

首先，我们需要对数据进行筛选。目标是找出所有位于匹兹堡的汽车维修店。

以下是创建筛选条件的步骤：

• 创建第一个条件，检查category_0列中的字符串值是否包含“auto repair”。
• 创建第二个条件，检查category_1列中的字符串值是否包含“auto repair”。
• 创建第三个条件，检查city列的值是否等于“Pittsburgh”。

condition1 = df['category_0'].str.contains('auto repair')
condition2 = df['category_1'].str.contains('auto repair')
condition3 = df['city'] == 'Pittsburgh'

接下来，我们需要将这三个条件组合起来。我们想要的是满足以下所有条件的行：店铺是汽车维修店（即category_0或category_1包含“auto repair”），并且位于匹兹堡。

以下是组合条件的方法：

• 使用逻辑或运算符| 将condition1和condition2组合，表示“汽车维修店”这个条件。
• 使用逻辑与运算符& 将上一步的结果与condition3组合，表示同时满足“位于匹兹堡”的条件。

final_condition = (condition1 | condition2) & condition3

现在，我们已经有了最终的筛选条件。接下来，我们可以应用这个条件来筛选数据框，并计算目标列的平均值。

以下是计算平均值的步骤：

• 使用df[final_condition]筛选出满足所有条件的行。
• 在筛选后的数据子集上，选择Stars列。
• 调用.mean()方法计算该列的平均值。

average_rating = df[final_condition]['Stars'].mean()

这段代码返回的结果，就是那些满足category_0为真或category_1为真，并且city为匹兹堡的行的Stars列的平均值。

本节课中我们一起学习了如何通过组合多个条件来筛选Pandas数据框，并计算指定列的平均值。核心步骤包括：创建布尔条件、使用逻辑运算符组合条件、应用条件筛选数据，最后调用.mean()方法进行聚合计算。

126：其他实用方法 🛠️

在本节课中，我们将学习Pandas库中几个非常实用的数据处理方法。这些方法能帮助我们快速了解数据集中的独特值、统计记录数量以及计算非空唯一值的数量。

---

上一节我们介绍了数据筛选和排序，本节中我们来看看如何利用Pandas快速获取数据的统计摘要信息。

识别数据集中的独特城市 🌆

首先，我们可能想知道数据集中包含了哪些不同的城市。这有助于我们了解数据的覆盖范围。

以下是获取“city”列中所有唯一值的方法：

unique_cities = df['city'].unique()

此方法返回“city”列中的所有不重复的值。

---

了解了有哪些城市后，我们自然会想知道每个城市中分别有多少条记录。

统计每个城市的记录数量 📊

我们可以计算数据集中每个城市出现的次数，从而了解业务在不同城市的分布情况。

以下是统计每个城市记录数量的方法：

city_counts = df['city'].value_counts()

此方法会统计“city”列中每个值出现的次数。

---

除了对城市进行分析，我们还可以关注数据集中具体的业务分类情况。

统计分类中的非空唯一值数量 🏷️

假设我们想了解“category 0”这一列中有多少种不同的、非空的用户分配的业务类别。

以下是计算“category 0”列中非空唯一值数量的方法：

unique_categories_count = df['category 0'].nunique()

此方法会计算“category 0”列中所有非空且不重复的值的数量。

---

本节课中我们一起学习了Pandas的三个核心方法：.unique()用于获取唯一值列表，.value_counts()用于统计频次，以及.nunique()用于计算非空唯一值的数量。掌握这些方法能让你更高效地对数据进行初步的探索和摘要分析。

127：更新与创建数据

在本节课中，我们将要学习如何在数据框中创建新的列，以及如何利用这些新列进行数据查询。这是数据处理中非常实用且基础的操作。

创建新列 🆕

在数据框中创建新列非常简单。你只需要为新列指定一个唯一的名称，并为其赋值即可。

例如，你可以使用以下语法来创建一个新列：

my_df['new_column'] = some_value

组合现有列 🔗

上一节我们介绍了如何创建简单的新列，本节中我们来看看如何通过组合现有列来创建更复杂的新列。

以下是一个具体的例子：添加一个名为 categories 的新列，该列将 category0 和 category1 的值组合成一个用逗号分隔的列表。

my_df['categories'] = my_df['category0'] + ', ' + my_df['category1']

这段代码将 category0 的字符串值与 category1 的字符串值连接起来，并用逗号分隔它们。

利用新列进行查询 🔍

现在我们已经创建了一个组合后的 categories 列，我们可以基于这个单一的列来查找业务数据。

以下是查找披萨餐厅的示例，通过检查 categories 列是否包含字符串 “pizza” 来实现：

pizza_restaurants = my_df[my_df['categories'].str.contains('pizza')]

本节课中我们一起学习了如何在数据框中创建新列，包括直接赋值和组合现有列，并利用新列进行数据筛选。这些是进行有效数据分析和处理的基础技能。

128：代码练习-添加评分列 📊

在本节课中，我们将学习如何为数据集添加一个新的列，并通过一个辅助函数来格式化该列的值。具体来说，我们将把1到5星的评分转换为一个1到10分的评分系统，并将其格式化为“x out of 10”的形式。

---

每个商家都有一个1到5星的评分值。我们的目标是添加一个新的评分列，将这个星级评分值转换为10分制下的一个可比较的值。

为了添加新列，我们可以直接命名一个新列并使用它。我们将设置rating列等于当前stars列的值乘以2。

df['rating'] = df['stars'] * 2

运行这段代码后，查看数据的前五行，我们可以看到每个商家除了1到5星的stars值外，现在还有一个1到10分的rating值。

---

上一节我们介绍了如何创建新的评分列。本节中，我们来看看如何更新这个新列，使其以“x out of 10”的格式显示评分。

首先，我们需要创建一个辅助函数。这个函数将接收一个评分值作为参数，并将其与一个字符串拼接起来。

以下是该函数的定义：

def convert_to_rating(x):
    return str(x) + ' out of 10'

这个名为convert_to_rating的函数接收一个参数x（即1到10之间的评分值），然后返回一个字符串，该字符串由x转换成的字符串与“ out of 10”拼接而成。这样，每个评分都会显示为“评分值 out of 10”。

---

为了对每一行的评分值运行这个辅助函数，我们需要使用apply方法。

以下是应用该函数的步骤：

1. 针对rating列，我们将convert_to_rating函数应用到每一个评分值上。
2. 然后，我们将用这个结果覆盖现有的rating列的值。

df['rating'] = df['rating'].apply(convert_to_rating)

运行这段代码后，再次获取数据的前五行，我们将看到每个评分现在都显示为特定的“x out of 10”格式。

---

本节课中我们一起学习了如何为DataFrame添加新列，以及如何使用apply方法和自定义函数来转换和格式化列中的数据。我们成功地将1到5星的评分转换并格式化为更直观的“x out of 10”形式。

129：分组汇总

在本节课中，我们将要学习如何使用Pandas库中的groupby方法对数据进行分组和汇总。这是数据分析中一个非常核心的操作，能够帮助我们按照特定类别查看数据的聚合信息。

分组方法

groupby方法根据您选择的变量将数据拆分成不同的组。

这个过程与SQL中的GROUP BY语句非常相似。

GroupBy对象

groupby方法返回一个GroupBy对象。这个对象类似于一个字典，其键是计算出的唯一分组，对应的值是该分组下的数据。

例如，当我们按“城市”分组时，键将是所有可能的城市名称。

我们可以使用.get_group()属性来获取特定组的记录。

例如，查询拉斯维加斯有多少家企业。但仅仅获取分组信息本身并不十分有用。

聚合计算

我们真正需要的是能够对每个组内的数据执行聚合计算。

以下是常见的聚合操作示例：

• 计数：grouped.size() 或 grouped.count()
• 求和：grouped.sum()
• 平均值：grouped.mean()
• 最大值：grouped.max()
• 最小值：grouped.min()

例如，要计算每个城市的平均评分，可以使用以下代码：

average_rating_by_city = df.groupby('city')['stars'].mean()

总结

本节课中我们一起学习了Pandas的groupby功能。我们了解到，groupby可以将数据按指定列分组，并返回一个便于进行聚合计算（如求平均、求和、计数等）的对象。这是进行数据分维度统计分析的基础工具。

130：24_03_02_NumPy库

在本节课中，我们将学习如何利用agg方法对分组数据进行聚合计算，并引入强大的科学计算库NumPy来执行多种统计运算。

使用agg方法进行聚合计算

上一节我们介绍了数据分组的基础知识，本节中我们来看看如何对分组后的数据进行更复杂的聚合计算。agg方法允许我们对分组数据执行聚合计算。

引入NumPy库进行多函数聚合

为了实现更丰富的统计功能，我们可以借助NumPy模块中的方法。NumPy是一个流行的科学计算包。

以下是使用NumPy进行聚合的步骤：

首先，我们需要导入NumPy库。

import numpy as np

然后，我们根据城市对数据进行分组，并调用agg方法。作为参数，我们传递NumPy的求和函数、平均值函数和标准差函数。

grouped_data = data.groupby('city')['star_rating'].agg([np.sum, np.mean, np.std])

最后，我们展示将这些聚合计算应用于“星级评分”属性的结果。

print(grouped_data)

本节课中我们一起学习了如何使用Pandas的agg方法结合NumPy库，对分组数据同时进行求和、求平均值和求标准差等多种聚合计算，从而高效地分析数据。

131：数据透视表

在本节课中，我们将要学习一个强大的数据汇总工具——数据透视表。我们将了解它的基本概念、工作原理以及如何在数据分析中应用它。

什么是数据透视表？ 📊

数据透视表是一种有用的数据汇总工具，它可以根据数据框的内容创建一个新的表格。

上一节我们介绍了数据透视表的基本定义，本节中我们来看看创建它需要哪些要素。

数据透视表的核心要素

为了对数据框进行透视，我们至少需要一个索引列来进行分组。

索引就像你在 group by 方法中用来分组的变量。数据透视表将沿着该索引为我们提供有用的汇总信息，例如求和或平均值。

以下是创建数据透视表时涉及的几个核心概念：

• 索引：用于对数据进行分组的列。
• 汇总函数：对分组后的数据执行的操作，例如 sum() 或 mean()。

总结

本节课中我们一起学习了数据透视表。我们了解到，数据透视表是一种基于数据框创建新汇总表格的工具，其核心在于通过指定的索引列对数据进行分组，并应用汇总函数（如求和、求平均值）来生成有意义的摘要信息。

132：使用索引 📊

在本节课中，我们将学习如何在创建数据透视表时使用索引。索引可以帮助我们以更有条理的方式组织和汇总数据。

创建以城市为索引的透视表

首先，我们创建一个数据透视表，并使用“城市”作为索引。默认情况下，数据透视表会计算结果中每一列的平均值。

pivot_city = df.pivot_table(index='city')

生成的 pivot_city 变量其类型仍然是一个数据框（DataFrame），但它现在按照城市进行了分组和汇总。

使用多级索引

上一节我们介绍了单索引，本节中我们来看看如何使用多个索引，这被称为多级索引。

以下是创建多级索引数据透视表的方法：

pivot_multi = df.pivot_table(index=['state', 'takeout'])

在这行代码中，我们同时使用了“州”和“外卖服务”作为索引。数据透视表会自动为我们排序数据。

多级索引的数据呈现

当使用多级索引时，表格中的每个单元格会显示在每个州内，对应不同外卖服务选项下的平均值。

例如，单元格内的数值代表了在特定州（如“CA”）中，特定外卖选项（如“是”或“否”）下所有相关数据的平均值。

---

本节课中我们一起学习了数据透视表中索引的使用。我们掌握了如何设置单索引来按城市汇总数据，以及如何使用多级索引（如州和外卖服务）来创建更细致、层次化的数据视图。索引是组织和理解复杂数据集的有力工具。

133：代码练习-平均评论数与评分

在本节课中，我们将通过一个练习来学习如何使用Pandas库创建数据透视表。具体目标是创建一个数据透视表，用于显示每个城市中酒吧和餐厅的平均评论数量和平均星级评分。为了简化操作，我们只关注category_0这一列。

概述

我们将从原始数据框开始，首先筛选出类别为“酒吧”和“餐厅”的行。然后，我们将以state、city和category_0作为索引，创建一个数据透视表，并计算review_count和stars两列的平均值。

筛选数据

首先，我们需要从原始数据框中筛选出仅包含酒吧和餐厅的数据。以下是具体步骤。

我们检查category_0列中的值是否在指定的列表中。这个列表包含“Bars”和“Restaurants”。这个操作会检查category_0列中的每个值是否为“酒吧”或“餐厅”。

我们将这个条件存储在变量bars_rest中。

bars_rest = df['category_0'].isin(['Bars', 'Restaurants'])

接着，我们使用这个条件来过滤原始数据框。

df_bars_rest = df[bars_rest]

运行以上代码后，我们将得到一个新的数据框df_bars_rest，其中只包含酒吧和餐厅的数据。这个筛选仅基于category_0列的值。

创建数据透视表

上一节我们筛选出了所需的数据，本节中我们来看看如何创建数据透视表。

现在，我们使用Pandas的pivot_table函数来创建数据透视表。我们将以state、city和category_0作为索引。

以下是创建数据透视表的代码。

pivot_state_cat = pd.pivot_table(df_bars_rest,
                                  index=['state', 'city', 'category_0'])

我们将这个数据透视表存储在变量pivot_state_cat中。运行后，我们会得到一个数据框，它实际上就是一个数据透视表。

查看特定列

在创建好的数据透视表中，我们只关心与评论和评分相关的列。

我们将查看数据透视表中的review_count和stars这两列。

result = pivot_state_cat[['review_count', 'stars']]

运行以上代码后，我们得到最终的数据透视表。现在，我们可以清晰地看到每个州、每个城市、每个类别（酒吧或餐厅）的平均评论数量和平均星级评分。

总结

本节课中我们一起学习了如何利用Pandas进行数据筛选和创建数据透视表。我们首先从原始数据中筛选出酒吧和餐厅的数据，然后以州、城市和类别为索引，创建了一个显示平均评论数和平均评分的数据透视表。这个练习帮助我们掌握了数据聚合和分析的基本方法。

134：聚合函数 📊

在本节课中，我们将学习如何在数据透视表中使用聚合函数，以计算除平均值以外的其他汇总统计数据，例如总和。我们还将探讨如何同时为不同的列应用不同的聚合方法。

概述

上一节我们介绍了数据透视表的基本概念。本节中，我们来看看如何使用 aggfunc 参数来指定不同的聚合函数，以及如何通过 values 和 columns 参数对数据进行更细致的分组分析。

指定聚合函数

要显示平均值以外的汇总统计数据，需使用 aggfunc 参数来指定聚合函数。同时，使用 values 参数来指定需要聚合的列。与之前一样，我们将使用 NumPy 包中的聚合方法。

例如，在我们的数据中，每个城市有多少条评论？我们可以创建一个数据透视表。

以下是创建该数据透视表的步骤：

1. 在 index 参数上设置州和城市。
2. 对于要聚合的值，指定评论数列，因为这是我们要计算总和的列。
3. 对于 aggfunc，指定要应用的聚合方法，我们将使用 NumPy 包中的 sum 方法。

代码示例如下：

pd.pivot_table(df, index=['state', 'city'], values='review_count', aggfunc=np.sum)

使用列参数进一步细分结果

我们可以通过再次使用 columns 参数来进一步细分结果。这里，我们创建一个以州和城市为索引的数据透视表。

然后，我们指定要聚合的值（评论数）和要应用的聚合方法。

我们还指定了 columns 参数，以便根据“是否提供外卖”来进一步细分结果。这样，我们可以看到每个城市的评论数量，并根据商家是否提供外卖进行了区分。

为不同列应用不同的聚合函数

我们还可以向 aggfunc 传递一个字典对象作为参数，该字典包含要对不同值执行的不同聚合函数。字典中可以包含多个键值对。

例如，如果我们想查看评论的总数和评分的平均值，可以使用以下格式来指定。

以下是创建该数据透视表的步骤：

1. 创建一个数据透视表。
2. 传递一个字典对象，其中列名作为键，应用于该列的聚合方法作为值。
   • 在本例中，review_count 是一个键，NumPy 的 sum 方法是应用于“评论数”列的值。
   • stars 是另一个键，NumPy 的 mean 方法是应用于“星级”列的值。

代码示例如下：

pd.pivot_table(df, index=['state', 'city'], values=['review_count', 'stars'], aggfunc={'review_count': np.sum, 'stars': np.mean})

总结

本节课中我们一起学习了数据透视表中聚合函数的高级用法。我们掌握了如何使用 aggfunc 参数指定不同的聚合方法（如求和），如何利用 columns 参数对数据进行多维度细分，以及如何通过传递字典来为不同的数据列同时应用不同的聚合函数。这些技巧能帮助我们更灵活、更高效地从数据中提取有价值的汇总信息。

135：Jupyter Notebook魔法函数

在本节课中，我们将学习Jupyter Notebook中一个非常实用的功能——魔法函数。这些特殊的命令以百分号%开头，能够帮助我们更高效地执行一些元操作或增强Notebook的功能。

什么是魔法函数？

上一节我们介绍了Jupyter Notebook的基本操作。本节中，我们来看看Jupyter Notebook内置的“魔法函数”。魔法函数是Jupyter Notebook特有的功能，它们以%或%%符号开头，用于执行一些常规Python代码无法直接完成的便捷操作，例如测量代码运行时间、加载外部库的特定模式，或者进行系统级操作。

一个实用的魔法函数示例：%pylab inline

一个常用且重要的魔法函数是%pylab inline。它的主要作用是同时导入NumPy和Matplotlib库，并设置图表在Notebook内直接显示，而不是弹出单独的窗口。

以下是使用%pylab inline的步骤和效果：

1. 在单独的代码单元格中运行：为了确保环境正确配置，这个魔法命令通常需要在Notebook的第一个代码单元格中执行。
2. 执行命令：在单元格中输入%pylab inline并运行。
3. 效果：运行后，Notebook会自动导入numpy和matplotlib.pyplot等科学计算和绘图库，并配置好内嵌绘图模式。

运行此命令后，你就可以直接在后续的单元格中使用如plot()等函数进行绘图，并且图表会直接显示在代码输出区域。

%pylab inline
# 运行后，即可直接使用numpy和matplotlib
x = linspace(0, 10, 100)
y = sin(x)
plot(x, y)

本节课中我们一起学习了Jupyter Notebook的魔法函数，重点介绍了%pylab inline这个用于配置科学计算和可视化环境的实用命令。掌握魔法函数能显著提升你在Notebook中编程和数据分析的效率。

136：Matplotlib数据可视化库

在本节课中，我们将学习Python中一个非常流行的数据可视化库——Matplotlib。我们将了解它的基本概念，并重点学习两种重要的图表类型：直方图和散点图。

什么是Matplotlib？ 📊

Matplotlib是一个用于Python的流行绘图库。它被包含在PyLab包中。这是一个非常强大的工具，可以绘制多种多样的图形，甚至可以为它们制作动画。

上一节我们介绍了Matplotlib的基本概念，本节中我们来看看我们将要重点学习的两种图表类型。

核心图表类型

我们将涵盖直方图和散点图。直方图用于表示数据集中值的分布情况。散点图则在XY平面上展示两个变量的一组数据点或观测值。

以下是这两种图表的核心概念描述：

• 直方图：其核心是统计并展示数据落入各个连续区间的频数。可以用以下伪代码逻辑表示其核心过程：

  # 假设 data 是一个数据列表
  bins = 将数据范围划分为若干个连续的区间
  for 每个数据点 in data:
      确定该数据点属于哪个区间
      将该区间的计数加1
  绘制每个区间及其对应的计数柱状图
  

• 散点图：其核心是将成对的 (x, y) 坐标在二维平面上用点标记出来。关系可以表示为：
  图表点集 = { (x₁, y₁), (x₂, y₂), ..., (xₙ, yₙ) }

---

本节课中我们一起学习了Matplotlib库的基本介绍，以及直方图和散点图这两种基础但至关重要的数据可视化图表的核心概念。理解这些是进行更复杂数据分析和可视化的第一步。

137：直方图比较 📊

在本节课中，我们将学习如何使用直方图来比较两个不同城市（匹兹堡和拉斯维加斯）的商家评分分布。我们将通过Python的Plotly库来实现这一可视化，从而直观地看出哪个城市拥有更多五星或一星评价。

概述与目标

我们想要探究的问题是：不同城市的评价模式有何差异？具体来说，在匹兹堡和拉斯维加斯这两个城市中，哪个城市的五星评价或一星评价数量更多？

为了解决这个问题，我们将绘制一个直方图来比较这两个城市商家的评分分布。整个过程主要分为两个步骤：首先准备数据并创建合适的数据框，然后使用Plotly库进行绘图并设置相关选项。

数据准备

在开始绘图之前，我们需要导入必要的库并准备好用于比较的数据。以下是数据准备阶段的关键步骤。

首先，我们需要导入Plotly Express库，它是一个用于快速创建图的高级接口。

import plotly.express as px

接下来，我们需要从数据源中筛选出匹兹堡和拉斯维加斯这两个城市的数据，并创建一个包含城市和评分两列的数据框，为后续绘图做好准备。

绘制直方图

数据准备就绪后，我们现在可以开始绘制比较直方图了。Plotly Express使得创建复杂的图表变得非常简单。

我们将使用 px.histogram 函数。以下是创建直方图的核心代码结构：

fig = px.histogram(data_frame=prepared_df,
                   x='stars',
                   color='city',
                   barmode='overlay', # 设置模式为叠加，便于比较
                   opacity=0.75,      # 设置透明度，使重叠部分可见
                   title='Rating Distribution: Pittsburgh vs Las Vegas')
fig.show()

在这段代码中：

• data_frame 参数指定我们准备好的数据框。
• x='stars' 指定将评分数据作为直方图的横轴。
• color='city' 指定根据城市字段对数据进行着色，从而区分两个城市。
• barmode='overlay' 是一个关键设置，它让两个城市的直方图条形重叠在一起，而不是并排排列，这样能更直观地比较分布形状。
• opacity 参数设置了条形的透明度，确保重叠部分也能清晰可见。

图表解读与分析

生成的图表将并排显示匹兹堡和拉斯维加斯商家的评分分布。通过观察直方图形状，我们可以进行以下分析：

以下是解读直方图时关注的核心点：

1. 峰值比较：观察哪个城市在特定评分区间（尤其是1星和5星）的条形更高，条形高度代表了该评分区间的商家数量。
2. 分布形状：比较两个城市整体评分的分布是偏左（低分多）、偏右（高分多）还是更为集中。
3. 重叠区域：利用叠加模式，可以直接看出在任一评分区间，哪个城市的商家数量占主导地位。

通过这种直观的比较，我们就能得出最初问题的结论，例如发现拉斯维加斯的商家可能拥有更多极端评价（极高或极低），而匹兹堡的评价可能更集中于中间范围。

总结

本节课中，我们一起学习了如何使用Plotly绘制比较直方图。我们首先明确了通过可视化比较两个城市评分分布的目标，然后完成了数据导入和筛选的准备工作，最后使用 px.histogram 函数并设置 color 和 barmode 参数成功创建了直观的叠加直方图。这种方法不仅能用于比较城市间的评分，还可以广泛应用于任何需要对比两个或多个组别数据分布的场合。

138：直方图编码演示-展示数据分布 📊

在本节课中，我们将学习如何在Jupyter Notebook中使用Matplotlib库创建直方图，以直观地展示数据的分布情况。我们将从配置环境开始，逐步完成数据可视化的全过程。

---

为了让Pla库能够加载，并使我们的可视化图表显示在Jupyter Notebook中，我们需要运行一个“魔法函数”。

以下是具体步骤：

1. 在代码单元格中输入 %pylab。
2. 运行该单元格以激活Matplotlib的交互模式。

现在，我们可以导入Matplotlib库中的绘图模块了。

---

上一节我们配置好了绘图环境，本节中我们来看看如何导入必要的库。

通过以下代码导入Matplotlib的pyplot模块，并为其设置一个常用的别名plt，以简化后续的调用。

import matplotlib.pyplot as plt

---

本节课中我们一起学习了在Jupyter Notebook中配置Matplotlib环境并导入pyplot模块的方法。掌握了这些基础步骤，我们就可以开始创建各种图表，包括接下来要绘制的直方图，来探索和分析数据了。

139：直方图编码演示-准备数据 📊

在本节课中，我们将学习如何为绘制直方图准备数据。具体来说，我们将从一个包含多个城市商业信息的数据集中，筛选出匹兹堡和拉斯维加斯两个城市的数据，并提取出我们关心的“星级评分”列。

概述

为了比较两个城市的商业评分分布，我们需要先从原始数据集中分离出各自的数据。本节将演示如何使用条件筛选创建新的数据框，并从中提取特定的数据列，为后续绘制直方图做好准备。

创建城市数据框

首先，我们需要从原始数据框中，根据“城市”这一条件，分别创建匹兹堡和拉斯维加斯两个独立的数据框。

以下是具体步骤：

1. 创建匹兹堡数据框：我们使用条件 city == ‘Pittsburgh’ 来筛选数据。

   df_pit = df[df[‘city’] == ‘Pittsburgh’]
   

   运行此代码后，我们得到了一个名为 df_pit 的新数据框，其中只包含匹兹堡的商业数据。查看前五行数据，可以确认筛选成功。

   

2. 创建拉斯维加斯数据框：接下来，我们使用条件 city == ‘Las Vegas’ 进行筛选。

   df_vegas = df[df[‘city’] == ‘Las Vegas’]
   

   我们将结果存储在 df_vegas 数据框中。同样，查看其前五行数据，可以确认其中均为拉斯维加斯的商业信息。

   

提取星级评分数据

上一节我们成功创建了两个城市的数据框。本节中，我们来看看如何从中提取出绘制直方图所需的核心数据——stars（星级评分）列。

因为直方图旨在展示数值的分布情况，所以我们只需要每个数据框中的评分数据。以下是提取方法：

1. 提取匹兹堡的评分数据：从 df_pit 数据框中提取 stars 列。

   pit_stars = df_pit[‘stars’]
   

2. 提取拉斯维加斯的评分数据：从 df_vegas 数据框中提取 stars 列。

   vegas_stars = df_vegas[‘stars’]
   

   提取完成后，我们可以查看 pit_stars 的前五行数据。可以看到，现在数据中只包含纯数值的星级评分，这正是我们绘制直方图所需要的格式。

   

总结

本节课中，我们一起学习了为比较性直方图准备数据的关键步骤。我们首先通过条件筛选，从原始数据集中分离出匹兹堡和拉斯维加斯两个城市的数据子集。接着，我们从这两个子集中提取了核心的分析指标——stars 评分列。现在，pit_stars 和 vegas_stars 这两个数据序列已经准备就绪，可以在接下来的课程中用于绘制并排的直方图，从而直观地对比两个城市商业评分的分布情况。

140：直方图编码演示-设置Pyplot选项 📊

在本节课中，我们将学习如何使用Matplotlib的Pyplot库创建和自定义直方图。我们将通过一个具体的例子，为两个不同城市（匹兹堡和拉斯维加斯）的餐厅星级评分数据绘制直方图，并学习如何设置透明度、颜色、标签等选项，使图表更具可读性和表现力。

---

上一节我们介绍了数据可视化的基本概念，本节中我们来看看如何使用Pyplot库的具体函数来绘制直方图。

首先，我们需要为匹兹堡的星级评分数据创建一个直方图。Pyplot库在创建可视化图表时提供了多种配置选项，我们将使用其中一些基础的选项。

以下是使用Pyplot库绘制直方图的基本代码结构：

plt.hist(data, alpha=0.3, color='yellow', label='Pittsburgh', bins='auto')

让我们详细解析这段代码中的参数：

• data：这是要绘制直方图的数据集，在本例中是匹兹堡的星级评分数据 pit_stars。
• alpha=0.3：这个参数设置直方图中柱子的透明度。值在0（完全透明）到1（完全不透明）之间，0.3表示70%的透明度。
• color='yellow'：这个参数设置直方图中柱子的填充颜色。
• label='Pittsburgh'：这个参数为这个直方图数据系列设置一个标签，该标签将用于图例。
• bins='auto'：这个参数设置X轴的分箱（即分组）规则。‘auto’ 表示让库自动决定最合适的分箱数量和宽度。

---

现在，让我们在同一个图表上添加拉斯维加斯的星级评分数据。这将把拉斯维加斯的数据与匹兹堡的数据叠加显示，便于对比。

以下是添加第二个直方图的代码：

plt.hist(data, alpha=0.3, color='red', label='Las Vegas', bins='auto')

在这段代码中，我们使用了相同的 alpha 和 bins 参数以保证样式一致，但将数据源更改为拉斯维加斯的评分数据 vegas_stars，颜色改为红色，标签改为“Las Vegas”。

---

本节课中我们一起学习了如何使用Matplotlib的Pyplot库绘制叠加直方图。我们掌握了 plt.hist() 函数的关键参数，包括如何指定数据源、设置柱子的透明度和颜色、添加数据标签以及控制分箱方式。通过将两个城市的数据绘制在同一张图上，我们可以直观地比较它们的星级评分分布。

141：直方图编码演示-显示可视化 📊

在本节课中，我们将学习如何使用Python的Matplotlib库创建和美化直方图，以可视化并比较两个不同数据集（匹兹堡和拉斯维加斯的评分数据）的分布情况。我们将从创建一个简单的重叠直方图开始，然后逐步添加标签、图例和标题，最后学习如何创建并排显示的直方图。

---

创建基础重叠直方图

首先，我们将在同一个图表中绘制两个直方图，以展示数据的分布。我们将使用 plt.show() 方法来显示图表。

以下是创建基础可视化图表的代码：

plt.show()

运行上述代码后，我们将看到一个简单的可视化图表。其中，黄色条形代表匹兹堡的数据，红色（或叠加后呈现的橙色）条形代表拉斯维加斯的数据。

---

添加图表标签与美化

上一节我们创建了基础图表，本节中我们来看看如何通过添加坐标轴标签、图例和标题来美化它，使图表信息更清晰。

我们将更新代码，添加以下元素：

• X轴和Y轴的标签。
• 图例，让Matplotlib自动选择最佳位置。
• 一个描述性的标题。

以下是更新后的代码：

plt.xlabel('rating')
plt.ylabel('Number of rating scores')
plt.legend(loc='best')
plt.title('Review Distribution Of Pittsburgh And Las Vegas')
plt.show()

运行更新后的代码，我们将看到美化后的可视化图表。黄色条形代表匹兹堡，红色条形代表拉斯维加斯，橙色部分则表示两个数据集重叠的区域。

---

创建并排显示的直方图

虽然重叠直方图可以展示数据重叠，但有时并排显示能让对比更清晰。接下来，我们将学习如何创建一个并排显示的直方图。

这次，我们将使用一个 hist 函数调用，但传入一个数据列表。以下是实现并排直方图的步骤和代码：

1. 调用 plt.hist() 函数。
2. 传入一个包含两个数据序列的列表：[pit_stars, vegas_stars]。
3. 设置透明度 alpha=0.7。
4. 指定颜色列表 color=['red', 'blue']，分别对应匹兹堡和拉斯维加斯。
5. 设置标签列表 label=['Pittsburgh', 'Las Vegas']。
6. 将 bins 参数设置为 ‘auto’，让库自动决定分组数量。

以下是完整的代码示例：

plt.hist([pit_stars, vegas_stars], alpha=0.7, color=['red', 'blue'], label=['Pittsburgh', 'Las Vegas'], bins='auto')
plt.xlabel('rating')
plt.ylabel('Number of rating scores')
plt.legend(loc='best')
plt.title('Review Distribution of Pittsburgh and Las Vegas')
plt.show()

运行这段代码，我们将得到最终的并排直方图。红色条形代表匹兹堡，蓝色条形代表拉斯维加斯。X轴表示平均评分，Y轴表示每个评分出现的次数。

---

总结

本节课中我们一起学习了使用Matplotlib创建直方图进行数据可视化的完整流程。我们从绘制基础的重叠直方图开始，然后学习了如何添加坐标轴标签、图例和标题来增强图表的可读性。最后，我们掌握了创建并排直方图的方法，以便更清晰地对两个数据集进行比较。这些技能是进行数据探索和结果展示的基础。

142：散点图 📊

在本节课中，我们将要学习如何使用散点图来可视化数据。散点图是一种强大的工具，可以帮助我们观察两个变量之间的关系，并比较不同类别在这些维度上的表现。

什么是散点图？

散点图在XY平面上展示了一组数据点或两个变量的观测值。

我们可以使用散点图在两个不同的维度上比较多个类别。本次，我们将可视化以下类别的商家数据：健康与医疗、快餐、以及早餐与早午餐。

准备数据

上一节我们介绍了散点图的基本概念，本节中我们来看看如何为绘图准备数据。

首先，为每个类别创建新的数据框。请注意，为了简化操作，我们将只使用category0列。

以下是创建数据框的示例代码：

# 假设df是原始数据框，包含‘category0’， ‘review_count’， ‘stars’等列
health_df = df[df['category0'] == 'Health & Medical']
fastfood_df = df[df['category0'] == 'Fast Food']
brunch_df = df[df['category0'] == 'Breakfast & Brunch']

创建散点图

数据准备完成后，接下来我们将使用这些数据框来创建散点图。

以下是绘制散点图的基本步骤：

1. 导入绘图库：首先，确保导入了必要的库，如matplotlib.pyplot。
2. 创建图形和坐标轴：使用plt.subplots()创建一个图形和一个坐标轴对象。
3. 绘制数据点：对每个类别的数据框，使用ax.scatter()方法绘制散点图，其中X轴代表评论数量，Y轴代表星级评分。
4. 添加图例和标签：为图表添加标题、坐标轴标签和图例，以增强可读性。
5. 显示图表：最后，使用plt.show()显示图表。

总结

本节课中我们一起学习了散点图的原理和应用。我们了解了散点图如何展示两个变量之间的关系，并实践了如何为不同类别的数据准备数据框以及绘制多类别散点图的基本步骤。通过将数据可视化，我们可以更直观地发现不同商业类别在评论数量和星级评分上的分布与差异。

143：散点图编码演示 - 比较不同维度的数据点

在本节课中，我们将学习如何使用Python的Pandas和Matplotlib库，通过散点图来可视化并比较不同类别业务的数据。具体来说，我们将分析三个不同行业（医疗健康、快餐、早餐与早午餐）的商家，比较它们的评论数量和星级评分。

我们将使用散点图来展示这些数据，因为散点图非常适合用于观察两个连续变量之间的关系，并能通过颜色或标记区分不同的数据组。

数据准备与类别筛选

首先，我们需要从数据集中筛选出三个特定类别的业务数据。假设我们有一个包含所有业务信息的数据框，我们需要为每个感兴趣的类别创建单独的数据子集。

以下是创建这些新数据框的步骤：

1. 确定原始数据框中用于标识业务类别的列名（例如 'category'）。
2. 使用条件筛选，为“医疗健康”、“快餐”以及“早餐与早午餐”这三个类别分别创建新的数据框。

对应的Python代码可能如下所示：

import pandas as pd

# 假设 df 是包含所有业务数据的原始DataFrame
# 筛选医疗健康类别的业务
health_df = df[df['category'] == 'Health and Medical']
# 筛选快餐类别的业务
fastfood_df = df[df['category'] == 'Fast Food']
# 筛选早餐与早午餐类别的业务
breakfast_df = df[df['category'] == 'Breakfast and Brunch']

通过以上代码，我们得到了三个独立的数据框，每个都只包含对应类别的商家数据，为后续的可视化做好了准备。

创建与定制散点图

在分离出所需类别的数据后，下一步是使用Matplotlib创建散点图。我们将把“评论数量”放在X轴，把“星级评分”放在Y轴，并用不同的颜色或标记来区分三个类别。

以下是绘制散点图的关键步骤：

• 初始化图表：使用 plt.figure() 创建一个新的图形窗口，并可使用 figsize 参数设置其大小。
• 绘制散点：对每个类别的数据框，分别调用 plt.scatter() 函数。我们需要指定X轴数据（评论数量）、Y轴数据（星级评分）、以及用于区分类别的颜色（color）或标记样式（marker）。
• 添加图例：为每个 plt.scatter() 调用设置一个 label 参数，然后使用 plt.legend() 来显示图例，以便读者能分辨哪个点集代表哪个类别。
• 添加标签与标题：使用 plt.xlabel(), plt.ylabel() 和 plt.title() 为图表添加清晰的轴标签和标题。
• 显示图表：最后，使用 plt.show() 将绘制好的图表展示出来。

一个基础的绘图代码结构如下：

import matplotlib.pyplot as plt

plt.figure(figsize=(10, 6))

plt.scatter(health_df['review_count'], health_df['stars'], color='blue', label='Health and Medical', alpha=0.6)
plt.scatter(fastfood_df['review_count'], fastfood_df['stars'], color='red', label='Fast Food', alpha=0.6)
plt.scatter(breakfast_df['review_count'], breakfast_df['stars'], color='green', label='Breakfast and Brunch', alpha=0.6)

plt.xlabel('Review Count')
plt.ylabel('Star Rating')
plt.title('Business Review Count vs. Star Rating by Category')
plt.legend()
plt.grid(True, linestyle='--', alpha=0.5)
plt.show()

在这段代码中，alpha 参数用于设置点的透明度，有助于在点重叠时更好地观察分布密度；grid 函数则添加了网格线，使读数更加方便。

图表解读与分析

绘制出散点图后，我们可以直观地进行比较分析。观察图表时，可以关注以下几个方面：

• 整体分布：观察点主要集中在哪个评论数量和星级评分区间。例如，是否大部分商家的评论数都少于500条？
• 类别间差异：比较不同颜色的点群。快餐店的评分是否普遍集中在某个范围？早餐店的评论数量是更多还是更少？
• 相关性趋势：是否存在某种趋势？例如，评论数量越多的商家，其星级评分是倾向于更高还是更低？这种趋势在不同类别间是否一致？
• 异常点：注意那些远离主要点群的孤立点。这些可能是评论数极高但评分很低，或评分极高但评论数很少的特殊商家。

通过这样的可视化分析，我们能够快速获得对数据集的直观理解，并发现潜在的模式或问题，这比单纯查看数字表格要有效得多。

本节课中，我们一起学习了如何使用Pandas进行数据筛选，以及如何利用Matplotlib绘制多系列散点图来比较不同维度（此处为不同业务类别）的数据点。散点图是探索两个变量间关系的强大工具，结合颜色区分，可以高效地在单一图表中呈现多组数据的对比情况。掌握这一技能，将有助于你在数据分析项目中更深入地挖掘数据洞察。

144：散点图编码演示-准备数据

在本节课中，我们将学习如何为绘制散点图准备数据。具体来说，我们将从一个数据集中筛选出三个特定类别的数据，为后续的可视化步骤打下基础。

上一节我们介绍了数据集的基本结构，本节中我们来看看如何根据业务类别筛选数据。

首先，我们需要从数据框中筛选出“健康与医疗”类别的数据。以下是具体步骤：

• 创建一个条件，筛选出 category_0 列等于“Health and medical”的行。
• 将筛选结果存储在变量 df_health 中。

接下来，我们以同样的方式筛选“快餐”类别的数据。

• 创建一个条件，筛选出 category_0 列等于“Fast food”的行。
• 将筛选结果存储在变量 df_fast 中。

最后，我们来筛选“早餐与早午餐”类别的数据。

• 创建一个条件，筛选出 category_0 列等于“Breakfast and brunch”的行。
• 将筛选结果存储在变量 df_break 中。

为了验证数据筛选是否正确，我们可以查看一下“早餐与早午餐”数据的前几行。

以下是查看数据前五行的代码：

df_break.head()

运行 head 函数后，我们可以看到这些行的 category_0 列确实都是“Breakfast and brunch”。这表明我们的数据筛选是成功的。

数据准备完成后，我们就可以进入下一步：绘制散点图。我们将使用 pyplot 的 scatter 方法在图表中放置散点图对象。

本节课中我们一起学习了如何为绘制散点图准备数据。我们通过条件筛选，从原始数据框中分离出了“健康与医疗”、“快餐”以及“早餐与早午餐”三个类别的数据子集，并验证了筛选结果的正确性。这些准备好的数据子集将是下一节绘制多类别散点图的基础。

145：散点图编码演示-设置Pyplot选项

在本节课中，我们将学习如何使用Matplotlib库的Pyplot模块创建和自定义散点图。我们将通过一个具体示例，展示如何在同一张图表中绘制多个数据集，并设置不同的标记、颜色和标签，最后添加坐标轴标签和图例。

创建第一个散点图

上一节我们介绍了散点图的基本概念，本节中我们来看看如何用代码实现它。首先，我们使用 plt.scatter() 函数来创建散点图。该函数的前两个参数分别是X轴和Y轴的数据。

对于“健康与医疗”类别的数据，我们将查看其星级评分与评论数量之间的关系。在散点图中，每个数据点对应图上的一个标记。

以下是创建“健康与医疗”类别散点图的代码：

plt.scatter(health['stars'], health['review_count'],
            marker='o', color='r', alpha=0.5, s=50, label='Health and Medical')

在这段代码中：

• health['stars'] 和 health['review_count'] 是X轴和Y轴的数据。
• marker='o' 设置标记形状为小写字母‘o’，即圆形。
• color='r' 设置标记颜色为红色。
• alpha=0.5 设置标记的透明度。
• s=50 设置标记的大小。
• label='Health and Medical' 为此系列数据设置标签。

添加第二个数据集

接下来，我们在同一个图表中添加第二个数据集。我们将为“快餐”类别的数据绘制散点图，以展示其星级评分与评论数量之间的关系。

以下是添加“快餐”类别散点图的代码：

plt.scatter(fast['stars'], fast['review_count'],
            marker='h', color='b', alpha=0.5, s=50, label='Fast Food')

在这段代码中：

• 我们将数据框名称从 health 更改为 fast。
• marker='h' 将标记形状更改为六边形。
• color='b' 将标记颜色更改为蓝色。
• 标签更新为 'Fast Food'。

添加第三个数据集

现在，我们在图表中添加第三个数据集。我们将为“早餐与早午餐”类别的数据绘制散点图。

以下是添加“早餐与早午餐”类别散点图的代码：

plt.scatter(break['stars'], break['review_count'],
            marker='^', color='g', alpha=0.5, s=50, label='Breakfast and Brunch')

在这段代码中：

• 我们将数据框名称更改为 break。
• marker='^' 将标记形状更改为上三角。
• color='g' 将标记颜色更改为绿色。
• 标签更新为 'Breakfast and Brunch'。

添加图表标签和图例

在绘制了所有数据系列之后，我们需要为图表添加坐标轴标签和图例，使图表信息更完整。

以下是添加标签和图例的代码：

plt.xlabel('Rating')
plt.ylabel('Review Count')
plt.legend(loc='upper left')

在这段代码中：

• plt.xlabel('Rating') 设置X轴的标签为“Rating”。
• plt.ylabel('Review Count') 设置Y轴的标签为“Review Count”。
• plt.legend(loc='upper left') 添加图例，并将其位置设置在图表左上角。

总结

本节课中我们一起学习了如何使用Matplotlib创建多系列散点图。我们掌握了 plt.scatter() 函数的基本用法，并学会了如何通过参数自定义每个数据系列的标记形状、颜色、大小、透明度和标签。最后，我们还为图表添加了坐标轴标签和图例，使其更具可读性。通过这个练习，你可以将多个数据集直观地呈现在同一张图表中进行比较分析。

146：散点图编码演示-显示可视化 📊

在本节课中，我们将学习如何使用Python的matplotlib库创建和显示散点图，并了解如何通过调整坐标轴比例（例如使用对数刻度）来优化数据可视化效果，以便更清晰地展示数据分布。

概述

上一节我们介绍了如何准备数据并创建散点图。本节中，我们将重点讲解如何显示和优化这个可视化图表。

显示散点图

要显示我们创建的散点图，需要使用 plt.show() 函数。

plt.show()

运行代码后，我们将得到一个可视化图表。

该图表展示了每个类别的评论数量和星级评分。每个标记点代表一个独立的商家。我们可以观察到，根据类别的不同，评论数量和星级评分呈现出一定的聚类现象。

优化坐标轴比例

在当前的图表中，Y轴（代表评论数量）上的一些异常值（离群点）挤压了其他数据点的显示空间，使得大部分数据点聚集在图表底部，难以观察。

为了解决这个问题，我们可以对图表进行一个小调整：将Y轴设置为对数刻度。这样，评论数量将以10的幂次（数量级）来显示，所有数值将在一个更易于管理的范围内呈现，从而改善可视化效果。

以下是实现步骤：

首先，我们需要从绘图对象中获取坐标轴属性。使用 plt.gca() 函数来获取当前坐标轴对象。

axes = plt.gca()

然后，我们将设置Y轴的刻度为对数刻度。使用坐标轴对象的 set_yscale 方法。

axes.set_yscale('log')

现在，让我们重新运行代码，查看更新后的可视化效果。

图表看起来好多了，也更易于分析。异常值不再影响其他数据点的显示，数据的分布模式变得更加清晰。

总结

本节课中我们一起学习了如何显示散点图，并掌握了通过设置对数刻度来优化图表显示的关键技巧。当数据范围差异巨大时，使用对数刻度可以有效避免异常值对整体可视化效果的干扰，使数据分布更直观。