Python笔记 on 知识仓库

概述与安装

Mon, 01 Jan 0001 00:00:00 +0000

Python 概述与安装#

什么是 Python？#

Python 是一种高级、解释型的编程语言，由 Guido van Rossum 在 1991 年首次发布。Python 的设计哲学强调代码的可读性和简洁的语法，特别是使用空格缩进来表示代码块。

核心特点#

简洁易读：Python 的语法清晰，代码可读性强，适合快速开发
功能强大：拥有丰富的标准库和庞大的第三方库生态系统
跨平台：可在 Windows、Linux、macOS 等多种操作系统上运行
面向对象：完全支持面向对象编程，也支持函数式编程
动态类型：无需声明变量类型，解释器会自动推断
解释型语言：代码直接运行，无需编译步骤
开源免费：Python 是开源的，可以自由使用和分发

Python 的应用领域#

Web 开发：Django、Flask 等框架
数据科学：NumPy、Pandas、Matplotlib 等库
机器学习：TensorFlow、PyTorch、Scikit-learn 等
自动化脚本：系统管理、文件处理等
游戏开发：Pygame 等库
网络编程：爬虫、API 开发等

Python 版本#

Python 2 vs Python 3#

Python 2 已于 2020 年 1 月 1 日停止维护，现在应该使用 Python 3。

主要区别：

Python 3 的 print 是函数，需要括号：print("Hello")
Python 3 的字符串默认是 Unicode
Python 3 的整数除法返回浮点数（使用 // 进行整数除法）
Python 3 改进了异常处理语法

本指南基于 Python 3.x 版本。

语法 Token

Mon, 01 Jan 0001 00:00:00 +0000

关键字#

Python 3 共有 35 个关键字：

逻辑值：True False None
逻辑运算：and or not
条件控制：if elif else
循环控制：for while break continue
异常处理：try except（捕获异常） finally（总是执行） raise（抛出异常）
函数定义：def lambda（匿名函数） return yield（生成器）
异步编程：async（异步函数） await（等待异步操作）
类与对象：class del（删除对象）
模块导入：import from as
作用域：global nonlocal（非局部变量，用于嵌套函
数）
上下文管理：with（上下文管理器）
成员检查：in is（身份检查）
其他：assert（断言） pass（空语句，占位符）

不常见关键字示例#

# 异常处理
try:
 result = 1 / 0
except ZeroDivisionError:
 print("除零错误")
else:
 pass
finally: # finally 必须放在 try-except语句的最后
 print("总是执行")

# raise - 抛出异常
x = -1
if x < 0:
 raise ValueError("x不能为负数")

# lambda - 匿名函数
add = lambda x, y: x + y
print(add(2, 3)) # 输出: 5

# yield - 生成器
def count():
 for i in range(3):
 yield i
gen = count()
print(next(gen)) # 输出: 0

# async/await - 异步编程
import asyncio
async def fetch_data():
 await asyncio.sleep(1)
 return "data"

# del - 删除对象
x = [1, 2, 3]
del x[0] # 删除索引0的元素，python有完善的垃圾回收机制

# python变量定义与赋值捆绑，需特别声明作用域才可对应修改外部变量
# global - 全局变量
x = 0
def func():
 global x 
 x = 10

# nonlocal - 非局部变量
def outer():
 x = 1
 def inner():
 nonlocal x
 x = 2

# with - 上下文管理
# 是用于上下文管理的语句，确保资源被正确获取和释放，无论是否发生异常
with open('file.txt', 'r') as f:
 content = f.read()

# is - 身份检查
# 是对象标识比较运算符，用于判断两个变量是否引用同一个对象
a = [1, 2]
b = [1, 2]
print(a is b) # False (不同对象)
print(a == b) # True (值相同)

# assert - 断言
# 是用于断言的关键字，用于在代码中插入调试断言
# 如果断言条件为假，程序会抛出 AssertionError异常
x = 5
assert x > 0, "x必须大于0"

# pass - 空语句
def empty_func():
 pass

基础语法

Mon, 01 Jan 0001 00:00:00 +0000

基础语法#

行与缩进#

Python 最具特色的就是使用缩进来表示代码块，不需要使用大括号 {}，缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数。

