一、下载 Python 解释器

官网下载地址：https://www.python.org/downloads/windows/

1. 安装要求

• 安装时需要勾选 Add Python to PATH，将 Python 添加到环境变量中。这样可以让系统在任何目录下都能找到 Python 解释器，便于在命令行中运行 Python 脚本。

2. 实现多版本共存

• 修改安装目录下的可执行文件名称
  • 将 python.exe 重命名为 python2.exe（示例）。这样可以避免不同版本的冲突。
• 同步修改对应目录下的 Scripts 文件夹中的 pip
  • 将 pip.exe 重命名为 pip2.exe。pip 是 Python 的包管理工具，用于安装第三方库。

二、基础篇 开始学习

1. 什么是变量

变量是编程中最基本的概念之一，它是用来存储数据的容器。在 Python 中，变量不需要像其他语言那样提前声明类型，可以直接赋值。这使得 Python 非常灵活和易学。变量的作用是让程序能够记住和操作数据，例如存储用户的输入、计算结果等。理解变量是学习编程的第一步，因为几乎所有的程序都需要使用变量来处理数据。

示例1：基本变量赋值

python
# 定义一个整数变量，用于存储年龄
age = 25
print(age)  # 输出变量的值: 25

# 定义一个字符串变量，用于存储姓名
name = "Alice"
print(name)  # 输出变量的值: Alice

示例2：变量重新赋值

python
# 变量可以重新赋值，这体现了 Python 的动态类型特性
x = 10  # 初始赋值整数
print(x)  # 输出: 10
x = "Hello"  # 重新赋值为字符串
print(x)  # 输出: Hello

2. 变量的内存管理

Python 使用引用计数（reference counting）来管理内存。当一个变量被赋值时，它实际上是指向内存中存储数据的对象。如果多个变量指向同一个对象，引用计数会增加。当引用计数为零时，对象会被垃圾回收器回收。这是一种自动内存管理方式，程序员不需要手动分配和释放内存，但需要注意循环引用等问题。

示例：

python
a = [1, 2, 3]  # 创建一个列表对象，引用计数为1
b = a  # b 指向同一个对象，引用计数增加到2
print(id(a), id(b))  # 打印内存地址，相同
# 当 a 和 b 都不再使用时，对象会被回收

3. 垃圾回收机制

Python 的垃圾回收机制包括两部分：引用计数和循环垃圾回收器。引用计数处理大多数情况，但对于循环引用（如两个对象互相引用），需要循环垃圾回收器来检测和清理。垃圾回收是自动的，但可以通过 gc 模块手动触发，以优化性能。

示例：

python
import gc  # 导入垃圾回收模块
# 强制进行垃圾回收
gc.collect()  # 这会清理不可达的对象
print("垃圾回收完成")

4. 变量的命名原则

变量命名是编程规范的重要部分。Python 遵循 PEP 8 命名约定：变量名应使用小写字母和下划线分隔单词（snake_case），不能以数字开头，只能包含字母、数字和下划线。好的命名能提高代码可读性，避免错误。

示例：

python
# 正确命名示例
user_name = "Bob"  # 使用下划线分隔
age = 30  # 简单明了

# 错误命名示例（这些会引发 SyntaxError）
# 2name = "Alice"  # 不能以数字开头
# user-name = "Bob"  # 不能使用连字符
# class = "Math"  # 不能使用关键字

5. 变量的id和type

id() 函数返回对象的唯一标识符，通常是内存地址。type() 函数返回对象的类型。这些函数帮助理解 Python 的对象模型，每个变量都是对对象的引用。

示例：

python
x = 42  # 创建一个整数对象
print(id(x))  # 输出对象的内存地址，如 140712345678912
print(type(x))  # 输出: <class 'int'>，表示整数类型

6. is与==的区别

== 是值比较运算符，检查两个对象的值是否相等。is 是身份比较运算符，检查两个变量是否指向同一个对象（内存地址相同）。在比较不可变对象时，is 可能与 == 结果相同，但对于可变对象，通常不同。

示例：

python
a = [1, 2, 3]  # 创建列表
b = [1, 2, 3]  # 创建另一个相同值的列表
print(a == b)  # True，值相等
print(a is b)  # False，不同对象

