【Python入门到精通】基础篇*上篇

走进Python编程世界：开启你的代码征途

001 Python编程世界的琅琊榜

在百花齐放的编程语言版图里，Python稳稳占据一席高地，称得上编程界家喻户晓的“琅琊榜名士”。C/C++深耕底层性能、Java稳固企业开发、Go语言擅长高并发，而Python凭借独有的气质，俘获了学生、工程师、数据分析师、自动化开发者无数爱好者。它不追求晦涩难懂的语法炫技，主打简洁通透、上手友好，横跨脚本开发、人工智能、数据分析、Web网站、自动化仿真、爬虫图形开发各大赛道，适配绝大多数普通人的学习目标。想要读懂当下技术浪潮，Python便是值得优先认识的第一名。

002 Python为什么这么火

Python能够持续走红，从来不是偶然。
第一，入门门槛低，语法贴近自然语言，不用纠结繁杂的语法格式，新手可以快速写出可运行代码；
第二，生态极度完善，海量第三方开源库覆盖各行各业，数据分析、图像处理、网络爬虫、Web开发皆有成熟工具；
第三，就业赛道宽广，人工智能、大数据自动化、测试运维、后端开发大量岗位将Python列为核心技能；
第四，跨平台通用，一份代码稍加适配，即可在Windows、Mac、Linux系统运行；
第五，开源社区活跃，遇到问题极易找到资料、教程与解决方案。
多重优势叠加，让Python成为当下学习人数增长最快的编程语言。

003 Python语言的特点

1. 简洁易读：强制缩进规范代码结构，减少大量括号、分号冗余代码，可读性拉满；
2. 解释型语言：无需提前编译，写完直接运行，调试高效，适合快速验证想法；
3. 面向对象+面向过程双支持，灵活适配不同开发场景；
4. 可扩展性强，支持调用C、C++编写的底层模块，兼顾开发效率与运行性能；
5. 丰富标准库，文件操作、网络访问、日期计算等常用功能开箱即用；
6. 开源免费，任何人可以自由下载、使用、修改源码，无商业授权压力。

004 选择Python版本

Python主流分为Python2与Python3两大分支，Python2已经全面停止维护，新项目一律选择Python3。
Python3内部小版本持续迭代，优先选择官方长期支持稳定版（如3.9~3.12系列）。
不建议盲目追求最新测试版本，新版本容易出现第三方库兼容bug；也不要选用年代过于老旧的版本，缺少新语法特性与安全更新。
确定版本后，全程统一环境，避免后期因为版本差异导致代码报错。

005 Windows系统下载安装Python

打开Python官方网站，进入下载页面获取对应稳定版本安装包。
运行安装程序时，务必勾选Add Python to PATH，自动配置系统环境变量，省去手动配置麻烦。
选择自定义安装路径，根据向导完成pip工具、文档、开发组件安装。
安装结束后打开CMD终端，输入python --version，能够正常输出版本号，代表安装成功。

006 Mac系统下载安装Python

Mac系统预装Python，但系统自带版本多为Python2，不建议直接使用。
方式一：官网下载macOS安装包图形化安装；
方式二：借助Homebrew包管理器，终端执行命令一键安装。
安装完成后区分系统自带Python与新版Python3，多数环境下使用python3命令调用。
同样在终端校验版本，确认环境变量正常，pip工具可用。

007 Linux系统下载安装Python

Ubuntu、CentOS等Linux发行版自带Python环境，但版本经常偏旧。
可以通过系统软件包管理器直接安装稳定版；若需要指定高版本，则下载源码包手动编译安装。
编译安装需要提前配置gcc等依赖工具。
Linux环境下默认使用python3指令运行程序，学会使用虚拟环境隔离不同项目依赖，避免库版本冲突。

008 使用IDLE开发工具

IDLE是Python自带的轻量IDE，安装Python后自动配备，无需额外下载。
它分为交互式命令窗口与代码编辑窗口：交互窗口适合单行代码即时测试，用来简单运算、验证语法；新建文件窗口可以编写完整.py脚本，保存后直接运行。
优点：零配置、开箱即用，非常适合零基础新手练习；缺点：缺少项目管理、代码提示、调试高级功能，适合入门练习，大型项目后续建议更换专业编辑器。

009 使用Emacs开发工具

Emacs是经典老牌可编程编辑器，属于资深开发者喜爱的工具。
安装Python开发相关插件后，支持语法高亮、代码补全、脚本一键运行、断点调试。
Emacs高度自定义，用户可以自由配置快捷键、界面布局、代码格式化规则。
学习成本相对更高，适合愿意深耕工具、追求高度个性化开发环境的学习者。除此之外VS Code、PyCharm也是当下主流的Python开发工具，可以根据需求备选。

010 编码并运行第一段Python程序

万事俱备，正式书写第一行代码。
打开开发工具，新建代码文件，输入经典入门语句：

print("Hello Python！开启我的编程之旅")

保存为hello.py，在终端或者编辑器内置运行功能执行脚本。
当屏幕成功打印出文字，意味着完整链路全部打通：环境安装、编辑器配置、代码编写、程序运行全部完成。
看似简单的一行输出，却是整个Python学习之路的起点。后续变量、循环、函数、类、第三方库，所有复杂功能，都将从这一段小程序开始延伸拓展。