# 正确的缩进
if True:
 print("这是if语句块")
 print("同一代码块，缩进相同")

# 错误的缩进会导致 IndentationError
if True:
print("错误：没有缩进") # 这会报错

缩进规则：

数据类型

Mon, 01 Jan 0001 00:00:00 +0000

数据类型#

Python 中的数据类型可以分为两大类：基本数据类型和容器类型。理解这些数据类型是掌握 Python 的基础。

数字类型#

整数（int）#

整数可以是正数、负数或零，没有大小限制（Python 3）。

# 整数
x = 10
y = -5
z = 0

# 大整数
big_number = 123456789012345678901234567890

# 不同进制的整数
binary = 0b1010 # 二进制，结果是 10
octal = 0o12 # 八进制，结果是 10
hexadecimal = 0xA # 十六进制，结果是 10

浮点数（float）#

浮点数表示带小数点的数字。

运算符和表达式

Mon, 01 Jan 0001 00:00:00 +0000

运算符和表达式#

运算符用于对值进行各种操作。Python 提供了丰富的运算符，包括算术、比较、逻辑、赋值等。

算术运算符#

算术运算符用于执行基本的数学运算。

# 加法
result = 10 + 5 # 15

# 减法
result = 10 - 5 # 5

# 乘法
result = 10 * 5 # 50

# 除法（返回浮点数）
result = 10 / 3 # 3.3333333333333335

# 整数除法（向下取整）
result = 10 // 3 # 3

# 取余（模运算）
result = 10 % 3 # 1

# 幂运算
result = 2 ** 3 # 8（2的3次方）
result = 2 ** 0.5 # 1.4142135623730951（平方根）

# 字符串和列表的运算
"Hello" + " " + "World" # 'Hello World'
[1, 2] + [3, 4] # [1, 2, 3, 4]
"Hi" * 3 # 'HiHiHi'
[1, 2] * 3 # [1, 2, 1, 2, 1, 2]

比较运算符#

比较运算符用于比较两个值，返回布尔值（True 或 False）。

控制流

Mon, 01 Jan 0001 00:00:00 +0000

控制流#

控制流语句用于控制程序的执行顺序，包括条件语句和循环语句。掌握控制流是编程的基础。

条件语句#

if 语句#

if 语句用于根据条件执行不同的代码块。

# 基本语法
if condition:
 # 如果条件为True，执行这里的代码
 statement

# 示例
age = 20
if age >= 18:
 print("已成年")

if-else 语句#

# 基本语法
if condition:
 # 如果条件为True，执行这里
 statement1
else:
 # 如果条件为False，执行这里
 statement2

# 示例
age = 15
if age >= 18:
 print("已成年")
else:
 print("未成年")

if-elif-else 语句#

# 基本语法
if condition1:
 statement1
elif condition2:
 statement2
elif condition3:
 statement3
else:
 statement4

# 示例：成绩等级
score = 85
if score >= 90:
 print("优秀")
elif score >= 80:
 print("良好")
elif score >= 60:
 print("及格")
else:
 print("不及格")

嵌套条件语句#

age = 25
has_license = True

if age >= 18:
 if has_license:
 print("可以开车")
 else:
 print("需要先考驾照")
else:
 print("未成年，不能开车")

条件表达式的简化#

# 使用逻辑运算符简化
age = 25
has_license = True

if age >= 18 and has_license:
 print("可以开车")

# 使用链式比较
x = 10
if 0 < x < 20:
 print("x在0和20之间")

循环语句#

for 循环#

for 循环用于遍历序列（如列表、字符串、元组等）。

函数

Mon, 01 Jan 0001 00:00:00 +0000

函数#

函数是组织代码的重要方式，可以将代码封装成可重用的块。Python 提供了强大的函数功能，包括参数传递、作用域、装饰器等。

函数定义和调用#

定义函数#

# 基本语法
def function_name(parameters):
 """文档字符串（可选）"""
 # 函数体
 return value # 可选

# 示例
def greet(name):
 """打印问候语"""
 print(f"Hello, {name}!")

# 调用函数
greet("Python") # 输出: Hello, Python!

函数文档字符串#