c = a  # c 指向 a 相同的对象
print(a is c)  # True，同一个对象

7. 小整数池的概念

为了优化性能，Python 对小整数（通常是 -5 到 256）使用对象池（interning），即重用相同的对象。这减少了内存使用和创建开销。对于大整数，每个赋值都会创建新对象。

示例：

python
a = 100  # 小整数，来自对象池
b = 100
print(a is b)  # True，同一个对象

x = 300  # 大整数，不池化
y = 300
print(x is y)  # False，不同对象

8. 常量一般是大写

虽然 Python 没有真正的常量（因为变量可以重新赋值），但约定使用大写字母命名常量，以表示它们不应被修改。这是一种代码规范，帮助开发者区分常量和变量。

示例：

python
PI = 3.14159  # 圆周率常量
MAX_SIZE = 100  # 最大尺寸常量
GRAVITY = 9.8  # 重力加速度常量
# 注意：这些仍然可以被重新赋值，但约定不这样做

9. 基本数据类型 数字类型 字符串类型 列表类型 字典类型 布尔值类型

Python 的基本数据类型是构建程序的基础。数字类型包括整数（int）和浮点数（float），用于数学运算。字符串（str）用于文本处理。列表（list）和字典（dict）是容器类型，用于存储多个值。布尔值（bool）用于逻辑判断。理解这些类型及其操作是编程的核心。

示例1：数字类型

python
# 整数类型，用于计数或索引
num = 10
print(type(num))  # <class 'int'>

# 浮点数类型，用于小数运算
pi = 3.14
print(type(pi))  # <class 'float'>

示例2：字符串类型

python
# 字符串是不可变的字符序列
name = "Python"
print(len(name))  # 长度: 6
print(name.upper())  # 转换为大写: PYTHON
print(name[0])  # 访问第一个字符: P

示例3：列表类型

python
# 列表是可变的有序容器
fruits = ["apple", "banana", "cherry"]
print(fruits[0])  # 访问第一个元素: apple
fruits.append("orange")  # 添加新元素
print(fruits)  # ['apple', 'banana', 'cherry', 'orange']
fruits.remove("banana")  # 删除元素
print(fruits)  # ['apple', 'cherry', 'orange']

示例4：字典类型

python
# 字典是键值对的无序容器
person = {"name": "Alice", "age": 25}
print(person["name"])  # 访问值: Alice
person["city"] = "Beijing"  # 添加新键值对
print(person)  # {'name': 'Alice', 'age': 25, 'city': 'Beijing'}
del person["age"]  # 删除键值对
print(person)  # {'name': 'Alice', 'city': 'Beijing'}

示例5：布尔值类型

python
# 布尔值只有 True 和 False，用于条件判断
is_true = True
is_false = False
print(is_true and is_false)  # False，逻辑与
print(is_true or is_false)   # True，逻辑或
print(not is_true)           # False，逻辑非

10. 直接引用间接引用 循环引用内存泄漏问题

直接引用是指变量直接指向对象。间接引用是指通过容器（如列表）指向对象。循环引用发生在两个或多个对象互相引用时，可能导致内存泄漏，因为引用计数无法降到零。Python 的循环垃圾回收器会检测并清理这些引用。

示例：

python
# 循环引用示例
a = [1, 2]  # 列表 a
b = [3, 4]  # 列表 b
a.append(b)  # a 引用 b
b.append(a)  # b 引用 a，形成循环
# 此时 a 和 b 的引用计数都为 2（自身 + 互相引用）
# 但循环垃圾回收器会检测到这个循环并回收它们

11. 标记清除机制 分代回收机制

垃圾回收使用标记-清除算法来处理循环引用：从根对象开始标记可达对象，然后清除未标记的对象。分代回收基于对象存活时间的假设，将对象分为三代，新对象在第0代，存活时间长的移到更高代，减少扫描频率，提高效率。

示例：

python
import gc
print(gc.get_stats())  # 查看各代的统计信息，如对象数量、回收次数
# 输出类似: [{'collections': 10, 'collected': 5, 'uncollectable': 0}, ...]

12. 与用户交互类型 input raw_input

