目录
课程信息与学习目标
C语言与Python核心对比
Python对象与变量机制
Python基本数据类型
四大内置容器
哈希概念
函数、模块、包、库
语法规范与命名
编程范式与示例
命令行演示完整过程
考点信号与易错点
复习自测题
总结
1. 课程信息与学习目标
学习目标
理解C语言与Python的核心差异：编译型 vs 解释型、静态类型 vs 动态类型、内存管理方式等。
掌握Python基本语法特点：冒号、缩进、动态类型、变量本质。
学会使用
import导入模块及常见导入形式。理解
__name__属性的作用及典型应用场景。掌握基本数据类型与四大容器：列表、元组、字典、集合。
了解哈希、可哈希、编码解码、小整数缓存等底层概念。
了解Python版本选择原则、代码规范及开发环境。
2. C语言与Python核心对比
2.1 C语言特点
面向过程：把问题拆解成步骤，每一步用函数实现。
以函数为核心：程序入口是
main()，所有程序从main开始执行，再调用其他函数。编译型语言：
流程：预处理
#include→ 编译 → 链接 → 可执行文件。修改源代码后必须重新编译，不能直接执行源码。
大型程序编译需要时间。
静态类型：
变量必须先声明类型，如
int a;。类型在编译期确定，之后不可改变。
int a表示：请系统分配空间，并约定这段二进制按“整数”解释。
贴近硬件：
可直接操作内存，支持指针、位运算。
适合嵌入式、单片机、驱动、数字信号处理、实时系统。
缺点：
内存要手动管理，容易指针越界、内存泄漏。
字符串处理麻烦，C中没有真正的字符串类型，只能用字符数组模拟。
大型项目开发效率低，跨平台常需重新编译。
指针很灵活，但“成也萧何，败也萧何”。有人喜欢辣椒，因为辣椒太辣；有人不喜欢辣椒，也是因为辣椒太辣。”意思是：同一个特性，既是优点也是缺点。C语言的指针和底层控制能力，正是这样的“辣椒”——它让C语言强大、高效、灵活，但也让C语言危险、繁琐、容易出错。
指针：灵活、高效、可控性强
C语言的指针可以直接操作内存，想访问哪块地址就访问哪块地址。效率非常高，贴近硬件，适合嵌入式、单片机、驱动、数字信号处理、实时系统等底层开发。程序员可以精确控制内存布局和资源，这是很多高级语言做不到的。败也指针：容易出错，管理负担重
因为太灵活，程序员必须自己管理内存：申请、使用、释放，一步都不能忘。容易出现：指针越界：指向了不该指的地方。
野指针：指针指向了已经释放或无效的内存。
内存泄漏：申请了内存，用完忘了释放，程序越跑越慢，最后只能重启电脑。
数组越界：访问数组之外的空间。
2.2 Python特点
一切皆对象：数字、字符串、列表、函数、类等都是对象。
解释执行：通常说Python是解释型；CPython实现会先编译为字节码，再解释执行。
动态类型：
变量不需要事先声明类型，赋值时自动确定。
变量可以重新绑定到不同类型的对象。
但Python仍是强类型语言：对象本身有类型，不是没有类型。
自动内存管理：无指针概念，内存自动申请与释放。
多范式：支持面向过程、面向对象、函数式编程。
丰富的库：
标准库：随Python解释器一起安装，如
math、random。第三方库：需额外安装，如
numpy。官方网址：
python.org；有大量扩展库，全球开发者贡献。被称为“胶水语言”，可融合多种语言编写的程序。
语法特点：
用冒号
:和缩进界定代码块。用
import导入模块。文件扩展名
.py。
程序可打包：把程序相关标准库、第三方包打成一个包，安装到别的电脑。
2.3 核心差异表
| 对比项 | C语言 | Python |
|---|---|---|
| 编程范式 | 面向过程，函数为核心 | 多范式，一切皆对象 |
| 执行方式 | 编译型：预处理→编译→链接 | 解释型：CPython先编译字节码再解释 |
| 类型系统 | 静态类型，先声明 | 动态类型，运行时推断 |
| 变量本质 | 一块固定类型的内存空间 | 对象的引用/标签 |
| 内存管理 | 手动申请释放，有指针 | 自动管理，无指针 |
| 代码块 | {} | 冒号+缩进 |
| 语句结束 | 分号; | 换行，通常不用分号 |
| 字符串 | 字符数组 | 内置str对象 |
| 入口 | main() | 模块顶层，常用if __name__ == '__main__' |
| 适合场景 | 嵌入式、驱动、底层 | 快速开发、数据处理、AI、脚本 |
2.4 编译型 vs 解释型
C语言编译过程：
预处理：处理
#include、#define等，把多个文件组装起来。编译：把源代码变成机器语言/目标文件。
链接：把一个一个编译后的文件链接成可执行文件。
交给机器执行。
源码修改后，必须重新编译。
Python解释执行：
Python代码不直接变成最终可执行文件再运行。
CPython中，通常先编译成字节码，再由解释器执行。
修改后一般无需手动编译，直接运行。
解释型不是绝对概念，不同实现可能不同。
2.5 静态类型 vs 动态类型
C：
int a;先声明，系统分配空间，约定按整数解释。类型不可变。Python：
a = 10直接赋值，变量是标签，类型运行时自动推断。比喻：C像孙悟空，没有唐僧的公文，别人不知道他是“师傅”还是“猴子”；Python像标签，贴到哪个对象就是哪个类型。
2.6 计算机执行程序只做两件事
总结：计算机执行程序归根结底就是：
处理数据：加减乘除、组合、拼装、逻辑运算等。
搬数据：
从外部输入设备采集数据：键盘、鼠标、手写板、视频图像等。
输出到外部设备：音箱、显示器、单片机端口、驱动信号等。
在内存中搬来搬去：如
b = a，把值从一个存储单元搬到另一个单元。
2.7 类型的本质
计算机内存底层只有二进制：
010101...。类型决定两件事：
占用多少内存空间。
这段二进制如何解释：整数？浮点数？字符？字符串？
int a：请求分配空间，并规定这段空间按整数解释。同一个二进制串，按整数解释和按浮点数解释，值完全不同。
Python中变量不直接存值，而是记录对象的地址；对象本身有类型。
3. Python对象与变量机制
3.1 一切皆对象
Python中处理的一切都叫对象。
内置对象无需
import即可使用：int、float、str、list、tuple、dict、set、bool等。对象有：
类型：
type()值：内容
身份/内存地址：
id()
3.2 变量 = 标签 / 引用 / 房间号
用“房间/总统套房/VIP贵宾室”比喻：
Python提前把
-5到256的小整数当作“常住贵宾”，安排好“总统套房”，有固定内存地址。变量名不是盒子，而是标签，记录对象的“房间号”。
x = 5：把x这个标签贴在5住的房间上，x记录5的地址。y = 5：y也指向同一个5，所以id(x) == id(y)。x = 289、y = 289：289超出小整数缓存范围，通常每次临时创建新房间，id可能不同。变量可以变类型：
x = 5后x = "abc"，只是把标签贴到另一个对象上。列表底层存的也是元素的引用/地址，所以列表可混合整数、字符串、列表等，“众生平等”。
3.3 小整数缓存
范围：
-5到256。这些整数被Python提前缓存，重复赋值时指向同一对象。
超出范围的大整数，通常每次创建新对象，但同一语句中可能优化复用，不要依赖。
示例：
x = 5 y = 5 print(id(x), id(y)) # 通常相同 a = 289 b = 289 print(id(a), id(b)) # 通常不同
3.4 常用内置函数
id(obj)：返回对象内存地址/身份。type(obj)：返回对象类型。isinstance(obj, type)：判断对象是否为某类型的实例，推荐使用。print()、input()、len()、max()、min()、sum()、abs()等内置函数无需导入。
3.5is与==的区别
is：判断两个变量是否引用同一个对象，即身份/地址相同。==：判断两个对象的值是否相等。示例：
a = [1, 2] b = [1, 2] print(a == b) # True print(a is b) # False
小整数可能
is为 True，但大整数或列表通常不是。考试常考：值相等 ≠ 同一个对象。
3.6 动态类型但强类型
动态：变量不需要声明类型，类型可随赋值改变。
强类型：对象有明确类型，操作受类型限制。
例：
"1" + 1会报错，不会自动当数字。类型决定对象“有什么本事”：列表能排序、追加；元组不能修改；字典按键查找。
4. Python基本数据类型
4.1 整数int
任意大，仅受内存限制，不会像C那样溢出。
C中两个大整数相乘可能溢出，需要用数组模拟大数运算；Python直接算。
进制表示：
0b二进制0o八进制0x十六进制
数字常量可加下划线增强可读性：
1_000_000，3.6+支持，我认为实用性一般。
4.2 浮点数float
双精度浮点数，存在精度误差。
不要直接用
==判断两个浮点数相等。应判断差值是否小于极小值，如：
abs(a - b) < 1e-6
隐式类型转换：整数与浮点数运算，结果为浮点数；范围往更复杂方向转。
4.3 复数complex
表示：
3 + 4j，j为虚部。属性：
.real实部.imag虚部方法：
.conjugate()共轭复数内置函数：
abs(3 + 4j)求模，结果为5.0。数学上复数运算与Python表达一致。
4.4 布尔类型bool
取值：
True、False。本质是
int的子类：True == 1，False == 0。关系运算、逻辑运算、成员测试、同一性运算的结果通常是布尔值。
C中常用0和非0表示真假，Python也有专门布尔常量。
4.5 字符串str
Python没有单独字符类型，单个字符也是字符串。
定界符：
单引号
'...'双引号
"..."三单引号
'''...'''三双引号
"""..."""
不同定界符可嵌套，避免转义。
原始字符串：
r'...'或R'...'，取消转义。如r'\n'长度为2，不是换行。字符串不可变，所有“修改”操作返回新字符串。
支持：
加法连接：
"Hello" + "World"常量并列连接：
"Hello" "World"格式化、查找、替换、排版、大小写转换等大量方法。
支持中文变量名，但不鼓励。
4.6 字节串bytes与编码解码
字符串 → 字节串：
str.encode(encoding='utf-8')字节串 → 字符串：
bytes.decode(encoding='utf-8')编码和解码必须使用相同字符集，否则乱码或报错。
比喻：莆田话“甘蔗”叫“架”，老太太说“我嫁给你”，小伙子听成嫁人，就是编码解码不一致。
英文ASCII在UTF-8、GBK等中通常一致。
汉字：
UTF-8通常一个汉字3字节。
GBK/GB2312通常一个汉字2字节。
示例：
s = "你好" b = s.encode("utf-8") print(b) # b'\xe4\xbd\xa0\xe5\xa5\xbd' print(b.decode("utf-8")) # 你好
4.7 空类型NoneType
类似C的
void概念，表示没有指定类型/空值。只有一个值：
None。
4.8 其他标准库数值类型
fractions.Fraction：分数运算，如Fraction(3, 5)。decimal.Decimal：高精度实数运算，适合财务等精度要求高的场景。了解即可，需要时查标准库。
5. 四大内置容器
| 容器 | 定界符 | 有序 | 可变 | 元素要求 | 访问方式 |
|---|---|---|---|---|---|
列表list | [] | 是 | 是 | 任意类型，可混合 | 下标，从0开始 |
元组tuple | () | 是 | 否 | 任意类型，可混合 | 下标 |
字典dict | {} | 无序 | 是 | 键唯一且可哈希，值任意 | 按键 |
集合set | {} | 无序 | 是 | 元素唯一且可哈希 | 不能下标，常用成员测试 |
5.1 列表list
创建：
lst = [1, "hello", [2, 3]]有序、可变、可嵌套、可混合类型。
下标从0开始，
lst[0]是第一个元素。常用操作：增删改查，如
append()、pop()、sort()。底层存引用，所以可以装不同类型。
5.2 元组tuple
创建：
tup = (1, "a", [2, 3])有序、不可变。
元组本身不能增删替换元素。
若元素是可变对象，如列表，列表内部可修改，但元组指向不变。
修改元组通常要重新创建，时间/空间成本增加。
5.3 字典dict
创建：
d = {"name": "Tom", "score": 95}键值对集合，键必须唯一且可哈希。
值可重复、任意类型。
访问：
d["name"]。键不能是列表，因为列表可变、不可哈希。
5.4 集合set
创建：
s = {1, 2, 3}或s = set([1, 2, 2])自动去重。无序、元素唯一、元素必须可哈希。
常用运算：并集
|、交集&、差集-。空集合必须用
set()；{}是空字典。
6. 哈希概念
哈希：通过哈希函数/散列函数，把任意长度数据映射为固定长度哈希值。
可哈希：对象生命周期内哈希值不变，且可与其他对象比较相等。
不可变类型通常可哈希：整数、字符串、元组。
可变类型通常不可哈希：列表、字典、集合。
作用：提高查找效率，字典和集合底层依赖哈希。
举例：
学号唯一，可哈希。
假设85个学生，100个座位，学号对100求余定位。
若冲突，即不同键映射到同一位置，需要解决策略，如开放寻址、找相邻空位、链地址法。
真正哈希算法会尽量让结果散开，减少冲突。
字典的键、集合的元素必须可哈希。
7. 函数、模块、包、库
7.1 函数
C函数：
定义包含：返回类型、函数名、参数列表、函数体。
声明是“合约/接口”，如
int add(int, int);。头文件
.h放声明，.c放实现。甲方调用，乙方实现。
Python函数：
def add(a, b): return a + b
特点：
以
def开头。不需要声明返回类型。
参数类型动态，实际能否运算取决于函数体。
return返回值。函数是模块化工具，也是接口/约定。
与AI对话也类似：说明输入、要求、期望输出格式。
7.2 模块
一个
.py文件就是一个模块。模块可包含函数、类、常量等。
模块化便于分工合作，类似C的多文件+头文件。
7.3 包/库
包一般是一个文件夹，包含多个模块。
通常有
__init__.py文件，__init__.py 本身通常是个空文件。它的存在就是为了告诉 Python：“这是个包，请按包来对待我。” 你平时写简单的代码，只要在里面建一个空文件放在那，不需要写任何代码，也就足够了。库/包可包含一个或多个模块。
标准库：随解释器安装，如
math、random。第三方库：需先安装再导入，如
numpy。
7.4 导入方式
import math print(math.sqrt(16)) from math import sqrt print(sqrt(16)) import math as m print(m.sqrt(16)) from math import sqrt as s print(s(16)) from math import * print(sqrt(16)) import numpy as np
内置函数无需导入。
标准库直接
import。第三方库先安装，再导入。
7.5__name__属性
每个模块都有
_ _name_ _。直接运行脚本时：
_ _name_ _ == '_ _main_ _'。被导入为模块时：
_ _name_ _为模块名。常见用法：
# hello.py def test(): print("this program run directly") if __name__ == '__main__': test()直接运行
python hello.py：输出this program run directly。另一个脚本
import hello：不会自动执行test()，因为__name__变成'hello'。作用：模块自测试，避免被导入时执行不必要代码。
8. 语法规范与命名
8.1 缩进与代码块
Python用冒号
:和缩进界定代码块。同一代码块缩进量必须相同，通常4个空格。
缩进错误会导致
IndentationError或逻辑错误。差一个空格都不行，老师曾因多一个空格排查很久。
循环、选择、函数、类等后面通常有冒号，下一行缩进。
8.2 注释
单行注释：
#多行注释：三引号
'''...'''或"""..."""，但必须在语句外才是注释。习惯：
#后空一格。C注释：
//单行，/* */多行。
8.3 标识符命名
可以以汉字、英文字母、下划线开头。
后接汉字、字母、数字、下划线。
不能包含空格、标点。
不能使用关键字。
大小写敏感。
不建议以下划线开头，有特殊含义；交互模式下
_表示上一次正确计算结果。不要覆盖内置模块名、类型名、函数名、已导入名。
如
id = 55后，id(3)会报错：int object is not callable。如
int = 3也可能造成混乱。
查看关键字：
import keyword print(keyword.kwlist)
8.4 版本选择
Python 2.x 已淘汰，旧遗留项目可能还用。
新代码用 Python 3.x。
标准库较稳定，尽量向后兼容。
第三方扩展库兼容性最头疼，升级可能接口变化。
项目要注意环境管理，一台电脑可装多个Python环境/虚拟环境。
选库尽量选稳定、常用的。
8.5 开发环境与打包
IDLE：Python自带。
PyCharm
打包工具：把程序相关标准库、第三方包打成一个包，安装到别的电脑。
官方下载：
python.org。
9. 编程范式与示例
9.1 命令式 vs 函数式
需求：列表所有数字加5，得到新列表。
命令式：
nums = list(range(10)) new = [] for n in nums: new.append(n + 5)
函数式：
def add5(x): return x + 5 new = list(map(add5, nums))
Python支持
lambda匿名函数。面向对象：列表自身有
append()等方法，数据与操作封装在一起。C中数据与操作常分离。
9.2 交换变量
a, b = 2, 3 a, b = b, a
Python可直接交换。
底层仍需要临时空间，但由Python内部完成。
C中通常需要第三方变量。
10. 考点信号与易错点
10.1 反复强调的考点信号
Python官方网址：
python.org，顶级域名.org。缩进：差一个空格都不行，冒号后必须缩进。
_ _name_ _：直接运行是'_ _main_ _'，被导入是模块名。is与==：面试和考试常考。小整数缓存：
-5到256。空集合：必须用
set()，{}是空字典。字典键不能是列表：因为列表可变、不可哈希。
浮点数不要直接
==。不要覆盖内置函数名：如
id = 55会导致id(3)报错。编码解码必须一致。
文件扩展名
.py。第三方库先安装再导入。
11.2 易错点
误以为Python没有类型：对象有类型，变量只是引用。
缩进不一致导致
IndentationError。混淆C编译型与Python解释型。
C需手动释放内存，Python自动管理。
字符串在C中是字符数组，Python中是对象。
空集合用
set()，不是{}。浮点数不要直接
==。不要覆盖内置函数名。
字典键不能是列表。
r'\n'长度是2。__name__不要写成name，是双下划线。
11. 复习自测题
Python和C在类型系统上的主要区别？
C静态类型，先声明，类型不可变；Python动态类型，运行时推断，变量可引用不同类型对象。为什么Python缩进非常重要？
Python用缩进界定代码块，同一代码块缩进必须相同，冒号后必须缩进。__name__的作用？
直接运行时为'__main__'，被导入时为模块名。常用if __name__ == '__main__':做模块自测。如何导入
math中的sqrt并起别名s？from math import sqrt as sPython官方网址顶级域名？
.org，即python.org。x = 256, y = 256，x is y结果？x = 257呢？
256在小整数缓存内，通常True；257超出，通常False。如何创建空集合？
s = set()；{}是空字典。为什么字典的键不能是列表？
列表可变、不可哈希，字典依赖键的哈希值定位。a = [1,2,3]; b = a; c = a.copy(); print(a is b, a == c)输出？True False。r'\n'长度？
2。is和==区别？is判断同一对象，==判断值相等。编码解码不一致会怎样？
乱码或报错，必须使用相同字符集。列表、元组、字典、集合最大区别？
列表有序可变；元组有序不可变；字典键值对，键可哈希唯一；集合无序唯一，元素可哈希。Python中小整数缓存范围？
-5到256。为什么不要用
id、int、list当变量名？
会覆盖内置函数/类型，导致命名空间冲突和报错。
12. 总结
这两节课的核心是：从C语言过渡到Python，建立“一切皆对象、变量是引用、类型动态但强类型、代码块靠缩进、容器靠哈希、模块靠导入”的认知框架。
C语言：静态、编译、手动、贴近硬件、以函数为核心。
Python：动态、解释、自动、一切皆对象、以对象和模块为核心。
变量不是盒子，是标签，记录对象地址。
类型决定内存解释方式和对象能力。
四大容器：列表、元组、字典、集合，各有用途。
哈希让字典和集合查找高效。
函数、模块、包让程序可复用、可分工。
缩进、命名、编码解码是常见易错点。
小测重点：
python.org、缩进、__name__、is与==、小整数缓存、空集合、字典键可哈希。
