Python快速入门

第01节：安装开发环境

1. 安装Python运行环境

在开始编写 Python 代码之前，我们需要先在电脑上安装Python的运行环境。

晓舟已经将安装包上传到专属会员群文档，【常用软件.zip】压缩包中，大家可以直接下载并安装。

安装注意事项：

运行下载好的安装包。在安装界面的第一个窗口，务必勾选 "Add Python [版本号] to PATH" 这个选项！这可以让我们在命令行窗口直接使用Python命令。

验证安装是否成功

打开终端（如果不熟悉终端程序，可以在《常用工具使用手册》文档找到终端程序的详细使用方法），在终端中输入。

python --version

如果屏幕上显示出你刚刚安装的 Python 版本号，说明Python安装成功了！

2. 安装开发工具

这里推荐使用 Cursor，它是一个基于 VS Code 的智能编辑器，内置了 AI 辅助功能。

安装包同样在【常用软件.zip】压缩包中，大家也可以到cursor官网下载最新版。《常用工具使用手册》中有cursor的使用方法。

3. 运行第一个程序

创建demo.py文件，在文件中输入

print("hello world")

保存文件，然后使用快捷键ctrl + ~(数字1左侧的案件)，可以打开cursor的终端。在终端中输入：

python demo.py

可以看到终端中输出“hello world”，说明我们编写的第一个程序成功运行。

这里对程序做简单的介绍：

print 是 Python 的一个内置函数，它的作用就是把括号里的内容打印到屏幕上。括号里的 "你好，Python!" 是一个字符串。

后续的文档中我们会详细讲解什么是字符串，什么是函数。

4. 代码中的注释

在我们编写代码时，有时需要添加一些说明文字，解释某段代码是做什么的，或者暂时让某行代码失效。这些只给我们自己或其他程序员看的说明文字，不会被 Python 解释器执行，就叫做注释，例如下面的代码

# 输出hello world
print("hello world")

#后面的内容就是注释，他不会被当做代码执行。

注释有两种常用方法：

解释代码的功能
禁止部分代码运行

# 输出hello world
print("hello world")

# print("这行代码被注释掉了，不会执行")

总结：

第一节内容已经完成了开发环境的搭建，从下一节开始，我们正式进入python的学习。

第02节：变量与基本数据类型

在第一节我们在终端中打印出了 "hello world"。但这只是一个固定的文本。如果我们想让程序处理一些会变化的信息，比如用户的名字、商品的价格、或者一个计算结果，就需要用到变量和不同的数据类型。

1. 变量：给数据贴标签

想象一下我们有一个储物柜，里面有很多格子。为了方便找到东西，我们会给每个格子贴上标签，比如“袜子”、“零食”、“工具”。

在 Python 中，变量就好比是这些标签。我们可以创建一个标签，然后把数据（比如数字、文字）放进这个标签“指向”的内存空间里。以后想用这个数据时，只需要喊这个标签的名字（变量名）就行了。

创建变量并赋值：

使用赋值运算符 = 来创建变量并将数据存进去。

## 创建一个名为 message 的变量，并把字符串 "你好" 存进去
message = "你好"

## 创建一个名为 age 的变量，并把整数 25 存进去
age = 25

## 创建一个名为 price 的变量，并把浮点数 9.9 存进去
price = 9.9

## 现在可以通过变量名来使用这些数据
print(message)
print(age)
print(price)

变量命名规则与建议：

给变量起名字很重要，好的名字能让代码更容易理解。

规则（必须遵守）：
- 只能包含字母、数字和下划线 (_)。
- 不能以数字开头。
- 不能使用 Python 的关键字（保留字，有特殊含义的词，如 print, if, else, for, while 等，编辑器通常会用不同颜色标出）。
- 区分大小写 (age 和 Age 是两个不同的变量)。
建议（约定俗成）：
- 名字要有意义，能描述变量存储的数据（比如用 user_name 而不是 un）。
- 使用小写字母和下划线来分隔单词（称为 snake_case 风格），例如 first_name, item_price。

变量的值可以改变：

变量之所以叫“变量”，就是因为它们存储的数据是可以变化的。

x = 10
print(x)  # 输出 10

x = 20    # 重新给变量 x 赋值
print(x)  # 输出 20

2. 数字

在 Python 中，处理数字是很常见的。主要有两种数字类型：

整数： 就是没有小数部分的数，可以是正数、负数或零。
```
count = 100
negative_number = -5
year = 2023
```
浮点数： 就是带小数点的数。
```
temperature = 36.6
pi = 3.14159
discount = 0.85
```
注意：即使小数部分是 0，比如 10.0，它也是一个浮点数。

我们可以对数字进行各种数学运算（下一章会详细学）。

3. 字符串

程序不仅处理数字，还需要处理文本信息，比如人名、地址、消息等。在 Python 中，文本信息被称为字符串。

创建字符串：

