1. 程序设计概述
程序是数据和指令的有序集合，写程序就是用数据和指令控制计算机做我们想让它做的事情。
程序设计就像：
- 给计算机当 "指挥官"，告诉它 "先做什么，再做什么"；
- 给生活当 "偷懒神器"，把重复的、复杂的任务交给计算机；
- 给大脑当 "逻辑训练师"，让你学会把想法变成清晰的步骤。
计算机科学家沃思（Niklaus Wirth）提出了一个著名的公式：
程序 = 算法 + 数据结构
算法是解决特定问题的方法，是程序设计的基础和灵魂。一个算法应具备 5 个特性：有穷性、确定性、可行性、输入和输出。计算机算法可分为两大类：数值计算算法（求解数值，如求方程的根）和非数值计算算法（处理事务，如排序、查找）。
Python 简介
Python 是由荷兰人吉多·范罗苏姆（Guido von Rossum）发明的一种开源、免费的编程语言，是目前世界上最受欢迎和拥有最多用户的编程语言。Python 强调代码的可读性和语法的简洁性，是一种面向对象的解释型语言。最近的四年时间 Python 语言都占据了编程语言排行榜冠军的宝座。
Python 的主要优势
- 学习入门容易：与 C、C++、Java 语言相比，Python 不需要建立 main 函数，语法简洁，代码量少。
- 功能强大：Python 有很丰富的库，既有官方开发的也有第三方开发的，很多功能模块已经写好，只需调用即可，不需要重新发明"轮子"。
- 应用领域非常广泛：网站后端开发、自动化运维、数据分析、游戏开发、自动化测试、网络爬虫、智能硬件开发等各个领域。
"Life is short, you need Python." —— 吉多·范罗苏姆
译："人生苦短，我用 Python"。
开发环境
工欲善其事，必先利其器。推荐安装官方的 Python 3 解释器（CPython，用 C 语言编写）。
交互式环境
打开 Windows 的"命令提示符"或"PowerShell"，输入 python 回车，即可进入交互式环境。所谓交互式环境，就是输入一行代码并按下 Enter 键，代码马上被执行，结果直接显示：
>>> 2 * 3
6
>>> 2 + 3
5
>>> quit() # 退出交互式环境集成开发环境 —— PyCharm
PyCharm 是由捷克 JetBrains 公司针对 Python 语言提供的集成开发环境（IDE），集编写代码、运行代码、调试代码、分析代码、版本控制等一系列功能于一体。官方提供两个版本：免费的社区版（Community Edition）——功能相对简单但对初学者完全够用；付费的专业版（Professional Edition）——功能非常强大，新用户可免费试用 30 天。
2. 第一个 Python 程序
打开 PyCharm 或交互式环境，输入以下代码运行：
print("我爱python!")
print('我来了')运行结果：
我爱python!
我来了上面的代码中使用了一个名为 print 的函数，用于输出指定的内容；print() 圆括号中的内容是字符串（文本内容）；在 Python 中，可以用单引号或双引号来表示一个字符串。建议大家每一行只写一条语句，保持代码良好的可读性。
注释
注释是编程语言的一个重要组成部分，用于在代码中解释代码的作用，增强代码可读性。也可以将暂时不需要运行的代码段通过注释屏蔽。注释会让代码更容易看懂但不会影响代码的执行结果。
Python 中有两种形式的注释：
- 单行注释：以
#和空格开头，注释从#开始后面一整行的内容。 - 多行注释：三个引号（通常用双引号）开头，三个引号结尾，常用于添加多行说明性内容。本质上是一种特殊的字符串，常被称为文档字符串。
# 这是一个单行注释
print("注释不会被输出") # 这里也是注释
"""
这是多行注释，
可以跨越多行，
通常用于函数或类的说明文档。
"""
print("多行注释演示结束")3. 关键字和标识符
关键字（Keyword）
Python 语言中定义了一些专有词汇，统称为"关键字"，如 break、class、if、print 等，它们都具有特定的含义，只能用于特定的位置。Python 中所有关键字是区分字母大小写的（例如 for 是关键字，但 FOR 不是）。
可以在 Python 终端中通过如下方式查看所有关键字：
import keyword
keyword.kwlistPython 所有关键字（35个）：
False None True and as assert async await
break class continue def del elif else except
finally for from global if import in is lambda
nonlocal not or pass raise return try while with yield标识符（Identifier）
Python 语言中的类名、对象名、方法名和变量名等，统称为"标识符"。为了提高程序的可读性，应尽量遵循"见其名知其意"的原则。标识符的具体命名规则如下：
- 由一个或多个字母（A~Z 和 a~z）、数字、下划线（_）组成，第一个字符不能是数字
- 不能是关键字
- 标识符中的字母是严格区分大小写的
- 不能包含空格、@、% 和 $ 等特殊字符
- 应避免开头和结尾都使用下划线（因为 Python 中大量采用这种名字定义特殊方法和变量）
| 合法标识符 | 非法标识符 | 原因 |
|---|---|---|
MYNAME |
4gen |
以数字开头 |
name |
for |
是 Python 关键字 |
name1 |
$book |
包含特殊字符 $ |
my_name |
4. 变量与常量
变量
所谓"变量"，就是在程序运行过程中值可以被改变的量。变量是数据的载体，简单说就是一块用来保存数据的内存空间，变量的值可以被读取和修改。和变量相对应的是"常量"，也就是在程序运行过程中值不能改变的量。
每个变量在使用前都必须赋值，变量赋值以后才会在内存中被创建。Python 中的变量在赋值时不需要类型声明，使用等号（=）来赋值，解释器会根据赋值语句自动推断变量类型。
在 Python 3.x 中，允许变量名是中文字符，但通常不推荐使用中文变量名：
num = 128 # 整数变量
姓名 = "小明" # 中文变量名可用，但不推荐
print(姓名)
a = b = c = 1 # 一次为多个变量赋同样的初值
print(id(a), id(b), id(c)) # 三个变量指向同一内存地址
# Python 是动态类型语言，变量的类型可以随时变化
number = 512 # 整型变量
print(type(number)) # <class 'int'>
number = "我爱Python编程" # 字符串类型变量
print(type(number)) # <class 'str'>常用数据类型
1. 整型（int）
Python 中可以处理任意大小的整数，支持二进制（0b前缀）、八进制（0o前缀）、十进制和十六进制（0x前缀）的表示法：
print(0b100) # 二进制整数 → 4
print(0o100) # 八进制整数 → 64
print(100) # 十进制整数 → 100
print(0x100) # 十六进制整数 → 2562. 浮点型（float）
浮点数即小数，除了数学写法（如 123.456）外还支持科学计数法（如 1.23456e2 表示 1.23456×10²）：
print(123.456) # 数学写法
print(1.23456e2) # 科学计数法 = 123.4563. 复数（complex）
复数由实数部分和虚数部分构成，可以用 a + bj 或 complex(a, b) 表示，实部和虚部都是浮点型。
a = 2.38 + 18.2j # 复数赋值
print(a)4. 字符串型（str）
字符串是 Python 中最常用的数据类型，是连续的字符序列，一般使用单引号（' '）、双引号（" "）或三引号（''' '''或""" """）界定。单引号和双引号中的字符序列必须在一行上，三引号内的字符序列可以分布在连续的多行上。
print('hello')
print("hello")
str1 = """白日依山尽
黄河入海流
欲穷千里目
更上一层楼
"""
print(str1)转义字符
Python 支持转义字符，即使用反斜杠 \ 对一些特殊字符进行转义：
| 转义字符 | 含义 |
|---|---|
\n | 换行符 |
\r | 回车 |
\t | 制表符 |
\\ | 一个反斜杠 \ |
\' | 单引号 ' |
\" | 双引号 " |
str2 = "白日依山尽\n黄河入海流\n欲穷千里目\n更上一层楼\n"
print(str2)
# 不同编码的字符，占用的字节数不一样
print(len('ABC')) # 3
print(len('\xe4\xb8\xad\xe6\x96\x87')) # 6（UTF-8 编码，每个中文字符占 3 字节）
print(len('中'.encode('utf-8'))) # 3
print(len('中')) # 1（Unicode 字符数）5. 布尔型（bool）
布尔型只有 True、False 两种值，可用于表示现实世界中的"是"和"否"、命题的"真"和"假"等。如果一个变量的值只有两种状态，就可以使用布尔型。
print(True)
print(False)变量命名规则与惯例
规则（必须遵守）：
- 变量名由字母（推荐英文字母）、数字和下划线构成，数字不能开头
- Python 是大小写敏感的编程语言（大写的
A和小写的a是两个不同的变量） - 变量名不要跟 Python 的关键字重名，尽可能避开保留字（如
int、print、input、str等）
惯例（推荐遵守）：
- 变量名通常使用小写英文字母，多个单词用下划线连接
- 受保护的变量用单个下划线开头
- 私有的变量用两个下划线开头
a = 45 # 定义变量a，赋值45
b = 12 # 定义变量b，赋值12
print(a, b) # 45 12
print(a + b) # 57
print(a - b) # 33
print(a * b) # 540
print(a / b) # 3.75type() 检查变量类型
可以使用 type() 函数对变量的类型进行检查：
a = 100
b = 123.45
c = 'hello, world'
d = True
print(type(a)) # <class 'int'>
print(type(b)) # <class 'float'>
print(type(c)) # <class 'str'>
print(type(d)) # <class 'bool'>类型转换
可以通过 Python 内置的函数来改变变量的类型：
| 函数 | 功能 |
|---|---|
int() | 将一个数值或字符串转换成整数，可指定进制 |
float() | 将一个字符串转换成浮点数 |
str() | 将指定的对象转换成字符串 |
chr() | 将整数（字符编码）转换成对应字符 |
ord() | 将一个字符转换成对应的整数（字符编码） |
a = 100
b = 123.45
c = '123'
d = '100'
e = '123.45'
f = 'hello, world'
g = True
print(float(a)) # 100.0 —— int 转 float
print(int(b)) # 123 —— float 转 int（截断小数）
print(int(c)) # 123 —— str 转 int
print(int(c, base=16)) # 291 —— str 按十六进制转 int
print(int(d, base=2)) # 4 —— str 按二进制转 int
print(float(e)) # 123.45 —— str 转 float
print(bool(f)) # True —— 有内容即为真
print(int(g)) # 1 —— True→1, False→0
print(chr(a)) # 'd' —— ASCII 码 100 对应字符 'd'
print(ord('d')) # 100 —— 字符 'd' 对应 ASCII 码 1005. 运算符
有了变量和运算符，我们就可以构造各种各样的表达式来解决实际问题。表达式由常量、变量、函数和运算符组合而成，编程语言对其进行解释和计算以得到另一个值。
运算符优先级（从高到低）
| 优先级 | 运算符 | 说明 |
|---|---|---|
| 最高 | [] [:] | 索引 / 切片 |
** | 幂 | |
~ + - | 按位取反 / 正号、负号 | |
* / % // | 乘 / 除 / 模 / 整除 | |
+ - | 加 / 减 | |
>> << | 右移 / 左移 | |
& | 按位与 | |
^ | 按位异或 | |
| | 按位或 | |
<= < > >= | 小于等于、小于、大于、大于等于 | |
== != | 等于 / 不等于 | |
is / is not | 身份运算符 | |
in / not in | 成员运算符 | |
not | 逻辑非 | |
and | 逻辑与 | |
or | 逻辑或 | |
| 最低 | = += -= *= /= %= //= **= &= |= ^= >>= <<= | 赋值运算符 |
💡 记不住优先级时，用圆括号（小括号）来确保运算的执行顺序。
算术运算符
print(1 + 2) # 3 —— 加法
print(2 - 1) # 1 —— 减法
print(2 * 3) # 6 —— 乘法
print(5 / 2) # 2.5 —— 除法（结果始终为浮点数）
print(5 // 2) # 2 —— 整除（向下取整）
print(5 % 2) # 1 —— 求模（取余）
print(5 ** 2) # 25 —— 幂运算🌾 趣味数学：国际象棋与麦粒
根据古波斯文献记载，国际象棋最早由印度宰相西萨·班·达依尔发明。印度舍罕王决定重赏发明者。西萨提出的奖赏看似微不足道：
在棋盘的第 1 格放 1 粒麦子，第 2 格放 2 粒，第 3 格放 4 粒，依此类推，每一格的麦粒数都是前一格的两倍，直至填满 64 格。
请同学们思考：一共需要多少粒麦子？
赋值运算符
赋值运算符将右边的值赋给左边的变量。赋值运算符还可以跟算术运算符组合成复合赋值运算符。Python 3.8 引入了一个新的赋值运算符 :=，称为海象运算符（长得像海象的獠牙 🦭），它可以在表达式内部为变量赋值：
a = 10
b = 3
a += b # 相当于：a = a + b
a *= a + 2 # 相当于：a = a * (a + 2)
print(a) # 大家算一下这里会输出什么比较运算符和逻辑运算符
比较运算符也称为关系运算符，会产生布尔值 True 或 False。逻辑运算符有三个：and（与）、or（或）和not（非）。
flag0 = 1 == 1 # True
flag1 = 3 > 2 # True
flag2 = 2 < 1 # False
flag3 = flag1 and flag2 # False —— 两边都为 True 才为 True
flag4 = flag1 or flag2 # True —— 一边为 True 即为 True
flag5 = not flag0 # False —— 取反
print('flag0 =', flag0) # flag0 = True
print('flag1 =', flag1) # flag1 = True
print('flag2 =', flag2) # flag2 = False
print('flag3 =', flag3) # flag3 = False
print('flag4 =', flag4) # flag4 = True
print('flag5 =', flag5) # flag5 = False
print(flag1 and not flag2) # True
print(1 > 2 or 2 == 3) # False6. 基本输入输出
input() 输入函数
Python 提供了内置函数 input()，用于接收用户的键盘输入，一般用法为：x = input("提示文字")。无论输入的是数字还是字符串，input() 函数返回的结果都是字符串，数据输入后，再根据需要转换成其它数据类型。
name = input("请输入名字：") # 输入数据
print("你的名字是：", name) # 输出数据
i = input("请输入数字：") # 输入的是字符类型
print(type(i)) # <class 'str'>
# i = int(input("请输入数字:")) # 将字符类型转换为整数print() 格式化输出
Python 使用内置函数 print() 将结果输出，格式为：print(输出的内容)。输出的内容可以是数字和字符串，也可以是变量或表达式。print() 函数默认是换行的，即输出语句后自动切换到下一行，如果要实现输出不换行的功能，可以设置 end=''。
print("白日依山尽") # 自动换到下一行
print("黄河入海流")
print("欲穷千里目")
print("更上一层楼")1. % 格式化（传统方式）
| 格式符 | 含义 |
|---|---|
%o | 输出八进制整数 |
%d | 输出十进制整数 |
%x | 输出十六进制整数 |
%f | 保留 6 位有效数字（浮点数），%.3f 则保留 3 位 |
%e | 指数形式输出（科学记数法） |
%s | 字符串输出 |
a = 30
print('%o' % a) # 八进制是 36
print('%d' % a) # 十进制是 30
print('%x' % a) # 十六进制是 1e
nHex = 0xFF
print("十六进制是%x,十进制是%d,八进制是%o" % (nHex, nHex, nHex))
# 十六进制是ff,十进制是255,八进制是377
# 浮点数
print('%f' % 2.22) # 默认保留 6 位小数
print('%.1f' % 2.22) # 取 1 位小数
print('%e' % 2.22) # 科学计数法
print('%.3e' % 2.22) # 取 3 位小数，科学计数法
print('%g' % 2222.2222) # 默认 6 位有效数字
print('%.7g' % 2222.2222) # 取 7 位有效数字
print('%.2g' % 2222.2222) # 取 2 位有效数字，自动转科学计数法
# 字符串格式化
print('%s' % 'hello world') # hello world
print('%20s' % 'hello world') # 右对齐，占 20 位
print('%-20s' % 'hello world') # 左对齐，占 20 位
print('%.2s' % 'hello world') # 截取 2 位 → he
print('%10.2s' % 'hello world') # 右对齐，10 位占位符，截取 2 位
print('%-10.2s' % 'hello world') # 左对齐，10 位占位符，截取 2 位
name = '小明'
age = 13
print('姓名：%s，年龄：%d' % (name, age))
# 姓名：小明，年龄：132. f-string（推荐方式，Python 3.6+）
使用 "f-字符串" 进行格式化输出的基本格式：print(f'{表达式}')
name = '小明'
age = 13
print(f'姓名：{name}，年龄：{age}')
# 设置小数位数
num = 3.1415926
print(f"π的值为：{num:.2f}") # 保留两位小数 → 3.14
# 千位分隔符
big_number = 1234567890
print(f"The big number is {big_number:,}")
print(f"The big number is {big_number:_}")
# 字符串对齐
s = "Hello"
print(f"|{s:<10}|") # 左对齐，总宽度为 10
print(f"|{s:>10}|") # 右对齐，总宽度为 10
print(f"|{s:^10}|") # 居中对齐，总宽度为 103. format() 方法
format() 功能更强大，把字符串当成一个模板，通过传入的参数进行格式化，使用大括号 {} 作为特殊字符代替 %。用法有三种形式：不带编号、带数字编号（可调换顺序）、带关键字。
print('{} {}'.format('hello', 'world')) # 不带字段
# hello world
print('{0} {1}'.format('hello', 'world')) # 带数字编号
# hello world
print('{0} {1} {0}'.format('hello', 'world')) # 打乱顺序
# hello world hello
print('{1} {1} {0}'.format('hello', 'world')) # 打乱顺序
# world world hello
print('{a} {b} {a}'.format(b='hello', a='world')) # 带关键字
# world hello world💡 默认情况下 Python 将结果输出到 IDLE 或标准控制台，实际上也可以重定向输出到指定文件中。
7. 格式化输出进阶
f-string 高级技巧
浮点数四舍五入
num = 3.1415926
print(f"{num:.2f}") # 保留两位小数 → 3.14
print(f"{num:.4f}") # 保留四位小数 → 3.1416
int_num = 123.987
print(f"{int_num:.0f}") # 整数舍入（0位小数）→ 124百分比格式化
rate = 0.758
print(f"{rate:.2%}") # 75.80%
print(f"{rate:.1%}") # 75.8%
rate2 = 0.3
print(f"{rate2:.0%}") # 30%前导零设置
num1 = 5
num2 = 123
print(f"{num1:03d}") # 3位长度，不足补零 → 005
print(f"{num2:05d}") # 5位长度 → 00123
decimal_num = 7.89
print(f"{decimal_num:06.2f}") # 总长度6，保留2位小数 → 007.89大数字格式化（千分位分隔符）
big_num = 1234567.89
print(f"{big_num:,}") # 1,234,567.89
print(f"{big_num:,.2f}") # 1,234,567.89（结合小数保留）
int_big = 987654321
print(f"{int_big:,}") # 987,654,321文本对齐 + 自定义填充字符
text = "Python"
print(f"{text:<10}") # 左对齐，总长度10 → "Python "
print(f"{text:>10}") # 右对齐，总长度10 → " Python"
print(f"{text:^10}") # 居中对齐 → " Python "
# 填充自定义字符（仅支持一个字符）
print(f"{text:-<10}") # 左对齐，填充 - → "Python----"
print(f"{text:=>10}") # 右对齐，填充 = → "====Python"
print(f"{text:*^10}") # 居中，填充 * → "**Python**"日期时间格式化
import datetime
now = datetime.datetime.now()
print(f"{now:%Y-%m-%d}") # 年-月-日 → 2025-11-13
print(f"{now:%Y/%m/%d %H:%M:%S}") # 年/月/日 时:分:秒 → 2025/11/13 17:40:09
print(f"{now:%H:%M:%S}") # 时:分:秒 → 17:40:09
print(f"{now:%A, %B %d, %Y}") # 星期, 月份 日期, 年 → Monday, November 13, 2025
today = datetime.date.today()
print(f"{today:%d/%m/%Y}") # 日期/月/年 → 13/11/2025调试技巧（f-string 便捷调试）
x = 10
y = 20
print(f"{x = }") # 直接显示变量名和值 → x = 10
print(f"{y = }") # y = 20
print(f"{x + y = }") # x + y = 30
num = 3.1415
print(f"{num = :.2f}") # 结合格式 → num = 3.14动态设置宽度和精度
width = 8
precision = 2
value = 123.456
print(f"{value:{width}.{precision}f}") # 总宽度8，保留2位 → " 123.46"列表去掉 [ ] 输出
my_list = [1, 2, 3, 4]
# 方法1：用 join() 拼接
print(' '.join(map(str, my_list))) # 1 2 3 4
print(','.join(map(str, my_list))) # 1,2,3,4
# 方法2：用 * 解包列表
print(*my_list) # 1 2 3 4
print(*my_list, sep=',') # 1,2,3,4
# 方法3：str() + 字符处理
print(str([my_list]).strip("]").strip("["))
print(str([my_list]).strip("]").strip("[").replace(",", " "))输出二进制数
Python 提供多种方式输出二进制格式的整数：
num = 10
# 使用 format() 方法
print('{0:b}'.format(num)) # 1010
# 使用 f-string
print(f'{num:b}') # 1010
# 使用 bin() 函数（含 0b 前缀）
binary_str = bin(num)[2:] # 去掉前缀 '0b'
print(binary_str) # 10108. len() 函数
len() 是 Python 内置函数，用于返回对象的长度或元素个数，适用于多种数据类型。
字符串（str）—— 返回字符个数
在 Python 3 中，字符串以 Unicode 编码存储，一个中文字符被视为一个独立的字符单元（无论内存中占多少字节）。所以 len('中') 返回 1。
s1 = 'hello'
s2 = '世界'
print(len(s1)) # 5
print(len(s2)) # 2列表（list）—— 返回元素个数
my_list = [1, 2, 3, 4]
print(len(my_list)) # 4元组（tuple）—— 返回元素个数
my_tuple = (10, 20, 30)
print(len(my_tuple)) # 3集合（set）—— 返回元素个数
my_set = {1, 2, 3}
print(len(my_set)) # 3字典（dict）—— 返回键值对数量
my_dict = {'a': 1, 'b': 2}
print(len(my_dict)) # 2自定义类实现 __len__()
class MyClass:
def __init__(self):
self.data = [1, 2, 3]
def __len__(self):
return len(self.data)
obj = MyClass()
print(len(obj)) # 3⚠️ 注意：len() 只能用于可计算长度的对象（对整数调用会报错）。对于嵌套数据结构，len() 只返回最外层的长度。例如nested_list = [[1, 2], [3, 4]]，len(nested_list)返回 2，而不是 4。
9. 如何学习一门新语言
程序员之道，万变不离其宗。说相声讲究"说、学、逗、唱"，学习程序最快也是最好的办法就是——"过、抄、仿、改、调、看、练、创、悟"：
1、过 —— 学习一门新语言，第一步先把基础知识大体过一遍，不求深解，只求了解
大致知道这门语言是什么样的，主要面向哪些场合，基本的语法格式即可
2、抄 —— 刚开始写代码，从书上抄，从例子里抄，边抄边想，边想边回忆语法
3、仿 —— 仿照给出的代码写一个属于自己的代码，熟悉了简单语法后尝试仿写
4、改 —— 在模仿的基础上，尝试修改代码，加入自己的想法和变化
5、调 —— 没有人能一下子写出完全正确的代码，通过不断调试来验证自己的想法
熟悉基本的调试工具以及调试方法
6、看 —— 出错时，将代码从头看到尾，看了一遍又一遍，直到快全部记住时
总能找出问题原因，相信方法总会比问题多
7、练 —— 重复 2-5 步三遍以上
8、创 —— 拿出一个完全没有写过的代码，根据要求一步步写出来
如果写不出来，或者中间一堆错误，请参考第 6 步
9、悟 —— 主动找到写代码的感觉和成就感，并保持下去
世界上最难的语言就这样掌握了"多么痛的领悟，它曾是你的伤痛，只是你回首学习时的每一步，都走的好艰苦！"