1️⃣ 前端开发技术栈#

2️⃣ 后端开发技术栈#

3️⃣ 移动开发技术栈#

4️⃣ 数据存储技术栈#

5️⃣ DevOps和基础设施#

6️⃣ 数据科学和AI/ML#

常见的生产级技术栈组合#

1
前端：React/Vue + Tailwind CSS + TypeScript
2
后端：Node.js + Express/Nest.js + TypeScript
3
数据库：MongoDB + Redis
4
部署：Docker + GitHub Actions + AWS/DigitalOcean

1
前端：React/Vue + Tailwind CSS
2
后端：Python + FastAPI/Django
3
数据库：PostgreSQL + Redis
4
数据科学：Pandas + Scikit-learn
5
部署：Docker + GitHub Actions + AWS

1
前端：React + TypeScript + Ant Design
2
后端：Spring Boot + Spring Cloud (微服务)
3
数据库：MySQL + Redis + Elasticsearch
4
消息队列：Kafka
5
监控：Prometheus + Grafana
6
部署：Kubernetes + Jenkins

1
后端：Go + Gin框架
2
数据库：PostgreSQL + Redis
3
消息队列：Kafka
4
缓存：Redis
5
部署：Docker + Kubernetes

1
跨平台：Flutter (推荐) 或 React Native
2
后端：Node.js/Python/Go
3
数据库：Firebase 或 PostgreSQL
4
推送：Firebase Cloud Messaging
5
分析：Firebase Analytics

选择标准#

不同场景推荐#

初创公司 → React/Vue + Node.js + PostgreSQL + Firebase部署
SaaS应用 → Next.js全栈 + PostgreSQL + Vercel部署
高并发系统 → Go/Java + MySQL + Redis + Kubernetes
数据密集型 → Python + PostgreSQL + Elasticsearch
移动应用 → Flutter (iOS+Android一套代码)
企业系统 → Spring Boot + Oracle + Kubernetes

初级开发者学习路线#

1
1. 学习HTML/CSS/JavaScript基础 (1-2周)
2
   ↓
3
2. 选一个前端框架深入学习 (2-3个月)
4
   - React 或 Vue (推荐React)
5
   ↓
6
3. 学习后端基础 (2-3个月)
7
   - Node.js + Express 或 Python + Flask
8
   ↓
9
4. 学习数据库 (1-2个月)
10
   - MySQL/PostgreSQL + Redis
11
   ↓
12
5. 做一个完整的全栈项目 (1个月)
13
   ↓
14
6. 学习部署上线 (2-3周)
15
   - Docker + GitHub Actions

中级开发者进阶路线#

1
1. 深入学习选定的框架生态
2
2. 学习架构设计和系统设计
3
3. 学习高级后端技能
4
   - 微服务架构
5
   - 消息队列
6
   - 缓存策略
7
4. 学习DevOps和部署
8
   - Kubernetes
9
   - 监控告警
10
5. 选择一个专向深入
11
   - 前端专家 → 性能优化、设计系统
12
   - 后端专家 → 架构、并发、性能
13
   - 全栈专家 → 系统设计、产品思维

Q: React vs Vue选哪个？#

A:

• React: 生态最强、工作机会最多、学习资源最丰富 → 推荐初学者
• Vue: 学习曲线更平缓、中文文档好、国内使用广泛
• 选择标准: 看公司技术栈、团队技能、个人兴趣

Q: Node.js 还是 Python 做后端？#

A:

• Node.js: 前后端统一、实时应用好、性能可以 → 全栈开发首选
• Python: 库最多、学习最简单、AI/ML生态强 → 数据导向项目首选
• 建议: 先学一个深入，再学另一个会很快

Q: 一定要学Kubernetes吗？#

A:

• 小团队: 不需要，Docker Compose + 云平台就够
• 中大型: 必须学，是业界标准
• 学习时机: 后端经验2年以上再学

Q: 什么时候该学习DevOps？#

A:

• 最早: 学会Docker、基本的CI/CD (半年经验后)
• 深入: 1-2年后学Kubernetes和完整DevOps体系
• 完全可选: 专业DevOps工程师才需要深入精通

Q: 开源的技术栈和商业的有什么区别？#

A:

• 开源: 免费、社区支持、可自定义、适合初创
• 商业: 官方支持、更稳定、企业友好、适合大公司
• 趋势: 越来越多优秀开源替代商业方案

近5年主要变化#

• ✅ Node.js全栈 成为主流
• ✅ TypeScript 逐渐成为标准
• ✅ Vite 快速替代Webpack
• ✅ Next.js/Nuxt 等全栈框架爆发
• ✅ Go语言 在后端和DevOps领域崛起
• ✅ Kubernetes 成为容器编排标准
• ✅ AI/LLM 集成成为新常态

未来方向#