字符串需要用英文的单引号 (') 或双引号 (") 包裹起来。两者效果通常一样，可以根据方便选择。

greeting = "Hello, World!"
name = '爱丽丝'
empty_string = "" # 空字符串也是字符串

什么时候用单引号，什么时候用双引号？ 如果字符串本身包含单引号，最好用双引号包裹；如果包含双引号，最好用单引号包裹。

quote1 = "She said, 'Hello!'" # 字符串包含单引号，用双引号包裹
quote2 = 'He replied, "Hi there!"' # 字符串包含双引号，用单引号包裹

如果字符串里既有单引号又有双引号，或者想换行，可以用三引号 (''' 或 """)。上一节我们已经介绍过，使用三引号也可以实现多行注释功能。三引号还可以在函数中当做文档字符串，这个以后我们再继续讨论。

简单的字符串拼接：

使用加号 + 可以将两个字符串连接（拼接）起来。

first_name = "张"
last_name = "三"
full_name = first_name + last_name # 结果是 "张三"
print(full_name)

greeting = "你好, "
message = greeting + full_name + "!" # 结果是 "你好, 张三!"
print(message)

注意：只能将字符串和字符串拼接，不能直接将字符串和数字拼接。

## 错误示例： print("年龄: " + 25) # 这会报错 TypeError
## 正确做法： print("年龄: " + str(25)) # 先把数字转成字符串

更优雅的字符串格式化：f-string

在 Python 3.6+ 版本中，引入了一种更简洁、更直观的字符串格式化方式：f-string（格式化字符串字面量）。只需要在字符串前加上字母f，然后在字符串中使用花括号 {} 来插入变量或表达式。

num = 123
s = f"The number is: {num}"
print(s) # 输出: The number is: 123

## 可以直接在 {} 中进行表达式计算
s = f"The number plus 10 is: {num + 10}"
print(s) # 输出: The number plus 10 is: 133

4. 判断真假：布尔值 (`bool`)

有时候，我们需要表示一些只有两种状态的逻辑值，比如“是”或“否”，“真”或“假”。在 Python 中，这种类型叫做布尔值。

布尔值只有两个可能的值：

True (真)
False (假)

注意：首字母必须大写。

is_student = True
is_adult = False
has_permission = True

print(is_student)
print(is_adult)

布尔值通常是比较运算（例如判断两个数是否相等）和逻辑运算的结果，在后续学习控制流程（if 语句）时非常重要。

5. 查看数据类型：`type()` 函数

如果我们不确定一个变量存储的数据到底是什么类型，可以使用 Python 内置的 type() 函数来查看。

message = "Hello"
count = 10
price = 99.9
is_active = True

print(type(message))  # 输出 <class 'str'>
print(type(count))    # 输出 <class 'int'>
print(type(price))    # 输出 <class 'float'>
print(type(is_active)) # 输出 <class 'bool'>

type() 函数会返回数据的具体类型信息。

6. 练习

创建几个变量，分别存储你的名字（字符串）、年龄（整数）、身高（浮点数，例如 1.75 表示 1 米 75）、是否是学生（布尔值）。
使用 print() 语句将这些变量的值输出到屏幕上。
尝试将你的名字和年龄拼接起来（注意需要先将年龄转换成字符串，然后打印出来。
使用 type() 函数检查你创建的每个变量的类型，并打印出来。

这一章我们学习了如何使用变量来存储不同类型的数据：整数、浮点数、字符串和布尔值。理解这些基本数据类型是学习后续内容的基础。下一章，我们将学习如何对这些数据进行运算。

第03章：运算符

上一节我们学习了如何用变量存储不同类型的数据。现在，我们要对这些数据进行操作，比如加减乘除、比较大小、组合逻辑判断等。这些操作需要用到运算符。

1. 算术运算符

Python 支持常见的数学运算，使用的符号和我们平时数学课上学的很类似。

加 (+)：

result = 5 + 3
print(result) # 输出 8

减 (-)：

result = 10 - 4
print(result) # 输出 6

乘 (*)：

result = 6 * 7
print(result) # 输出 42

除 (/)：

result = 10 / 2
print(result) # 输出 5.0 (注意：除法结果总是浮点数)

result = 10 / 3
print(result) # 输出 3.3333...

取模 (%)： 计算除法的余数。

remainder = 10 % 3 # 10 除以 3 等于 3 余 1
print(remainder) # 输出 1

is_even = 10 % 2 # 判断偶数常用方法：偶数除以2余数为0
print(is_even) # 输出 0

幂 (**)： 计算一个数的几次方。

power = 2 ** 3 # 2 的 3 次方 (2 * 2 * 2)
print(power) # 输出 8

square = 5 ** 2 # 5 的平方
print(square) # 输出 25

整除 (//)： 计算除法，但结果只取整数部分（向下取整）。

result = 10 // 3 # 10 除以 3 等于 3.33...，只取整数部分
print(result) # 输出 3

result = 11 // 2
print(result) # 输出 5

2. 比较运算符

比较运算符用于比较两个值的大小或是否相等，其运算结果永远是布尔值 (True 或 False)。这在后续的条件判断 (if 语句) 中非常重要。

等于 (==)： 判断两个值是否相等。注意：是两个等号，一个等号 (=) 是赋值！

print(5 == 5)   # 输出 True
print(5 == 3)   # 输出 False
print("hello" == "hello") # 输出 True
print("Hello" == "hello") # 输出 False (大小写敏感)

不等于 (!=)： 判断两个值是否不相等。

print(5 != 3)   # 输出 True
print(5 != 5)   # 输出 False
print("apple" != "orange") # 输出 True

大于 (>)：

print(10 > 5)   # 输出 True
print(5 > 10)   # 输出 False
print(5 > 5)    # 输出 False

小于 (<)：

print(3 < 8)    # 输出 True
print(8 < 3)    # 输出 False
print(8 < 8)    # 输出 False

大于等于 (>=)：

print(10 >= 5)  # 输出 True
print(5 >= 5)   # 输出 True
print(3 >= 5)   # 输出 False

小于等于 (<=)：

print(3 <= 8)   # 输出 True
print(8 <= 8)   # 输出 True
print(10 <= 8)  # 输出 False

3. 逻辑运算符

逻辑运算符用于连接或修改布尔值 (True / False)，构建更复杂的条件判断。

与 (and)： 只有当两边的条件都为 True 时，结果才为 True；否则为 False。

age = 25
is_student = True

print(age > 18 and is_student == True) # True and True -> True
print(age < 30 and is_student == False) # True and False -> False
print(age < 18 and is_student == True) # False and True -> False

或 (or)： 只要当两边的条件有至少一个为 True 时，结果就为 True；只有两边都为 False 时才为 False。

score = 80
has_vip_card = False

print(score >= 60 or has_vip_card == True) # True or False -> True
print(score < 60 or has_vip_card == True) # False or True -> True
print(score < 60 or has_vip_card == False) # False or False -> False

非 (not)： 对一个布尔值取反。not True 结果是 False，not False 结果是 True。

is_raining = False
print(not is_raining) # not False -> True

is_logged_in = True
print(not is_logged_in) # not True -> False

运算优先级： 通常，not 的优先级最高，然后是 and，最后是 or。可以使用括号 () 来明确指定运算顺序，就像数学运算一样。

print(True or False and False) # 先算 and: True or False -> True
print((True or False) and False) # 先算 or: True and False -> False

4. 赋值运算符

我们已经知道 = 是赋值运算符。Python 还提供了一些复合赋值运算符，可以简化代码。

a = a + 1 可以简写为 a += 1
b = b - 5 可以简写为 b -= 5
c = c * 2 可以简写为 c *= 2
d = d / 4 可以简写为 d /= 4
e = e % 3 可以简写为 e %= 3
f = f ** 2 可以简写为 f **= 2
g = g // 10 可以简写为 g //= 10

示例：

count = 0
count += 1  # count 现在是 1
print(count)

price = 100
price *= 0.8 # 打八折，price 现在是 80.0
print(price)

这些复合赋值运算符让代码更简洁。

5. 练习

计算 (100 + 50) * 2 的结果。
判断 100 是否大于 50 * 2。
判断 20 是否既是偶数 (20 % 2 == 0) 又小于 30。
有一个变量 score = 75，判断它是否大于等于 60 或者小于 10。
使用复合赋值运算符，将变量 total = 10 的值增加 5，然后乘以 3。

掌握了这些基础运算符，我们就能对数据进行各种计算和比较了。下一章我们将学习如何存储一系列的数据，即列表和字典。

第04节：常用数据结构

很多时候，我们需要同时处理一组数据，比如一个班级所有学生的名字、一本书的章节标题、或者一个用户的配置信息。这就需要用到更复杂的数据结构。本章我们学习两种最常用、也最重要的结构：列表和字典。

1. 列表

想象一下你的购物清单，上面按顺序写着你要买的东西：牛奶、鸡蛋、面包...

列表 (List) 就是 Python 中用来存储一系列有序元素的数据结构。列表非常灵活，可以包含任何类型的数据（数字、字符串、布尔值，甚至其他列表），而且里面的元素可以被修改。

创建列表

使用方括号 [] 来创建列表，元素之间用逗号 , 分隔。

## 一个包含整数的列表
numbers = [1, 2, 3, 4, 5]
print(numbers)

## 一个包含字符串的列表
fruits = ["apple", "banana", "cherry"]
print(fruits)

## 一个包含混合类型的列表
mixed_list = [10, "hello", 3.14, True]
print(mixed_list)

## 一个空列表
empty_list = []
print(empty_list)

访问列表元素

列表中的每个元素都有一个索引（也可以叫下标），代表它在列表中的位置。索引从 0 开始！ 第一个元素的索引是 0，第二个是 1，以此类推。

使用方括号 [] 加上索引号来访问特定位置的元素。

fruits = ["apple", "banana", "cherry"]

## 访问第一个元素 (索引 0)
first_fruit = fruits[0]
print(first_fruit) # 输出: apple

## 访问第三个元素 (索引 2)
third_fruit = fruits[2]
print(third_fruit) # 输出: cherry

## 也可以使用负数索引，-1 代表最后一个元素，-2 代表倒数第二个，以此类推
last_fruit = fruits[-1]
print(last_fruit) # 输出: cherry

注意：如果使用的索引超出了列表的范围（比如列表只有3个元素，却尝试访问 fruits[3]），程序会报错 IndexError。

修改列表元素

列表中的值可以直接通过赋值运算符来修改。

colors = ["red", "green", "blue"]
print(colors) # 输出: ['red', 'green', 'blue']

## 修改第二个元素 (索引 1)
colors[1] = "yellow"
print(colors) # 输出: ['red', 'yellow', 'blue']

添加元素：`.append()`

使用列表的 .append() 方法可以在列表的末尾添加一个新元素。 (方法是与特定数据类型关联的函数，使用 . 来调用)。

my_list = [1, 2]
print(my_list) # 输出: [1, 2]

my_list.append(3)
print(my_list) # 输出: [1, 2, 3]

my_list.append("four")
print(my_list) # 输出: [1, 2, 3, 'four']

获取列表长度：`len()`

使用内置的 len() 函数可以获取列表包含多少个元素。

numbers = [10, 20, 30, 40]
length = len(numbers)
print(length) # 输出: 4

empty_list = []
print(len(empty_list)) # 输出: 0

列表还有很多其他操作（插入、删除、排序等），但对于入门，掌握创建、访问、修改、添加末尾元素和获取长度是最核心的。

2. 字典

想象一个储物柜，每个格子不是按顺序编号，而是贴着标签，比如“姓名”、“年龄”、“城市”。你想找某个信息，直接看对应的标签就行。

字典 (Dictionary, dict) 是 Python 中用来存储一系列无序的键值对 (Key-Value Pair) 的数据结构。每个元素都由一个键 (Key) 和一个值 (Value) 组成，键是唯一的，用来查找对应的值。

创建字典

使用花括号 {} 来创建字典，每个键值对写成 key: value 的形式，键值对之间用逗号 , 分隔。

## 创建一个表示个人信息的字典
person = {
    "name": "李四",
    "age": 30,
    "city": "上海",
    "is_student": False
}
print(person)

## 一个空字典
empty_dict = {}
print(empty_dict)

键 (Key)： 通常是字符串或数字，必须是唯一的，不可变的类型。我们常用字符串作键。
值 (Value)： 可以是任何数据类型（数字、字符串、布尔值、列表，甚至其他字典）。

访问字典元素

字典是无序的，所以不能像列表那样通过数字索引访问。我们使用键来访问对应的值，同样使用方括号 []。

person = {
    "name": "李四",
    "age": 30,
    "city": "上海"
}

## 访问 "name" 键对应的值
name = person["name"]
print(name) # 输出: 李四

## 访问 "age" 键对应的值
age = person["age"]
print(age) # 输出: 30

注意：如果使用的键在字典中不存在（比如 person["gender"]），程序会报错 KeyError。

修改字典元素

可以直接通过赋值修改字典中的键值：

person = {
    "name": "李四",
    "age": 30,
    "city": "上海"
}
print(person)

## 修改 "city" 键的值
person["city"] = "北京"
print(person) # 输出: {'name': '李四', 'age': 30, 'city': '北京'}

添加键值对：

如果使用一个字典中不存在的键进行赋值，就会在字典中添加一个新的键值对。

person = {
    "name": "李四",
    "age": 30
}
print(person)

## 添加新的键值对 "occupation"
person["occupation"] = "工程师"
print(person) # 输出: {'name': '李四', 'age': 30, 'occupation': '工程师'}

列表 vs. 字典：

列表 (List)： 有序集合，通过数字索引访问，适合存储顺序重要的数据。
字典 (Dictionary)： 无序键值对集合，通过唯一的键访问，适合存储需要通过标签查找的数据。

3. 练习

创建一个包含你最喜欢的三部电影名称的列表（字符串）。
打印出列表中的第二部电影。
使用 .append() 方法向列表末尾添加一部你最近看的电影。
创建一个字典，包含你的“姓名 (name)”（字符串）、“出生年份 (birth_year)”（整数）和“喜欢的颜色 (favorite_color)”（字符串）。
打印出你的出生年份。
向字典中添加一个新的键值对，键是“城市 (city)”，值是你当前所在的城市（字符串）。
修改字典中“喜欢的颜色”的值为你现在最喜欢的颜色。
分别打印出修改后的列表和字典。

列表和字典是 Python 中极其重要的数据结构，熟练掌握它们是进行更复杂编程的基础。下一章我们将学习如何控制程序的执行流程，让程序能够根据不同的情况做出不同的反应。

第05节：流程控制语句

到目前为止，我们写的 Python 代码都是从上到下一行接一行地执行。但真实的程序往往需要根据不同的情况做出不同的反应，或者重复执行某些任务。这就需要用到流程控制语句，本节主要讲解条件语句和循环语句。

1. 让程序做选择：条件语句

条件语句允许程序根据某个条件是否满足 (是 True 还是 False) 来决定执行哪段代码。最常用的条件语句是 if、elif 和 else。

`if` 语句：满足条件才执行

if 语句是最基本的条件判断。它检查紧跟在 if 后面的条件表达式。如果条件为 True，就执行 if 下方缩进的代码块；如果条件为 False，就跳过这段缩进的代码块。

语法：

if 条件表达式:
    # 条件为 True 时执行的代码块 (必须缩进!)
    语句1
    语句2
    ...
## 这里是不受 if 控制的代码 (没有缩进)

重要：

条件表达式 通常是一个结果为布尔值 (True 或 False) 的表达式，比如比较运算 (age > 18) 或逻辑运算 (score >= 60 and score <= 100)。
条件表达式后面必须有冒号 :。
if 下方的代码块必须缩进 (通常是 4 个空格)，表示这部分代码属于 if 语句。

示例：

age = 20

if age >= 18:
    print("您已成年。") # 条件 age >= 18 为 True，所以这行会执行

print("程序继续执行...") # 这行没有缩进，总会执行

temperature = 15
if temperature < 10:
    print("天气寒冷，请多穿衣服。") # 条件为 False，这行不会执行

`if-else` 语句：两种选择

if-else 语句提供了一种二选一的逻辑：如果 if 的条件为 True，执行 if 下方的代码块；否则 (即条件为 False 时)，执行 else 下方的代码块。

语法：

if 条件表达式:
    # 条件为 True 时执行的代码块
    语句1
else:
    # 条件为 False 时执行的代码块 (else下方也要缩进!)
    语句2

示例：

score = 75

if score >= 60:
    print("恭喜，及格了！") # 条件为 True，执行这里
else:
    print("很遗憾，需要继续努力。")

## ---

light_is_on = False

if light_is_on == True: # 或者可以直接写 if light_is_on:
    print("灯是开着的。")
else:
    print("灯是关着的。") # 条件为 False，执行这里

`if-elif-else` 语句：多种选择

当有多个条件需要判断时（超过两种情况），可以使用 if-elif-else 结构。elif 是 "else if" 的缩写。程序会从上到下依次检查 if 和 elif 的条件：

如果 if 条件为 True，执行其代码块，然后整个结构结束。
如果 if 条件为 False，检查第一个 elif 的条件。如果为 True，执行其代码块，然后整个结构结束。
如果第一个 elif 也为 False，检查下一个 elif...
如果所有的 if 和 elif 条件都为 False，则执行 else 下方的代码块（else 是可选的）。

语法：

if 条件1:
    # 条件1 为 True 时执行
    语句块1
elif 条件2:
    # 条件1 为 False，条件2 为 True 时执行
    语句块2
elif 条件3:
    # 条件1、2 为 False，条件3 为 True 时执行
    语句块3
## ... 可以有更多 elif
else:
    # 以上所有条件都为 False 时执行 (可选)
    语句块N

示例：

grade = 85

if grade >= 90:
    print("优秀")
elif grade >= 80: # grade >= 90 不满足，检查这个 (85 >= 80 为 True)
    print("良好") # 执行这里，然后结束
elif grade >= 60:
    print("及格")
else:
    print("不及格")

## ---

day = "Sunday"

if day == "Saturday":
    print("今天是周六，休息！")
elif day == "Sunday":
    print("今天是周日，也休息！") # 执行这里
else:
    print("今天需要工作/学习。")

条件嵌套

if 语句内部还可以包含其他的 if 语句，形成嵌套结构，用于处理更复杂的逻辑。

age = 25
has_ticket = True

if age >= 18:
    print("已成年。")
    if has_ticket == True:
        print("可以入场。") # 嵌套的 if
    else:
        print("需要购票才能入场。") # 嵌套的 else
else:
    print("未成年，不能入场。")

注意：嵌套层数不宜过多，否则代码会变得难以理解。

2. 重复执行任务：循环语句

循环语句允许程序重复执行某段代码块，直到满足某个退出条件。Python 主要有两种循环：for 循环和 while 循环。

`for` 循环：遍历序列

for 循环通常用于遍历一个序列 (Sequence) 中的每个元素，比如列表、字符串或其他可迭代的对象。它会依次取出序列中的每个元素，并执行循环体内的代码。

语法：

for 临时变量 in 可迭代对象:
    # 对每个元素执行的代码块 (必须缩进!)
    语句1
    语句2
    # 在这里可以使用 临时变量

可迭代对象：可以是列表、字符串等。
临时变量：每次循环时，序列中的当前元素会被赋值给这个变量。你可以自己给它命名。

示例：遍历列表

fruits = ["apple", "banana", "cherry"]

for fruit in fruits: # 依次取出 "apple", "banana", "cherry" 赋值给 fruit
    print("我喜欢吃 " + fruit)

## 输出:
## 我喜欢吃 apple
## 我喜欢吃 banana
## 我喜欢吃 cherry

示例：遍历字符串

message = "Hello"

for char in message: # 依次取出 "H", "e", "l", "l", "o" 赋值给 char
    print(char)

## 输出:
## H
## e
## l
## l
## o

range() 函数：生成数字序列

如果想让代码重复固定次数，经常配合 range() 函数使用 for 循环。range() 可以生成一个整数序列。

range(结束值)：生成从 0 到 结束值-1 的整数序列。
range(起始值, 结束值)：生成从 起始值 到 结束值-1 的整数序列。
range(起始值, 结束值, 步长)：生成从 起始值 开始，每次增加 步长，直到 结束值-1 的序列。

## 打印 0 到 4
for i in range(5): # range(5) 生成 0, 1, 2, 3, 4
    print(i)

print("---")

## 打印 1 到 5
for i in range(1, 6): # range(1, 6) 生成 1, 2, 3, 4, 5
    print(i)

print("---")

## 打印 0 到 10 之间的偶数
for i in range(0, 11, 2): # range(0, 11, 2) 生成 0, 2, 4, 6, 8, 10
    print(i)

`while` 循环：当条件为真时持续执行

while 循环会在其后的条件表达式为 True 时，持续执行循环体内的代码块。每次执行完循环体后，会重新检查条件表达式。直到条件变为 False 时，循环才会结束。

语法：

while 条件表达式:
    # 条件为 True 时执行的代码块 (必须缩进!)
    语句1
    语句2
    # 重要：通常需要在这里更新与条件相关的变量，否则可能导致无限循环!

示例：

count = 0
while count < 5: # 条件 count < 5
    print("Count is:", count)
    count = count + 1 # 或者 count += 1，更新条件变量

print("循环结束")

## 输出:
## Count is: 0
## Count is: 1
## Count is: 2
## Count is: 3
## Count is: 4
## 循环结束

重要： 使用 while 循环时，必须确保循环体内部有代码能最终让 条件表达式 变为 False，否则就会陷入无限循环 (Infinite Loop)，程序会一直运行下去，需要手动停止。

循环中的 break 和 continue (可选)

break： 立刻跳出整个循环（for 或 while），执行循环后面的代码。
continue： 立刻结束当前这次循环，跳过本次循环中 continue 后面的语句，直接开始下一次循环。

## break 示例: 找到第一个大于 5 的数就停止
numbers = [1, 3, 7, 2, 9, 4]
for num in numbers:
    if num > 5:
        print("找到大于 5 的数:", num)
        break # 跳出整个 for 循环
    print("当前数字:", num)

## continue 示例: 只打印偶数
for i in range(1, 11):
    if i % 2 != 0: # 如果 i 是奇数
        continue # 跳过本次循环，不执行下面的 print
    print("偶数:", i)

3. 练习

编写一个程序，判断一个变量 score 的值：如果大于等于 90，打印 "A"；如果大于等于 80 小于 90，打印 "B"；如果大于等于 60 小于 80，打印 "C"；否则打印 "D"。
使用 for 循环和 range() 函数，打印出 1 到 10 的所有数字。
创建一个包含几个朋友名字的列表，使用 for 循环向每个朋友打招呼，例如打印 "你好, [朋友名字]!"。
使用 while 循环，计算并打印出 1 到 5 的所有整数的和 (1+2+3+4+5)。
修改练习 4，如果累加的和超过 10，就使用 break 提前结束循环。

掌握了条件语句和循环语句，你就能编写出更智能、更灵活的程序了。下一章我们将学习如何将代码组织成可重用的块——函数。

第06节：函数

随着我们编写的程序越来越复杂，可能会遇到一些问题：

代码重复： 同样或类似的代码片段需要在程序的不同地方多次使用。
难以维护： 如果需要修改某个重复的功能，就得去修改所有用到它的地方，容易出错且效率低下。
结构混乱： 大段的代码堆砌在一起，逻辑不清晰，难以阅读和理解。

我们可以使用Python中的函数来解决这个问题。函数允许我们将一段具有特定功能的代码打包起来，给它起一个名字，然后在需要的地方通过这个名字来调用（执行）它。

1. 定义函数

在 Python 中，使用 def 关键字来定义一个函数。

基本语法：

def 函数名(参数列表):
    """
    (可选) 函数文档字符串 - 描述函数的功能、参数和返回值
    """
    # 函数体 - 实现函数功能的代码块 (必须缩进!)
    语句1
    语句2
    # ...
    return 返回值 # (可选)

def： 定义函数的关键字。
函数名： 给函数起的名字，遵循变量命名规则（小写字母和下划线）。好的函数名应该能清晰地表达函数的功能，例如 greet_user, calculate_sum。
参数列表 (Parameters)： 括号 () 里是函数的参数，是函数需要接收的外部信息。参数之间用逗号 , 分隔。如果函数不需要接收任何信息，括号也不能省略，但里面是空的，例如 def say_hello():。
:： 参数列表后面必须有冒号。
"""文档字符串""" ： 可选。通常是函数定义的第一行，用三引号包裹的多行字符串，用来解释函数的作用、参数含义、返回值等。这是一个好习惯，有助于他人（和未来的你）理解函数。
函数体： 实现函数具体功能的代码块，必须缩进。
return 返回值： 可选。return 语句用于指定函数的返回值，也就是函数执行完毕后反馈给调用者的结果。如果函数没有 return 语句，或者 return 后面没有跟任何值，它默认返回一个特殊的值 None。

示例：定义一个简单的问候函数

def greet():
    """打印简单的问候语"""
    print("你好！欢迎学习 Python 函数！")

## 定义一个带参数的问候函数
def greet_user(name): # name 是参数，用于接收用户的名字
    """根据提供的名字打印问候语"""
    print("你好, " + name + "!")

## 定义一个计算两个数之和的函数
def add_numbers(num1, num2): # num1 和 num2 是参数
    """计算并返回两个数字的和"""
    result = num1 + num2
    return result # 返回计算结果

注意：定义函数只是创建了这个“积木块”，此时函数体内的代码并不会执行。

2. 调用函数

定义好函数之后，我们需要调用 (Call) 它来执行其中的代码。调用函数很简单，只需要使用函数名加上一对括号 () 即可。如果函数定义时有参数，调用时通常需要提供相应的参数值 (Arguments)。

语法：

函数名(参数值列表)

示例：调用上面定义的函数

## 调用 greet() 函数
greet() # 输出: 你好！欢迎学习 Python 函数！

## 调用 greet_user() 函数，并传入参数值 "小明"
greet_user("小明") # 输出: 你好, 小明!
greet_user("莉莉") # 输出: 你好, 莉莉!

## 调用 add_numbers() 函数，并传入参数值 5 和 3
## 函数会返回一个结果，我们可以用一个变量来接收它
sum_result = add_numbers(5, 3)
print("5 和 3 的和是:", sum_result) # 输出: 5 和 3 的和是: 8

## 也可以直接打印函数的返回值
print(add_numbers(10, 20)) # 输出: 30

## 调用没有 return 语句的函数，其返回值是 None
result_from_greet = greet()
print("greet() 函数的返回值:", result_from_greet) # 输出: greet() 函数的返回值: None

3. 参数传递

当调用带参数的函数时，我们需要提供与参数列表对应的值。这些传入的值被称为实际参数 (Arguments)，而函数定义时的参数被称为形式参数 (Parameters)。

最基本的参数传递方式是位置参数 (Positional Arguments)。调用函数时，提供的参数值会按顺序依次传递给函数定义中的参数。

def describe_pet(animal_type, pet_name):
    """显示宠物的信息"""
    print("我有一只 " + animal_type + "。")
    print("它的名字叫 " + pet_name + "。")

## 调用函数，按位置传递参数
describe_pet("猫", "咪咪") # "猫" 传给 animal_type, "咪咪" 传给 pet_name

## 输出:
## 我有一只 猫。
## 它的名字叫 咪咪。

## 如果顺序搞错，结果可能就不对了
describe_pet("小白", "狗") # "小白" 传给 animal_type, "狗" 传给 pet_name

## 输出:
## 我有一只 小白。
## 它的名字叫 狗。

注意：调用时提供的参数数量通常需要和函数定义时的参数数量一致。

4. 返回值

函数可以通过 return 语句将执行结果返回给调用它的地方。返回值可以是任何数据类型（数字、字符串、列表、字典、布尔值等）。

函数执行到 return 语句时，会立即结束，并将 return 后面的值返回。return 后面的代码不会被执行。
一个函数可以有多个 return 语句（例如在不同的 if 分支中），但一次调用只会执行其中一个 return。
如果函数没有 return 语句，或者 return 后面没有值，则默认返回 None。

def check_score(score):
    """根据分数判断等级并返回"""
    if score >= 60:
        return "及格" # 执行到这里，函数结束并返回 "及格"
        print("这里不会执行") # 这行代码永远不会被执行
    else:
        return "不及格"

result1 = check_score(75)
print("75分的结果:", result1) # 输出: 75分的结果: 及格

result2 = check_score(50)
print("50分的结果:", result2) # 输出: 50分的结果: 不及格

def no_return_function():
    x = 1 + 1
    # 没有 return 语句

value = no_return_function()
print("没有 return 的函数返回值:", value) # 输出: 没有 return 的函数返回值: None

5. 练习

定义一个名为 say_goodbye 的函数，它不需要参数，功能是打印一句 "再见！"。然后调用这个函数。
定义一个名为 square 的函数，它接收一个数字 num 作为参数，并返回这个数字的平方。调用这个函数计算 5 的平方并打印结果。
定义一个名为 get_greeting 的函数，它接收一个名字 name 作为参数，并返回一个包含问候语的字符串，例如 "你好, [name] 欢迎你！"。调用这个函数，传入你的名字，并将返回的问候语存储在一个变量中，然后打印这个变量。
定义一个函数 find_max，接收两个数字 a 和 b 作为参数，返回两者中较大的那个数。

函数是 Python 编程中非常核心和重要的概念。通过将代码组织成函数，我们可以编写出更简洁、更清晰、更易于维护的程序。下一章我们将了解如何使用别人已经写好的函数（模块）。

第07节：模块化

Python 自带了很多非常有用的模块，这些模块构成了 Python 标准库 (Python Standard Library)。标准库是 Python 安装时就自带的，包含了处理文本、数学运算、日期时间、文件操作、网络通信等各种功能的模块。这意味着你不需要额外安装任何东西，就可以直接使用这些强大的功能。

1. 导入模块

要在你的 Python 程序中使用一个模块里的功能，首先需要将这个模块导入 (Import) 到当前的程序中。导入模块最常用的方式是使用 import 关键字。

语法：

import module_name

import 是导入关键字。
module_name 是你想要导入的模块的名称（通常是模块文件的名字，不带 .py 后缀）。

示例：导入数学模块 math

import math # 导入 Python 内置的 math 模块

一旦导入了模块，你就可以使用该模块中定义的函数或变量了。

2. 使用模块中的功能

导入模块后，要使用模块里的函数或变量，通常需要通过 模块名. 的方式来调用。

语法：

模块名.函数名(参数)
模块名.变量名

示例：使用 math 模块的功能

math 模块提供了很多数学相关的函数和常量。

import math

## 使用 math 模块中的 sqrt() 函数计算平方根
result = math.sqrt(16) # 计算 16 的平方根
print(result) # 输出: 4.0

## 使用 math 模块中的 pi 常量 (圆周率)
print(math.pi) # 输出: 3.141592653589793

## 使用 math 模块中的 pow() 函数计算幂 (类似 **)
power = math.pow(2, 3) # 计算 2 的 3 次方
print(power) # 输出: 8.0

示例：使用 random 模块生成随机数

random 模块用于生成各种随机数。

import random

## 生成一个 1 到 10 之间的随机整数 (包含 1 和 10)
random_integer = random.randint(1, 10)
print("随机整数:", random_integer)

## 从列表中随机选择一个元素
my_list = ["苹果", "香蕉", "橘子"]
random_fruit = random.choice(my_list)
print("随机选择的水果:", random_fruit)

## 生成一个 0.0 到 1.0 之间的随机浮点数
random_float = random.random()
print("随机浮点数:", random_float)

只导入模块中的特定功能 (可选)

有时我们只需要模块中的某一个或几个函数，可以使用 from ... import ... 的语法。

from math import sqrt, pi # 只导入 math 模块中的 sqrt 函数和 pi 常量

## 现在可以直接使用 sqrt 和 pi，不需要加模块名 math. 前缀
result = sqrt(25)
print(result) # 输出: 5.0
print(pi)     # 输出: 3.14159...

## ---

from random import randint # 只导入 randint 函数

random_num = randint(100, 200)
print(random_num)

这种方式可以少写一些代码，但如果导入的函数名与你自己的变量或函数名冲突，可能会引起混淆。对于初学者，推荐先掌握标准的 import module_name 方式。

3. 简单实践

尝试结合之前学过的知识和 math、random 模块来解决一些小问题。

示例：计算圆的面积

import math

radius = 5 # 圆的半径
area = math.pi * (radius ** 2) # 面积 = π * r²
## 或者使用 math.pow(): area = math.pi * math.pow(radius, 2)
print("半径为", radius, "的圆面积是:", area)

示例：模拟掷骰子

import random

dice_roll = random.randint(1, 6) # 骰子点数是 1 到 6
print("你掷出的点数是:", dice_roll)

if dice_roll == 6:
    print("恭喜，掷出了 6！")
elif dice_roll == 1:
    print("运气不太好，掷出了 1。")

4. 练习

导入 math 模块，计算 9 的平方根并打印出来。
导入 random 模块，生成一个 1 到 100 之间的随机整数，并判断这个数是奇数还是偶数，打印相应的结果（例如 "生成的随机数 X 是奇数/偶数"）。
创建一个包含几个颜色的列表（例如 colors = ["red", "green", "blue", "yellow"]），导入 random 模块，并使用 random.choice() 随机选择一个颜色打印出来。

在实际项目开发中，我们不仅要使用标准库模块，还需要使用第三方模块，如何下载、安装、管理第三方模块，我在《常用工具使用手册》中的pip工具教程内容有详细的讲解。

第08节：总结

通过前7节内容的学习，我们已经初步掌握了python的基础语法。后续晓舟还会持续更新智能体开发文档和案例。

大家可以在抖音【晓舟报告】首页加入【晓舟的AI交流66群】，一起交流技术问题，并获取更多学习资料。

最后祝大家早日富可敌国，【晓舟的直播时间是】工作日中午12:00，抖音直播间见啦，拜拜~

# Python快速入门

# 第01节：安装开发环境

# 1. 安装Python运行环境

# 2. 安装开发工具

# 3. 运行第一个程序

# 4. 代码中的注释

# 总结：

# 第02节：变量与基本数据类型

# 1. 变量：给数据贴标签

# 2. 数字

# 3. 字符串

# 4. 判断真假：布尔值 (bool)

# 5. 查看数据类型：type() 函数

# 6. 练习

# 第03章：运算符

# 1. 算术运算符

# 2. 比较运算符

# 3. 逻辑运算符

# 4. 赋值运算符

# 5. 练习

# 第04节：常用数据结构

# 1. 列表

# 创建列表

# 访问列表元素

# 修改列表元素

# 添加元素：.append()

# 获取列表长度：len()

# 2. 字典

# 创建字典

# 访问字典元素

# 修改字典元素

# 添加键值对：

# 3. 练习

# 第05节：流程控制语句

# 1. 让程序做选择：条件语句

# if 语句：满足条件才执行

# if-else 语句：两种选择

# if-elif-else 语句：多种选择

# 条件嵌套

# 2. 重复执行任务：循环语句

# for 循环：遍历序列

# while 循环：当条件为真时持续执行

# 3. 练习

# 第06节：函数

# 1. 定义函数

# 2. 调用函数

# 3. 参数传递

# 4. 返回值

# 5. 练习

# 第07节：模块化

# 1. 导入模块

# 2. 使用模块中的功能

# 3. 简单实践

# 4. 练习

# 第08节：总结

Python快速入门

第01节：安装开发环境

1. 安装Python运行环境

2. 安装开发工具

3. 运行第一个程序

4. 代码中的注释

总结：

第02节：变量与基本数据类型

1. 变量：给数据贴标签

2. 数字

3. 字符串

4. 判断真假：布尔值 (`bool`)

5. 查看数据类型：`type()` 函数

6. 练习

第03章：运算符

1. 算术运算符

2. 比较运算符

3. 逻辑运算符

4. 赋值运算符

5. 练习

第04节：常用数据结构

1. 列表

创建列表

访问列表元素

修改列表元素

添加元素：`.append()`

获取列表长度：`len()`

2. 字典

创建字典

访问字典元素

修改字典元素

添加键值对：

3. 练习

第05节：流程控制语句

1. 让程序做选择：条件语句

`if` 语句：满足条件才执行

`if-else` 语句：两种选择

`if-elif-else` 语句：多种选择

条件嵌套

2. 重复执行任务：循环语句

`for` 循环：遍历序列

`while` 循环：当条件为真时持续执行

3. 练习

第06节：函数

1. 定义函数

2. 调用函数

3. 参数传递

4. 返回值

5. 练习

第07节：模块化

1. 导入模块

2. 使用模块中的功能

3. 简单实践

4. 练习

第08节：总结