第一章：Python3 基础入门：从零基础到实战精通

---

文章目录：

0、前言

[0.1 Python 的起源、历史与发展背景](#0.1 Python 的起源、历史与发展背景)

[1.1.1 诞生：1989 年的圣诞假期项目](#1.1.1 诞生：1989 年的圣诞假期项目)

[1.1.2 关键版本里程碑](#1.1.2 关键版本里程碑)

[1.1.3 Python 为什么能成功？（历史背景决定的优势）](#1.1.3 Python 为什么能成功？（历史背景决定的优势）)

[1.1.4 Python 设计哲学：The Zen of Python](#1.1.4 Python 设计哲学：The Zen of Python)

[一、初识 Python：开启编程之旅](#一、初识 Python：开启编程之旅)

[1.1 Python 是什么？](#1.1 Python 是什么？)

[1.2 Python 的核心优势](#1.2 Python 的核心优势)

[1.3 Python 能做什么？（全岗位适配）](#1.3 Python 能做什么？（全岗位适配）)

[1.4 Python 3 环境安装（零基础必看）](#1.4 Python 3 环境安装（零基础必看）)

[1.4.1 Windows 系统安装](#1.4.1 Windows 系统安装)

[1.4.2 MacOS 系统安装](#1.4.2 MacOS 系统安装)

[1.4.3 Linux 系统安装（CentOS/Ubuntu）](#1.4.3 Linux 系统安装（CentOS/Ubuntu）)

[1.5 第一个 Python 程序：Hello World](#1.5 第一个 Python 程序：Hello World)

[1.6 Python 运行方式](#1.6 Python 运行方式)

[二、Python 3 数据类型：数据的「容器」](#二、Python 3 数据类型：数据的「容器」)

[2.1 数据类型分类](#2.1 数据类型分类)

[2.1.1 基本数据类型（不可变类型）](#2.1.1 基本数据类型（不可变类型）)

[2.1.2 复合数据类型（可变 / 不可变）](#2.1.2 复合数据类型（可变 / 不可变）)

[2.2 数字类型（Number）](#2.2 数字类型（Number）)

[2.2.1 整数（int）](#2.2.1 整数（int）)

[2.2.2 浮点数（float）](#2.2.2 浮点数（float）)

[2.2.3 布尔值（bool）](#2.2.3 布尔值（bool）)

[2.2.4 复数（complex）](#2.2.4 复数（complex）)

[2.3 字符串类型（str）](#2.3 字符串类型（str）)

[2.4 空类型（NoneType）](#2.4 空类型（NoneType）)

[2.5 复合数据类型](#2.5 复合数据类型)

[2.5.1 列表（list）](#2.5.1 列表（list）)

[2.5.2 元组（tuple）](#2.5.2 元组（tuple）)

[2.5.3 字典（dict）](#2.5.3 字典（dict）)

[2.5.4 集合（set）](#2.5.4 集合（set）)

[2.6 数据类型转换](#2.6 数据类型转换)

三、变量与关键字：编程的「基础单元」

[3.1 变量的定义](#3.1 变量的定义)

[3.1.1 变量命名规则（必须遵守）](#3.1.1 变量命名规则（必须遵守）)

[3.1.2 变量赋值语法](#3.1.2 变量赋值语法)

[3.2 Python 关键字](#3.2 Python 关键字)

[3.3 变量的特性](#3.3 变量的特性)

[四、语句：Python 的「执行逻辑」](#四、语句：Python 的「执行逻辑」)

[4.1 语句分类](#4.1 语句分类)

[4.2 赋值语句](#4.2 赋值语句)

[4.3 条件语句（if-elif-else）](#4.3 条件语句（if-elif-else）)

[4.3.1 单分支 if 语句](#4.3.1 单分支 if 语句)

[4.3.2 双分支 if-else 语句](#4.3.2 双分支 if-else 语句)

[4.3.3 多分支 if-elif-else 语句](#4.3.3 多分支 if-elif-else 语句)

[4.4 循环语句](#4.4 循环语句)

[4.4.1 for 循环（遍历循环）](#4.4.1 for 循环（遍历循环）)

[4.4.2 while 循环（条件循环）](#4.4.2 while 循环（条件循环）)

[4.4.3 循环控制语句](#4.4.3 循环控制语句)

[4.5 空语句（pass）](#4.5 空语句（pass）)

五、表达式：数据的「运算逻辑」

[5.1 表达式的定义](#5.1 表达式的定义)

[5.2 表达式的分类](#5.2 表达式的分类)

[5.3 表达式示例](#5.3 表达式示例)

[5.4 表达式与语句的区别](#5.4 表达式与语句的区别)

六、运算符与操作对象：数据的「运算工具」

[6.1 算术运算符](#6.1 算术运算符)

[6.2 比较运算符](#6.2 比较运算符)

[6.3 赋值运算符](#6.3 赋值运算符)

[6.4 逻辑运算符](#6.4 逻辑运算符)

[6.5 成员运算符](#6.5 成员运算符)

[6.6 身份运算符](#6.6 身份运算符)

[6.7 位运算符（了解即可）](#6.7 位运算符（了解即可）)

[6.8 运算符优先级](#6.8 运算符优先级)

七、字符串操作：文本处理的「核心技能」

[7.1 字符串的定义与特性](#7.1 字符串的定义与特性)

[7.2 字符串索引与切片](#7.2 字符串索引与切片)

[7.2.1 索引（下标）](#7.2.1 索引（下标）)

[7.2.2 切片（截取子串）](#7.2.2 切片（截取子串）)

[7.3 字符串拼接与重复](#7.3 字符串拼接与重复)

[7.4 字符串常用内置方法](#7.4 字符串常用内置方法)

[7.4.1 大小写转换](#7.4.1 大小写转换)

[7.4.2 查找与替换](#7.4.2 查找与替换)

[7.4.3 分割与拼接](#7.4.3 分割与拼接)

[7.4.4 去除空白字符](#7.4.4 去除空白字符)

[7.4.5 判断字符串类型](#7.4.5 判断字符串类型)

[7.5 字符串格式化（3 种方式）](#7.5 字符串格式化（3 种方式）)

[7.5.1 f-string 格式化（Python 3.6+ 推荐，简洁高效）](#7.5.1 f-string 格式化（Python 3.6+ 推荐，简洁高效）)

[7.5.2 format () 方法格式化](#7.5.2 format () 方法格式化)

[7.5.3 % 占位符格式化（传统方式）](#7.5.3 % 占位符格式化（传统方式）)

[7.6 字符串转义字符](#7.6 字符串转义字符)

[7.7 字符串实战案例（全岗位通用）](#7.7 字符串实战案例（全岗位通用）)

八、总结与进阶指引

[8.1 核心知识点回顾](#8.1 核心知识点回顾)

[8.2 进阶学习方向（按岗位选择）](#8.2 进阶学习方向（按岗位选择）)

[8.3 学习建议](#8.3 学习建议)

---

0、前言

在数字化、智能化全面渗透的今天，Python 早已超越单一编程语言的范畴，成为前端开发、后端服务、运维自动化、人工智能、数据分析、爬虫开发等全领域的通用工具。它以语法简洁、可读性强、生态丰富、跨平台兼容等核心优势，稳居全球编程语言排行榜前列，是零基础入门编程、职场技能提升、AI 探索的首选语言。

0.1 Python 的起源、历史与发展背景

Python 并非偶然诞生的语言，它是计算机科学发展与工程实践结合的经典产物，其历史与背景深刻影响了今天的语法设计、生态格局与行业地位。

1.1.1 诞生：1989 年的圣诞假期项目

Python 的创始人是吉多・范罗苏姆（Guido van Rossum） ，一位荷兰籍计算机科学家。1989 年圣诞期间，阿姆斯特丹实验室放假，Guido 为了打发时间、同时解决当时编程语言的痛点，决定开发一门简单易用、可读性强、可扩展的新语言。

他的设计目标非常明确：

1. 代码像自然语言一样易读；
2. 开发效率远高于运行效率（让程序员更省力）；
3. 支持模块化与扩展，方便接入 C/C++；
4. 开源、免费、社区驱动。

这门语言被命名为 Python，并非与蛇有关，而是源自 Guido 非常喜欢的 BBC 电视剧《蒙提・派森的飞行马戏团（Monty Python's Flying Circus）》。

1.1.2 关键版本里程碑

• 1991 年：Python 第一个公开版本（0.9.0）发布，已支持类、函数、异常处理、核心数据类型。
• 2000 年：Python 2.0 发布，加入垃圾回收、列表推导式等重要特性。
• 2008 年 ：Python 3.0 发布，为了修复历史设计缺陷，采用不兼容 Python 2 的全新设计。
• 2020 年 1 月 1 日 ：Python 2 正式停止维护（End of Life），全球全面进入 Python 3 时代。
• 2020 年后：Python 3.6+ 引入 f-string、类型注解、异步语法，成为 AI、云计算、自动化的标准语言。

1.1.3 Python 为什么能成功？（历史背景决定的优势）

1. 诞生时机好：1990 年代正是互联网兴起阶段，Python 刚好适配 Web、脚本、自动化需求。
2. 设计哲学先进：强调优雅、简洁、可读，拒绝 "炫技式代码"，适合团队协作。
3. 开源与社区：从第一天起就是开源语言，由全球志愿者共同维护，无商业绑定。
4. 胶水语言定位：能轻松调用 C/C++/Java/Go，成为 "系统粘合剂"，特别适合运维、后端、AI。

1.1.4 Python 设计哲学：The Zen of Python

在 Python 解释器中输入以下命令，可查看官方设计思想，它也是你写代码的原则：

# 查看 Python 之禅（官方设计哲学）
import this

核心思想摘录：

• 优美胜于丑陋
• 明了胜于晦涩
• 简洁胜于复杂
• 可读性很重要
• 现在就做，哪怕不如不做，但永远不要为了做而做

---

一、初识 Python：开启编程之旅

1.1 Python 是什么？

Python 是一种解释型、面向对象、动态数据类型的高级编程语言，由荷兰人 Guido van Rossum 于 1989 年发明，1991 年正式发布。Python 3 是目前主流版本（Python 2 已于 2020 年停止维护），本文所有代码均基于 Python 3.8+ 版本编写，兼容最新稳定版特性。

1.2 Python 的核心优势

1. 语法极简：代码接近自然语言，无需复杂语法即可实现功能，降低学习门槛；
2. 跨平台兼容：一套代码可在 Windows、MacOS、Linux 等系统无缝运行；
3. 生态爆炸：拥有数十万第三方库（如 AI 领域的 TensorFlow/PyTorch、后端的 Django/Flask、运维的 Ansible、前端自动化的 Selenium），无需重复造轮子；
4. 应用广泛：覆盖 Web 开发、自动化运维、数据分析、人工智能、爬虫、游戏开发、物联网等全场景；
5. 社区活跃：全球开发者社区庞大，问题解决方案丰富，学习资源充足。

1.3 Python 能做什么？（全岗位适配）

• 前端开发者：自动化测试、前端构建工具、接口调试、数据可视化；
• 后端开发者：快速搭建 Web 服务、API 接口、微服务、数据库操作；
• 运维工程师：服务器自动化部署、日志分析、监控告警、批量运维；
• AI 爱好者：机器学习、深度学习、数据处理、模型训练、AI 应用开发；
• 普通民众：办公自动化（Excel/Word 处理）、数据整理、小工具开发。

1.4 Python 3 环境安装（零基础必看）

1.4.1 Windows 系统安装

1. 访问 Python 官网（https://www.python.org/downloads/），下载 Python 3.8+ 稳定版；
2. 安装时务必勾选「Add Python to PATH」（自动配置环境变量）；
3. 打开命令提示符（CMD），输入 python --version，显示版本号即安装成功。

1.4.2 MacOS 系统安装

1. 安装 Homebrew（包管理器）：/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"；
2. 安装 Python 3：brew install python3；
3. 验证：python3 --version。

1.4.3 Linux 系统安装（CentOS/Ubuntu）

• Ubuntu：sudo apt update && sudo apt install python3 python3-pip；
• CentOS：sudo yum install python3 python3-pip；
• 验证：python3 --version。

1.5 第一个 Python 程序：Hello World

Python 无需复杂编译，直接运行代码，入门零障碍。

# 【Python 入门第一行代码】打印 Hello World
# print() 是 Python 内置函数，用于输出内容到控制台
print("Hello, Python3! 欢迎开启编程之旅")

# 扩展：输出带变量的字符串
name = "Python 学习者"
print(f"你好，{name}！Python 3 基础入门超简单")

运行结果：

Hello, Python3! 欢迎开启编程之旅
你好，Python 学习者！Python 3 基础入门超简单

1.6 Python 运行方式

1. 交互式运行 ：打开 CMD/Terminal，输入 python3（Windows 输入 python），进入 Python 交互环境，直接输入代码回车运行；
2. 脚本文件运行 ：新建 .py 后缀文件（如 hello.py），编写代码后，命令行输入 python3 hello.py 运行；
3. IDE 开发：推荐 PyCharm（专业开发）、VS Code（轻量通用）、Jupyter Notebook（AI / 数据分析），提升开发效率。

---

二、Python 3 数据类型：数据的「容器」

数据类型是编程语言的核心基础，Python 3 是动态类型语言 ，无需提前声明变量类型，解释器自动识别。Python 数据类型分为基本数据类型 和复合数据类型，所有数据类型均为对象，符合面向对象特性。

2.1 数据类型分类

2.1.1 基本数据类型（不可变类型）

1. 数字类型（Number）：整数（int）、浮点数（float）、复数（complex）、布尔值（bool）；
2. 字符串类型（str）：文本数据；
3. 空类型（NoneType）：表示空值。

2.1.2 复合数据类型（可变 / 不可变）

1. 列表（list）：有序、可变、可重复的集合；
2. 元组（tuple）：有序、不可变、可重复的集合；
3. 字典（dict）：无序、可变的键值对集合；
4. 集合（set）：无序、不可重复的集合。

2.2 数字类型（Number）

数字类型用于存储数值，支持数学运算，是编程中最常用的类型。

2.2.1 整数（int）

正整数、负整数、0，无大小限制。

# 定义整数变量
age = 26          # 正整数
temperature = -5  # 负整数
zero = 0          # 零

# 查看数据类型：type() 函数
print(type(age))          # 输出：<class 'int'>，表示整数类型
print("年龄：", age)      # 输出：年龄：26

2.2.2 浮点数（float）

带小数点的数值，用于存储小数。

# 定义浮点数变量
height = 1.75      # 身高（米）
pi = 3.1415926     # 圆周率

print(type(height))        # 输出：<class 'float'>
print("身高：", height)    # 输出：身高：1.75

2.2.3 布尔值（bool）

只有两个值：True（真）、False（假），本质是 int 的子类（True=1，False=0）。

# 定义布尔变量
is_student = True    # 是学生
is_working = False   # 未工作

print(type(is_student))    # 输出：<class 'bool'>
print(True + 1)            # 输出：2（True 等价于 1）
print(False + 1)           # 输出：1（False 等价于 0）

2.2.4 复数（complex）

用于科学计算，格式：实部+虚部j。

# 定义复数
complex_num = 3 + 4j
print("复数：", complex_num)    # 输出：复数：(3+4j)
print(type(complex_num))        # 输出：<class 'complex'>

2.3 字符串类型（str）

字符串是由单引号、双引号、三引号包裹的文本，用于存储文字、符号等数据，是不可变类型。

# 1. 单引号定义字符串
str1 = 'Python 基础入门'
# 2. 双引号定义字符串（支持嵌套单引号）
str2 = "我喜欢 'Python' 语言"
# 3. 三引号定义多行字符串
str3 = """Python
是一门
简单易用的语言"""

print(str1)
print(str2)
print(str3)
print(type(str1))    # 输出：<class 'str'>

2.4 空类型（NoneType）

None 表示空值，不等于 0、空字符串、False，是独立的数据类型。

# 定义空值变量
empty = None
print(empty)                # 输出：None
print(type(empty))          # 输出：<class 'NoneType'>

2.5 复合数据类型

2.5.1 列表（list）

• 定义：用 [] 包裹，元素用逗号分隔；
• 特性：有序、可变、可存储不同类型数据。

# 定义列表：存储姓名、年龄、身高、是否学生
person = ["张三", 25, 1.80, True]
print("列表：", person)          # 输出：列表： ['张三', 25, 1.8, True]
print(type(person))              # 输出：<class 'list'>

# 列表元素修改（可变特性）
person[1] = 26    # 修改年龄为26
print("修改后列表：", person)    # 输出：修改后列表： ['张三', 26, 1.8, True]

2.5.2 元组（tuple）

• 定义：用 () 包裹，元素用逗号分隔；
• 特性：有序、不可变（元素不能修改）。

# 定义元组：固定的坐标值
coordinate = (10, 20, 30)
print("元组：", coordinate)      # 输出：元组： (10, 20, 30)
print(type(coordinate))          # 输出：<class 'tuple'>

# 尝试修改元组元素：会报错（元组不可变）
# coordinate[0] = 100  # 报错：TypeError

2.5.3 字典（dict）

• 定义：用 {} 包裹，元素为 键:值 对，键唯一；
• 特性：无序、可变，通过键快速取值。

# 定义字典：存储用户信息
user = {
    "name": "李四",
    "age": 28,
    "job": "后端工程师"
}
print("字典：", user)            # 输出完整字典
print("姓名：", user["name"])    # 通过键取值：输出 李四
print(type(user))                # 输出：<class 'dict'>

2.5.4 集合（set）

• 定义：用 {} 包裹，元素用逗号分隔；
• 特性：无序、不可重复，自动去重。

# 定义集合：自动去重
numbers = {1, 2, 2, 3, 3, 3}
print("集合（去重后）：", numbers)    # 输出：集合（去重后）： {1,2,3}
print(type(numbers))                  # 输出：<class 'set'>

2.6 数据类型转换

Python 支持不同数据类型之间的强制转换，通过内置函数实现：

• int()：转整数；float()：转浮点数；str()：转字符串；list()：转列表；
• tuple()：转元组；dict()：转字典；set()：转集合。

# 1. 字符串转整数
num_str = "100"
num_int = int(num_str)
print("转换后类型：", type(num_int))    # 输出：<class 'int'>

# 2. 整数转字符串
num = 200
num_str2 = str(num)
print("转换后类型：", type(num_str2))   # 输出：<class 'str'>

# 3. 列表转集合（去重）
list1 = [1,1,2,2,3]
set1 = set(list1)
print("列表转集合：", set1)             # 输出：{1,2,3}

---

三、变量与关键字：编程的「基础单元」

3.1 变量的定义

变量是存储数据的容器，用于在内存中保存数据，方便后续调用。Python 变量无需声明类型，直接赋值即可。

3.1.1 变量命名规则（必须遵守）

1. 由字母、数字、下划线组成，不能以数字开头；
2. 区分大小写（Name 和 name 是两个不同变量）；
3. 不能使用 Python 关键字；
4. 见名知意（如 age 表示年龄，而非 a1）。

3.1.2 变量赋值语法

变量名 = 数据 （= 是赋值运算符，不是等于）

# 变量赋值示例
# 1. 单个变量赋值
name = "AI 爱好者"
age = 20

# 2. 多个变量同时赋值
a, b, c = 1, 2, 3
x = y = z = 0    # 多个变量赋相同值

print("姓名：", name, "年龄：", age)    # 输出：姓名： AI 爱好者 年龄：20
print("a=", a, "b=", b, "c=", c)       # 输出：a= 1 b= 2 c= 3

3.2 Python 关键字

关键字是 Python 内置的保留字符 ，有特殊语法含义，不能用作变量名、函数名 。Python 3 共有 35 个关键字，可通过 keyword 模块查看：

# 查看 Python 3 关键字
import keyword
print("Python 3 关键字列表：")
print(keyword.kwlist)

核心关键字（基础常用） ：False、None、True、and、as、break、class、def、else、for、if、import、in、is、not、or、print、return、while 等。

3.3 变量的特性

1. 动态类型：变量类型可随时改变；
2. 引用传递：变量存储的是数据的内存地址，而非数据本身；
3. 可重复赋值：同一变量可多次赋值，新值覆盖旧值。

# 变量动态类型示例
var = 10        # 整数类型
var = "Python"  # 改为字符串类型
print(var)      # 输出：Python
print(type(var))# 输出：<class 'str'>

# 变量重复赋值
num = 5
num = 10
print(num)      # 输出：10（新值覆盖旧值）

---

四、语句：Python 的「执行逻辑」

语句是 Python 执行操作的基本单位 ，一条语句就是一个完整的执行指令。Python 语句无需分号结尾（可加可不加），通过缩进区分代码块（强制要求，4 个空格或 1 个 Tab）。

4.1 语句分类

1. 简单语句：单行完成操作（如赋值语句、打印语句）；
2. 复合语句：多行代码组成，包含代码块（如 if 语句、for 循环、while 循环）。

4.2 赋值语句

最基础的语句，用于给变量赋值。

# 赋值语句
score = 95    # 简单赋值语句
result = "及格" if score >= 60 else "不及格"    # 赋值+条件表达式
print(result)    # 输出：及格

4.3 条件语句（if-elif-else）

根据条件判断执行不同代码，实现分支逻辑，是编程核心控制语句。

4.3.1 单分支 if 语句

# 单分支：满足条件才执行
score = 85
if score >= 60:
    print("成绩合格")    # 缩进 4 个空格，属于 if 代码块

4.3.2 双分支 if-else 语句

# 双分支：满足/不满足条件各执行一段代码
age = 17
if age >= 18:
    print("已成年")
else:
    print("未成年")    # 输出：未成年

4.3.3 多分支 if-elif-else 语句

# 多分支：多个条件判断
score = 75
if score >= 90:
    print("优秀")
elif score >= 70:
    print("良好")    # 输出：良好
elif score >= 60:
    print("及格")
else:
    print("不及格")

4.4 循环语句

重复执行一段代码，提高代码复用性，分为 for 循环和 while 循环。

4.4.1 for 循环（遍历循环）

用于遍历列表、字符串、字典等可迭代对象，适合已知循环次数的场景。

# 1. 遍历列表
fruits = ["苹果", "香蕉", "橙子"]
for fruit in fruits:
    print("水果：", fruit)

# 2. 遍历数字范围：range(start, end, step) 生成连续数字
for i in range(1, 6):    # 生成 1-5 的数字
    print("循环次数：", i)

4.4.2 while 循环（条件循环）

满足条件就循环，适合未知循环次数的场景。

# while 循环：计算 1-5 的和
sum_num = 0
i = 1
while i <= 5:
    sum_num += i    # 累加：sum_num = sum_num + i
    i += 1          # 循环变量自增
print("1-5 的和：", sum_num)    # 输出：15

4.4.3 循环控制语句

• break：跳出整个循环，终止执行；
• continue：跳过当前循环，继续下一次循环。

# break 示例：找到数字 3 就停止循环
for i in range(1, 6):
    if i == 3:
        break
    print(i)    # 输出：1、2

# continue 示例：跳过数字 3
for i in range(1, 6):
    if i == 3:
        continue
    print(i)    # 输出：1、2、4、5

4.5 空语句（pass）

pass 是占位语句，不执行任何操作，用于保持代码结构完整，避免语法错误。

# 占位语句：后续补充代码
score = 50
if score < 60:
    pass    # 暂不编写逻辑，无报错
else:
    print("合格")

---

五、表达式：数据的「运算逻辑」

5.1 表达式的定义

表达式是由运算符、操作对象、变量、函数组成的式子 ，执行后会返回一个结果。简单来说，任何有值的代码都是表达式。

5.2 表达式的分类

1. 算术表达式 ：1 + 2 * 3；
2. 比较表达式 ：age > 18；
3. 逻辑表达式 ：True and False；
4. 赋值表达式 ：a = 10；
5. 函数表达式 ：len("Python")。

5.3 表达式示例

# 1. 算术表达式：返回计算结果
expr1 = 10 + 5 * 2
print(expr1)    # 输出：20

# 2. 比较表达式：返回布尔值
expr2 = 10 > 5
print(expr2)    # 输出：True

# 3. 逻辑表达式：返回布尔值
expr3 = True and False
print(expr3)    # 输出：False

# 4. 函数表达式：返回函数执行结果
expr4 = len("Python 基础")
print(expr4)    # 输出：6

5.4 表达式与语句的区别

• 表达式 ：有返回值，可参与运算（如 1+2）；
• 语句 ：执行操作，无返回值（如 print(1+2)、if 语句）。

---

六、运算符与操作对象：数据的「运算工具」

运算符是用于执行运算的符号，操作对象是参与运算的数据（变量、常量、表达式）。Python 运算符分为 7 大类，覆盖所有运算场景。

6.1 算术运算符

用于数学计算，支持数字类型运算。

运算符	说明	示例
+	加法	1 + 2 = 3
-	减法	5 - 3 = 2
*	乘法	2 * 3 = 6
/	除法（返回浮点数）	6 / 2 = 3.0
//	整除（返回整数）	7 // 2 = 3
%	取余	7 % 2 = 1
**	幂运算	2 ** 3 = 8

# 算术运算符实战
a = 10
b = 3
print("加法：", a + b)      # 13
print("除法：", a / b)      # 3.3333333333333335
print("整除：", a // b)     # 3
print("取余：", a % b)      # 1
print("幂运算：", a ** b)   # 1000

6.2 比较运算符

用于比较两个数据的大小关系，返回布尔值（True/False）。

运算符	说明
==	等于
!=	不等于
>	大于
<	小于
>=	大于等于
<=	小于等于

# 比较运算符实战
x = 5
y = 3
print(x == y)    # False
print(x > y)     # True
print(x <= y)    # False

6.3 赋值运算符

用于给变量赋值，结合算术运算符简化代码。

运算符	说明	示例
=	简单赋值	a = 10
+=	加等于	a += 5 → a = a+5
-=	减等于	a -= 5 → a = a-5
*=	乘等于	a = 5 → a = a5
/=	除等于	a /= 5 → a = a/5

# 赋值运算符实战
num = 10
num += 5    # 等价于 num = num + 5
print(num)  # 15

num *= 2    # 等价于 num = num * 2
print(num)  # 30

6.4 逻辑运算符

用于布尔值运算，连接多个条件，返回布尔值.

运算符	说明
and	逻辑与：全真才真，一假则假
or	逻辑或：一真则真，全假才假
not	逻辑非：取反

# 逻辑运算符实战
a = True
b = False
print(a and b)    # False
print(a or b)     # True
print(not a)      # False

# 多条件判断
age = 22
is_work = True
if age >= 18 and is_work:
    print("成年且工作")    # 输出

6.5 成员运算符

判断元素是否在容器中（列表、字符串、字典等），返回布尔值。

• in：在容器中返回 True；
• not in：不在容器中返回 True。

# 成员运算符实战
str1 = "Python"
list1 = [1,2,3]
print("P" in str1)        # True
print(4 not in list1)      # True

6.6 身份运算符

判断两个变量是否引用同一个对象（内存地址是否相同）。

• is：同一对象返回 True；
• is not：不同对象返回 True。

# 身份运算符实战
a = [1,2,3]
b = a       # b 引用 a 的内存地址
c = [1,2,3] # c 是新对象
print(a is b)      # True
print(a is c)      # False（值相同，内存地址不同）

6.7 位运算符（了解即可）

用于二进制运算，适合底层开发、算法场景，运维 / AI 基础阶段极少使用。

运算符	说明
&	按位与
|	按位或
^	按位异或
~	按位取反
<<	左移
>>	右移

6.8 运算符优先级

运算顺序：括号 > 幂运算 > 算术运算符 > 比较运算符 > 逻辑运算符 > 赋值运算符。

# 优先级示例：先乘除后加减
result = 10 + 5 * 2
print(result)    # 20

# 括号改变优先级
result2 = (10 + 5) * 2
print(result2)   # 30

---

七、字符串操作：文本处理的「核心技能」

字符串是 Python 最常用的数据类型，前端、后端、运维、AI 均需大量处理文本数据。Python 提供了丰富的字符串操作方法，无需依赖第三方库，即可完成拼接、截取、替换、查找、格式化等操作。

7.1 字符串的定义与特性

1. 不可变：字符串创建后，无法修改单个字符；
2. 有序：可通过索引（下标）获取字符；
3. 支持切片：截取子字符串。

7.2 字符串索引与切片

7.2.1 索引（下标）

字符串中每个字符对应一个索引，从左到右从 0 开始，从右到左从 -1 开始。

# 字符串索引
str1 = "Python3"
# 索引取值：变量[下标]
print(str1[0])    # 输出：P（第一个字符）
print(str1[-1])   # 输出：3（最后一个字符）

7.2.2 切片（截取子串）

语法：字符串[起始索引:结束索引:步长]

• 起始索引：包含，默认 0；
• 结束索引：不包含，默认字符串长度；
• 步长：默认 1，负数表示反向截取。

# 字符串切片
str2 = "Hello Python"
# 截取前 5 个字符
print(str2[0:5])    # 输出：Hello
# 截取从 6 到末尾
print(str2[6:])     # 输出：Python
# 反向截取
print(str2[::-1])   # 输出：nohtyP olleH（字符串反转）

7.3 字符串拼接与重复

1. 拼接 ：+ 运算符；
2. 重复 ：* 运算符。

# 字符串拼接
str_a = "Python"
str_b = "基础入门"
result = str_a + " " + str_b
print(result)    # 输出：Python 基础入门

# 字符串重复
print(str_a * 3) # 输出：PythonPythonPython

7.4 字符串常用内置方法

Python 字符串内置 40+ 方法，覆盖所有文本处理场景，以下是高频实用方法（带详细注释）：

7.4.1 大小写转换

str3 = "python"
print(str3.upper())    # 转大写：PYTHON
print(str3.capitalize()) # 首字母大写：Python
str4 = "PYTHON"
print(str4.lower())    # 转小写：python

7.4.2 查找与替换

str5 = "Hello Python Python"
# 查找子串索引：找不到返回 -1
print(str5.find("Python"))    # 输出：6
# 替换字符串：replace(旧串, 新串, 替换次数)
print(str5.replace("Python", "Java", 1)) # 替换一次：Hello Java Python

7.4.3 分割与拼接

str6 = "苹果,香蕉,橙子"
# 分割字符串：split(分隔符) → 返回列表
list2 = str6.split(",")
print(list2)    # 输出：['苹果', '香蕉', '橙子']

# 拼接字符串：join(列表) → 列表转字符串
str7 = "-".join(list2)
print(str7)     # 输出：苹果-香蕉-橙子

7.4.4 去除空白字符

str8 = "  Python 3  "
# 去除首尾空白：strip()
print(str8.strip())    # 输出：Python 3
# 去除左侧空白：lstrip()
print(str8.lstrip())   # 输出：Python 3  
# 去除右侧空白：rstrip()
print(str8.rstrip())   # 输出：  Python 3

7.4.5 判断字符串类型

str9 = "12345"
str10 = "Python123"
print(str9.isdigit())    # 判断是否全数字：True
print(str10.isalpha())   # 判断是否全字母：False

7.5 字符串格式化（3 种方式）

用于动态拼接字符串，前端展示、日志输出必备技能。

7.5.1 f-string 格式化（Python 3.6+ 推荐，简洁高效）

# f-string：在字符串前加 f，{} 包裹变量
name = "AI 开发者"
age = 25
info = f"姓名：{name}，年龄：{age}"
print(info)    # 输出：姓名：AI 开发者，年龄：25

7.5.2 format () 方法格式化

# format() 格式化
info2 = "姓名：{}，年龄：{}".format(name, age)
print(info2)

7.5.3 % 占位符格式化（传统方式）

# % 占位符：%s 字符串，%d 整数，%f 浮点数
info3 = "姓名：%s，年龄：%d" % (name, age)
print(info3)

7.6 字符串转义字符

用于表示特殊字符，以 \ 开头。

• \n：换行；\t：制表符；\'：单引号；\"：双引号；\\：反斜杠。

# 转义字符示例
print("Hello\nPython")    # 换行输出
print("我喜欢\'Python\'")  # 输出：我喜欢'Python'

7.7 字符串实战案例（全岗位通用）

# 【实战】用户信息格式化输出（前端/后端通用）
username = "运维工程师"
job = "自动化运维"
skill = "Python + Linux + AI"
# 拼接用户简介
user_info = f"姓名：{username} | 职业：{job} | 技能：{skill}"
# 去除空白、转大写、分割
user_info_clean = user_info.strip().upper()
user_info_list = user_info_clean.split("|")
# 输出结果
print("格式化用户信息：", user_info)
print("处理后信息：", user_info_clean)
print("分割后列表：", user_info_list)

运行结果：

格式化用户信息： 姓名：运维工程师 | 职业：自动化运维 | 技能：Python + Linux + AI
处理后信息： 姓名：运维工程师 | 职业：自动化运维 | 技能：PYTHON + LINUX + AI
分割后列表： ['姓名：运维工程师 ', ' 职业：自动化运维 ', ' 技能：PYTHON + LINUX + AI']

---

八、总结与进阶指引

本文全面覆盖 Python 3 基础核心知识点 ，从「初识 Python、数据类型、变量与关键字、语句、表达式、运算符、字符串操作」7 大模块，系统讲解了 Python 基础语法，搭配可直接运行的代码 + 详细注释，适配前端、后端、运维、AI 爱好者等全受众，内容专业、易懂、可直接发布。

8.1 核心知识点回顾

1. Python 优势：语法简洁、跨平台、全场景适用；
2. 数据类型：掌握 int/str/list/dict 4 大核心类型；
3. 变量规则：合法命名、动态类型、禁止关键字；
4. 核心语句：if 分支、for/while 循环、缩进规范；
5. 运算符：7 大类运算符，优先级牢记；
6. 字符串：索引、切片、方法、格式化，文本处理必备。

8.2 进阶学习方向（按岗位选择）

1. 前端开发者：Python + Selenium（自动化测试）、Python + Flask（接口开发）；
2. 后端开发者：Django/Flask 框架、数据库操作、接口开发；
3. 运维工程师：自动化脚本、Ansible、日志分析、服务器监控；
4. AI 爱好者：数据处理（Pandas）、机器学习（Scikit-learn）、深度学习（TensorFlow）；
5. 零基础：函数、模块、异常处理、文件操作、面向对象。

8.3 学习建议

1. 多敲代码：编程是实践学科，逐行运行本文代码，理解每一行逻辑；
2. 勤做笔记：整理关键字、运算符、字符串方法，形成知识体系；
3. 实战落地：用 Python 写小工具（如计算器、文本处理、数据统计），巩固基础；
4. 持续进阶：基础扎实后，学习函数、模块、第三方库，对接岗位实战。

Python 3 基础是所有进阶开发的基石，掌握本文内容，即可轻松应对日常开发、自动化操作、AI 基础应用等场景。后续可继续学习 Python 函数、模块、异常处理、文件操作等进阶内容，逐步成为 Python 全栈开发者！

🙌 感谢你读到这里！

🔍 技术之路没有捷径，但每一次阅读、思考和实践，都在悄悄拉近您与目标的距离。

💡 如果本文对你有帮助，不妨 👍 点赞、📌 收藏、📤 分享 给更多需要的朋友！

💬 欢迎在评论区留下你的想法、疑问或建议，我会一一回复，我们一起交流、共同成长 🌿

🔔 关注我，不错过下一篇干货！我们下期再见！✨