• 🚀 边缘计算 - 更接近用户的计算
• 🚀 Serverless/FaaS - 无服务器架构
• 🚀 WebAssembly - 浏览器中运行高性能代码
• 🚀 AI自动化开发 - AI辅助编码加速
• 🚀 低代码/无代码 - 降低开发门槛
• 🚀 Rust - 系统编程和高性能应用

必学（所有开发者）#

• 一门编程语言深入学习
• 一个前端框架（如果做Web开发）
• 关系型数据库设计和SQL
• 版本控制（Git）
• 基本的HTTP和API概念

重要（根据职业方向）#

• 状态管理（如果做前端）
• 一个后端框架（如果做全栈）
• 缓存和消息队列（后端）
• Docker容器化（DevOps）
• 基本的系统设计（2年+经验）

进阶（职业发展）#

• 选定一个方向专深（前端/后端/DevOps）
• 架构设计和性能优化
• 微服务和分布式系统
• Kubernetes容器编排
• 监控告警体系

字面量#

概念：书写到代码内的，被固定下来的，值，就是字面量。

即：某些值是如何在代码里面写出来的。

值的类型：

Python中值类型很多，目前简单接触了解3个：

• 整型（Integer、int）：整数的意思（包含负的）
• 浮点型（Float）：浮点数的意思（有小数点的数字）（包含负的）
• 字符串、文本（String、str）：文本类型
  • 中文、英文、数字、符号等一堆字符的集合体，就是字符串

三种类型在代码中的书写方式：

1
# 整型
2
321
3
-123
4

5
# 浮点型
6
32.11
7
-11.23
8

9
# 字符串
10
"黑马程序员666"

整型、浮点型和日常生活中所见，基本一致

字符串（文本）需要以""包围起来（Python语法要求，必须）

print也可以将字面量在屏幕中显示出来，如下代码：

1
print(666)
2
print(12.34)
3
print("黑马666")

注释#

概念：对代码的解释说明文本。注释本身不是代码（执行的时候会被自动删除），只在阅读的时候有用。

简单来说，有了注释，就可以对代码的内容做解释和说明。

分类：

• 单行注释：以# 开头，其所在行右侧全部内容作为注释存在
  • 一般建议# 和注释内容之间，相隔一个空格
  • 示例：# 我是注释