011 Python程序其他运行方式

很多新手只知道在编辑器内点击运行，其实Python脚本拥有多种执行途径。除IDE内置运行按钮外，可以直接双击.py文件执行；在Windows、Mac、Linux各自的终端、命令提示符、Shell中输入指令运行；还能够将脚本打包成可执行文件脱离Python环境直接打开。同时支持以交互式模式逐行执行代码，也可以通过第三方工具、批处理脚本定时调用Python程序。不同运行方式适用于调试、日常开发、自动化任务等不同场景，熟练掌握可以极大提升灵活度。

012 提高开发效率——安装文本编辑器

自带的IDLE仅适合入门练习，长期开发需要专业文本编辑器。主流选择包含VS Code、Sublime Text、Atom等工具。这类编辑器拥有语法高亮、自动缩进、代码补全、多文件管理、插件扩展等能力。安装Python配套插件后，可实现一键运行代码、语法实时检查、格式化代码。轻量化编辑器启动迅速，资源占用低，兼顾简单脚本与中小型项目，是介于简易IDLE和重型IDE之间的最优选择，也是绝大多数Python学习者过渡阶段的首选工具。

013 快速运行Hello World程序

搭建好编辑器环境后，再次上手经典Hello World程序。新建空白文件，写入输出代码，保存为.py后缀文件。借助编辑器内置运行快捷键，无需手动切换终端，一键执行查看结果。熟练掌握文件保存路径规范，避免因中文路径、空格路径导致程序运行失败。快速运行能够帮助我们高频验证代码思路，养成“写完一小段，立刻测试”的良好习惯，为之后复杂代码调试打下基础。

014 在终端会话中运行Python代码

终端是程序员必备操作环境。打开系统终端，输入python或python3即可进入Python交互式会话。在交互环境中可以即时输入单行代码并马上得到结果，适合测试语法、简单运算、临时验证函数效果。
也可以不进入交互模式，直接执行指令：python hello.py运行本地脚本。学会看懂终端报错信息，当代码出错时，终端会精准提示错误位置与错误类型，这是排查BUG最重要的手段。

015 字符编码

计算机底层只能识别二进制数字，无法直接存储文字、符号。字符编码就是一套规则：把人类文字映射成二进制数据。早期诞生了ASCII编码，仅支持英文字母、数字与基础符号，无法存储中文。为了容纳各国语言，陆续出现GB2312、GBK等中文编码。不同编码标准互不兼容，一旦编码和解码规则不一致，就会出现乱码。乱码是开发中高频踩坑问题，想要彻底解决，必须理解编码底层原理。

016 Unicode编码和UTF-8编码

Unicode相当于一张全球统一的字符登记表，为世界上几乎所有文字分配唯一编号，但它只定义字符编号，没有规定如何存储传输。
UTF-8是Unicode最流行的实现方式，是一种可变长度编码：英文、符号占用1字节，中文占用3字节。优势是兼容ASCII、节省存储空间，也是互联网、Python、网页通用标准。
简单区分：Unicode是字符集，UTF-8是编码方案。日常开发统一使用UTF-8，能从根源规避绝大多数中文乱码问题。

017 Python中的编码

Python3做出重大优化：字符串str默认采用Unicode存储；字节类型bytes使用具体编码（通常为UTF-8）。
字符串与字节之间依靠encode()编码、decode()解码相互转换。
编写源代码文件时，推荐文件头部统一声明编码# -*- coding: utf-8 -*-。虽然新版Python3默认源文件编码就是UTF-8，但养成显式声明的规范，可以兼容老旧运行环境，避免移植代码时出现莫名乱码。读写文件时，务必主动指定encoding=“utf-8”。

018 实现输入功能

程序不应该只能单向输出，input()函数负责接收用户从控制台输入的内容。运行代码后程序暂停，等待用户键入文字并回车确认，所有接收得到的数据默认都是字符串类型。
我们可以接收用户名、数字、文本信息，再结合后续逻辑进行处理。同时需要注意，如果需要获取数字，必须手动使用int()、float()完成类型转换。输入功能搭建起人与程序交互的桥梁，是制作交互式小程序的基础。

示例：

name = input("请输入你的名字：")
print(f"你好，{name}")

019 实现输出功能

print()是Python最基础的输出函数，可以在控制台打印信息。它支持同时输出多个数据，用逗号隔开；支持格式化输出，拼接变量与文本。
常见三种格式化方式：字符串拼接、%格式化、str.format()，以及Python3.6之后推荐使用的f-string。
同时可以修改print默认行为：调整末尾换行符、设置多个内容之间的分隔符。熟练灵活运用输出方式，能够清晰展示运行结果，方便调试查看变量数据。

020 使用注释时的注意事项

注释用于给开发者阅读，Python解释器会直接忽略注释内容，不会执行。
单行注释使用#，多行注释使用三引号""" """。
编写注释有几条核心准则：

1. 不要复述代码本身已经显而易见的逻辑；
2. 重点说明为什么这么写，而不是描述代码做了什么；
3. 及时维护注释，代码修改后同步更新注释，防止注释和代码脱节误导他人；
4. 避免大量冗余注释，保持代码自身可读性优先；
5. 正式项目不要遗留大量调试用注释代码，发布前清理干净。
   规范的注释是团队协作、长期维护项目不可或缺的好习惯。

