Python笔记精炼版

第1章 · 入门基础

Python 本质

• 脚本语言、解释型、面向对象、强类型
• 1989年荷兰人 Guido 发明，1991年发布
• 优点：简单易学、高层语言（不用管内存）、丰富库
• 缺点：强制缩进、运行速度相对较慢

语法特点

• 无分号，通过缩进（4空格） 区分代码块
• 注释：# 单行，'''/""" 多行
• 变量无声明，直接赋值

输入输出

print('hello')          # 输出
name = input('输入：')   # 输入，结果永远是字符串

标识符规则

• 数字、字母、下划线组成，不能数字开头
• 不能是关键字，区分大小写

---

第2章 · 运算符 & 数据类型

基础数据类型

可变 vs 不可变 ：用 id() 看内存地址，改后地址不变→可变，地址变了→不可变（创建了新对象）

类型	示例	可变？
tuple	(1,2,3)	❌
NoneType	None	❌
int	1	❌
float	3.14	❌
bool	True/False	❌
str	'hello'	❌
bytes	b'hello'	❌
dict	{'a':1}	✅
set	{1,2,3}	✅
list	[1,2,3]	✅

格式化字符串

# f-string（推荐）
print(f'我叫{name}，今年{age}岁')

# %占位符：%s字符串 %d整数 %f浮点 %.2f保留2位小数
print('我叫%s，今年%d岁，年薪%.2f万' % (name, age, salary))

# format
print('我叫{}，今年{}岁'.format(name, age))

运算符

• 算术 : + - * / % ** //
• 赋值 : = += -= *= /=
• 比较 : > < >= <= == !=
• 逻辑 : and or not
  • 短路：a and b（遇False停）、a or b（遇True停）
• 成员 : in / not in
• 身份 : is / is not

布尔隐式判断（假值）

0, '', None, [], (), {}, set()  →  False

---

第3章 · 分支结构

# 单分支
if 条件: ...

# 双分支
if 条件: ... else: ...

# 多分支
if 条件1: ...
elif 条件2: ...
else: ...

# 嵌套 if（一般不超过3层）
if 条件1:
    if 条件2: ...

# match-case（3.10+）
match value:
    case 模式1: ...
    case 模式2: ...
    case _: ...

---

第4章 · 循环

while vs for

• for：已知循环次数，遍历序列
• while：未知循环次数，条件控制

# while
while 条件: ...

# for-in
for i in range(5): ...          # 0~4
for i in range(1, 10, 2): ...   # 1,3,5,7,9

break     # 跳出整个循环
continue  # 跳出当前这次循环
pass      # 占位符

# for-else（没有break才执行else）
for i in range(5):
    ...
else:
    ...  # 没break时执行

双重循环

for i in range(4):           # 外层：行
    for j in range(4):       # 内层：列
        print('*', end='')
    print()                  # 换行

---

第5章 · 列表 & 随机数

列表本质

• 有序集合，元素类型可以不同，支持动态扩容
• [] 创建，下标从0开始

列表操作

lst = [1, 2, 3]
lst.append(4)        # 尾部追加
lst.extend([5,6])    # 扩展列表
lst.insert(1, 99)    # 指定位置插入
lst.pop()            # 弹出末尾
lst.pop(1)           # 弹出指定索引
lst.remove(3)        # 移除指定元素
lst.reverse()        # 翻转（原列表）
lst.sort()           # 升序（原列表）
sorted(lst)          # 排序（新列表）
lst.index(2)         # 查找元素索引
lst.count(2)         # 计数
lst.clear()          # 清空
max(lst) / min(lst)  # 最大/最小值
len(lst)             # 长度

切片 start🔚step

lst[1:5]    # 下标1~4
lst[:3]     # 前3个
lst[::2]    # 步长2
lst[::-1]   # 翻转

遍历

for i in lst:
for i in range(len(lst)):
for idx, val in enumerate(lst):

数学功能

abs(-10)  # absolute 求x的绝对值
max(23,13,7,89,34) # 求最大值
min(23,13,7,89,34) # 求最小值
pow(2,3) # 求一个数的多少次幂 
round(78.12345,3) # 返回浮点数x的四舍五入值,如果给出n值，则表示舍入到小数点后几位

math & random

import math
math.ceil(3.14)   # 4 向上取整
math.floor(3.14)  # 3 向下取整
math.sqrt(9)      # 3 开平方