• 多行注释：以"""开头，以""" 结尾，在其闭合区间内，全部内容作为注释存在
  • 注意：""" """ """ 如果这样写，最后的"""是无用的，即闭合区间的匹配逻辑是就近匹配一堆"""

变量#

概念：在程序运行的过程中，进行数据的存储，同时存储的数据也可以发生修改。

特点：

1. 可以存储数据，且不限类型

2. 存储的数据是可以修改的（变量的变字由来）

3. 变量本身没有类型，但是存储的数据是有类型的，注意如下口头语：

   1. 字符串变量，表示一个存放了字符串数据的变量

4. 可以被重复使用

   1
   name = "周杰轮"
   2
   print(name)
   3
   print(name)
   4
   ...
   5
   # name变量可以任意重复利用

语法：

1
变量名 = 变量值;

=是赋值语句，表示：右侧先执行得到结果，将结果赋予左侧的变量存储。

右侧先执行得到结果，将结果赋予左侧的变量存储。

右侧先执行得到结果，将结果赋予左侧的变量存储。

即：不论右侧如何写，反正右侧必须全部执行完毕得到结果，才会将结果赋予左侧变量。

print输出多份内容#

print语句（函数）可以向屏幕内一次性输出多份内容，语法如下：

1
print(内容1, 内容2, ... ,..., 内容N)

• 内容可以是：字面量、变量、表达式（会产生计算结果的）（比如5+3）

示例：

1
name = "大锤"
2
print("你好我是", name, "，很高兴认识你")
3

4
# 结果： 你好我是 大锤 ，很高兴认识你

数据类型#

上图是Python较为完整的常见数据类型，我们目前仅仅接触三个：

• 整型（int、整数）
• 浮点型（float、小数）
• 字符串型（string、str、文本）

转换#

在转换的时候要注意：

1. 任何类型都可以转换为字符串
2. 字符串不一定能转换为数字，比如：
   1. "123" 可以转换为123
   2. "abc123" 就无法转换为数字了
   3. 即：要求字符串内部全部是数字才行

标识符#

概念：标识符是编程语言中，对任何事物的命名，这个名字都叫做标识符

简单来说，标识符就是名字

运算符#

字符串#

1
info = "黑马" + "程序员"
2
print(info)
3
# 运行结果：黑马程序员

字符串格式化（%占位符形式）#

语法：

1
"%s %d %f ... ..." % (变量, 变量, 变量, ....,...)

• %s 表示以字符串形式占位，等到数据的填充
• %d 表示以整数形式占位，等到数据的填充
• %f表示以浮点数形式占位，等到数据的填充
• %占位符的数量要和后续提供填充的数据的数量是一比一
• 任意数据类型可以用%s占位，但是不是任意类型都可以用%d或%f占位，要注意数据的转换关系
  • 如：%f占位，提供的数据是”abc”肯定是不可以的

示例：

1
name = "周杰轮"
2
print("你是：%s" % name)
3
# 结果是： 你是 周杰轮
4

5
age = 11
6
height = 172.55
7
print("你是%s，身高：%f，年龄：%d" % (name, height, age))
8
# 结果：你是周杰轮，身高：172.550000，年龄：11

默认的%f占位，浮点数会使用6位小数精度，没有的话会补充0

字符串格式化（f_format、f_string形式）#

语法：

1
f"{变量、常量、表达式}......"

示例：

1
name = "周杰轮"
2
age = 11
3
height = 172.55
4
print(f"你是{name}，身高：{height}，年龄：{age}")
5
# 结果：你是周杰轮，身高：172.55，年龄：11

字符串格式化的数字精度#

基础写法是：

1
%md
2
%m.nf

• m 表示数字的宽度
• .n 表示小数点的宽度
  • 仅对浮点数有效

示例：

1
age = 11
2
print("%5d" % age)    # 结果：   11   11前面还有3个空格补充到5的宽度
3
print(f"{age:5d}")    # 结果：   11   11前面还有3个空格补充到5的宽度
4

5
height = 172.55
6
print("%7.1f" % height)   # 结果：  172.6    前面有2个空格 小数点精确1位（有四舍五入效果）
7
print(f"{height:7.2f}")    # 结果：  172.6    前面有2个空格 小数点精确1位（有四舍五入效果）

表达式#

概念：能够产出明确结果的代码语句，称之为表达式。

示例，如下都是表达式：

1
5+3
2
2*3+5/2
3
type(1)
4
age * 10  # age是一个变量
5
input("请输入：")
6
5>2

input输入#

概念：获取用户的键盘录入数据

语法：

1
name = input()    # 从键盘输入内容，赋值给name变量
2

3
name = input("请输入姓名：")  # 先将请输入姓名的提升语输出，然后从键盘输入内容，赋值给name变量

特点：无论输入的是什么，得到的结果都是字符串类型，如果需要输入数字类型，请自行转换类型。

• print：对外输出信息数据
• input：从外部接收信息输入

布尔数据类型#

概念：布尔类型表示的是2个状态，即：真或假。其字面量为：True 表示真、False 表示假

注意：True和False的大小写

布尔用于存储一些逻辑判断的结果，逻辑判断在生活中或程序中非常常见，用来表示成立或不成立，即非黑即白

所以用True表示成立、False表示不成立。

其类型名为：bool

比较运算符#

比较运算符主要用于对2个数据进行大小的比较。

可用运算符有：

• == 用于比较相等（注意是2个等于号）
• != 用于比较不相等
• > 比较大于
• < 比较小于
• >= 比较大于等于
• <= 比较小于等于

这些运算符统统产出的结果是：布尔类型

逻辑运算符#

逻辑运算符主要对多个判断条件进行连接，进行统一判断。

主要有3个：

• and 用法：a and b a为True并且b为True，则结果为True
• or 用法：a or b a为True或者b为True，则结果为True
• not 用法：not a a为True则结果为False，反之a为False则结果为True，即取反

if语句#

功能：做逻辑判断，即xxx是否满足，满足则做特定的事情。

语法：

1
if 条件:
2
    条件满足后的代码
3
    ...
4
    ...

• if 是关键字，表示如果
• 条件是表达式，要求必须必须必须是布尔类型结果
• :不要忘记
• 注意缩进有4个空格
  • 表示层次关系，即条件满足后的代码，属于这个if判断

示例：

1
age = 19
2
if age >= 18:
3
    print("成年")

当满足条件，则输出成年

if else语句#

功能：做逻辑判断，即满足xxx，则做特定的事情，否则，则做特定的事情

语法：

1
if 条件:
2
    条件满足后的代码
3
    ...
4
else:
5
    条件满足后的代码
6
    ...

• else和if是同层次，即缩进是一致的
• else后面不需要写条件了（使用if的条件）
• :不要忘记
• else内的代码，不要忘记缩进4个空格

示例：

1
money = int(input("请告诉我你还有多少钱："))
2

3
if money >= 10000:
4
    print("去买个新电脑")
5

6
else:
7
    print("洗洗睡吧")

if elif else语句#

功能：做多个条件判断，对多个条件挨个做判断，满足则执行特定操作，如果都不满足则执行特定操作。

语法：

1
if 条件:
2
    条件满足后的代码
3
    ...
4
elif 条件2:
5
    条件满足后的代码
6
    ...
7
elif 条件3:
8
    条件满足后的代码
9
    ...
10
...
11
...
12
elif 条件N:
13
    条件满足后的代码
14
    ...
15
else:
16
    条件满足后的代码
17
    ...

• elif是关键字，不要写错
• elif 可以写多个，无限制
• 每一个elif 需要写条件
• elif 不可以单独存在，是搭配if后存在的
• 注意缩进
• if和多个elif是有序且互斥
  • 从if开始向下挨个判断，只要有满足的，则就不会理会其它了
  • 不管有多少条件，就是N 选 1

if嵌套#

功能：在if判断内或else内或elif内，可以继续写if elif else

一般用于前置条件判断

语法：

1
if 条件:
2
    ...
3
    if 条件:
4
        ...
5
    else:
6
        ...
7
elif 条件:
8
    ...
9
    if 条件:
10
        ...
11
    else:
12
        if ...
13
      elif ...
14
        else ...
15
else:
16
    ...
17
    if 条件:
18
        if ...
19
      elif ...
20
        else ...
21
    else:
22
        ...

如上语法，可以自由组合嵌套层次，层次不限制层数但是

一般建议不超过3层嵌套

• Python解释器不会晕，100层都搞的定
• 我们人会晕

猜数字案例，我们课上是3层嵌套完成的（3次猜测机会）

如果要避免嵌套还是有方法的：保密

while循环基础语法#

概念：循环是对特定的操作，当条件满足则持续执行下去，直到条件不满足为止。

语法：

1
while 条件:
2
    循环代码
3
    ...

• while 是关键字不要写错
• 条件 必须产出布尔结果
• 缩进 不要忘记

示例：

1
while 1 == 1:
2
    print("你好")

这个代码满足循环语法，但是：无限循环

为了避免无限循环，我们自行在语法外引入限制，即循环三要素：

• 循环控制因子的创建
• 基于循环控制因子的条件判断
• 循环控制因子的更新

三要素合力，确保循环受限。

示例：

1
# 打印我喜欢你 10次
2
# 基础循环，缺少控制，所以会导致无限执行
3
# while True:
4
#     print("我喜欢你")
5

6
# 控制循环在有限次数内执行，有3个要素
7
# 1. 循环控制因子（某个变量）
8
# 2. 循环控制条件（基于因子做判断）
9
# 3. 循环因子更新（修改因子的值）
10

11
# 控制因子
12
num = 0
13

14
# 控制条件（基于因子）
15
while num < 10:
16
    print("第%d次表白：我喜欢你" % num)
17
    num += 1        # 因子更新

while循环嵌套#

语法：

1
while 条件:
2
    ...
3
    ...
4

5
    while 条件:
6
        ...
7
        ...

如上是一个2层嵌套

使用嵌套循环一定注意：

• 空格的缩进 ，因为Python是通过空格缩进决定层次关系
• 向右缩进，层次就低

案例：九九乘法表

1
row = 1                 # 外层循环因子
2

3
while row <= 9:         # 基于因子的条件
4

5
    col = 1             # 内层循环因子
6
    while col <= row:   # 基于因子的条件
7
        print(f"{col}*{row}={col*row}", end="\t")
8
        col += 1        # 内层循环因子更新
9

10
    print()             # 外层循环功能，换一行
11
    row += 1            # 外层循环因子更新

for循环基础语法#

语法：

1
for 临时变量 in 待处理数据集:
2
    ...
3
    ...

流程：从待处理数据集中，挨个取出内容，赋予临时变量，然后执行循环语句，循环往复。

和while循环的流程对比，如下是while：

如下是for：

如上图可以看到，for循环对比while的区别在于：

• while循环有三要素（因子创建、条件判断、因子更新），for循环没有
• while有条件控制，则控制条件即可成为无限循环
• for循环没有条件，只是挨个取出待处理元素，实际上无法形成无限循环

1
for 临时变量 in 待处理数据集:
2
    ...
3
    ...

1
name = "itheima666你好"
2
# 字符串可以被for循环使用，并且被逐个取出
3
for x in name:
4
    print(x)

变量作用域#

在Python中变量是由其作用的范围的，离开其生效范围，则无法使用。

如下代码：

1
for x in range(5):
2
    age = 10
3
    print(age)
4

5
print(age)

此代码中，age变量创建是在for循环内部，所以age的生效范围，仅在for循环内，即

• 上述代码第三行，是OK的
• 第五行代码，是不OK的，因为脱离了age的生效范围

变量的生效范围一般是：

• 如果写在: 内，比如if elif else while for with 等
  • 则生效在:所属的范围内
• 如果写在文件中，则全文件生效

口诀：缩进靠左访问缩进靠右变量，不可以

反之，缩进靠右访问缩进靠左是OK的

continue关键字#

作用：可以控制循环的执行，具体是：当循环代码遇到continue的时候，将跳过本次循环，直接进入下一次循环

示例：

1
for x in range(5):
2
    print("aaa")
3
    continue
4
    print("bbb")

• 上述代码的print("bbb")将永远无法执行，因为遇到continue循环直接进入下一次

break关键字#

作用：可以控制循环的执行，具体是：当循环代码遇到break的时候，直接结束循环

示例：

1
for x in range(5):
2
    print("aaa")
3
    break
4
    print("bbb")

• 上述代码仅输出一次aaa 后就结束，因为遇到break后，整个循环就结束了

注意：

continue和break

• 仅对循环有效（for和while）

• 在嵌套应用的时候，仅对所属的循环（for和while有效）

  1
  for j in range(1, 11):
  2
      print(f"今天是第{j}天干饭")
  3
  
  4
      for i in range(1, 11):
  5
          flag = int(input(f"第{j}天的第{i}碗饭吃不吃，吃输入1不吃输入0："))
  6
          if flag == 0:
  7
              break       # break会直接结束循环（同样和if没关系，仅对for和while有效）
  8
  
  9
          print(f"吃完了第{i}碗饭，真香")

  如上代码，break仅对第四行代码的这个for循环有效。

概念#

函数是：提前写好的、可以重复利用的、具有特定功能的代码片段

特点：

• 提前写好才能用
• 写好后，可以无限制重复用
• 功能是特定功能

主要作用：避免程序内重复的代码，一旦有重复的代码就可以封装为函数。

语法：

1
def 函数名([形参列表]):
2
    函数内容
3
    [return 返回值]

调用函数：

1
函数名([实参列表])

参数#

参数分为：

• 形式参数：在书写（声明）函数的时候，（声明）要求的传入参数
• 实际参数：在调用函数的时候，实际传入的参数

特点：

• 支持任意个传入参数

• 多个传入参数用逗号分隔，如：

  1
  def add(x, y, z):
  2
      return x + y + z

  如上三个参数，用逗号分隔

• 形参和实参是一一对应，如：

  1
  def add(x, y, z):
  2
      return x + y + z
  3
  
  4
  add(1, 3, 5)

  add函数在调用的时候，实际参数的数量和形式参数的数量要一致，同时1会提供给x，3给y，5给z，有对应关系

• 实参的传入类型不受限制，如下：

  1
  def add(x, y, z):
  2
      return x + y + z
  3
  
  4
  add("1", "2", "3")

  传入的时候自己注意，如果传入不兼容，可能报错

返回值#

概念：函数对外提供的执行结果

语法：

1
def 函数名([形参列表]):
2
    函数内容
3
    [return 返回值]

通过return对外提供

示例：

1
def add(x, y, z):
2
    return x + y + z
3

4
sum = add(1, 3, 5)

• sum 就能得到return提供的值：9

None#

在Python中有一个数据类型：NoneType ，它只有一个字面量：None

None表示：空、啥也没有

函数如果没有写return，则默认返回值是：None

或者函数也可以写return None 直接对外返回None

作用：

• 用在if判断中，因为None就等同于False

• 用在变量声明上，某些变量在写的时候，暂时不需要初始值，可以以None代替

  1
  age = None    # 此时age不需要初始值，可以以None代替
  2
  
  3
  for i in range(5):
  4
      age = int(input())
  5
  
  6
  # 为了避免作用域问题，age需要再for循环外部定义
  7
  # for循环外定义的时候，不需要初始值，可以以None代替
  8
  print("最后一个同学的年龄是：%d " % age)

• 用于返回的返回值，只要有需要就可以返回None

函数的规范注释#

语法：

1
def 函数名(参数):
2
    """