021 注意变量的命名规则和建议

变量名是代码最基础的标识，必须遵守硬性语法规则，同时遵循行业规范。
硬性规则：变量名只能由字母、数字、下划线构成；不能以数字开头；严格区分大小写；不可以使用Python内置关键字，例如if、for、def、class等。
开发规范建议：Python变量推荐蛇形命名法（小写字母+下划线，如user_name）；不要使用无意义单字母名称（除循环临时变量i,j），尽量见名知意；禁止使用中文变量名（虽然语法支持，但跨环境极易引发编码异常）；常量全部大写，例如MAX_NUM。规范命名能大幅提升代码可读性，方便后续自查与团队协作。

022 注意Python语言的缩进规则

与C、Java依靠大括号划分代码块不同，Python依靠缩进区分代码层级，这是新手最容易出错的关键点。
默认规范使用4个空格作为一层缩进，不建议混用Tab制表符与空格，混用会直接触发语法报错。if、for、while、def、class等冒号结尾语句，下一行必须缩进。同一代码块保持缩进对齐；缩进层级错误，不仅运行报错，还会直接改变程序逻辑。很多新手逻辑正确却代码崩溃，根源往往就是缩进混乱。养成统一缩进习惯，是学好Python的必修课。

023 变量赋值的真正意义

很多初学者误以为赋值是“把数值装进变量盒子”，在Python中这个理解并不准确。
a = 10本质流程：在内存中创建对象10，变量a作为标签、引用指向这个内存对象。执行b = a并不是复制数据，而是让标签b和a指向同一个对象。
区分可变对象与不可变对象：数字、字符串属于不可变类型，重新赋值会让变量指向新对象；列表、字典等可变对象，多个变量指向同一对象时，一处修改全部同步生效。理解引用机制，才能搞懂函数传参、深浅拷贝等后续难点。

024 解码字节流

网络传输、文件读写、二进制数据交互时，数据大多以字节流（bytes）形式存在。
字节流无法直接当作正常文本使用，必须通过decode()解码转为字符串str。
语法示例：b'python'.decode("utf-8")。解码时必须明确编码格式，常用UTF-8、GBK；如果编码格式不匹配，直接抛出UnicodeDecodeError乱码或报错。与之对应，字符串使用encode()编码得到字节流。编码与解码成对出现，是处理爬虫、文件、网络接口数据的高频操作。

025 访问字符串中的值

Python字符串属于有序序列，支持下标索引取值。索引从0开始，代表第一个字符；同时支持负索引，-1代表字符串最后一位字符。
使用字符串[索引]获取单个字符；使用切片[起始:结束:步长]截取一段子串。注意切片规则：左闭右开，结束索引位置字符不会被包含。
示例：

s = "Python"
print(s[0])
print(s[-1])
print(s[0:4])

熟练掌握索引和切片，是字符串、列表数据处理的基础。

026 更新字符串

新手常会尝试s[0] = "A"修改字符串指定字符，运行后直接报错。
原因：Python字符串是不可变序列，创建完成后，内存中的原始内容无法直接修改。
想要实现字符串更新，正确思路：通过切片拼接、replace替换、分割重组等方式生成一段全新字符串，再用变量接收新对象。旧字符串若无其他变量引用，最终会被垃圾回收。理解字符串不可变特性，可以规避大量初学者常见bug。

027 转义字符

字符串中部分字符拥有特殊含义，无法直接书写，依靠转义字符\实现。
常用转义字符：\n换行、\t制表符、\\输出反斜杠、\"与\'在引号内输出引号。
如果一段文本存在大量反斜杠（例如文件路径、正则表达式），频繁转义十分繁琐，可以使用原始字符串r""，原始字符串内部所有字符原样输出，不再解析转义符号。灵活运用转义字符与原始字符串，解决路径、文本排版相关问题。

028 格式化字符串

开发中经常需要把变量嵌入文本输出，也就是字符串格式化。
Python主流四种方案：

1. %格式化：早期传统写法；
2. str.format()：兼容性更强；
3. f-string（格式化字面量）：Python3.6+推荐方案，写法简洁直观，直接在字符串内{变量}取值，支持简单运算；
4. 字符串拼接+：只适合少量字符串合并，不建议混用字符串与数字。
   日常开发优先选择f-string，兼顾可读性与运行效率。

029 字符串处理函数

Python内置大量字符串方法，无需额外安装库，开箱即用。
常用功能：strip()去除首尾空白字符；split()分割字符串生成列表；join()将序列拼接为字符串；replace()内容替换；upper()/lower()大小写转换；find()/index()查找子串位置；startswith()、endswith()判断首尾文本。
字符串处理是爬虫、文本分析、数据清洗最常用的操作，熟练掌握内置方法，可以避免大量重复手写循环逻辑。

030 整型数字类型

int整型，用来表示没有小数的整数，如10、-256。
Python3的整型不再限制数值大小，可以轻松处理超大整数，不用担心溢出问题。
支持十进制、二进制0b、八进制0o、十六进制0x多种进制写法；提供bin()、oct()、hex()实现进制互相转换。
可以使用int()函数把合法数字字符串、浮点数强制转为整数（浮点数转换直接舍弃小数部分，不会四舍五入）。整数是数值运算、计数逻辑最基础的数据类型。