import random
random.choice([1,2,3])      # 随机选一个
random.randint(1,10)        # 1~10随机整数
random.random()             # 0~1随机浮点
random.shuffle(lst)         # 随机打乱
random.randrange(1,10,2)    # 1~10步长2随机

---

第6章 · 元组 & 字典 & 集合

元组 tuple（不可变）

t = (1, 2, 3)
t = (1,)  # 单元素要加逗号
t[0]      # 访问
t.count() / t.index()

字典 dict

列表存相似数据（多个商品），字典存不同属性（一个人的多项信息）

d = {'name': '小明', 'age': 18}
d['name']           # 访问（key不存在报错）
d.get('name')       # 访问（key不存在返回None）
d.get('name', '默认值')
d.keys()            # 所有key
d.values()          # 所有value
d.items()           # 所有键值对
d.update(d2)        # 合并字典
d.pop('name')       # 删除指定key

集合 set（无序无重复）

s = {1, 2, 3}
s.add(4)            # 添加
s.update([5,6])     # 批量添加
s.remove(3)         # 删除（不存在报错）
s.discard(3)        # 删除（不存在不报错）
s1 & s2             # 交集
s1 | s2             # 并集
s1 - s2             # 差集

深浅拷贝

# 赋值：引用，改一个都变
b = a

# 浅拷贝：一维独立，二维共享
b = a.copy()          # 一维OK
b = copy.copy(a)      # 同上

# 深拷贝：完全独立
b = copy.deepcopy(a)  # 多维也OK

---

第7章 · 字符串

字符串 str

不可变类型：每次修改（replace/upper等）都创建新字符串，原字符串不变

转义字符

\n  换行
\t  制表符(Tab)
\\  反斜杠本身
\'  单引号
\"  双引号
r'' 原始字符串，转义字符失效，常用于路径/正则

常用方法

方法	作用
str.upper() / .lower()	大小写转换
str.swapcase()	大小写互换
str.title()	每个单词首字母大写
str.strip('x')	去除两边指定字符（默认空格）
str.lstrip() / .rstrip()	去除左/右边
str.split('x')	分割为列表
str.splitlines()	按行分割
'x'.join(列表)	合并为字符串
str.replace(old, new, count)	替换
str.find('x')	查找，返回索引/-1
str.rfind('x')	从右查找
str.count('x')	计数
str.startswith('x')	是否以x开头
str.endswith('x')	是否以x结尾
str.isdigit()	是否纯数字
str.isalpha()	是否纯字母/文字
str.isupper() / .islower()	是否全大写/小写
str.center(width)	居中
str.zfill(width)	右对齐0填充

编解码

s.encode('utf-8')     # 编码
b.decode('utf-8')     # 解码

ASCII

ord('a')   # 97  字符→ASCII
chr(97)    # 'a'  ASCII→字符

---

第8章 · 函数基础

定义 & 调用

def fn(a, b):    # 形参
    return a + b

fn(1, 2)         # 实参

参数类型

类型	示例	说明
位置参数	fn(1, 2)	按顺序传参
关键字参数	fn(a=1, b=2)	指定参数名
默认参数	def fn(a, b=10)	不传用默认值
不定长*args	def fn(*args)	接收多个位置参数→元组
不定长**kwargs	def fn(**kwargs)	接收多个关键字参数→字典

返回值

• return 值 --- 返回数据
• return --- 返回 None
• return a, b, c --- 返回元组
• return 下方代码不执行

匿名函数 lambda

f = lambda x, y: x + y
f(1, 2)  # 3

递归

def digui(n):
    if n == 1: return 1
    return n * digui(n - 1)

---

第9章 · 作用域 & 装饰器

变量作用域（LEGB法则：从内到外逐层查找）

L → Local          局部作用域（函数内）
E → Enclosing      闭包外函数
G → Global         全局
B → Built-in       内建

global / nonlocal

global x    # 在函数内修改全局变量
nonlocal x  # 在闭包内修改外层变量

闭包

def outer(x):
    def inner():
        return x + 1
    return inner   # 返回内部函数

装饰器 @decorator

def outer(fn):
    def inner(*args, **kwargs):
        print('前')    # 加功能
        fn(*args, **kwargs)
        print('后')    # 加功能
    return inner

@outer
def test():
    print('原函数')

test()  # → 前 → 原函数 → 后

---

第10章 · 列表推导式 & 生成器 & 迭代器 & 模块

列表推导式

[i**2 for i in range(5)]                    # [0,1,4,9,16]
[i for i in range(10) if i % 2 == 0]       # 偶数筛选
[i+j for i in 'ab' for j in '12']          # 双重循环