3
    函数说明文本
4
    :param 参数1: 参数1的说明
5
    :param 参数2: 参数2的说明
6
    ...
7
    :param 参数N: 参数N的说明
8
    :return: 返回值的说明
9
    """
10
    函数体
11
    return ...

作用：规范代码，提高可读性，并提升B格

函数的嵌套调用#

概念：嵌套调用就是在一个函数的函数体中调用了另一个函数

如图，为嵌套调用，结果是：1 2 3

特点：在函数执行的时候，如果遇到调用其它函数，则先执行这个函数，等函数运行完成后，在返回来继续执行未完成的工作。

见到函数就进入执行

示例：

1
"""
2
嵌套调用的基本原则是：```遇到函数就进入执行```，执行完成后再回到当初的位置继续向下
3
def func_b():
4
    print("22222")
5
    func_a()
6
    print("33333")
7
比如执行完222后，遇到函数了，则进入，将函数执行完成后再回来继续执行333
8
"""
9

10

11
def func_a():
12
    print("11111")
13

14

15
def func_b():
16
    print("22222")
17
    func_a()
18
    print("33333")
19

20

21
def func_c():
22
    print("44444")
23
    func_b()
24
    print("55555")
25

26

27
func_c()
28

29

30
# 结果是：
31
# 4 -> 2 ->1 -> 3 -> 5

局部变量#

概念：写在函数内部的是局部变量，其作用范围只在函数内部有效。

1
def func():
2
    # num是局部变量，作用域（生命周期）仅在函数内部有效
3
    # 局部变量：写在函数内部的变量（也叫做临时变量）
4
    num = 100
5
    print("内部输出", num)
6

7

8
func()
9

10
# 当函数执行完成后，临时变量（局部变量）num已经不存在了
11
# 即num存在的时间只有在调用函数的那一会儿
12

13
# 在print语句执行的这个地方，num已经不存在了
14
print("外部输出：", num)

如上代码，15行访问num是错误的，因为num此时不存在了，即脱离了它应有的作用域范围。

全局变量#

概念：没有写在函数内部的是全局变量，作用范围在函数内和外都生效。

1
"""
2
全局变量就是：不定义在函数内部的变量
3
"""
4
# 全局变量
5
num = 100       # 作用域在于整个代码
6

7

8
def func_a():
9
    print(f"a: {num}")
10

11

12
def func_b():
13
    num = 200       # 这个num是一个和全局num同名的局部变量
14
    print(f"b: {num}")  # 此时访问的num是局部变量num
15

16

17
func_a()
18
func_b()
19

20
print(f"外部：{num}")

如上代码，num就是全局，在函数内和函数外均可用

1
num = 100       # 作用域在于整个代码
2
def func_a():
3
    print(f"a: {num}")
4

5
def func_b():
6
    num = 200       # 这个num是一个和全局num同名的局部变量
7
    print(f"b: {num}")  # 此时访问的num是局部变量num
8

9
func_a()
10
func_b()
11

12
print(f"外部：{num}")

1
a：100
2
b：200
3
外部：100

1
"""
2
全局变量就是：不定义在函数内部的变量
3
"""
4
# 全局变量
5
num = 100       # 作用域在于整个代码
6

7

8
def func_a():
9
    print(f"a: {num}")
10

11

12
def func_b():
13
    global num      # 在此函数内部使用的num是全局变量
14
    num = 200       # 这个num就是访问全局变量，修改他的值
15
    print(f"b: {num}")  # 此时访问的num是全局变量num
16

17

18
func_a()
19
func_b()
20

21
print(f"外部：{num}")

概念#

数据容器：一种数据类型，可以存储多个元素在内。

根据是否可以修改、是否允许重复、是否有序等等特点数据容器有如下类型：

• 列表（list）
• 元组（tuple）
• 字符串（string、str）
• 字典（dictate）
• 集合（set）

列表#

list（列表）

语法#

字面量

1
[元素, 元素, ..., 元素]
2

3
[1, 2, 3]
4
["itheima", "你好"]

变量

1
name = ["itheima", "666"]
2
ages = [11, 22, 33]

空list

1
name = []
2
name = list()

嵌套

1
ages = [ [1,2,3], [4,5,6]]

下标访问#

列表元素有下标值（每一个元素的序号）

• 从前到后（从左到右）下标是0、1、2、…、N 即从0开始递增
• 从后到钱（从右到左）下标是-1、-2、-3、…、-N 即从-1开始递减

可以通过下标值访问列表的特定位置的元素，如下

1
nums = [1, 3, 5]
2
下标是：
3
[ 1,  3,  5]
4
  0   1   2   正向下标
5
  -3  -2  -1  反向下标
6

7
通过下标访问
8
nums[0]  # 得到1
9
num[-2]  # 得到3

操作方法#

不需要背下来，练习两次即可。

用多了自然就记住了，用不到硬记也是个忘

需要用的时候有个大概概念印象即可查询AI等工具或翻看笔记

元组#

1
(元素, ..., 元素)
2

3
(1, 2, 3)
4

5
("itheima", )

1
name = ("周杰伦", "林军杰")
2
nums = (1, 2, 3)

1
name = ()
2
name = tuple()

1
age = ( (1, 2, 3), (4, 5, 6) )

1
age = (1, 2, [3, 4, 5])

1
(1, 2, 地址)

1
nums = (1, 2, [5, 6, 7])
2
# 正常操作
3
nums[2][2] = 10  # 可以的
4
nums[2].append(11) # 可以的
5

6
# 错误操作
7
nums[2] = [1, 2, 3]  # 不可以，相当于用新list去替换老的list，即记录的内存地址要变，是不允许的

操作方法#

因为元组不可变，所以操作方法也少了很多。

字符串#

字符串：也是数据容器，其内部存放的元素固定为字符，是多个字符的集合体，称之为字符的串串。

1
name = "itheima"
2
name = 'itheima'
3
name = """itheima"""

常用操作方法#

重点方法：

• replace
• split
• strip

可迭代类型#

到目前为止，我们学习到的数据类型中，可迭代类型（可用于for循环的）有：

• 列表
• 元组
• 字符串

带有下标的，都可以用于for循环

序列的切片#

概念：序列是指有序的、有下标索引的数据容器。

序列是支持切片，语法：

示例

1
lst = ["aa", "bb", 3, 5, 6]
2
# 取出来"bb", 3
3
print(lst[1:3])
4

5
# 取出来 5, 3, "bb"
6
print(lst[-2:-5:-1])
7
# 反向操作即步长为负数，要求 开始下标在结束下标的右侧
8

9
t = (1, 3, 5, 7, 9, 11, 13, 15, 17)
10
# 取出来 3 7
11
print(t[1:4:2])
12
# 取出来 15, 9, 3
13
print(t[-2:0:-3])
14

15
name = "itheima 666 and itcast"
16
# 反转字符串
17
print(name[::-1])
18
# d a 6 6 a
19
print(name[-8:5:-2])
20
# 取出来666
21
print(name[8:11])       # 步长不写默认为1
22

23
"""
24
序列都可以切片（序列就是有下标的）
25
- 字符串
26
- 元组
27
- 列表
28
"""

集合#

特点：

• 可以支持非常多的元素在内（2**63 -1）
• 存放任意数据类型，支持混装
• 支持修改
• 内部数据无序（无下标）
• 不支持重复元素

集合内部是去重的，重复的元素只保留一份

因为去重，所以内部无序（实际顺序是hash表顺序、如果hash算法不同，顺序可能不同）

语法：

1
{元素, ..., ..., 元素}

字面量

1
{1, 2, 3, 3, 3}  # 实际存储是 {1, 2, 3}  内部去重了

变量

1
s = {1, 2, 3}

空集合

1
s = set()
2
# 注意，s = {} 不是空集合，而是空字典

嵌套

1
s = {{1,2}, {3, 4}, {5, 6}}

常用操作#

这些操作基本用不到，写两遍即可

字典#

概念：字典内部是存放了一堆的键值对，键值对是：Key:Value的对

在字典中Key 不允许重复，如果重复则新数据覆盖老数据。

字典可以基于Key 去找到其对应的Value

• 可以支持非常多的元素在内（2**63 -1）
• 存放任意数据类型，支持混装
  • Key数据类型不可为字典，一般类型用：字符串、整数
  • Value数据类型随意，不限制
• 支持修改
• 内部数据无序（无下标）
• 不支持重复Key

1
d = {}
2
d = dict()

1
{"a": 1, "b": 2}
2
# 是Key:Value的形式

1
d = {"周杰轮": 99, "王力鸿": 88, "林军杰": 77}

1
d = {
2
    "周杰轮": {"语文": 99, "数学": 88, "英语": 22},
3
    "林军杰": {"语文": 88, "数学": 66, "英语": 21},
4
    "王力鸿": {"语文": 66, "数学": 11, "英语": 33},
5
}
6

7
d = {
8
    "周杰轮": ["唱", "跳", "rap"],
9
    "林军杰": ["吃", "喝", "玩"],
10
    "王力鸿": ["睡", "呆", "憨"]
11
}

常用操作#

数据容器的对比#

数据容器的通用操作#

字符串的大小比较#

字符串（中文、英文、数字、符号等）都是存储的数字，显示的是字符串

• 英文、数字、符号，都是以ASCII码表，比如”a”对应97 “A”对应65
• 中文，一般以UTF-8或GBK编码（UTF-8更通用），也有对应的数字

所以字符串比较本质是比较各个字符的数字大小。

字符串是按位比较，一位位比，每一个位出结果则整体大小就确定。

比如：

• abe 大于abc 以为a==a b==b e>c 在第三位确定了大小
• abc 大于ab 因为a==a b==b 但是c > 啥也没有
• 21 大于 123 因为 "2" > "1" 则直接出结果

ASCII码表如下：

常用口诀（用于英文和数字）

• 小写大于大写字母
• 大写字母大于数字
• 其余查表吧

返回多个返回值#

语法：

1
def func(...):
2
    ...
3
    return 值,值,...,值    # 返回多个值，逗号分隔即可
4

5
# 调用的时候用多个变量接收
6
变量,变量,...,变量 = func()

示例

1
def func(...):
2
    return 1, 2
3

4
x, y = func()
5
# x接收1
6
# y接收2

1
def func(...):
2
    return 1, 2
3

4
x = func()
5
# x的值是：(1, 2)   是一个元组

函数的多种传参形式#

1
def func(x, y, z):
2
    ...
3

4
func(1, 2, 3)

1
def func(x, y, z):
2
    ...
3

4
func(x=1, y=2, z=3)

1
def func(x, y, z):
2
    ...
3

4
func(y=2, z=3, x=1)

1
def func(x, y, z):
2
    ...
3

4
func(1, 2, z=3)

1
func(x=1, 2, z=3)

缺省参数（默认值参数）#

在编写函数的时候，可以给某个参数提供默认值，此参数即可实现

• 调用的时候，不传入值，则使用默认值
• 如果传入值，则使用传入值

语法：

1
def func(x, y, z=10):
2
    ...

在调用的时候：

• 写的是：func(1, 2) 可以看到只给x和y传入值，没有提供z的值，则z使用默认值10
• 写的是：func(1, 2, 3) 则z使用提供的3

注意，带有默认值的参数，必须在没有默认值参数的右侧。

如下写法是错误的：

1
def func(x, y=1, z):
2
    ...

y这个带有默认值的参数，在非默认值参数z的左侧，是不符合语法要求，错误。

不定长参数（元组接收）#

概念：可以写一个参数，表示不定长（参数数量不确定），将传入的参数全部收集到一个元组内。

语法：

1
def func(x, y, *z):
2
  ...

• x和y是普通参数
• z是不定长（元组接受）的参数，z就是一个元组，收集传入的实际参数

示例

1
def func(x, y, *z):
2
  ...
3

4
func(1, 2, 3, 4, 5, 6, 7, 8, 9)

如上代码：

• 1和2是提供给普通参数x和y
• 后续的3, 4, 5, 6, 7, 8, 9 全部存入了参数z中
• 参数z是一个元组

不定长参数（字典接收）#

概念：可以写一个参数，表示不定长（参数数量不确定），将传入的参数全部收集到一个字典内。

语法：

1
def func(x, y, **z):
2
  ...

• x和y是普通参数
• z是不定长（元组接受）的参数，z就是一个元组，收集传入的实际参数

用字典接收是2个*号

示例

1
def func(x, y, **z):
2
  ...
3

4
func(1, 2, id=1,name='a',addr='shanghai',gender='男')

如上：

• 1和2传给普通参数x和y
• 后续的id=1,name=‘a’,addr=‘shanghai’,gender=‘男’会被收集为字典，存入变量z（字典）中
• 即z内部的数据是4个键值对

1
def func(name, age, *args, **kwargs):
2
    print(f"我是{name}, 年龄{age}岁, 我的爱好有：", end="")
3
    for i in args:          # args是元组
4
        print(i, end=" ")
5

6
    print()
7
    print("我的其它信息：", end=" ")
8

9
    for key in kwargs:      # kwargs是字典
10
        print(f"{key}: {kwargs[key]}", end="、")
11

12
    print()
13

14

15
func("周杰轮", 11, "唱", "rap", "跳", "打篮球", addr="石岩", id=123, money=20000)

函数作为参数传递#

概念：一般使用函数，都是传入的数据，如数字、字符串、数据容器。这种传递我们称之为：数据的传递。

除此以外，函数也可以接收函数作为参数传递，这样就不是传递的数据了，而是传递的计算逻辑（函数）

示例

1
"""
2
写函数的时候：
3
- 形式参数，可以接收函数传入
4
- 实际参数，真的可以传入一个函数
5