def add(a, b):
 """
 计算两个数的和
 
 参数:
 a: 第一个数
 b: 第二个数
 
 返回:
 两个数的和
 """
 return a + b

# 访问文档字符串
print(add.__doc__)
help(add)

返回值#

# 返回单个值
def square(x):
 return x ** 2

result = square(5) # 25

# 返回多个值（实际上是返回元组）
def get_name_age():
 return "Alice", 30

name, age = get_name_age() # 元组解包
result = get_name_age() # ('Alice', 30)

# 没有return语句，返回None
def do_nothing():
 pass

result = do_nothing() # None

参数传递#

位置参数#

位置参数按照定义顺序传递。

面向对象编程

Mon, 01 Jan 0001 00:00:00 +0000

面向对象编程#

面向对象编程（OOP）是一种编程范式，使用类和对象来组织代码。Python 完全支持面向对象编程。

类和对象基础#

定义类#

# 基本语法
class ClassName:
 """类的文档字符串"""
 # 类体

# 示例
class Dog:
 """狗类"""
 pass

# 创建对象（实例化）
my_dog = Dog()
print(type(my_dog)) # <class '__main__.Dog'>

实例属性#

class Dog:
 def __init__(self, name, age):
 """初始化方法"""
 self.name = name # 实例属性
 self.age = age

# 创建对象
my_dog = Dog("旺财", 3)
print(my_dog.name) # 旺财
print(my_dog.age) # 3

# 动态添加属性
my_dog.color = "棕色"
print(my_dog.color) # 棕色

实例方法#

class Dog:
 def __init__(self, name, age):
 self.name = name
 self.age = age
 
 def bark(self):
 """实例方法"""
 print(f"{self.name}在叫：汪汪！")
 
 def get_info(self):
 return f"{self.name}今年{self.age}岁"

my_dog = Dog("旺财", 3)
my_dog.bark() # 旺财在叫：汪汪！
print(my_dog.get_info()) # 旺财今年3岁

类属性和实例属性#

类属性#

类属性属于类本身，所有实例共享。

异常处理

Mon, 01 Jan 0001 00:00:00 +0000

异常处理#

异常处理是 Python 中处理错误和异常情况的机制。良好的异常处理可以使程序更加健壮。

什么是异常？#

异常是程序运行时发生的错误。当 Python 遇到错误时，会抛出（raise）一个异常。

# 常见的异常
1 / 0 # ZeroDivisionError: division by zero
int("abc") # ValueError: invalid literal for int()
x[10] # IndexError: list index out of range
d["key"] # KeyError: 'key'（如果key不存在）

try-except 语句#

基本语法#

try:
 # 可能出错的代码
 result = 10 / 0
except ZeroDivisionError:
 # 处理异常
 print("除零错误！")

# 程序继续执行
print("程序继续运行")

捕获多个异常#

try:
 x = int(input("输入一个数字: "))
 result = 10 / x
except ValueError:
 print("输入的不是数字！")
except ZeroDivisionError:
 print("不能除以零！")

# 捕获多个异常类型
try:
 # 代码
 pass
except (ValueError, TypeError):
 print("值错误或类型错误")

# 捕获所有异常（不推荐，除非必要）
try:
 # 代码
 pass
except Exception as e:
 print(f"发生错误: {e}")

获取异常信息#

try:
 result = 10 / 0
except ZeroDivisionError as e:
 print(f"错误类型: {type(e).__name__}")
 print(f"错误信息: {e}")
 print(f"错误详情: {e.args}")

try-except-else 语句#

else 子句在没有异常时执行。

模块和包

Mon, 01 Jan 0001 00:00:00 +0000

模块和包#

模块和包是 Python 中组织代码的方式。模块是包含 Python 代码的文件，包是包含多个模块的目录。

模块（Module）#

什么是模块？#

模块是一个包含 Python 代码的文件，通常以 .py 为扩展名。

# 文件：math_utils.py
def add(a, b):
 return a + b

def multiply(a, b):
 return a * b

PI = 3.14159

导入模块#

# 导入整个模块
import math_utils
result = math_utils.add(2, 3)

# 导入并重命名
import math_utils as mu
result = mu.add(2, 3)

# 从模块导入特定函数
from math_utils import add, multiply
result = add(2, 3)