字典 & 集合推导式

{i: i*i for i in range(5)}                 # 字典推导式
{i for i in range(5)}                      # 集合推导式

生成器（Generator）

核心特征：惰性求值，按需生成，不占内存

生成器表达式 vs 列表推导式

lst = [i**2 for i in range(10)]    # 列表：立即生成全部，占内存
gen = (i**2 for i in range(10))    # 生成器：不生成，用的时候才产出

取值方式

g = (i**2 for i in range(5))

next(g)         # 0 → 手动取值，取完抛出 StopIteration
next(g)         # 1

for x in g:     # for 循环自动处理 StopIteration
    print(x)    # 4, 9, 16（从上一次 next 继续）

yield 生成器函数

def count_down(n):
    while n > 0:
        yield n      # 暂停，返回值，记住当前位置
        n -= 1

c = count_down(3)
next(c)  # 3
next(c)  # 2
next(c)  # 1
# next(c)  # StopIteration

# yield 与 return 的区别：
#   return → 函数结束，返回结果
#   yield  → 函数暂停，记住状态，下次继续

适用场景

处理大数据/无限序列（读取大文件、实时数据流）
内存敏感的场景：列表推导式可能撑爆内存，生成器按需产出

迭代器（Iterator）

迭代器 = 可以用 next() 一个个取值的对象

可迭代对象 = 可以用 for 遍历的对象

关系图

可迭代对象（Iterable）
  ├── list, tuple, dict, set, str
  ├── 生成器（generator）
  └── range, enumerate, zip等
         │ iter() 转换 ↓
         迭代器（Iterator）
  └── 生成器、map/filter/zip/enumerate等返回的都是迭代器

判断方式

from collections.abc import Iterable, Iterator

isinstance([], Iterable)                              # True
isinstance([], Iterator)                              # False
isinstance((i for i in range(3)), Iterator)           # True

转换：可迭代对象 → 迭代器

lst = [1, 2, 3]
it = iter(lst)          # list 本身不是迭代器，需要通过 iter() 转换
next(it)               # 1
next(it)               # 2
next(it)               # 3
# next(it)             # StopIteration

for 循环的本质

# for x in lst: ...  等价于：
it = iter(lst)
while True:
    try:
        x = next(it)
        # 循环体
    except StopIteration:
        break

总结对比

概念	Iterable（可迭代）	Iterator（迭代器）
能用 for？	✅	✅
能用 next()？	❌	✅
示例	list, dict, str, tuple	生成器
转换	---	iter(obj) 从 Iterable 得到

模块导入

import os
from random import randint
from module import name, age
import random as r

# 第三方模块安装
pip install numpy -i https://pypi.tuna.tsinghua.edu.cn/simple/

---

第11章 · 常用模块

os 模块

os.listdir()        # 列出目录
os.mkdir()          # 创建文件夹
os.makedirs()       # 创建多层
os.rmdir()          # 删除空文件夹
os.remove()         # 删除文件
os.rename()         # 重命名
os.getcwd()         # 当前路径
os.path.join()      # 拼接路径
os.path.split()     # 拆分路径
os.path.splitext()  # 拆分文件名+扩展名
os.path.isfile()    # 是否文件
os.path.isdir()     # 是否目录
os.path.exists()    # 是否存在
os.path.getsize()   # 文件大小

time / datetime

time.time()         # 时间戳
time.sleep(2)       # 延迟2秒

datetime.datetime.now()           # 当前时间
d.strftime('%Y-%m-%d %H:%M:%S')   # 日期→字符串
datetime.datetime.strptime(s, fmt) # 字符串→日期

json

json.loads(s)       # 字符串→字典
json.dumps(d)       # 字典→字符串

文件操作

# 读
f = open('a.txt', 'r', encoding='utf-8')
f.read() / f.read(n) / f.readline() / f.readlines()
f.close()

# 写
f = open('a.txt', 'w', encoding='utf-8')
f.write('hello')
f.close()

# with-as（自动关闭）
with open('a.txt', 'r') as f:
    content = f.read()

文件模式 ：r读 w写（覆盖） a追写 rb读二进制 wb写二进制

---

第12章 · 面向对象入门

面向对象思想

• 面向过程：关注步骤，亲力亲为（代码从上往下依次执行）
• 面向对象：关注对象，委托他人（找到对象，让对象干活）
• 类=模板，对象=具体实例。先定义类，再创建对象

