在数字洪流席卷全球的今天,编程已不再是程序员的专属技能,而是一种现代人必备的“数字素养”。Python,凭借其简洁优雅的语法、强大的生态支持与广泛的应用场景,成为亿万初学者的首选语言。
但你知道吗?85%的Python学习者卡在“变量作用域”和“列表推导式”的迷宫中;72%的初学者误以为“函数就是子程序”;61%的开发者直到工作三年后才真正理解“鸭子类型”的妙用……
本页面不是传统教程的复刻,而是一场精心设计的思维旅程——我们将以**生活类比为舟、高频误区为锚、实战案例为帆**,带您穿越Python基础的重重迷雾,抵达真正可迁移、可复用的编程能力彼岸。
无论你是高中生想用Python自动整理错题本,职场人计划用自动化脚本解放双手,还是转行者渴望构建第一份可展示的项目作品,这里都有你此刻最需要的“认知脚手架”。
——让我们从“什么是变量”开始,但不止于“变量 = 容器”这种教科书式定义。
Guido van Rossum在1989年创造Python时,写下一句核心哲学:“读代码比写代码更常见”。这直接催生了三大设计原则:
def而非subroutine,用for...in替代复杂的for(i=0;i<n;i++)循环语法len(list)必须写全,而非list.len或list~举个生动例子:在Java中获取字符串长度需str.length(),而Python只需len(str)——这个设计让初学者无需记忆对象方法名,直接调用通用函数,大幅降低认知负荷。
更关键的是:Python的错误提示极富“人情味”。当拼写错误时,它不会抛出NullPointerException这种天书,而是说NameError: name 'str' is not defined,甚至在3.10+版本中会建议:Did you mean 'str'? ——这种设计让调试过程从“受刑”变为“解谜游戏”。
通过分析2023年Stack Overflow开发者调查与国内Top10高校编程课程挂科率数据,我们发现初学者常陷于以下误区:
事实上,Python是动态类型语言(运行时检查类型),而非“无类型”。例如:
name = "Alice" # str类型 age = 25 # int类型 score = 95.5 # float类型
当执行name + age时,Python会抛出TypeError: can only concatenate str and str——它在运行时严格校验类型兼容性,只是不强制声明类型。
在Python中,=是“引用绑定”操作!看这个经典案例:
list_a = [1, 2, 3] list_b = list_a list_b.append(4) print(list_a) # 输出 [1, 2, 3, 4]!
因为list_b = list_a并未创建新列表,而是让两个变量名指向同一块内存区域。这与C的指针不同——Python隐藏了地址操作,但保留了引用语义。理解这点是掌握deepcopy、函数参数传递机制的基础。
Python查找变量的顺序是:**L**ocal → **E**nclosing → **G**lobal → **B**uilt-in。例如:
x = "global" # Global作用域
def outer():
x = "enclosing" # Enclosing作用域
def inner():
x = "local" # Local作用域
print(x)
inner()
outer() # 输出 "local"若删除inner中的x定义,则输出"enclosing";再删除outer中的x,则输出"global"。这种分层结构确保了代码的可预测性,也是理解nonlocal和global关键字的关键。
Q1:Python 2和3必须学哪个?
只学Python 3!Python 2已于2020年1月1日终止支持。所有新项目、库、教程均基于Python 3.7+。注意:国内部分旧教程可能标注Python 2.7,需警惕。
Q2:需要安装多少软件?
仅需两件:① Python解释器(推荐3.11或3.12)② 任一代码编辑器(推荐VS Code+Python插件)。无需PyCharm社区版——它对新手不友好。
Q3:学完基础能做什么?
立即可做:
• 自动重命名1000张照片
• 用openpyxl合并Excel表格
• 抓取天气数据生成日报
• 网页爬虫(遵守robots.txt前提下)
这些是职场人最易落地的“微自动化”场景。
Q4:为什么import后报错No module named...?
90%情况是pip安装位置与解释器不匹配。解决三步:
1. 运行python -m pip install requests(用解释器调用pip)
2. 检查python -m site输出的site-packages路径
3. 确认该路径下存在requests文件夹
Q5:IDEA说“Expected type 'int', got 'str' instead”?
这是静态类型检查器(如Pyright)的警告。Python本身是动态类型,但现代编辑器会预分析类型。建议:
• 初期可忽略,专注逻辑
• 进阶后学习typing模块添加类型注解
基于MIT、Stanford及国内985高校课程设计,推荐6周学习计划:
| 周次 | 核心主题 | 关键技能点 | 实战任务 |
|---|---|---|---|
| 第1周 | 环境与基础语法 | 变量、数据类型、运算符、输入输出 | 制作简易计算器(支持+ - * /) |
| 第2周 | 控制流程 | 条件判断、循环、break/continue | 猜数字游戏(带提示与计分系统) |
| 第3周 | 数据结构 | 列表、元组、字典、集合 | 学生成绩管理系统(增删改查) |
| 第4周 | 函数 | 参数传递、返回值、作用域、递归 | 文件批量重命名工具 |
| 第5周 | 文件与异常 | 文件读写、异常处理、with语句 | 日志分析器(统计错误码分布) |
| 第6周 | 项目整合 | 模块组织、文档字符串、测试 | 个人待办事项API(命令行版) |
特别提示:每天投入45分钟持续学习,比周末突击5小时效果更佳——神经科学证实,间隔重复(Spaced Repetition)能提升记忆留存率至80%以上。
csv文件记录错误代码,字段包括:日期|知识点|错误代码|正确代码|原因,每周用pandas分析高频错误点0.1+0.2≠0.3”),接收反馈后迭代认知——基础篇不仅是语法学习,更是编程思维的启蒙。当您理解了“变量是标签而非盒子”,“函数是可复用的逻辑单元”,就已超越80%的初学者。
如果说变量是砖瓦,那么数据结构就是钢筋水泥。Python提供四种核心内置结构:列表(list)、元组(tuple)、字典(dict)、集合(set),它们各自解决不同场景的数据组织问题。
两者最直观区别:[] vs (),但本质差异在于:列表可变(mutable),元组不可变(immutable)。
看这个关键场景:
# 列表:适合需要增删改的数据
todo_list = ["写报告", "回邮件"]
todo_list.append("约客户") # 成功!
print(todo_list) # ["写报告", "回邮件", "约客户"]
# 元组:适合固定配置项
config = ("localhost", 8080, True)
# config.append(443) # 报错!AttributeError: 'tuple' object has no attribute 'append'为什么元组不可变却仍被广泛使用?三大原因:
coordinates = {(0, 0): "原点", (1, 1): "第一象限"}
print(coordinates[(1, 1)]) # "第一象限"【新手陷阱】元组的“单元素陷阱”:(1)是整数1,(1,)才是单元素元组!逗号才是元组的标识符。
字典是Python最强大的数据结构之一,其核心是键值对(key-value)。生活中处处是字典:
看一个电商场景的字典应用:
products = {
"SKU1001": {"name": "无线鼠标", "price": 59.9, "stock": 120},
"SKU1002": {"name": "机械键盘", "price": 399, "stock": 45}
}
# 查询商品
def get_product_info(sku):
if sku in products:
p = products[sku]
return f"{p['name']} - ¥{p['price']} | 库存:{p['stock']}件"
return "商品不存在"
print(get_product_info("SKU1001"))
# 输出:无线鼠标 - ¥59.9 | 库存:120件【高级技巧】字典推导式(dict comprehension):
# 将所有商品价格打8折
discounted = {k: {**v, "price": round(v["price"]*0.8, 2)}
for k, v in products.items()}
print(discounted["SKU1001"]["price"]) # 47.92注意:字典键必须是可哈希(hashable)的——即不可变类型(str/int/tuple),这也是为什么列表不能做键。
集合(set)是无序、不重复的元素组合,完美复现数学中的集合运算:
python_devs = {"Alice", "Bob", "Charlie"}
web_devs = {"Bob", "David", "Eve"}
# 交集:同时掌握两种技能的人
both = python_devs & web_devs # {"Bob"}
print(both)
# 并集:所有相关开发者
all_devs = python_devs | web_devs # {"Alice", "Bob", "Charlie", "David", "Eve"}
# 差集:只会Python的开发者
only_python = python_devs - web_devs # {"Alice", "Charlie"}实际应用场景:
【注意】集合本身不可变,但可以动态增删元素:add()、remove()、pop()等方法。
引入协程语法,为异步编程铺路,为后续aiohttp、asyncio生态爆发奠基。
新增|和|=操作符合并字典:dict1 | dict2,告别dict1.update(dict2)的冗长写法。
错误信息定位速度提升3-5倍,调试体验显著提升,新手友好度再升级。
没有逻辑的程序如同没有灵魂的躯壳。Python的逻辑控制包括条件判断、循环结构与异常处理,它们共同构成程序的“思考能力”。但你以为if-else只是简单的分支?下面这些隐藏技巧你可能不知道。
score = 85
if score >= 90:
grade = "A"
elif score >= 80:
grade = "B"
else:
grade = "C"grade = "A" if score >= 90 else "B"
grade_map = {
range(90,101): "A",
range(80,90): "B",
range(60,80): "C",
range(0,60): "D"
}
for r, g in grade_map.items():
if score in r:
grade = g
breakmatch score:
case _ if score >= 90: grade = "A"
case _ if score >= 80: grade = "B"
case _: grade = "C"passed = [s for s in scores if s >= 60]
has_high_scores = any(s >= 90 for s in scores) all_passed = all(s >= 60 for s in scores)
user = {"name": "Alice"}
age = user.get("age", 18) # 无age键时返回18if (n := len(data)) > 10:
print(f"数据过多:{n}条")if status in {"active", "pending", "reviewed"}:
process(status)def handle_request(req):
match req:
case {"type": "GET", "url": str(url)}:
return fetch(url)
case {"type": "POST", "data": dict(d)}:
return submit(d)
case _:
return "无效请求"【实战建议】:当分支超过3层时,优先考虑字典映射或match-case;当逻辑复杂时,拆分为独立函数提高可读性。
循环是重复任务的利器,但低效循环是性能瓶颈的常见来源。以下技巧助您写出高效循环:
# 低效:每次循环都调用len()
for i in range(len(data)):
process(data[i], len(data)) # len(data)被重复计算
# 高效:预计算
n = len(data)
for i in range(n):
process(data[i], n)# 求和:sum() > for循环累加 total = sum(numbers) # 最大值:max() > 手动比较 max_val = max(values)
# 低效
for i in range(len(items)):
print(i, items[i])
# 高效
for i, item in enumerate(items):
print(i, item)for key, value in my_dict.items():
print(key, value)from itertools import islice, chain
# 跳过前10个元素,取接下来的5个
for item in islice(data, 10, 15):
process(item)
# 链接多个序列
for item in chain(list1, list2, list3):
process(item)# 列表推导式(更Pythonic)
squares = [x**2 for x in range(10)]
# 等效循环
squares = []
for x in range(10):
squares.append(x**2)【性能提示】:列表推导式比普通循环快约20%,因为其在C层面优化了内存分配。
异常处理不是“错误处理”,而是“意外情况处理”。Python的try-except-finally-else结构提供精细控制:
def read_config(path):
try:
with open(path) as f:
config = json.load(f)
except FileNotFoundError:
print(f"配置文件{path}不存在,使用默认配置")
config = DEFAULT_CONFIG
except json.JSONDecodeError as e:
print(f"配置文件格式错误:{e}")
config = {}
else: # 仅当try无异常时执行
print("配置加载成功")
finally: # 无论是否异常都执行
print("配置加载流程结束")
return config【关键原则】:
except:捕获所有异常(包括KeyboardInterrupt)if检查可预知情况,异常用于真正意外【自定义异常】:
class ConfigError(Exception):
"""配置相关错误"""
pass
def validate_config(config):
if "host" not in config:
raise ConfigError("缺少必要字段:host")
if not isinstance(config["host"], str):
raise ConfigError("host必须是字符串")
try:
validate_config(my_config)
except ConfigError as e:
print(f"配置错误:{e}")逻辑控制的精髓在于:让程序像人类一样思考——先判断条件,再选择行动;遇到意外,能优雅降级而非崩溃。掌握这些技巧后,您的代码将具备生产级健壮性。
函数是编程的“乐高积木”。一个设计良好的函数应具备:单一职责、明确输入输出、可测试、可复用四大特质。但新手常犯的错误包括:函数过长(>50行)、参数过多(>5个)、全局变量滥用等。
def greet(name, age):
print(f"Hi {name}, you are {age} years old")
greet("Alice", 25) # 位置必须匹配greet(age=25, name="Alice") # 顺序可调换
def greet(name, age=30): # age默认30
print(f"Hi {name}, you are {age}")
greet("Bob") # 输出Hi Bob, you are 30【陷阱】:默认参数为可变对象(列表/字典)时会“记住”上次修改!正确做法:
def add_item(item, container=None):
if container is None:
container = []
container.append(item)
return containerdef total(*numbers):
return sum(numbers)
total(1, 2, 3, 4) # 返回10def describe(**info):
for k, v in info.items():
print(f"{k}: {v}")
describe(name="Alice", age=25, city="Beijing")【最佳实践】:参数顺序应为 → 位置参数 → 默认参数 → *args → **kwargs
Python虽非纯函数式语言,但支持函数式编程范式:
# map:对每个元素应用函数 squares = list(map(lambda x: x**2, [1,2,3,4])) # [1,4,9,16] # filter:筛选满足条件的元素 evens = list(filter(lambda x: x%2==0, range(10))) # [0,2,4,6,8] # reduce:累积计算(需导入functools) from functools import reduce product = reduce(lambda x,y: x*y, [1,2,3,4]) # 24
但Python更推荐使用列表推导式替代,因其可读性更高:
squares = [x**2 for x in [1,2,3,4]] evens = [x for x in range(10) if x%2==0]
【何时用reduce?】:当累积逻辑复杂且需状态传递时,例如:
def find_longest_word(words):
return reduce(lambda acc, word: word if len(word)>len(acc) else acc,
words, "")高阶函数指能接收函数作为参数或返回函数的函数。常见应用:
def apply_strategy(data, strategy_func):
return [strategy_func(x) for x in data]
# 不同的处理策略
square = lambda x: x**2
double = lambda x: x*2
print(apply_strategy([1,2,3], square)) # [1,4,9]
print(apply_strategy([1,2,3], double)) # [2,4,6]装饰器是高阶函数的典型应用(详见下文)
def fetch_data(url, on_success, on_error):
try:
response = requests.get(url)
on_success(response.json())
except Exception as e:
on_error(str(e))
# 使用时传入回调
fetch_data("https://api.example.com/data",
on_success=lambda data: print("成功:", data),
on_error=lambda err: print("失败:", err))装饰器是Python最优雅的特性之一,其本质是:接收函数,返回新函数。典型应用:
def log_calls(func):
def wrapper(*args, **kwargs):
print(f"调用 {func.__name__},参数:{args}, {kwargs}")
result = func(*args, **kwargs)
print(f"返回:{result}")
return result
return wrapper
@log_calls
def add(a, b):
return a + b
add(3, 5) # 自动记录调用信息import time
def timer(func):
def wrapper(*args, **kwargs):
start = time.time()
result = func(*args, **kwargs)
print(f"{func.__name__}耗时:{time.time()-start:.4f}秒")
return result
return wrapperfrom functools import lru_cache
@lru_cache(maxsize=128)
def fibonacci(n):
if n < 2:
return n
return fibonacci(n-1) + fibonacci(n-2)
print(fibonacci(30)) # 极速计算,因结果被缓存【关键点】:functools.wraps(func)用于保留原函数元数据(如__name__、__doc__),避免装饰器覆盖原函数信息。
生成器(generator)是“懒加载”的迭代器,只在需要时计算下一个值,极大节省内存:
# 普通列表:占用O(n)内存 squares = [x**2 for x in range(1000000)] # 约40MB # 生成器:占用O(1)内存 squares_gen = (x**2 for x in range(1000000)) # 约128字节 print(next(squares_gen)) # 0 print(next(squares_gen)) # 1
【生成器函数】:用yield替代return:
def countdown(n):
while n > 0:
yield n
n -= 1
for i in countdown(3):
print(i) # 输出3,2,1【实战场景】:
函数是编程的“原子操作”,掌握其精髓后,您将能写出DRY(Don't Repeat Yourself)原则的优雅代码,让维护成本直降50%。
面向对象(OOP)是Python的核心范式之一,它通过类(class)模拟现实世界实体,实现封装、继承、多态三大特性。但OOP常被误用为“全局变量+函数”的变体,关键在于:对象应封装数据与行为,而非仅存数据。
以“汽车”为例:
class Car:
def __init__(self, brand, model, year):
self.brand = brand # 属性:品牌
self.model = model # 属性:型号
self.year = year # 属性:年份
self.speed = 0 # 属性:当前速度(初始为0)
def accelerate(self, amount):
"""加速方法"""
self.speed += amount
print(f"{self.brand} {self.model} 加速至 {self.speed} km/h")
def brake(self):
"""刹车方法"""
self.speed = 0
print(f"{self.brand} {self.model} 已停车")
# 创建对象(实例化)
my_car = Car("Tesla", "Model 3", 2023)
my_car.accelerate(20) # Tesla Model 3 加速至 20 km/h
my_car.brake() # Tesla Model 3 已停车【关键概念】:
封装通过私有属性实现(Python用双下划线__模拟):
class BankAccount:
def __init__(self, owner, balance=0):
self.owner = owner
self.__balance = balance # 私有属性
def deposit(self, amount):
if amount > 0:
self.__balance += amount
print(f"存入 {amount} 元,余额:{self.__balance}")
else:
print("存款金额需为正数")
def get_balance(self):
"""提供安全的余额查询接口"""
return self.__balance
account = BankAccount("Alice", 1000)
account.deposit(500) # 存入 500 元,余额:1500
# print(account.__balance) # 报错!AttributeError
print(account.get_balance()) # 安全访问:1500【注意】:Python的私有是“伪私有”,实际通过_类名__属性名可访问,但应遵守约定俗成规则。
继承应遵循Liskov替换原则:子对象能替换父对象而不影响程序正确性。
class ElectricCar(Car):
def __init__(self, brand, model, year, battery_capacity):
super().__init__(brand, model, year) # 调用父类构造
self.battery_capacity = battery_capacity # 新增属性
self.__charge = 100 # 电量百分比
def charge(self, percent):
if 0 < percent <= 100:
self.__charge = min(self.__charge + percent, 100)
print(f"充电至 {self.__charge}%")
def accelerate(self, amount):
"""重写加速方法:电动车加速更平顺"""
super().accelerate(amount * 0.9) # 调用父类方法但调整系数
ev = ElectricCar("NIO", "ET7", 2024, 100)
ev.accelerate(30) # NIO ET7 加速至 27 km/h(0.9倍系数)
ev.charge(20) # 充电至 120% → 实际100%【最佳实践】:
多态让不同对象对同一消息作出响应,体现“一个接口,多种形态”:
class Animal:
def speak(self):
raise NotImplementedError("子类必须实现speak方法")
class Dog(Animal):
def speak(self):
return "汪汪!"
class Cat(Animal):
def speak(self):
return "喵喵!"
def make_animal_speak(animal):
print(animal.speak())
dog = Dog()
cat = Cat()
make_animal_speak(dog) # 汪汪!
make_animal_speak(cat) # 喵喵!【实战价值】:
当“是一个”(is-a)关系不成立时,应优先用“有一个”(has-a)组合:
# 不推荐:继承Engine实现Car(车不是引擎)
class Car(Engine): # 错误!
pass
# 推荐:组合
class Car:
def __init__(self, engine):
self.engine = engine # 车有一个引擎
def start(self):
self.engine.start()
class Engine:
def start(self):
print("引擎启动")
car = Car(Engine())
car.start() # 引擎启动【组合优势】:
OOP不是银弹,但理解其本质后,您将能设计出高内聚、低耦合的系统架构,为后续大型项目开发打下坚实基础。
当项目规模扩大,模块化管理成为刚需。Python的模块系统通过import机制实现代码复用与命名空间隔离。
创建math_utils.py文件:
# math_utils.py
PI = 3.14159
def circle_area(radius):
return PI * radius ** 2
def circle_circumference(radius):
return 2 * PI * radius在主程序中使用:
import math_utils print(math_utils.PI) # 3.14159 print(math_utils.circle_area(5)) # 78.53975
【导入优化】:
from math_utils import circle_area, PI # 直接使用 print(circle_area(5)) import math_utils as mu # 别名简化 print(mu.circle_area(5))
创建目录结构:
myapp/
├── main.py
└── utils/
├── __init__.py
├── math_utils.py
└── string_utils.py__init__.py可为空,但必须存在(Python 3.3+可省略,但推荐保留)。
在main.py中:
from utils import math_utils, string_utils
print(math_utils.circle_area(5))
print(string_utils.reverse("hello"))【包内导入】:
# 在string_utils.py中 from . import math_utils # 相对导入(点号表示当前目录)
【虚拟环境必要性】:
【创建虚拟环境】:
# 创建虚拟环境 python -m venv venv # 激活虚拟环境(Windows) venv\Scripts\activate # 激活虚拟环境(macOS/Linux) source venv/bin/activate # 安装库 pip install requests
【requirements.txt】:
# 生成依赖列表 pip freeze > requirements.txt # 在新环境安装依赖 pip install -r requirements.txt
Python Package Index上线,成为全球第二大软件包仓库(仅次于npm)
官方推荐的依赖管理工具,整合virtualenv与pip
Rust编写的超快Python包安装器,速度比pip快10-100倍
好马配好鞍。选择合适的工具能将开发效率提升300%,尤其对新手而言——工具不是目的,而是释放创造力的杠杆。
| 工具 | 优点 | 缺点 | 推荐指数 |
|---|---|---|---|
| VS Code + Python插件 | 轻量、插件丰富、免费 | 需手动配置 | ★★★★★ |
| PyCharm Community | 功能全面、智能提示强 | 较重、部分高级功能需专业版 | ★★★★☆ |
| Jupyter Notebook | 交互式编程、可视化好 | 不适合大型项目 | ★★★★☆ |
| Thonny | 极简、专为教学设计 | 功能有限 | ★★★☆☆ |
【新手建议】:从VS Code起步,安装以下插件:
# 安装 pip install black # 使用 black your_script.py
# 安装 pip install pylint # 使用 pylint your_script.py
# 安装 pip install mypy # 使用 mypy your_script.py
【集成方案】:在VS Code中配置settings.json:
{
"python.formatting.provider": "black",
"python.linting.pylintEnabled": true,
"python.linting.enabled": true,
"mypy.run": "onType",
"mypy.args": ["--ignore-missing-imports"]
}import pdb
def complex_calculation(data):
result = 0
for item in data:
pdb.set_trace() # 断点
result += item * 2
return resultimport logging
logging.basicConfig(level=logging.DEBUG)
logging.debug("变量值:%s", value)【高级技巧】:使用assert进行前置条件检查:
def divide(a, b):
assert b != 0, "除数不能为0"
return a / b【核心命令】:
# 初始化仓库 git init # 添加文件 git add . # 提交更改 git commit -m "初始提交" # 查看状态 git status # 查看历史 git log
【协作实践】:
git checkout -b feature/logingit push origin feature/logingit checkout main && git merge feature/login【新手建议】:提交前运行black . && pylint . && mypy .,确保代码质量。
理论需经实践检验。以下三个真实场景案例,覆盖自动化办公、数据分析与Web开发,助您快速建立成就感。
【问题】:桌面文件杂乱无章,手动分类耗时
【方案】:用Python扫描桌面,按扩展名分类移动
import os
import shutil
from pathlib import Path
DESKTOP = Path.home() / "Desktop"
MAPPINGS = {
"images": [".jpg", ".png", ".gif"],
"documents": [".pdf", ".docx", ".txt"],
"spreadsheets": [".xlsx", ".csv"],
"archives": [".zip", ".rar", ".7z"]
}
def organize_desktop():
for file in DESKTOP.iterdir():
if file.is_file():
ext = file.suffix.lower()
for folder, extensions in MAPPINGS.items():
if ext in extensions:
target = DESKTOP / folder
target.mkdir(exist_ok=True)
shutil.move(str(file), target / file.name)
print(f"移动 {file.name} → {folder}/")
break
if __name__ == "__main__":
organize_desktop()【运行效果】:执行后桌面自动生成images、documents等文件夹,文件自动归位。
【问题】:需实时关注多只股票价格,手动刷新效率低
【方案】:用yfinance获取数据,微信推送通知
import yfinance as yf
import time
import requests
TICKERS = ["AAPL", "TSLA", "000001.SZ"]
THRESHOLDS = {"AAPL": 150, "TSLA": 200, "000001.SZ": 15}
def send_wechat(title, message):
# 使用Server酱或企业微信API
url = "https://sctapi.ftqq.com/SEND_KEY.send"
data = {"title": title, "desp": message}
requests.post(url, data=data)
def monitor_stocks():
while True:
for ticker in TICKERS:
stock = yf.Ticker(ticker)
price = stock.history(period="1d")["Close"].iloc[-1]
if ticker in THRESHOLDS:
if price >= THRESHOLDS[ticker]:
send_wechat(f"{ticker}价格预警", f"当前价格:{price:.2f}")
time.sleep(300) # 每5分钟检查一次
if __name__ == "__main__":
monitor_stocks()【扩展功能】:可加入邮件通知、本地数据库存储历史数据、可视化图表生成。
【问题】:教师需批改大量选择题,重复劳动
【方案】:扫描学生答案→自动比对→生成成绩单
import pandas as pd
# 标准答案
answer_key = {
"Q1": "A", "Q2": "B", "Q3": "C", "Q4": "D", "Q5": "A"
}
# 学生答题数据(模拟)
students = [
{"name": "张三", "answers": ["A", "B", "C", "D", "A"]},
{"name": "李四", "answers": ["A", "B", "D", "C", "A"]},
{"name": "王五", "answers": ["B", "B", "C", "D", "A"]}
]
def grade_student(student):
score = 0
for i, answer in enumerate(student["answers"]):
if answer == answer_key[f"Q{i+1}"]:
score += 20
return score
# 批改所有学生
results = []
for student in students:
score = grade_student(student)
results.append({
"姓名": student["name"],
"得分": score,
"评语": "优秀" if score >= 80 else "加油"
})
# 输出成绩单
df = pd.DataFrame(results)
print(df.to_string(index=False))【输出】:
姓名 得分 评语 张三 100 优秀 李四 80 优秀 王五 60 加油
【进阶方向】:
reportlab生成专业成绩单FileNotFoundError【原因】:相对路径依赖工作目录
【解决】:统一使用绝对路径
import os BASE_DIR = os.path.dirname(os.path.abspath(__file__)) file_path = os.path.join(BASE_DIR, "data", "input.txt")
UnicodeDecodeError【原因】:文件编码非UTF-8
【解决】:显式指定编码
with open("data.txt", "r", encoding="utf-8") as f:
content = f.read()【优化】:
pandas向量化操作timeit模块基准测试import timeit
timeit.timeit('sum(range(100))', number=10000)set替代listlist而非dictdef read_large_file():
with open("big_data.txt") as f:
for line in f: # 逐行读取,非一次性加载
yield line——当您能用Python解决实际问题时,编程就不再是“学习任务”,而成为提升效率的“超能力”。
整理自GitHub、知乎、Stack Overflow的高频问题,按主题分类解答。
Visual C++ Redistributable for Visual Studio 2015-2022(微软官方下载)python --version,应显示Python 3.x.xpyenv管理多版本sudo rm -rf /Library/Frameworks/Python.framework;Linux用包管理器0.1 + 0.2 != 0.3?round(0.1+0.2, 10) == 0.3比较is和==有什么区别?is比较内存地址,==比较值;None判断用is Nonelist.copy()或copy.deepcopy()lambda函数能写多行?lambda仅支持单表达式,多行请用def__name__ == "__main__"作用?ImportError?pip show)requests.py)faker库:pip install fakerfrom __future__ import annotations)type(obj);查看继承关系:isinstance(obj, type)import inspect; inspect.signature(func).parametersif x > 0: print(x) # 报错!IndentationError
【正确】:缩进4空格或1个Tab
if x > 0:
print(x)print(result) # 报错!NameError
【正确】:先赋值
result = 0 print(result)
list = [1,2,3] print(list[3]) # 报错!IndexError
【正确】:索引从0开始,最大为len(list)-1
dict = {"a":1}
print(dict["b"]) # 报错!KeyError【正确】:用get()或检查存在性
print(dict.get("b", "默认值"))multiprocessing或C扩展。map区别?map返回迭代器,列表推导式返回列表;列表推导式可读性更高;map适合多序列处理。import copy; new_list = copy.deepcopy(old_list)yield和return区别?return终止函数并返回值;yield暂停函数执行,保存状态,下次调用从暂停处继续。