input() 函数用于从用户获取输入，返回字符串。在 Python 2 中有 raw_input()，但在 Python 3 中已移除，统一使用 input()。这允许程序根据用户输入动态调整行为。

示例：

python
# 获取用户输入
name = input("Enter your name: ")  # 提示用户输入
print("Hello, " + name)  # 输出问候
# 如果用户输入 "Alice"，输出 "Hello, Alice"

13. 格式化输出 % format f

字符串格式化是将变量插入字符串的方法。% 格式化是旧方法，format() 方法更灵活，f-string（Python 3.6+）最简洁。这些方法使输出更可读和专业。

示例1：% 格式化

python
name = "Alice"
age = 25
print("My name is %s, I am %d years old." % (name, age))  # %s 字符串，%d 整数

示例2：format() 方法

python
print("My name is {}, I am {} years old.".format(name, age))  # {} 占位符
print("My name is {0}, I am {1} years old.".format(name, age))  # 索引占位符

示例3：f-string

python
print(f"My name is {name}, I am {age} years old.")  # 直接嵌入变量
print(f"Next year I will be {age + 1}.")  # 可以在 {} 中计算

14. 算数运算与比较运算

算数运算符用于数学计算：+ 加、- 减、* 乘、/ 除、// 整除、% 模、** 幂。比较运算符用于比较值：== 等于、!= 不等于、< 小于、> 大于、<= 小于等于、>= 大于等于。结果通常是布尔值。

示例：

python
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，幂运算
print(a > b)   # True，大于
print(a == b)  # False，等于

15. 可变与不可变类型

不可变类型（如 int、str、tuple）一旦创建不能修改，只能创建新对象。可变类型（如 list、dict）可以原地修改。这影响了赋值、函数参数传递等行为。理解这一点有助于避免意外的副作用。

示例：

python
# 不可变类型示例
s = "hello"
# s[0] = 'H'  # TypeError: 'str' object does not support item assignment

# 可变类型示例
lst = [1, 2, 3]
lst[0] = 10  # 允许修改
print(lst)  # [10, 2, 3]

16. 条件判断

条件判断使用 if 语句，根据条件执行不同代码块。这是控制程序流程的基础。条件通常是布尔表达式。

示例：

python
age = 18
if age >= 18:
    print("Adult")  # 如果条件为真，执行这里
else:
    print("Minor")  # 否则执行这里

17. 逻辑运行 not and or

逻辑运算符用于组合布尔值：not 取反、and 逻辑与、or 逻辑或。它们遵循短路求值原则，提高效率。

示例：

python
a = True
b = False
print(not a)     # False，取反
print(a and b)   # False，与：都真才真
print(a or b)    # True，或：有一个真就真
print(not (a and b))  # True，组合使用

18. 成员运算 in

in 运算符检查元素是否在容器中，返回布尔值。适用于列表、字符串、字典等可迭代对象。

示例：

python
lst = [1, 2, 3]
print(2 in lst)     # True，2 在列表中
print(4 in lst)     # False，4 不在列表中

s = "hello"
print('e' in s)     # True，'e' 在字符串中

19. if判断 多条件判断

使用 elif 处理多个条件，按顺序检查，直到找到真条件。else 处理所有条件都假的情况。

示例：

python
score = 85
if score >= 90:
    print("A")      # 优秀
elif score >= 80:
    print("B")      # 良好
elif score >= 70:
    print("C")      # 及格
else:
    print("D")      # 不及格

20. 浅拷贝和深拷贝

浅拷贝创建新对象，但内部元素仍是引用。深拷贝递归创建新对象，完全独立。使用 copy 模块实现。浅拷贝适合简单对象，深拷贝用于复杂嵌套结构。

示例：

python
import copy
original = [[1, 2], [3, 4]]  # 嵌套列表
shallow = copy.copy(original)  # 浅拷贝
deep = copy.deepcopy(original)  # 深拷贝

original[0][0] = 99  # 修改原对象
print("Original:", original)   # [[99, 2], [3, 4]]
print("Shallow:", shallow)     # [[99, 2], [3, 4]] 受影响
print("Deep:", deep)           # [[1, 2], [3, 4]] 不受影响

21. while 循环