类 & 对象

class Dog:
    name = '旺财'           # 类属性

    def __init__(self, name):  # 构造
        self.name = name       # 对象属性

    def bark(self):            # 对象方法
        print(self.name)

dog = Dog('旺财')   # 创建对象
dog.bark()

关键概念

概念	说明	类比 Java
self	当前对象引用	this
__init__	构造函数	构造器
__del__	析构函数	finalize
类属性	所有对象共享	static变量
对象属性	每个对象独有	实例变量

---

第13章 · 面向对象进阶

封装

私有属性本质是名字修饰 （__age → _Girl__age），不是真私有，是"君子协议"

class Girl:
    def __init__(self):
        self.__age = 18      # 私有属性

    @property
    def age(self):           # 获取私有属性
        return self.__age

    @age.setter
    def age(self, v):        # 设置私有属性
        self.__age = v

类方法 & 静态方法

class Demo:
    count = 0

    @classmethod
    def class_method(cls):        # cls = 类本身
        cls.count += 1
        return cls.count

    @staticmethod
    def static_method(a, b):      # 无 cls/self，独立工具函数
        return a + b

print(Demo.class_method())        # 1  → 类名调用（推荐）
print(Demo.static_method(1, 2))   # 3

方法类型	装饰器	第一个参数	能访问哪些
实例方法	无	self	全部（类属性、对象属性、其他方法）
类方法	@classmethod	cls	类属性、其他类方法、静态方法（不能访问对象属性）
静态方法	@staticmethod	无	不建议访问类中内容（独立的工具方法）

继承

super() 不是父类对象，是一个代理/导航器，沿着 MRO 链往上找父类方法，自动把当前实例传进去

class Parent:
    def __init__(self, name):
        self.name = name

    def greet(self):
        print(f'父类：{self.name}')

class Child(Parent):
    def __init__(self, name, age):
        super().__init__(name)   # 继承父类构造
        self.age = age

    def greet(self):             # 重写（override）父类方法
        super().greet()          # 调用父类被重写的方法
        print(f'子类：{self.age}岁')

多继承 & MRO

MRO （C3线性化）：把多继承的"多条链"压成一条线 → 子类→父类1→父类2→...→object

super() 不一定是跳到直接父类，而是沿着 MRO 链往后找下一个。同一个方法被不同子类调用，super() 走向不同

class Son(Mother, Father):   # MRO: Son→Mother→Father→object
    pass

### 特殊属性
```python
__dict__   # 类→类信息字典 / 对象→属性字典
__name__   # 类名（只能通过类访问）
__module__ # 类所在的模块名
__class__  # 对象所属的类

运算符重载

def __add__(self, other):   # 定义+行为
def __str__(self):          # print时调用
def __repr__(self):         # repr()时调用

---

多态

同一方法，不同实现 ------ 多态的前提：继承 + 重写

Python 是"鸭子类型"：不关心对象类型，只关心有没有这个方法

class Animal:
    def speak(self): pass

class Dog(Animal):
    def speak(self): print('汪汪汪！')

class Cat(Animal):
    def speak(self): print('喵喵喵！')

def make_sound(animal):
    animal.speak()

make_sound(Dog())  # 汪汪汪！
make_sound(Cat())  # 喵喵喵！

抽象

抽象类 （ABC）不能被实例化，抽象方法只声明不实现，子类必须重写

使用 from abc import ABC, abstractmethod

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self): pass

class Circle(Shape):
    def __init__(self, r): self.r = r
    def area(self): return 3.14 * self.r * self.r

# Shape()  # ❌ 报错
c = Circle(5)
print(c.area())  # 78.5

---

第14章 · 异常处理

异常特点：遇到异常程序会终止在那一行，后续代码不执行。异常处理就是将异常暂时屏蔽，让后续代码正常执行

try:
    # 可能出错的代码
except Exception as e:
    # 出错时执行（记录错误日志等）
else:
    # 没出错时执行
finally:
    # 无论是否出错都执行（清理操作，如关闭文件）

raise ValueError('错误信息')   # 手动抛出异常
assert a != 0                   # 断言：断定条件为真，否则报错

---

第15章 · 虚拟环境

python -m venv .venv           # 创建
source .venv/bin/activate      # 激活（mac）
deactivate                     # 退出
pip freeze > requirements.txt  # 导出依赖
pip install -r requirements.txt # 安装依赖

仓库地址

https://github.com/Abbylolo/demo-ptyhon.git