031 浮点型数字类型

浮点型float用来存储带小数的数值，例如 3.14、-0.618。
Python浮点数遵循IEEE 754标准，存在精度丢失问题，不要直接用==判断两个浮点数是否相等。

a = 0.1 + 0.2
print(a)         # 输出 0.30000000000000004
print(a == 0.3)  # False

# 正确做法：判断差值是否小于极小值
print(abs(a - 0.3) < 1e-9)

可以使用float()将字符串、整数转为浮点数；科学计数法也属于浮点类型。

num1 = 1.68
num2 = 2e3   # 2000.0
num3 = float("9.99")
print(num1, num2, num3)

032 布尔型数字类型

布尔类型bool只有两个取值：True和False。
本质是特殊整数：True == 1，False == 0。

print(True + 1)   # 2
print(False * 5)  # 0
print(True == 1)   # True
print(False == 0) # True

任意数据都可以用bool()转换成布尔值：空字符串、0、空列表、None都会得到False，其余一般为True。

print(bool(0))
print(bool(""))
print(bool("python"))
print(bool([1,2]))
print(bool([]))

033 复数型数字类型

Python原生支持复数complex，格式：实部 + 虚部j，j代表虚数单位。

c1 = 3 + 4j
c2 = complex(2, 5)
print(c1)
print(c2)
print(c1.real)   # 获取实部
print(c1.imag)   # 获取虚部
print(c1.conjugate()) # 获取共轭复数

复数之间支持加减乘除运算，多用于信号处理、科学计算。

034 总结整数支持的运算符

整型支持全套算术运算：+ - * / // % **