# 导入所有（不推荐）
from math_utils import *
result = add(2, 3)

模块搜索路径#

Python 按以下顺序搜索模块：

文件操作

Mon, 01 Jan 0001 00:00:00 +0000

文件操作#

文件操作是编程中的常见任务。Python 提供了简单而强大的文件操作功能。

打开和关闭文件#

open() 函数#

# 基本语法：open(file, mode='r', encoding=None)
file = open("data.txt", "r")
content = file.read()
file.close() # 必须关闭文件

文件模式#

# 'r' - 只读模式（默认）
file = open("data.txt", "r")

# 'w' - 写入模式（覆盖）
file = open("data.txt", "w")

# 'a' - 追加模式
file = open("data.txt", "a")

# 'x' - 创建模式（文件不存在时创建）
file = open("new_file.txt", "x")

# 'b' - 二进制模式
file = open("image.jpg", "rb")

# 't' - 文本模式（默认）
file = open("data.txt", "rt")

# '+' - 读写模式
file = open("data.txt", "r+") # 读写
file = open("data.txt", "w+") # 读写（覆盖）

with 语句（推荐）#

使用 with 语句可以自动关闭文件，即使发生异常也会关闭。

高级特性

Mon, 01 Jan 0001 00:00:00 +0000

高级特性#

Python 提供了许多高级特性，如生成器、迭代器、推导式等，这些特性可以让代码更简洁、高效。

迭代器和可迭代对象#

可迭代对象与迭代器的关系#

类型	实现方法	特点
可迭代对象	`__iter__()`	可用 `for` 遍历，可多次迭代
迭代器	`__iter__()` + `__next__()`	可迭代对象的子集，一次性消耗，用完即止

迭代器一定是可迭代对象；可迭代对象不一定是迭代器（如 list 可多次迭代）。

可迭代对象（Iterable）#

可迭代对象是可以返回迭代器的对象，实现了 __iter__() 方法。

# 常见的可迭代对象
my_list = [1, 2, 3] # 列表
my_string = "hello" # 字符串
my_dict = {"a": 1} # 字典
my_set = {1, 2, 3} # 集合
my_tuple = (1, 2, 3) # 元组

# 检查是否为可迭代对象
from collections.abc import Iterable
print(isinstance(my_list, Iterable)) # True

# 使用iter()获取迭代器
iterator = iter(my_list)

迭代器（Iterator）#

迭代器是实现了 __iter__() 和 __next__() 方法的对象。

常用内置函数

Mon, 01 Jan 0001 00:00:00 +0000

常用内置函数#

Python 提供了丰富的内置函数，无需导入即可使用。掌握这些函数可以大大提高编程效率。

类型相关函数#

type() 和 isinstance()#

# type() - 获取对象类型
print(type(10)) # <class 'int'>
print(type("hello")) # <class 'str'>
print(type([1, 2])) # <class 'list'>

# isinstance() - 检查对象类型（推荐）
print(isinstance(10, int)) # True
print(isinstance("hello", str)) # True
print(isinstance([1, 2], (list, tuple))) # True（检查多个类型）

len()#

# 获取序列长度
print(len("hello")) # 5
print(len([1, 2, 3])) # 3
print(len({"a": 1})) # 1
print(len((1, 2, 3))) # 3

str(), int(), float(), bool()#

# 类型转换
str(123) # '123'
int("123") # 123
int(3.7) # 3（向下取整）
float("3.14") # 3.14
bool(1) # True
bool(0) # False
bool("") # False
bool("abc") # True

list(), tuple(), dict(), set()#

# 创建容器
list("abc") # ['a', 'b', 'c']
tuple([1, 2, 3]) # (1, 2, 3)
dict([("a", 1), ("b", 2)]) # {'a': 1, 'b': 2}
set([1, 2, 2, 3]) # {1, 2, 3}

数学函数#

abs()#

# 绝对值
abs(-5) # 5
abs(5) # 5
abs(-3.14) # 3.14

round()#

# 四舍五入
round(3.14159) # 3
round(3.14159, 2) # 3.14（保留2位小数）
round(3.5) # 4
round(2.5) # 2（注意：Python的round使用"银行家舍入"）

min() 和 max()#