while 循环在条件为真时重复执行代码块。适用于不确定循环次数的情况。需要确保条件最终变为假，否则死循环。

示例：

python
i = 0
while i < 5:  # 条件：i 小于 5
    print(i)   # 执行代码块
    i += 1     # 更新条件变量
# 输出: 0 1 2 3 4

22. 死循环的效率问题

死循环（条件永远为真）会无限运行，消耗 CPU 资源，可能导致程序冻结或系统崩溃。应避免，除非有意（如服务器监听）。

示例：

python
# 死循环示例（不要运行，否则程序无法停止）
# while True:
#     print("Infinite loop")  # 无限打印
# 要停止，按 Ctrl+C

23. 退出while循环的两种方式

方式1：使用 break 立即退出循环。方式2：让条件变为假。break 用于异常退出，条件改变用于正常结束。

示例1：break

python
i = 0
while True:  # 无限循环
    if i == 3:
        break  # 退出循环
    print(i)
    i += 1
# 输出: 0 1 2

示例2：条件改变

python
i = 0
while i < 3:  # 条件
    print(i)
    i += 1  # 最终 i=3，条件为假
# 输出: 0 1 2

24. while循环嵌套

嵌套 while 循环是内层循环在每次外层迭代中执行。适用于多维数据处理，如矩阵。

示例：

python
i = 0
while i < 3:  # 外层循环
    j = 0
    while j < 2:  # 内层循环
        print(f"i={i}, j={j}")
        j += 1
    i += 1
# 输出:
# i=0, j=0
# i=0, j=1
# i=1, j=0
# ...

25. while与continue

continue 跳过当前迭代的剩余代码，直接进入下一次循环。用于跳过某些情况。

示例：

python
i = 0
while i < 5:
    i += 1
    if i == 3:
        continue  # 跳过打印 3
    print(i)  # 打印其他数字
# 输出: 1 2 4 5

26. while与 else

else 子句在循环正常结束（非 break）时执行。用于处理循环完成后的逻辑。

示例：

python
i = 0
while i < 3:
    print(i)
    i += 1
else:
    print("Loop ended normally")  # 循环正常结束
# 输出: 0 1 2 Loop ended normally

27. for循环语法介绍和应用

for 循环遍历可迭代对象（如列表、字符串），每次取一个元素执行代码块。适用于已知序列的遍历，比 while 更简洁。

示例：

python
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:  # 遍历列表
    print(fruit)       # 打印每个水果
# 输出: apple banana cherry

28. for循环遍历字典

字典遍历可以访问键、值或键值对。使用 keys()、values()、items() 方法。

示例：

python
person = {"name": "Alice", "age": 25}
for key in person:  # 遍历键
    print(key, person[key])  # 打印键和值

for value in person.values():  # 遍历值
    print(value)

for key, value in person.items():  # 遍历键值对
    print(f"{key}: {value}")

29. range介绍

range() 生成整数序列（顾头不顾腚），用于创建循环计数器。参数：start（默认0）、stop（不包含）、step步长（默认1）。

示例：

python
# range(start, stop, step)
for i in range(5):  # 0 到 4
    print(i)  # 0 1 2 3 4

for i in range(1, 10, 2):  # 1 到 9，步长2
    print(i)  # 1 3 5 7 9

30. for+range应用介绍

结合 for 和 range 进行固定次数循环，常用于计数或索引访问。

示例：

python
for i in range(3):  # 循环3次
    print("Hello", i)  # Hello 0 Hello 1 Hello 2

31. for循环嵌套 示例打印99乘法表

嵌套 for 循环，外层控制行，内层控制列。乘法表是经典应用。

示例：

python
for i in range(1, 10):  # 外层：1 到 9
    for j in range(1, i+1):  # 内层：1 到 i
        print(f"{j}*{i}={i*j}", end=" ")  # 打印乘法式，不换行
    print()  # 内层结束，换行
# 输出 9 行乘法表

32. 数字类型参数与返回值

函数可以接受数字参数，进行运算，返回结果。参数传递是引用，但数字是不可变的。

示例：

python
def add(a, b):  # 定义函数，接受两个参数
    return a + b  # 返回和

result = add(5, 3)  # 调用函数
print(result)  # 8