6
这种写法称之为函数式编程，核心思想是：传入的是计算逻辑
7
"""
8
def func(compute):
9
    # 被计算数据固定为1和2，要计算的逻辑取决于传入的compute函数
10
    result = compute(1, 2)
11
    print(result)
12

13

14
def compute1(x, y):
15
    return x + y
16
def compute2(x, y):
17
    return x - y
18
def compute3(x, y):
19
    return x * y
20
def compute4(x, y):
21
    return x / y
22

23

24
# 传入的是compute函数，而非变量和数据
25
# 传的是函数也就是传的是计算的逻辑
26
func(compute1)
27
func(compute2)
28
func(compute3)
29
func(compute4)

如上代码，传递的compute 1 2 3 4 就是4个不同的函数，代表4种不同的计算逻辑。

函数是可以作为参数传递的。

lambda匿名函数#

语法：

1
lambda 形参列表: 函数体(一行)

作用：用来快速实现一个匿名的函数

• 带有名字的函数是：def 函数名(...) ...
  • 有名字可以重复调用
• 匿名函数就是：lambda x, y: ...
  • 没有名字，只是临时用一次

示例

1
def func(compute):
2
    # 被计算数据固定为1和2，要计算的逻辑取决于传入的compute函数
3
    result = compute(1, 2)
4
    print(result)
5

6

7
# 调用func4次，完成+-*/
8
# 这些函数仅用一次，不用于重复使用，所以用lambda快速实现
9
func(lambda x, y: x + y)
10
func(lambda x, y: x - y)
11
func(lambda x, y: x * y)
12
func(lambda x, y: x / y)

• 上面调用的4次func，传入的4个不同的计算逻辑
• 这4个不同的计算逻辑就是4个匿名函数，只用一次

在以后的功能开发中，会遇到一些仅需要传入计算逻辑（函数）的函数，就可以用lambda快速实现。

匿名函数也可以有名字，用变量接收即可，如下：

1
chengfa = lambda x, y: x * y
2
print(chengfa(1, 3))