Python 基础------Python 的基本语法、数据类型、函数、类、模块
最近准备面试了，准备一些python相关的知识
熟悉 Python 的基本语法、数据类型、函数、类、模块等
1. Python 基本语法
| 语法分类 | 语法规则 | 示例代码 |
|---|---|---|
| 1. 注释 | 单行注释以 # 开头；多行注释用三引号 ''' 或 """ 包裹。 |
# 这是单行注释<br>''' 这是多行注释<br>可以跨行 ''' |
| 2. 变量赋值 | 直接赋值，无需声明类型，支持多重赋值。 | x = 10a, b = 1, "hello" |
| 3. 输入输出 | 输入用 input()，输出用 print()，支持 f-string 格式化。 |
name = input("请输入姓名：")<br>print(f"你好，{name}!") |
| 4. 代码块与缩进 | 用缩进（4个空格）表示代码块，不可混用空格与 Tab。 | if x > 0:<br> print("正数") |
| 5. 条件语句 | 使用 if-elif-else 结构，条件后需加冒号 :。 |
if score >= 90:<br> print("A")<br>else:<br> print("B") |
| 6. 循环语句 | for 循环遍历序列；while 循环条件执行。 |
for i in range(3):<br> print(i)<br>while x > 0:<br> x -=1 |
| 7. 异常处理 | 使用 try-except-finally 结构捕获异常。 |
try:<br> x = 1/0<br>except ZeroDivisionError:<br> print("除零错误") |
| 8. 函数定义 | 使用 def 关键字定义函数，参数可设置默认值。 |
def add(a, b=1):<br> return a + b |
| 9. 类与对象 | 用 class 定义类，__init__ 为构造函数，方法需包含 self 参数。 |
class Dog:<br> def __init__(self, name):<br> self.name = name |
| 10. 模块导入 | 使用 import 导入模块，或 from ... import ... 导入特定功能。 |
import math<br>from math import sqrt |
| 11. 多行语句 | 使用反斜杠 \ 或括号 () 换行。 |
total = 1 + 2 + \<br> 3 + 4 |
| 12. 运算符 | 支持算术、比较、逻辑、赋值等运算符。 | +, -, ==, and, or, += |
| 13. 字符串格式化 | 使用 f-string、format() 或 % 格式化字符串。 |
print(f"结果：{x}")<br>print("结果：{}".format(x)) |
关键语法说明
-
缩进规则：Python 依赖缩进区分代码块，同一代码块内缩进必须一致。
-
冒号
:：if、for、while、def、class等语句后必须加冒号。 -
变量命名：字母/下划线开头，区分大小写，避免关键字（如
if,class）。 -
代码简洁性：Python 强调代码可读性，遵循 PEP8 规范（如运算符两侧加空格）。
2. Python 数据类型
1. 基本数据类型
| 类型 | 描述 | 示例 | 可变性 | 内存结构 | 常用操作 |
|---|---|---|---|---|---|
整数 (int) |
表示整数值，无大小限制 | x = 10 |
不可变 | 直接存储数值 | 算术运算、比较运算 |
浮点数 (float) |
表示小数或科学计数法数值 | y = 3.14z = 2e5 |
不可变 | 直接存储数值 | 四舍五入 (round())、类型转换 |
字符串 (str) |
表示文本数据，用单/双引号包裹 | s = "Hello"s = 'Python' |
不可变 | 字符序列 | 切片、拼接、格式化、查找、替换 |
布尔值 (bool) |
表示逻辑值 True 或 False |
flag = True |
不可变 | 直接存储布尔值 | 逻辑运算 (and, or, not) |
2. 复合数据类型
| 类型 | 描述 | 示例 | 可变性 | 内存结构 | 常用操作 | |
|---|---|---|---|---|---|---|
列表 (list) |
有序、可变的元素集合，支持混合类型 | lst = [1, "a", True] |
可变 | 动态数组 | 增删 (append(), pop())、遍历、切片 |
|
元组 (tuple) |
有序、不可变的元素集合，支持混合类型 | tup = (1, 2, "b") |
不可变 | 固定数组 | 索引访问、解包 | |
集合 (set) |
无序、不重复的元素集合 | s = {1, 2, 3} |
可变 | 哈希表实现 | 并集 (` | )、交集 (&)、差集 (-`) |
字典 (dict) |
键值对集合，键必须为不可变类型 | d = {"name": "Alice", "age": 20} |
可变 | 哈希表实现 | 增删键值对、遍历 (keys(), values()) |
3. 其他数据类型
| 类型 | 描述 | 示例 | 可变性 | 内存结构 | 常用操作 |
|---|---|---|---|---|---|
空值 (NoneType) |
表示空值或缺失值 | x = None |
不可变 | 单例对象 | 判空 (if x is None:) |
字节 (bytes) |
不可变的二进制序列 | b = b"hello" |
不可变 | 字节序列 | 编码解码 (encode(), decode()) |
字节数组 (bytearray) |
可变的二进制序列 | ba = bytearray(b"hello") |
可变 | 动态字节数组 | 修改字节内容 |
冻结集合 (frozenset) |
不可变的集合 | fs = frozenset({1, 2}) |
不可变 | 哈希表实现 | 集合运算（同 set） |
数据类型转换表
| 目标类型 | 转换函数 | 示例 | 注意事项 |
|---|---|---|---|
整数 (int) |
int() |
int("123") → 123 |
字符串需为数字格式 |
浮点数 (float) |
float() |
float("3.14") → 3.14 |
支持科学计数法（如 "2e3"） |
字符串 (str) |
str() |
str(100) → "100" |
任何类型均可转为字符串 |
列表 (list) |
list() |
list("abc") → ['a', 'b', 'c'] |
可迭代对象（字符串、元组等）转换 |
元组 (tuple) |
tuple() |
tuple([1, 2, 3]) → (1, 2, 3) |
同列表转换 |
集合 (set) |
set() |
set([1, 2, 2, 3]) → {1, 2, 3} |
自动去重 |
字典 (dict) |
dict() |
dict([("a", 1), ("b", 2)]) → {'a':1, 'b':2} |
需可迭代的键值对结构 |
关键特性说明
-
可变性（Mutability）
-
不可变类型：
int,float,str,tuple,frozenset,bytes-
修改时会创建新对象，原对象不变。
-
-
可变类型：
list,dict,set,bytearray-
可直接修改内容，对象内存地址不变。
-
-
-
内存占用与性能
-
列表和字典因动态扩容，内存占用较高；元组和字符串因不可变性，内存更高效。
-
集合和字典基于哈希表，查询速度接近 O(1)。
-
-
使用场景建议
-
列表：需要频繁增删元素的有序集合。
-
元组：存储不可变数据（如配置参数）。
-
字典：键值映射关系（如 JSON 数据）。
-
集合：去重或集合运算（如交集、并集）。
-
3. Python 函数
1. 函数基础
| 类别 | 描述 | 示例代码 |
|---|---|---|
| 函数定义 | 使用 def 关键字定义函数，支持文档字符串（docstring）。 |
def greet(name):<br> """打印问候语"""<br> print(f"Hello, {name}!") |
| 调用函数 | 通过函数名和参数调用函数。 | greet("Alice") # 输出：Hello, Alice! |
| 返回值 | 使用 return 返回结果，可返回多个值（以元组形式）。 |
def add_sub(a, b):<br> return a+b, a-b<br>result = add_sub(5, 3) # → (8, 2) |
| 匿名函数 | 使用 lambda 定义单行函数。 |
square = lambda x: x ** 2print(square(3)) # → 9 |
| 空函数 | 使用 pass 占位未实现的函数体。 |
def empty_func():<br> pass |
2. 函数参数类型
| 参数类型 | 描述 | 示例代码 |
|---|---|---|
| 位置参数 | 按参数顺序传递值。 | def func(a, b):func(1, 2) |
| 默认参数 | 参数可设置默认值，调用时可省略。 | def func(a, b=2):func(1) # → a=1, b=2 |
| 可变参数 | 使用 *args 接收任意数量的位置参数（元组形式）。 |
def sum_all(*args):sum_all(1, 2, 3) # → args=(1, 2, 3) |
| 关键字参数 | 使用 **kwargs 接收任意数量的关键字参数（字典形式）。 |
def print_info(**kwargs):print_info(name="Alice", age=20) |
| 仅关键字参数 | 在 * 后的参数必须通过关键字传递。 |
def func(a, *, b):func(1, b=2) # 正确func(1, 2) # 报错 |
3. 函数作用域与闭包
| 类别 | 描述 | 示例代码 |
|---|---|---|
| 局部变量 | 函数内定义的变量，仅在函数内有效。 | def func():<br> x = 10 # 局部变量<br>func()<br>print(x) # 报错 |
| 全局变量 | 使用 global 声明函数内可修改全局变量。 |
x = 5<br>def func():<br> global x<br> x = 10<br>func() # x 变为 10 |
| 闭包 | 函数嵌套时，内部函数可捕获外部函数的变量。 | def outer():<br> n = 1<br> def inner():<br> print(n)<br> return inner<br>f = outer()<br>f() # 输出 1 |
| nonlocal | 在嵌套函数中修改外部函数的变量（非全局）。 | def outer():<br> x = 1<br> def inner():<br> nonlocal x<br> x = 2<br> inner()<br> print(x) # → 2 |
4. 函数高级特性
| 特性 | 描述 | 示例代码 |
|---|---|---|
| 递归函数 | 函数调用自身，需设置终止条件。 | def factorial(n):<br> return 1 if n == 0 else n * factorial(n-1) |
| 装饰器 | 通过 @decorator 语法增强函数功能。 |
def logger(func):<br> def wrapper(*args):<br> print("函数被调用")<br> return func(*args)<br> return wrapper<br>@logger<br>def add(a, b):<br> return a + b |
| 生成器函数 | 使用 yield 返回迭代器，可暂停和恢复执行。 |
def count_up(n):<br> i = 0<br> while i < n:<br> yield i<br> i += 1<br>for num in count_up(3):<br> print(num) # 输出 0,1,2 |
| 错误处理 | 函数内可抛出异常或捕获异常。 | def divide(a, b):<br> if b == 0:<br> raise ValueError("除数不能为零")<br> return a / b |
5. 函数工具与技巧
| 工具/技巧 | 描述 | 示例代码 |
|---|---|---|
| 函数注解 | 为参数和返回值添加类型提示（不影响运行）。 | def add(a: int, b: int) -> int:<br> return a + b |
| 偏函数 | 使用 functools.partial 固定部分参数，生成新函数。 |
from functools import partial<br>add_five = partial(add, 5)<br>add_five(3) # → 8 |
| 函数式编程 | 使用 map()、filter() 等工具处理数据。 |
nums = [1, 2, 3]<br>squared = list(map(lambda x: x**2, nums)) # → [1,4,9] |
| 内存管理 | 函数内大量数据建议使用生成器或迭代器，避免内存占用。 | def read_large_file(file):<br> with open(file) as f:<br> for line in f:<br> yield line |
关键总结
-
参数传递：Python 中参数传递为 对象引用传递，对可变对象（如列表）的修改会影响原始对象。
-
作用域规则：遵循 LEGB 规则（Local → Enclosing → Global → Built-in）。
-
装饰器本质：高阶函数（接受函数作为参数或返回函数）。
-
生成器优势：惰性求值，节省内存，适合处理大数据流。
4. Python 类
1. 类基础
| 类别 | 描述 | 示例代码 | 关键点 |
|---|---|---|---|
| 定义类 | 使用 class 关键字定义类，类名通常采用大驼峰命名法。 |
class Dog:<br> pass |
类名后加冒号 : |
| 构造函数 | 使用 __init__ 方法初始化对象属性。 |
class Dog:<br> def __init__(self, name):<br> self.name = name |
self 表示实例自身 |
| 实例变量 | 通过 self.变量名 定义，每个实例独立拥有。 |
self.age = 3 |
实例变量属于对象，而非类 |
| 实例方法 | 类中定义的普通方法，第一个参数为 self。 |
def bark(self):<br> print("汪汪！") |
必须通过实例调用 |
| 类变量 | 在类内部直接定义，所有实例共享。 | class Dog:<br> species = "Canine" |
通过类名或实例访问 |
| 类方法 | 使用 @classmethod 装饰器定义，第一个参数为 cls（类本身）。 |
@classmethod<br>def get_species(cls):<br> return cls.species |
可访问类变量，不可访问实例变量 |
| 静态方法 | 使用 @staticmethod 装饰器定义，无需 self 或 cls 参数。 |
@staticmethod<br>def info():<br> print("狗的通用信息") |
与类逻辑相关，但无需访问类/实例属性 |
2. 继承与多态
| 类别 | 描述 | 示例代码 | 关键点 |
|---|---|---|---|
| 单继承 | 子类继承父类的属性和方法。 | class Bulldog(Dog):<br> pass |
支持方法重写（Override） |
| 多继承 | 子类可继承多个父类，按顺序解析方法（MRO）。 | class A(B, C):<br> pass |
避免菱形继承问题 |
| 方法重写 | 子类可重写父类方法以实现不同行为。 | class Bulldog(Dog):<br> def bark(self):<br> print("低吼！") |
多态的核心体现 |
| super() | 调用父类方法，常用于重写构造函数。 | class Bulldog(Dog):<br> def __init__(self, name, power):<br> super().__init__(name)<br> self.power = power |
避免硬编码父类名 |
3. 封装与访问控制
| 类别 | 描述 | 示例代码 | 关键点 |
|---|---|---|---|
| 公有成员 | 默认所有成员均为公有，可直接访问。 | self.name = "旺财" |
无访问限制 |
| 受保护成员 | 约定以单下划线 _ 开头，提示外部勿直接访问（非强制）。 |
self._age = 3 |
仅约定，实际仍可访问 |
| 私有成员 | 以双下划线 __ 开头，触发名称改编（Name Mangling），禁止外部直接访问。 |
self.__secret = "密码" |
实际可通过 _类名__变量名 访问 |
| 属性装饰器 | 使用 @property 和 @属性名.setter 控制属性访问。 |
@property<br>def age(self):<br> return self._age<br>@age.setter<br>def age(self, value):<br> if value > 0:<br> self._age = value |
实现数据验证和封装 |
4. 特殊方法与运算符重载
| 类别 | 描述 | 示例代码 | 关键点 |
|---|---|---|---|
__str__ |
定义对象的字符串表示（用户友好），由 print() 调用。 |
def __str__(self):<br> return f"Dog: {self.name}" |
必须返回字符串 |
__repr__ |
定义对象的官方字符串表示（开发者友好），由 repr() 调用。 |
def __repr__(self):<br> return f"Dog('{self.name}')" |
通常可用于重建对象 |
__eq__ |
重载 == 运算符。 |
def __eq__(self, other):<br> return self.name == other.name |
可自定义相等性判断 |
__add__ |
重载 + 运算符。 |
def __add__(self, other):<br> return self.age + other.age |
支持对象间的运算 |
__call__ |
使实例可像函数一样被调用。 | def __call__(self):<br> print("对象被调用！") |
obj() 触发此方法 |
5. 高级特性与设计模式
| 类别 | 描述 | 示例代码 | 关键点 |
|---|---|---|---|
| 抽象基类 | 使用 abc 模块定义抽象类，强制子类实现特定方法。 |
from abc import ABC, abstractmethod<br>class Animal(ABC):<br> @abstractmethod<br> def sound(self):<br> pass |
无法实例化抽象类 |
| 混入类（Mixin） | 通过多继承为类添加通用功能。 | class LoggerMixin:<br> def log(self, msg):<br> print(f"LOG: {msg}")<br>class MyClass(LoggerMixin):<br> pass |
强调功能复用 |
| 单例模式 | 确保类只有一个实例。 | class Singleton:<br> _instance = None<br> def __new__(cls):<br> if not cls._instance:<br> cls._instance = super().__new__(cls)<br> return cls._instance |
重写 __new__ 方法 |
| 元类 | 通过定义 type 的子类控制类的创建行为。 |
class Meta(type):<br> def __new__(cls, name, bases, attrs):<br> # 自定义逻辑<br> return super().__new__(cls, name, bases, attrs) |
高级特性，用于框架开发 |
关键总结
-
面向对象三大特性：
-
封装：通过访问控制隐藏内部细节。
-
继承：实现代码复用和层次化设计。
-
多态：同一方法在不同类中有不同实现。
-
-
类与实例的关系：
-
类是模板，实例是具体对象。
-
类变量和实例变量作用域不同。
-
-
设计原则：
-
单一职责：一个类只负责一项任务。
-
开放封闭：对扩展开放，对修改关闭。
-
5. Python 模块
1. 模块基础
| 类别 | 描述 | 示例代码 |
|---|---|---|
| 模块定义 | 一个 .py 文件即为一个模块，用于组织代码和功能复用。 |
my_module.py 文件内容：def hello(): print("Hello from module!") |
| 模块导入 | 使用 import 导入模块，或 from ... import ... 导入特定功能。 |
import math<br>from math import sqrt |
| 模块别名 | 使用 as 为模块或函数设置别名，简化调用。 |
import numpy as np<br>from datetime import datetime as dt |
| 模块重载 | 使用 importlib.reload() 重新加载已修改的模块。 |
import importlib<br>importlib.reload(my_module) |
2. 常用模块示例
| 模块名 | 核心功能 | 示例代码 |
|---|---|---|
os |
操作系统交互（文件、目录、路径操作）。 | os.listdir() # 列出目录内容<br>os.path.join("a", "b") # 路径拼接 |
sys |
系统相关功能（命令行参数、退出程序等）。 | sys.argv # 命令行参数列表<br>sys.exit() # 退出程序 |
math |
数学运算（三角函数、对数、常数等）。 | math.pi # π值<br>math.sqrt(16) # → 4.0 |
datetime |
日期和时间处理。 | datetime.now() # 当前时间<br>date(2023, 10, 1) # 创建日期对象 |
random |
生成随机数或随机选择。 | random.randint(1, 10) # 随机整数<br>random.choice(["a", "b"]) |
json |
JSON 数据编码与解码。 | json.dumps({"name": "Alice"}) # 转为JSON字符串<br>json.loads('{"name": "Alice"}') |
3. 模块搜索路径
| 路径来源 | 描述 | 查看方式 |
|---|---|---|
| 当前目录 | Python 首先搜索执行脚本的当前目录。 | import sys; print(sys.path) |
环境变量 PYTHONPATH |
自定义模块搜索路径，优先级高于默认路径。 | 在终端设置：export PYTHONPATH=/my/path |
| 标准库目录 | Python 安装路径下的标准库目录（如 site-packages）。 |
内置模块路径 |
| 第三方库目录 | 通过 pip 安装的第三方模块存储路径。 |
pip show numpy 查看位置 |
4. 包（Package）
| 类别 | 描述 | 示例代码 |
|---|---|---|
| 包定义 | 包含 __init__.py 文件的目录（Python 3.3+ 可隐式）。 |
目录结构：my_package/├── init.py ├── module1.py └── module2.py` |
| 导入子模块 | 使用点号 . 导入包内子模块。 |
from my_package import module1<br>import my_package.module2 |
__init__.py |
包初始化文件，可为空或定义包级变量/函数。 | # __init__.py<br>__version__ = "1.0" |
| 相对导入 | 在包内使用相对路径导入其他子模块（限于包内部）。 | from . import module1 # 当前目录<br>from .. import parent_module |
5. 模块高级特性
| 类别 | 描述 | 示例代码 |
|---|---|---|
__name__ 属性 |
模块独立运行时，__name__ 为 "__main__"；被导入时为模块名。 |
if __name__ == "__main__":<br> print("直接运行") |
__file__ 属性 |
获取模块的完整文件路径。 | print(__file__) # 输出当前模块路径 |
| 模块文档 | 使用三引号编写模块级文档字符串，可通过 __doc__ 访问。 |
"""这是模块的文档说明"""<br>print(__doc__) |
| 模块发布 | 通过 setup.py 打包模块，发布到 PyPI。 |
from setuptools import setup<br>setup(name="mymodule", version="1.0") |
6. 常见问题与注意事项
| 问题 | 解决方案/说明 |
|---|---|
| 循环导入 | 避免模块 A 导入模块 B，同时模块 B 导入模块 A，重构代码结构。 |
| 模块未找到 | 检查 sys.path 是否包含模块所在目录，或设置 PYTHONPATH。 |
| 同名模块冲突 | 使用别名或调整导入顺序（优先加载自定义模块）。 |
| 缓存问题 | 修改模块后需重启解释器或使用 importlib.reload() 重新加载。 |
关键总结
-
模块化编程优势：提高代码复用性、可维护性和可读性。
-
包管理工具：使用
pip安装第三方模块，virtualenv管理虚拟环境。 -
标准库资源：Python 内置模块覆盖文件操作、网络通信、数据处理等常见需求。
浙公网安备 33010602011771号