# 最小值
min(1, 2, 3) # 1
min([1, 2, 3]) # 1
min("abc", "def", key=len) # 'abc'（使用key函数）

# 最大值
max(1, 2, 3) # 3
max([1, 2, 3]) # 3
max("hello", "hi", key=len) # 'hello'

sum()#

# 求和
sum([1, 2, 3, 4]) # 10
sum([1, 2, 3], 10) # 16（从10开始累加）
sum(range(5)) # 10（0+1+2+3+4）

pow()#

# 幂运算
pow(2, 3) # 8（2的3次方）
pow(2, 3, 5) # 3（2的3次方对5取模）
2 ** 3 # 8（等价写法）

divmod()#

# 返回商和余数
divmod(10, 3) # (3, 1)（10除以3，商3余1）
quotient, remainder = divmod(10, 3)

序列操作函数#

sorted()#

# 排序（返回新列表）
numbers = [3, 1, 4, 1, 5]
sorted(numbers) # [1, 1, 3, 4, 5]
sorted(numbers, reverse=True) # [5, 4, 3, 1, 1]

# 使用key函数
words = ["apple", "banana", "cherry"]
sorted(words, key=len) # ['apple', 'banana', 'cherry']（按长度）
sorted(words, key=str.lower) # 按小写字母排序

# 对字典排序
d = {"b": 2, "a": 1, "c": 3}
sorted(d.items(), key=lambda x: x[1]) # [('a', 1), ('b', 2), ('c', 3)]

reversed()#

# 反转序列（返回迭代器）
list(reversed([1, 2, 3])) # [3, 2, 1]
list(reversed("hello")) # ['o', 'l', 'l', 'e', 'h']

# 字符串反转
"hello"[::-1] # 'olleh'（切片方式）

enumerate()#

# 同时获取索引和值
fruits = ["apple", "banana", "cherry"]
for index, fruit in enumerate(fruits):
 print(f"{index}: {fruit}")
# 输出:
# 0: apple
# 1: banana
# 2: cherry

# 指定起始索引
for index, fruit in enumerate(fruits, start=1):
 print(f"{index}: {fruit}")

zip()#

# 同时遍历多个序列
names = ["Alice", "Bob", "Charlie"]
ages = [25, 30, 35]
for name, age in zip(names, ages):
 print(f"{name} is {age} years old")

# 转换为列表
list(zip(names, ages)) # [('Alice', 25), ('Bob', 30), ('Charlie', 35)]

# 解包
names2, ages2 = zip(*zip(names, ages))

range()#

# 生成数字序列
list(range(5)) # [0, 1, 2, 3, 4]
list(range(2, 5)) # [2, 3, 4]
list(range(0, 10, 2)) # [0, 2, 4, 6, 8]
list(range(5, 0, -1)) # [5, 4, 3, 2, 1]

输入输出函数#

print()#

# 基本用法
print("Hello, World!")

# 多个参数
print("Hello", "World", "!") # Hello World !

# 指定分隔符
print("Hello", "World", sep="-") # Hello-World

# 指定结束符
print("Hello", end="")
print("World") # HelloWorld（不换行）

# 格式化输出
name = "Alice"
age = 30
print(f"{name} is {age} years old") # Alice is 30 years old

input()#

# 获取用户输入
name = input("请输入你的名字: ")
print(f"你好, {name}!")

# 注意：input()返回字符串
age = input("请输入年龄: ")
age = int(age) # 需要转换类型

对象操作函数#

id()#

# 获取对象的内存地址
x = [1, 2, 3]
print(id(x)) # 某个内存地址

hash()#

# 获取对象的哈希值
hash("hello") # 某个整数
hash((1, 2, 3)) # 某个整数
# hash([1, 2, 3]) # 错误！列表不可哈希

dir()#

# 获取对象的属性和方法列表
dir([]) # 列表的所有方法
dir(str) # 字符串的所有方法
dir(__builtins__) # 所有内置函数和异常

vars() 和 dict#

# 获取对象的属性字典
class MyClass:
 def __init__(self):
 self.x = 1
 self.y = 2

obj = MyClass()
print(vars(obj)) # {'x': 1, 'y': 2}
print(obj.__dict__) # {'x': 1, 'y': 2}