33. 数字类型之进制转化 不同进制之间的转换方法

进制转换使用内置函数：bin() 转二进制、oct() 转八进制、hex() 转十六进制、int() 从其他进制转十进制。参数指定进制基数。

示例1：十进制转其他进制

python
num = 10
print(bin(num))  # '0b1010' 二进制
print(oct(num))  # '0o12' 八进制
print(hex(num))  # '0xa' 十六进制

示例2：其他进制转十进制

python
print(int('1010', 2))   # 10，二进制转十进制
print(int('12', 8))     # 10，八进制转十进制
print(int('a', 16))     # 10，十六进制转十进制
print(int('10', 10))    # 10，十进制（默认）

34. 字符串的切片操作，strip操作，split拆分

字符串切片允许提取子字符串，通过索引访问。strip() 移除首尾空白，split() 根据分隔符拆分字符串。这些操作是文本处理的基础，提高数据清理效率。

示例1：切片操作

python
s = "Hello, World!"
print(s[0:5])    # 'Hello'，从索引0到4
print(s[7:])     # 'World!'，从索引7到末尾
print(s[::-1])   # '!dlroW ,olleH'，反转字符串
print(s[::2])    # 'Hlo ol!'，每隔一个字符

示例2：strip操作

python
s = "  Hello, World!  "
print(s.strip())      # 'Hello, World!'，移除首尾空格
print(s.lstrip())     # 'Hello, World!  '，只移除左边
print(s.rstrip())     # '  Hello, World!'，只移除右边

示例3：split拆分

python
s = "apple,banana,cherry"
print(s.split(','))   # ['apple', 'banana', 'cherry']，按逗号拆分
print(s.split(',', 1)) # ['apple', 'banana,cherry']，最多拆分1次
s2 = "one two three"
print(s2.split())     # ['one', 'two', 'three']，默认按空格拆分

35. 字符串的常见其他操作

字符串有丰富的内置方法用于检查、转换和操作。包括长度检查、大小写转换、查找、替换等。这些方法使字符串处理更高效。

示例1：长度和大小写

python
s = "Hello World"
print(len(s))        # 11，字符串长度
print(s.lower())     # 'hello world'，转换为小写
print(s.upper())     # 'HELLO WORLD'，转换为大写
print(s.capitalize()) # 'Hello world'，首字母大写
print(s.title())     # 'Hello World'，每个单词首字母大写

示例2：查找和替换

python
s = "Hello World"
print(s.find('o'))      # 4，找到第一个'o'的索引
print(s.rfind('o'))     # 7，找到最后一个'o'的索引
print(s.index('o'))     # 4，类似find，但找不到会报错
print(s.replace('o', '0')) # 'Hell0 W0rld'，替换所有'o'

示例3：检查方法

python
s = "Hello123"
print(s.isalpha())      # False，是否全字母
print(s.isalnum())      # True，是否字母数字
print(s.isdigit())      # False，是否全数字
print(s.islower())      # False，是否小写
print(s.isupper())      # False，是否大写
print(s.isspace())      # False，是否全空格
print(s.istitle())      # True，是否标题格式

示例4：格式化方法

python
s = "hello"
print(s.center(10, '*')) # '**hello***'，居中填充
print(s.ljust(10, '-'))  # 'hello-----'，左对齐填充
print(s.rjust(10, '-'))  # '-----hello'，右对齐填充
print(s.swapcase())      # 'HELLO'，大小写交换

示例5：其他操作

python
s = "hello\tworld"
print(s.expandtabs(4))   # 'hello   world'，展开制表符
print(s.count('l'))      # 3，计数'l'出现次数
print(max(s))            # 'w'，最大字符
print(min(s))            # ' '，最小字符（空格）

示例6：startswith和endswith

python
s = "Hello World"
print(s.startswith('He')) # True，是否以'He'开头
print(s.endswith('ld'))   # True，是否以'ld'结尾

示例7：join方法

python
words = ['Hello', 'World']
print(' '.join(words))    # 'Hello World'，用空格连接
print('-'.join(words))    # 'Hello-World'，用连字符连接

36. 可迭代对象改列表 list()