a = 10
b = 3
print(a + b)   # 加 13
print(a - b)   # 减 7
print(a * b)   # 乘 30
print(a / b)   # 除，结果浮点数 3.333...
print(a // b)  # 地板除，向下取整 3
print(a % b)   # 取余数 1
print(a ** b)  # 幂运算 1000

注意：/永远返回float；想要整数结果优先使用//。

035 Python中的数学函数

内置基础数学函数无需导入模块；高级函数需要import math。

# 内置函数
print(abs(-9))       # 绝对值
print(round(3.56,1))  # 四舍五入

import math
print(math.ceil(2.1))    # 向上取整 3
print(math.floor(2.9))   # 向下取整 2
print(math.sqrt(16))     # 平方根
print(math.pi)           # 圆周率
print(math.sin(math.pi/2))

036 字符串的格式化技巧

重点演示 f-string、format、百分号格式化，推荐f-string。

name = "小明"
age = 18
# f-string（推荐 Python3.6+）
s1 = f"姓名：{name}，年龄：{age}"
print(s1)

# format
s2 = "姓名：{}，年龄：{}".format(name, age)
print(s2)

# 百分号老式写法
s3 = "姓名：%s，年龄：%d" % (name, age)
print(s3)

# 格式化数字：保留小数
pi = 3.14159
print(f"圆周率={pi:.2f}")

037 什么是运算符和表达式

运算符：用来执行运算的符号 + - * > = and；
表达式：由变量、常量、运算符组合而成，运算后产生一个结果。

# 下面整行都是表达式
a = 1 + 2 * 3
print(10 > 5)
name = "py" + "thon"

表达式可以直接放在print()、if判断、赋值语句中使用。

038 算术运算符和算术表达式

算术运算符用于数值计算，构成算术表达式。

x = 7
y = 2
expr1 = x + y
expr2 = x ** y
expr3 = x // y
expr4 = x % y
print(expr1, expr2, expr3, expr4)

# 运算优先级：先乘除后加减，括号优先
res = 2 + 3 * 4
res2 = (2 + 3) * 4
print(res, res2)

039 比较运算符和比较表达式

比较运算符：> < >= <= == !=
运算结果永远是布尔值 True / False。

a = 10
b = 6
print(a > b)
print(a == b)
print(a != b)
print(5 <= 5)

# Python支持连续比较（特色语法）
num = 8
print(5 < num < 10)   # 等价于 5 < num and num <10

040 基本赋值运算符和表达式

基础赋值符号 =，衍生复合赋值：+= -= *= /= //= %= **=

n = 5
n += 2    # n = n + 2
print(n)

n -= 1    # n = n -1
print(n)

n *= 3
print(n)

n //= 2
print(n)

n **= 2
print(n)

⚠️注意：=是赋值，==才是判断相等，新手极易混淆。

041 复合赋值运算符和表达式

复合赋值运算符将算术运算与赋值合并书写，简化代码。包含：+= -= *= /= //= %= **=。

a = 10
a += 3   # a = a + 3
print(a)

a -= 2   # a = a - 2
print(a)

a *= 2   # a = a * 2
print(a)

a //= 3  # a = a // 3
print(a)

a %= 2   # a = a % 2
print(a)

a **= 4  # a = a ** 4
print(a)

注意：复合赋值不能直接写 a += 1 + 2 以外的连续链式等式，并且不支持像C语言一样自增a++、自减a--。

042 位运算符和位表达式

位运算符直接操作数字二进制补码：&按位与、|按位或、^按位异或、~按位取反、<<左移、>>右移。

a = 6    # 0110
b = 3    # 0011
print(a & b)   # 0010 → 2
print(a | b)   # 0111 → 7
print(a ^ b)   # 0101 → 5
print(~a)      # 按位取反 -7
print(a << 1)  # 左移一位 12
print(a >> 1)  # 右移一位 3

常用于底层硬件开发、权限掩码、高效乘除运算，左移等价乘以2，右移等价整除2。

043 逻辑运算符和逻辑表达式

逻辑运算符：and、or、not，用于组合多个条件，支持短路求值。

a = 10
b = 0
# and：全真才真，遇到假立刻短路
print(a > 5 and b > 1)
# or：一真即真，遇到真立刻短路
print(a > 5 or b > 1)
# not：取反
print(not a > 5)

# 短路特性演示
def test():
    print("函数执行")
    return False
print(0 and test())  # 前面为False，test不会运行
print(1 or test())   # 前面为True，test不会运行

044 成员运算符和成员表达式

in 和 not in，判断元素是否存在于序列（字符串、列表、元组、集合、字典键）中。

lst = [10,20,30]
print(20 in lst)
print(40 not in lst)

s = "python"
print("yt" in s)

d = {"name":"Tom"}
print("name" in d)       # 字典只检索key，不检索value
print("Tom" not in d)

045 身份运算符和身份表达式

身份运算符：is、is not，判断两个变量是否指向同一个对象（内存地址一致）。

a = [1,2,3]
b = [1,2,3]
c = a
print(a is c)
print(a is b)
print(a is not b)
# 使用id()查看内存地址
print(id(a))
print(id(b))
print(id(c))

046 运算符的优先级

优先级从高到低简要排序：
括号() > 位运算 > 算术运算 > 比较运算 > 身份运算符 > 成员运算符 > not > and > or
同一优先级从左向右计算。

# 示例：优先顺序验证
res = 3 + 5 > 2 and 10 << 1 == 20
print(res)
# 推荐：复杂表达式尽量使用括号，提高可读性，不要依靠记忆优先级
res2 = ((3 + 5) > 2) and ((10 << 1) == 20)
print(res2)

047 “==”运算符的秘密

== 作用是判断两个对象的值是否相等，底层调用对象魔法方法 __eq__()。
只要对象重写__eq__，就可以自定义相等判定规则。

list1 = [1,2,3]
list2 = [1,2,3]
print(list1 == list2)  # True，值相等
print(list1 is list2)   # False，不是同一个对象

简单理解：==关心内容，不关心内存地址。

048 身份运算符的特质

is 不对比数值，直接对比内存地址 id() 返回值。
Python对小整数池、短字符串常量池做缓存优化，会出现看似奇怪的现象：

a = 20
b = 20
print(a is b)  # True，小整数缓存

m = 300
n = 300
print(m is n)  # 交互式环境大概率False，超出小整数范围

s1 = "hello"
s2 = "hello"
print(s1 is s2)

缓存机制是解释器优化手段，不能依靠is判断数值是否相等。

049 总结and和or的用法

and 和 or 不一定返回布尔值，会返回实际参与运算的对象，这是Python独有特性。

• and：遇到假值，返回第一个假值；全部为真，返回最后一个真值
• or：遇到真值，返回第一个真值；全部为假，返回最后一个假值

print(0 and 100)   # 0
print(20 and 100)  # 100
print(0 or 100)    # 100
print(20 or 100)   # 20

# 常用小技巧：简易默认值
name = input("输入姓名：") or "匿名用户"
print(name)

050 is运算符和“==”运算符的区别

1. ==：值相等判断，调用__eq__；
2. is：同一性判断，判断id()内存地址完全一致；

x = [1,2]
y = [1,2]
print(x == y)  # True 内容相同
print(x is y)  # False 两块内存

num1 = 5
num2 = 5
print(num1 == num2)
print(num1 is num2)

使用准则：

• 判断数值、字符串内容相等，使用 ==；
• 判断变量是否为None，规范写法必须使用 is None。

051 什么是条件语句

代码默认从上至下顺序执行，而条件语句可以根据条件真假，选择性执行不同代码分支，实现程序分支逻辑。
条件语句依靠布尔表达式结果做判断：条件结果为True执行对应代码；结果为False则跳过。Python条件语句核心关键字：if、elif、else。

# 基础逻辑演示
score = 80
# 表达式结果决定分支走向
if score >= 60:
    print("考试及格")
print("程序执行结束")

052 最简单的if语句

基础语法：

if 条件表达式:
    执行语句块

冒号不能省略，内部代码必须缩进。只有条件成立时，缩进内代码才运行；不成立直接跳过。

age = 20
if age >= 18:
    print("已成年，可以观看成人内容")

num = 5
if num % 2 == 0:
    print("这是偶数")
# 5是奇数，条件不成立，无任何输出

053 使用if…else语句

提供两条分支：条件成立执行if块；不成立执行else块，二选一。
语法：

if 条件表达式:
    语句块1
else:
    语句块2

age = 16
if age >= 18:
    print("成年人")
else:
    print("未成年人")

n = 7
if n % 2 == 0:
    print(f"{n} 是偶数")
else:
    print(f"{n} 是奇数")

054 使用if…elif…else语句

多分支选择结构，实现多选一。程序自上而下依次判断，命中第一个成立条件后执行对应代码，后续分支不再判断。else为可选兜底分支。
语法：

if 条件1:
    语句块1
elif 条件2:
    语句块2
elif 条件3:
    语句块3
else:
    兜底语句

score = 85
if score >= 90:
    print("优秀")
elif score >= 80:
    print("良好")
elif score >= 60:
    print("及格")
else:
    print("不及格")

055 if语句的嵌套

在一个if/elif/else代码块内部，继续书写条件判断，形成嵌套结构。适合多层级、递进式判断。
⚠️重点：严格控制缩进层级，缩进混乱直接导致逻辑错误。

age = 22
has_id = True
if age >= 18:
    print("年龄达标")
    if has_id:
        print("拥有证件，可以进入")
    else:
        print("缺少证件，禁止进入")
else:
    print("年龄不足，禁止进入")

056 使用elif实现switch语句功能

Java、C语言拥有switch匹配语法，Python原生没有switch（旧版本）。最简单的替代方案就是连续elif，根据变量不同取值匹配分支。

day = 3
if day == 1:
    print("星期一")
elif day == 2:
    print("星期二")
elif day == 3:
    print("星期三")
else:
    print("未知日期")

优点：写法直观、新手容易理解；缺点：分支非常多时代码冗长。

057 使用字典实现switch语句功能

利用字典键值映射模拟分支，键作为匹配条件，值绑定函数，实现简洁的多分支分发，代码更加清爽。

def case_one():
    print("执行分支1")

def case_two():
    print("执行分支2")

def case_default():
    print("默认分支")

switch_dict = {
    1: case_one,
    2: case_two
}

select = 2
# get获取对应函数，找不到执行默认分支
func = switch_dict.get(select, case_default)
func()

058 自定义编写一个类实现switch语句功能

封装类，打造可复用的Switch工具，支持case匹配与default兜底，高度模仿其他语言switch风格。

class Switch:
    def __init__(self, value):
        self.val = value
        self.has_match = False

    def case(self, case_val):
        if self.val == case_val and not self.has_match:
            self.has_match = True
            return True
        return False

    def default(self):
        if not self.has_match:
            return True
        return False

# 调用示例
s = Switch(4)
if s.case(1):
    print("匹配1")
elif s.case(2):
    print("匹配2")
elif s.default():
    print("执行默认分支")

059 剖析True和False条件判断的用法

if判断中，不仅仅只有True/False可以充当条件，Python存在隐式布尔转换规则：
假值（Falsy）：0、0.0、""、[]、{}、()、None → 等效False
真值（Truthy）：非0数字、非空字符串、非空容器对象 → 等效True

# 隐式布尔转换演示
name = ""
if name:
    print("输入有效姓名")
else:
    print("姓名为空")

nums = [1,2,3]
if nums:
    print("列表不为空")

num = 0
if num:
    print("真值")
else:
    print("假值")

开发常用技巧：直接if lst:判断列表是否非空，不用写if len(lst) > 0。

060 再次提醒不支持switch语句的问题

在Python3.10之前，语言原生不存在switch-case关键字，只能通过elif、字典、自定义类模拟实现。

补充知识点：Python3.10新增 match-case 模式匹配，是功能更强大的升级版switch，但和传统switch仍有区别。

# Python3.10+ match-case示例，供了解
num = 2
match num:
    case 1:
        print("一")
    case 2:
        print("二")
    case _:
        print("其他")

学习建议：初学阶段不要依赖match-case，优先熟练掌握if-elif-else；保证代码拥有更好的版本兼容性。

061 最简洁的条件判断语句写法

Python提供三元表达式，把简单if-else压缩成一行，适合简短赋值场景。
语法：变量 = 满足条件的值 if 条件 else 不满足条件的值

age = 20
res = "成年" if age >= 18 else "未成年"
print(res)

num = 7
msg = "偶数" if num % 2 == 0 else "奇数"
print(msg)

# 不建议多层三元表达式嵌套，可读性会急剧下降

062 使用for循环语句

for循环属于遍历循环，用于依次取出序列（字符串、列表、元组、range等）里每一个元素，重复执行代码块。Python的for和C/C++风格for不同，是面向可迭代对象遍历。

# 遍历字符串
for char in "Python":
    print(char)

063 基本的for循环语句

标准基础写法：

fruits = ["苹果", "香蕉", "橙子"]
for fruit in fruits:
    print(f"水果名称：{fruit}")

执行流程：逐个取出fruits内元素赋值给fruit，执行缩进内代码；全部遍历完毕，循环结束。

064 通过序列索引迭代

有时需要同时拿到元素下标与内容，可以搭配range()+len()实现索引遍历。

fruits = ["苹果", "香蕉", "橙子"]
for i in range(len(fruits)):
    print(f"索引{i}，内容：{fruits[i]}")
# 更推荐enumerate（后续常用）
for idx, val in enumerate(fruits):
    print(f"索引{idx}，内容：{val}")

065 使用for…else循环语句

else绑定for循环：正常遍历结束、没有被break打断时，才执行else代码块；break跳出循环则else不运行。

nums = [1, 3, 5, 7]
for n in nums:
    if n == 4:
        print("找到数字4")
        break
else:
    print("循环正常结束，没有执行break，未找到4")

066 嵌套for循环语句

循环内部再写循环，常用于二维数据、九九乘法表等场景。外层循环走一次，内层完整跑完一轮。

# 九九乘法表示例
for i in range(1, 10):
    for j in range(1, i+1):
        print(f"{j}×{i}={i*j}", end="\t")
    print()

067 使用while循环语句

while属于条件循环，只要条件表达式结果为True，就持续执行循环体；适合循环次数不确定的场景。

068 基本的while循环语句

语法：

while 条件:
    循环代码块

i = 1
while i <= 5:
    print(i)
    i = i + 1  # 务必更新计数器，防止死循环

069 使用while…else循环语句

规则和for…else完全一致：循环正常结束（非break退出）执行else。

i = 1
while i <= 3:
    print(i)
    i += 1
else:
    print("while循环正常执行完毕")

070 死循环问题

条件永远为True，代码无限循环，称为死循环。

# 典型死循环，谨慎运行！
# while True:
#     print("无限输出")

# 意外产生死循环：忘记更新变量
# i = 0
# while i < 10:
#     print(i)
#     # 缺少 i +=1

应用场景：服务常驻监听、菜单交互；调试时可用 Ctrl+C 强制终止。

071 使用while循环嵌套语句

while内部嵌套while循环。

i = 1
while i <= 3:
    j = 1
    while j <= 2:
        print(f"i={i}, j={j}", end=" | ")
        j += 1
    print()
    i += 1

072 使用break循环控制语句

break 立刻终止当前所在循环，直接跳出循环，后续循环不再执行。

for i in range(1, 10):
    if i == 5:
        break
    print(i)
# 输出：1 2 3 4

073 使用continue循环控制语句

continue 终止本次循环，直接进入下一轮条件判断，不会跳出整个循环。

for i in range(1,6):
    if i == 3:
        continue
    print(i)
# 输出：1 2 4 5

074 使用pass循环控制语句

pass是空语句，占位符，不执行任何操作。保持语法完整性，防止代码报错，方便后续补充逻辑。

for i in range(3):
    if i == 1:
        pass  # 暂时预留位置，后续写代码
    else:
        print(i)

075 总结for循环语句

1. for循环用于遍历可迭代对象：列表、字符串、元组、range、集合等；
2. 优先用于循环次数已知场景；
3. 搭配range()生成连续数字；enumerate()同时获取索引和值；
4. 支持for…else结构；
5. 可用break终止、continue跳过本次迭代。

# range用法回顾
for num in range(2,10,2):
    print(num) # 2 4 6 8

076 总结break和continue语句

• break：跳出整个循环，循环彻底结束；
• continue：仅跳过当前这一轮，马上开启下一轮；
  ⚠️注意：两者只作用于最内层循环，外层循环不受影响。

for i in range(1,4):
    print(f"外层{i}")
    for j in range(1,4):
        if j == 2:
            break
        print(f"内层{j}")

077 使用while循环的注意事项

1. 循环体内记得更新条件变量，避免死循环；
2. while True死循环一定要设计出口（break）；
3. 复杂条件尽量用括号区分优先级；
4. while…else不要滥用，容易造成阅读困惑；
5. 不确定循环次数优先while；确定遍历范围优先for。

# 带退出条件的交互式while
while True:
    cmd = input("输入q退出：")
    if cmd == "q":
        break
    print(f"你输入：{cmd}")

078 创建数字列表

列表list是有序可变容器，存放一组数据，用[]定义。

# 方式1：直接定义
num_list = [10, 20, 30, 40]
# 方式2：list转换可迭代对象
num_list2 = list(range(1,6))
print(num_list2)  # [1,2,3,4,5]
# 混合类型列表（不推荐频繁混用）
mix_list = [100, "python", 3.14]
print(mix_list)

079 访问列表中的值

通过索引、切片取值；索引从0开始，支持负索引。

lst = ["A","B","C","D"]
print(lst[0])    # A
print(lst[-1])   # D
print(lst[1:3])  # ['B', 'C']

# 不要访问超出范围索引，会触发IndexError
# print(lst[10])

080 使用列表中的值

取出列表元素参与运算、判断、拼接等逻辑。

score_list = [88, 76, 92, 59]
total = 0
for s in score_list:
    total += s
avg = total / len(score_list)
print(f"总分：{total}，平均分：{avg:.2f}")

# 判断元素是否在列表内
if 92 in score_list:
    print("存在92分")

081 更新列表元素

列表是可变序列，可通过索引直接赋值修改指定位置元素。

lst = [10, 20, 30]
lst[1] = 99
print(lst)  # [10, 99, 30]

# 切片批量修改
lst[0:2] = [1, 2]
print(lst)  # [1, 2, 30]

注意：索引不能超出列表范围，否则抛出IndexError。

082 插入新的元素

三种常用插入方式：append()尾部追加、insert()指定位置插入、extend()批量追加序列。

nums = [1, 2, 3]
nums.append(4)
print(nums)  # [1, 2, 3, 4]

nums.insert(1, 99)
print(nums)  # [1, 99, 2, 3, 4]

083 在列表中删除元素

del按索引删除、pop()弹出元素（有返回值）、remove()按值删除第一个匹配项。

lst = ["a", "b", "c", "d"]
del lst[1]
print(lst)  # ['a', 'c', 'd']

val = lst.pop()
print(val)   # d
print(lst)   # ['a', 'c']

lst.remove("a")
print(lst)   # ['c']

remove()删除不存在元素会报错，删除前建议先用in判断。

084 使用sort()方法对列表进行永久性排序

sort()直接修改原列表，原地排序，无返回值。

nums = [5, 2, 9, 1]
nums.sort()
print(nums)  # [1, 2, 5, 9]

# 降序排序
nums.sort(reverse=True)
print(nums)  # [9, 5, 2, 1]

085 使用sorted()方法对列表进行临时排序

sorted()返回新列表，不会改动原始数据。

nums = [5, 2, 9, 1]
new_nums = sorted(nums)
print("原列表：", nums)
print("排序后：", new_nums)

new_desc = sorted(nums, reverse=True)
print("降序：", new_desc)

086 倒序输出列表中的信息

reverse()原地反转列表顺序。

lst = [1, 3, 5, 7]
lst.reverse()
print(lst)  # [7, 5, 3, 1]

# 切片方式临时反转，不修改原列表
lst2 = [2,4,6]
print(lst2[::-1])
print(lst2)

087 获取列表的长度

内置函数len()统计容器内元素总个数。

data = [11, 22, 33, 44]
print(len(data))  # 4

empty = []
print(len(empty)) # 0

088 列表中的运算符

支持 + 拼接、* 重复、in 成员判断。

a = [1, 2]
b = [3, 4]
c = a + b
print(c)  # [1, 2, 3, 4]

print(a * 3)  # [1, 2, 1, 2, 1, 2]

print(2 in a)    # True
print(99 not in a) # True

089 列表截取与拼接

切片语法 [start:end:step]，左闭右开；+用于拼接。

lst = ["A", "B", "C", "D", "E"]
print(lst[1:4])
print(lst[:3])
print(lst[2:])
print(lst[::2])

list1 = [1,2]
list2 = [3,4]
merge = list1 + list2
print(merge)

090 列表嵌套

列表内部元素依然是列表，用来表达二维结构。

matrix = [[1, 2], [3, 4], [5, 6]]
print(matrix[0])
print(matrix[0][1])

# 循环遍历嵌套列表
for row in matrix:
    for item in row:
        print(item, end=" ")

091 获取列表元素中的最大值和最小值

内置函数 max()、min()。

scores = [78, 92, 56, 85]
print(max(scores))
print(min(scores))

092 追加其他列表中的值

extend()把另一个序列所有元素追加到当前列表，区别于append()。

a = [1,2]
b = [3,4]
a.extend(b)
print(a) # [1, 2, 3, 4]

# 对比append
c = [1,2]
c.append(b)
print(c) # [1, 2, [3, 4]]

093 在列表中统计某元素出现的次数

使用.count(元素)。

words = ["hi", "python", "hi", "hi"]
cnt = words.count("hi")
print(cnt) # 3

094 清空列表中的元素

两种常用方式：clear()、切片赋值[:]。

lst = [1,2,3]
lst.clear()
print(lst)

lst2 = [10,20]
lst2[:] = []
print(lst2)

095 复制列表中的元素

直接赋值只是引用；想要独立副本使用切片或者copy()。

a = [1,2,3]
b = a          # 同一个对象
c = a.copy()   # 新列表
d = a[:]       # 新列表

a[0] = 99
print("a:", a)
print("b:", b)
print("c:", c)

096 获取列表中某个元素的索引

.index(元素)返回第一个匹配元素下标。

lst = [10, 20, 30, 20]
pos = lst.index(20)
print(pos) # 1

元素不存在会抛出ValueError。

097 注意排列顺序的多样性

排序默认按照自然大小；字符串按ASCII码比较；同时区分大小写。

str_list = ["Banana", "apple", "Cat"]
str_list.sort()
print(str_list)

# 忽略大小写排序
str_list.sort(key=str.lower)
print(str_list)

098 尝试有意引发错误

主动观察异常，方便以后排错。

lst = [1, 2, 3]
# print(lst[10])   # IndexError

# lst.remove(99)  # ValueError

学习目标：看懂报错信息，定位问题代码。

099 创建并访问元组

元组tuple使用()定义，不可变序列，索引、切片用法和列表一致。

t = (10, 20, 30)
print(t[0])
print(t[-1])
print(t[1:])

# 单元素元组必须加逗号
t_single = (666,)
print(type(t_single))

100 修改元组

元组本身整体不可修改，不能增删、替换元素。

t = (1, 2, 3)
# t[0] = 99  # TypeError

# 变通方案：转列表修改后再转回元组
lst = list(t)
lst[0] = 99
t_new = tuple(lst)
print(t_new)

# 特殊情况：元组内嵌套可变对象，可变对象内容允许修改
t2 = ([1,2], 5)
t2[0].append(3)
print(t2)

转载自 CSDN-专业IT技术社区

原文链接：https://blog.csdn.net/2301_81248642/article/details/163512167