hasattr(), getattr(), setattr()#

class MyClass:
 def __init__(self):
 self.x = 1

obj = MyClass()

# hasattr() - 检查是否有属性
print(hasattr(obj, "x")) # True
print(hasattr(obj, "y")) # False

# getattr() - 获取属性
print(getattr(obj, "x")) # 1
print(getattr(obj, "y", 0)) # 0（默认值）

# setattr() - 设置属性
setattr(obj, "y", 2)
print(obj.y) # 2

函数式编程工具#

map()#

# 对序列的每个元素应用函数
numbers = [1, 2, 3, 4]
squared = list(map(lambda x: x**2, numbers)) # [1, 4, 9, 16]

# 多个序列
list(map(lambda x, y: x + y, [1, 2], [3, 4])) # [4, 6]

filter()#

# 过滤序列
numbers = [1, 2, 3, 4, 5]
evens = list(filter(lambda x: x % 2 == 0, numbers)) # [2, 4]

# 过滤None值
values = [1, None, 2, None, 3]
filtered = list(filter(None, values)) # [1, 2, 3]

reduce()#

# 累积计算（需要导入）
from functools import reduce

numbers = [1, 2, 3, 4]
product = reduce(lambda x, y: x * y, numbers) # 24

# 带初始值
sum_with_init = reduce(lambda x, y: x + y, numbers, 10) # 20

其他常用函数#

any() 和 all()#

# any() - 至少一个为True
any([False, False, True]) # True
any([False, False, False]) # False

# all() - 全部为True
all([True, True, True]) # True
all([True, False, True]) # False

slice()#

# 创建切片对象
my_list = [0, 1, 2, 3, 4, 5]
s = slice(1, 4)
print(my_list[s]) # [1, 2, 3]

iter() 和 next()#

# iter() - 获取迭代器
my_list = [1, 2, 3]
iterator = iter(my_list)
print(next(iterator)) # 1
print(next(iterator)) # 2

# next() - 获取下一个值
print(next(iterator, "默认值")) # 3
print(next(iterator, "默认值")) # 默认值（迭代器耗尽）

open()#

# 打开文件
with open("file.txt", "r") as f:
 content = f.read()

eval() 和 exec()#

# eval() - 执行表达式（危险！）
result = eval("2 + 3") # 5

# exec() - 执行代码（危险！）
exec("x = 10")
print(x) # 10

# 注意：eval()和exec()存在安全风险，应谨慎使用

函数分类总结#

类型检查和转换#

type(), isinstance(), str(), int(), float(), bool(), list(), tuple(), dict(), set()

数学运算#

abs(), round(), min(), max(), sum(), pow(), divmod()

序列操作#

len(), sorted(), reversed(), enumerate(), zip(), range()

输入输出#

print(), input()

对象操作#

id(), hash(), dir(), vars(), hasattr(), getattr(), setattr()

函数式编程#

map(), filter(), reduce()（需要导入functools）

逻辑判断#

any(), all()

使用建议#

优先使用内置函数，它们通常比自定义实现更快
理解函数的返回值类型（列表、迭代器等）
注意内存效率（生成器 vs 列表）
合理使用lambda和函数式编程工具
避免使用eval()和exec()，除非绝对必要

下一步#

恭喜！你已经掌握了 Python 的核心内容。可以继续学习：

PEP 8 规范附录

Mon, 01 Jan 0001 00:00:00 +0000

PEP 8 代码风格指南附录#

PEP 8 是 Python 官方的代码风格指南，旨在提高代码可读性和一致性。详见 pep8.org。

代码布局#

缩进#

使用 4 个空格 缩进，不使用 Tab
续行缩进：与括号内首行对齐，或额外缩进 4 空格

# 续行与括号对齐
def long_function_name(var_one, var_two,
 var_three, var_four):
 return var_one

# 悬挂缩进（续行额外缩进）
result = some_function_that_takes_arguments(
 'arg1', 'arg2', 'arg3',
 'arg4', 'arg5'
)

行宽#

每行最多 79 字符
文档字符串/注释建议 72 字符 内换行

空行#

顶级定义之间：2 个空行
类内方法之间：1 个空行
函数内逻辑块之间：可加空行提高可读性