list() 构造函数将可迭代对象转换为列表。适用于字符串、元组、range等，使数据结构更灵活。

示例1：字符串转列表

python
s = "hello"
lst = list(s)
print(lst)  # ['h', 'e', 'l', 'l', 'o']，每个字符成元素

示例2：range转列表

python
r = range(5)
lst = list(r)
print(lst)  # [0, 1, 2, 3, 4]

示例3：元组转列表

python
t = (1, 2, 3)
lst = list(t)
print(lst)  # [1, 2, 3]

37. 列表的内置方法 索引取值，追加，插入，extend, del,pop

列表是可变序列，支持索引访问和多种修改方法。索引从0开始，负索引从末尾。方法包括添加、插入、扩展、删除等。

示例1：索引取值

python
lst = [1, 2, 3, 4, 5]
print(lst[0])     # 1，第一个元素
print(lst[-1])    # 5，最后一个元素
print(lst[1:4])   # [2, 3, 4]，切片

示例2：追加和插入

python
lst = [1, 2, 3]
lst.append(4)     # 添加到末尾
print(lst)        # [1, 2, 3, 4]
lst.insert(1, 10) # 在索引1处插入10
print(lst)        # [1, 10, 2, 3, 4]

示例3：extend和删除

python
lst = [1, 2, 3]
lst.extend([4, 5]) # 扩展列表
print(lst)         # [1, 2, 3, 4, 5]
popped = lst.pop() # 删除并返回最后一个元素
print(popped)      # 5
print(lst)         # [1, 2, 3, 4]
del lst[1]         # 删除索引1的元素
print(lst)         # [1, 3, 4]

38. 队列和堆栈 队列FIFO先进先出，入队操作，出队操作，先入先出原则。堆栈：出栈先入后出

队列（Queue）遵循FIFO（先进先出），如排队。堆栈（Stack）遵循LIFO（后进先出），如栈盘。Python列表可模拟这些数据结构。

示例1：队列模拟

python
# 使用列表模拟队列
queue = []
queue.append(1)  # 入队
queue.append(2)
queue.append(3)
print(queue.pop(0))  # 出队：1，FIFO
print(queue.pop(0))  # 出队：2
print(queue)         # [3]

示例2：堆栈模拟

python
# 使用列表模拟堆栈
stack = []
stack.append(1)  # 入栈
stack.append(2)
stack.append(3)
print(stack.pop())   # 出栈：3，LIFO
print(stack.pop())   # 出栈：2
print(stack)         # [1]

39. 元组的类型和元组的内置方法

元组是不可变序列，一旦创建不能修改。适用于固定数据，如坐标。内置方法少，主要用于索引和计数。

示例1：元组创建和索引

python
t = (1, 2, 3, 2)
print(t[0])     # 1，索引访问
print(t.count(2)) # 2，计数元素出现次数
print(t.index(3)) # 2，找到元素索引

示例2：元组不可变性

python
t = (1, 2, 3)
# t[0] = 10  # TypeError: 'tuple' object does not support item assignment
print(t)  # (1, 2, 3)

40. 字典类型和字典的操作方法

字典是键值对的无序容器，键唯一，值可变。用于快速查找，如映射关系。操作包括添加、删除、更新等。

示例1：创建和访问

python
d = {'name': 'Alice', 'age': 25}
print(d['name'])     # 'Alice'，通过键访问
print(d.get('age'))  # 25，安全访问
print(d.get('city', 'Unknown'))  # 'Unknown'，默认值

示例2：添加和更新

python
d = {'name': 'Alice'}
d['age'] = 25        # 添加键值对
print(d)             # {'name': 'Alice', 'age': 25}
d.update({'city': 'Beijing'})  # 更新多个
print(d)             # {'name': 'Alice', 'age': 25, 'city': 'Beijing'}

示例3：删除和遍历

python
d = {'a': 1, 'b': 2, 'c': 3}
del d['b']           # 删除键
print(d)             # {'a': 1, 'c': 3}
print(d.pop('a'))    # 1，删除并返回值
print(d)             # {'c': 3}
print(d.keys())      # dict_keys(['c'])，所有键
print(d.values())    # dict_values([3])，所有值
print(d.items())     # dict_items([('c', 3)])，所有项