# 两个空行分隔顶级定义
import os


def function_one():
 pass


def function_two():
 pass


class MyClass:
 """类文档"""

 def method_one(self):
 pass

 def method_two(self):
 pass

导入#

导入放在文件顶部，在模块注释和文档字符串之后
顺序：标准库 → 相关第三方 → 本地应用
每组之间空一行
使用绝对导入，避免 from ... import *

"""模块文档字符串"""

import os
import sys

import numpy as np
import pandas as pd

from mypackage.utils import helper

命名规范#

类型	规范	示例
模块	短小全小写，下划线可选	`my_module`, `mymodule`
类	驼峰命名 PascalCase	`MyClass`
函数/变量	小写下划线 snake_case	`my_function`, `my_var`
常量	全大写下划线	`MAX_SIZE`, `DEFAULT_TIMEOUT`
私有	单下划线前缀	`_internal_var`
名称修饰	双下划线前后缀	`__name__`（魔术方法）

避免使用的名称#

单字符：l、O、I（易与数字混淆）
可接受：i、j、k（循环变量），e（异常）

表达式与语句#

空格#

# 二元运算符两侧各一个空格
x = 1
result = a + b

# 逗号后一个空格
spam(ham[1], {eggs: 2})
foo = (0,)

# 函数默认参数 = 两侧不加空格
def func(a=0, b=None):
 pass

# 切片冒号两侧空格可选，保持一致
ham[1:9], ham[1:9:3]

比较#

# 与 None 比较用 is / is not
if x is None:
 pass
if x is not None:
 pass

# 布尔值用 is True / is False（慎用），通常直接 if x:

字符串引号#

单引号 ' 与双引号 " 等效，项目内保持一致
三引号文档字符串用 """

注释#

块注释#

与代码同级缩进
每行以 # 加一个空格开头

# 这是一个块注释
# 说明下面的逻辑
x = process(data)

行尾注释#

与语句至少 2 个空格间隔
少用，避免行过长

x = x + 1 # 补偿边界

文档字符串#

所有公共模块、函数、类、方法应写文档字符串
多行格式：首行摘要，空行，详细说明

def complex(real=0.0, imag=0.0):
 """Form a complex number.

 Keyword arguments:
 real -- the real part (default 0.0)
 imag -- the imaginary part (default 0.0)
 """
 return complex(real, imag)

类型注解（PEP 484）#

建议为函数参数和返回值添加类型注解
提高可读性和工具链支持

def greeting(name: str) -> str:
 return f'Hello {name}'

工具支持#

flake8：检查 PEP 8 违规
black：自动格式化（有自身风格，与 PEP 8 大部分一致）
isort：自动排序导入
mypy：静态类型检查

原则总结#

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.

附录1-PEP 8 规范

Mon, 01 Jan 0001 00:00:00 +0000

PEP 8 代码风格指南附录#

PEP 8 是 Python 官方的代码风格指南，旨在提高代码可读性和一致性。详见 pep8.org。

代码布局#

缩进#

使用 4 个空格 缩进，不使用 Tab
续行缩进：与括号内首行对齐，或额外缩进 4 空格

# 续行与括号对齐
def long_function_name(var_one, var_two,
 var_three, var_four):
 return var_one

# 悬挂缩进（续行额外缩进）
result = some_function_that_takes_arguments(
 'arg1', 'arg2', 'arg3',
 'arg4', 'arg5'
)

行宽#

每行最多 79 字符
文档字符串/注释建议 72 字符 内换行

空行#

顶级定义之间：2 个空行
类内方法之间：1 个空行
函数内逻辑块之间：可加空行提高可读性

# 两个空行分隔顶级定义
import os


def function_one():
 pass


def function_two():
 pass


class MyClass:
 """类文档"""

 def method_one(self):
 pass

 def method_two(self):
 pass

导入#

导入放在文件顶部，在模块注释和文档字符串之后
顺序：标准库 → 相关第三方 → 本地应用
每组之间空一行
使用绝对导入，避免 from ... import *

"""模块文档字符串"""

import os
import sys

import numpy as np
import pandas as pd

from mypackage.utils import helper

命名规范#

类型	规范	示例
模块	短小全小写，下划线可选	`my_module`, `mymodule`
类	驼峰命名 PascalCase	`MyClass`
函数/变量	小写下划线 snake_case	`my_function`, `my_var`
常量	全大写下划线	`MAX_SIZE`, `DEFAULT_TIMEOUT`
私有	单下划线前缀	`_internal_var`
名称修饰	双下划线前后缀	`__name__`（魔术方法）

避免使用的名称#

单字符：l、O、I（易与数字混淆）
可接受：i、j、k（循环变量），e（异常）

表达式与语句#

空格#

# 二元运算符两侧各一个空格
x = 1
result = a + b

# 逗号后一个空格
spam(ham[1], {eggs: 2})
foo = (0,)

# 函数默认参数 = 两侧不加空格
def func(a=0, b=None):
 pass

# 切片冒号两侧空格可选，保持一致
ham[1:9], ham[1:9:3]

比较#

# 与 None 比较用 is / is not
if x is None:
 pass
if x is not None:
 pass

# 布尔值用 is True / is False（慎用），通常直接 if x:

字符串引号#

单引号 ' 与双引号 " 等效，项目内保持一致
三引号文档字符串用 """

注释#

块注释#

与代码同级缩进
每行以 # 加一个空格开头

# 这是一个块注释
# 说明下面的逻辑
x = process(data)

行尾注释#

与语句至少 2 个空格间隔
少用，避免行过长

x = x + 1 # 补偿边界

文档字符串#

所有公共模块、函数、类、方法应写文档字符串
多行格式：首行摘要，空行，详细说明

def complex(real=0.0, imag=0.0):
 """Form a complex number.

 Keyword arguments:
 real -- the real part (default 0.0)
 imag -- the imaginary part (default 0.0)
 """
 return complex(real, imag)

类型注解（PEP 484）#

建议为函数参数和返回值添加类型注解
提高可读性和工具链支持

def greeting(name: str) -> str:
 return f'Hello {name}'

工具支持#

flake8：检查 PEP 8 违规
black：自动格式化（有自身风格，与 PEP 8 大部分一致）
isort：自动排序导入
mypy：静态类型检查

原则总结#

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.

附录2-生成可执行文件

Mon, 01 Jan 0001 00:00:00 +0000

Python 生成可执行文件附录#

将 Python 脚本打包为独立可执行文件，可在无 Python 环境的机器上运行，便于分发与部署。

核心概念#

为何需要可执行文件#

无 Python 环境：目标机器未安装 Python 或版本不一致时仍可运行。
便于分发：单文件或单目录即可交付，无需配置依赖。
保护源码：打包后用户难以直接查看或修改源码（非强加密）。

实现方式概览#

方式	代表工具	原理
打包器	PyInstaller、cx_Freeze	将解释器、依赖与脚本打包成目录或单文件，运行时解压/加载。
编译型	Nuitka	将 Python 编译为 C，再编译为原生二进制，无内置解释器。

工具选型简表#

工具	适用场景	跨平台	依赖复杂度	体积/启动
PyInstaller	通用、快速打包	是	低，自动分析多	单文件较大、首次略慢
cx_Freeze	需精细控制、跨平台一致	是	中，常需写配置	目录分发，可控
Nuitka	追求性能、体积或兼容性	是	高，需 C 编译器	体积与启动更优，编译慢

PyInstaller（推荐首选）#

安装#

pip install pyinstaller

单文件与目录打包#

单文件：产出单个 exe（Windows）或可执行文件，运行时解压到临时目录。适合分发。
目录：产出一个目录，内含可执行文件与依赖。启动更快，便于调试。

# 单文件（最常用）
pyinstaller --onefile script.py

# 目录模式（默认）
pyinstaller script.py

常用参数#

参数	说明
`--onefile` / `-F`	打包成单文件
`--name` / `-n`	指定生成的可执行文件名
`--icon` / `-i`	指定图标（Windows .ico）
`--add-data`	将数据文件/目录打进包（格式：`src;dest` 或 `src:dest`）
`--hidden-import`	显式加入未自动检测到的模块
`--console` / `--noconsole`	是否保留控制台（GUI 程序常用 `--noconsole`）

示例：