编程是使用计算机语言编写指令，让计算机按照我们的想法执行任务的过程。就像人类使用语言交流一样，我们需要用编程语言与计算机"对话"，告诉它要做什么、怎么做。
掌握基本语法，能够编写简单程序，理解变量、函数、控制流等基础概念
熟练运用数据结构、算法，掌握面向对象编程，能够解决中等复杂度问题
深入理解系统架构，掌握设计模式，能够设计复杂系统，具备性能优化能力
具备创新思维，能够推动技术发展，在特定领域有深度专长，具备技术领导力
编程语言可以分为不同的类型，每种类型都有其特点和适用场景：
Python作为一门编程语言，具有以下显著优势：
| 特性 | Python | Java | C++ | JavaScript |
|---|---|---|---|---|
| 学习曲线 | ⭐ 简单 | ⭐⭐ 中等 | ⭐⭐⭐ 困难 | ⭐ 简单 |
| 执行速度 | ⭐⭐ 中等 | ⭐⭐⭐ 快速 | ⭐⭐⭐ 快速 | ⭐ 较慢 |
| 开发效率 | ⭐⭐⭐ 很高 | ⭐⭐ 中等 | ⭐ 较低 | ⭐⭐⭐ 很高 |
| 生态系统 | ⭐⭐⭐ 丰富 | ⭐⭐⭐ 丰富 | ⭐⭐ 中等 | ⭐⭐⭐ 丰富 |
| 内存管理 | ⭐⭐⭐ 自动 | ⭐⭐⭐ 自动 | ⭐ 手动 | ⭐⭐⭐ 自动 |
| 适用场景 | 数据科学、AI、Web开发、自动化 | 企业应用、Android开发、大数据 | 系统编程、游戏开发、高性能应用 | 前端开发、Node.js后端、移动应用 |
学习编程不仅仅是学习语法，更重要的是培养编程思维。编程思维是一种解决问题的思维方式，它能够帮助我们更有效地分析问题、设计解决方案并实现目标。这种思维方式不仅在编程中重要，在日常生活和工作中同样具有重要价值。
逻辑思维是编程的基础，它要求我们按照严格的逻辑顺序来分析和解决问题。
# 逻辑思维示例
if temperature > 30:
print("天气炎热")
elif temperature > 20:
print("天气温暖")
else:
print("天气凉爽")抽象思维是将复杂问题简化为可管理的概念和模型的能力。
# 抽象思维示例
class Student:
def __init__(self, name, age):
self.name = name
self.age = age
# 将学生抽象为对象系统思维考虑问题的整体性和各部分之间的关系，注重系统的整体功能。
# 系统思维示例
def process_data(data):
cleaned = clean_data(data)
analyzed = analyze_data(cleaned)
return generate_report(analyzed)
# 系统化的数据处理流程将复杂问题分解为更小、更易管理的子问题。
# 问题分解示例
# 开发购物网站
1. 用户注册系统
2. 商品展示模块
3. 购物车功能
4. 支付系统集成识别问题中的重复模式和规律，应用已知的解决方案。
# 模式识别示例
# 排序问题解决
1. 识别数据特征
2. 选择排序算法
3. 实现优化
4. 性能测试从目标结果出发，逆向推导解决方案。
# 逆向思维示例
# 实现登录功能
1. 需要验证密码
2. 需要获取用户信息
3. 需要数据库连接
4. 需要前端界面快速构建原型，通过迭代改进来完善解决方案。
编写一个程序，让用户猜一个1-100之间的随机数，程序给出提示。
实现一个支持加减乘除的简单计算器。
设计一个简单的学生信息管理系统。
开发一个批量文件处理工具。
开发一个简单的网络爬虫程序。
完成一个完整的数据分析项目。
Python是一门易于上手、功能强大的编程语言。它拥有高效的高级数据结构，并采用了一种简单而有效的面向对象编程范式。Python简洁优雅的语法、动态类型以及其解释型语言的特性，使它成为在各大主流平台上进行脚本编写与快速应用开发的理想选择。
详情请阅读Python官方文档或Python指南点击查看
标识符是用来给变量、函数、类等命名的"名字"，在Python中，变量名、函数名、类名等都属于标识符。标识符必须遵循一定的命名规则，良好的命名习惯不仅能提高代码的可读性，还能减少错误和提高开发效率。
name 和 Name 是不同的标识符
if、for、class 等）
类名采用大驼峰命名法，每个单词的首字母都大写。
# 类名示例
class Student:
pass
class UserAuthenticationManager:
pass
class DatabaseConnectionPool:
pass变量名和函数名采用小写字母加下划线的命名方式。
# 变量和函数示例
user_name = "Alice"
total_score = 95
def calculate_average_score(scores):
return sum(scores) / len(scores)
def get_user_by_id(user_id):
pass常量采用全大写字母加下划线的命名方式。
Python中有一些特殊的命名约定，用于表示特定的含义。
# 特殊命名示例
class MyClass:
def __init__(self):
self._private_var = 10
self.__mangled_name = 20
def __str__(self):
return "MyClass instance"选择能够清楚表达用途的名称，避免使用缩写或模糊的名称。
uncalccheckmaxa、b、tempdata、info、stuffdo_something、process在描述性和简洁性之间找到平衡，避免过长或过短的名称。
n、x - 过短且不明确在整个项目中保持命名风格的一致性，提高代码的可维护性。
get_、set_、is_ 前缀getUser 和 get_userMAX_VALUE 和 maxValue这是一个完整的学生管理系统示例，展示了如何在实际项目中应用良好的命名规范。
# 常量定义
MAX_STUDENTS_PER_CLASS = 30
DEFAULT_GRADE = 0
SUPPORTED_SUBJECTS = ["Math", "Science", "English"]
# 类定义
class Student:
def __init__(self, student_id, first_name, last_name):
self.student_id = student_id
self.first_name = first_name
self.last_name = last_name
self.grades = {}
self._is_active = True # 私有变量
def get_full_name(self):
return f"{self.first_name} {self.last_name}"
def add_grade(self, subject, score):
if subject in SUPPORTED_SUBJECTS:
self.grades[subject] = score
def calculate_average_grade(self):
if not self.grades:
return DEFAULT_GRADE
return sum(self.grades.values()) / len(self.grades)
# 函数定义
def create_student_database():
return {}
def add_student_to_database(database, student):
if len(database) < MAX_STUDENTS_PER_CLASS:
database[student.student_id] = student
return True
return False
def find_student_by_id(database, student_id):
return database.get(student_id)
# 使用示例
if __name__ == "__main__":
student_db = create_student_database()
new_student = Student("001", "Alice", "Johnson")
add_student_to_database(student_db, new_student)变量是用来存储数据的"名字"，它代表了内存中的一个值。通过变量名，我们可以方便地访问、修改和使用数据。变量就像一个标签，把某个值贴上一个名字，后续可以通过这个名字反复引用和操作该值。
变量名要有实际意义，避免使用 a、b、temp 这类无意义命名。
# 变量赋值与类型自动推断
a = 10 # int 整型
a = "hello" # str 字符串
a = 3.14 # float 浮点型
# 合法命名
user_name = "Tom"
score_1 = 99
# 不合法命名（会报错）
# 1score = 100
# user-age = 20
# for = 5
# 全局变量与局部变量
x = 100 # 全局变量
def foo():
y = 200 # 局部变量
print(x, y)
foo()
# print(y) # 报错，y只在foo函数内有效变量名不能以数字开头，不能包含空格、减号、特殊符号，不能与Python关键字重名。
变量名应简洁、描述性强，遵循 snake_case 规范，如 user_score、total_price。
Python提供了丰富的基本数据类型，每种类型都有其特定的用途和操作方式。了解这些数据类型是掌握Python编程的基础。
💡 数字类型可直接参与算术运算，bool本质上是int的子类。
💡 字符串不可变，拼接和修改会生成新对象。
💡 元组内容不可变，但可包含可变对象（如列表）。
💡 列表是最常用的可变序列类型，支持嵌套和多种内置方法。
💡 集合中的元素必须可哈希（不可变类型），集合本身可变。
💡 字典的键必须可哈希（不可变类型），值可为任意对象。
在Python中，对象是对数据的抽象。程序中的所有数据都是通过对象或对象之间的关系来表示的。无论是数字、字符串、列表，还是你自己定义的类型，统统都是对象。甚至连代码本身，在某种意义上也可以被当作对象来看待。
注意：上图是简化的教学模型，用于理解基本概念。实际Python内存管理更加复杂。
引用（Reference）是Python中变量与对象之间的连接桥梁，它本质上是一个内存地址，指向堆中实际存储数据的对象。
通过交互式演示了解栈的LIFO（后进先出）特性，观察元素如何入栈和出栈。
Last In, First Out - 最后进入的元素最先被移除。就像叠盘子一样，最后放上去的盘子会最先被取走。
演示Python的内存管理和对象共享机制，理解引用、对象和内存地址的关系。
掌握Python的流程控制语句，包括条件判断、循环结构和控制语句，实现程序的逻辑控制。
score = 85
if score >= 90:
print("优秀")
elif score >= 60:
print("及格")
else:
print("不及格")💡 条件判断支持任意复杂的逻辑表达式。
status = "success"
match status:
case "success":
print("操作成功")
case "fail":
print("操作失败")
case _:
print("未知状态")💡 match语句仅支持Python 3.10及以上版本，case _ 表示默认分支。
# for循环遍历列表
for name in ["Tom", "Alice", "Bob"]:
print(name)
# for循环遍历区间
for i in range(3):
print(i) # 输出0,1,2
# while循环
count = 0
while count < 3:
print(count)
count += 1💡 for循环适合遍历，while循环适合条件驱动。
# break/continue/pass 示例
for i in range(5):
if i == 2:
continue # 跳过2
if i == 4:
break # 提前结束循环
print(i)
for i in range(3):
pass # 什么都不做
💡 合理使用循环控制语句可提升代码灵活性和可读性。
掌握Python函数编程的核心概念，包括函数定义、参数传递、作用域、闭包等，提升代码复用性和可维护性。
函数用于封装可复用的代码块，使用 def 关键字定义。可以有参数和返回值，提升代码复用性和可维护性。
# 定义和调用函数
def add(a, b):
"""返回a和b的和"""
return a + b
result = add(3, 5)
print(result) # 输出8def get_name_and_age():
return "Tom", 18
name, age = get_name_and_age()
print(name, age)def greet(name, msg="你好"):
print(msg, name)
greet("Alice")
greet("Bob", "Hi")
def add_all(*args):
return sum(args)
print(add_all(1, 2, 3))x = 10
def foo():
global x
x = 20
foo()
print(x) # 20def bad_default(arg=[]):
arg.append(1)
return arg
# 错误示例
def good_default(arg=None):
if arg is None:
arg = []
arg.append(1)
return arg掌握Python文件操作的核心技能，包括文本文件读写、二进制文件处理、异常处理和路径操作。
Python使用 open() 函数进行文件读写。
# 写文件
with open("test.txt", "w", encoding="utf-8") as f:
f.write("Hello, world!\n")
f.write("第二行内容\n")
# 读文件
with open("test.txt", "r", encoding="utf-8") as f:
content = f.read()
print(content)文件操作常见异常包括文件不存在、权限不足等。可用 try...except 捕获异常：
try:
with open("not_exist.txt", "r", encoding="utf-8") as f:
data = f.read()
except FileNotFoundError:
print("文件不存在！")
except PermissionError:
print("没有权限访问该文件")处理图片、音频等非文本文件时，需用二进制模式：
# 读取二进制文件
with open("image.png", "rb") as f:
data = f.read()
# 写入二进制文件
with open("copy.png", "wb") as f:
f.write(data)跨平台处理文件路径，推荐用 os 和 os.path：
掌握Python面向对象编程的核心概念，包括类、对象、继承、多态和特殊方法，构建结构化的程序。
面向对象编程（OOP）是Python的核心特性之一。类（Class）是创建对象的模板，对象是类的实例。
# 基本类定义示例
class Student:
"""学生类"""
def __init__(self, name, age, student_id):
self.name = name # 实例属性
self.age = age
self.student_id = student_id
self.courses = [] # 课程列表
def introduce(self):
return f"我叫{self.name}，今年{self.age}岁"
# 创建对象实例
student1 = Student("张三", 20, "2023001")
print(student1.introduce())继承允许我们创建一个继承另一个类属性和方法的新类。多态允许不同类的对象对同一方法有不同的实现。
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def work(self):
return "我在工作"
class Student(Person):
def work(self):
return "我在学习" # 重写父类方法
# 多态调用
student = Student("小明", 18)
print(student.work()) # 我在学习Python中的特殊方法以双下划线开头和结尾，用于定义对象的行为。
class Book:
def __str__(self):
return f"《{self.title}》 作者：{self.author}"
def __eq__(self, other):
return self.title == other.title
def __lt__(self, other):
return self.price < other.price
# 使用示例
book1 = Book("Python编程", "张三", 59)
print(book1) # 调用__str__探索Python的高级语法特性，包括列表推导式、生成器、装饰器等，提升代码的简洁性和效率。
列表推导式是Python中创建列表的简洁方式，生成器可以高效处理大量数据。
# 列表推导式示例
# 基本语法：[表达式 for 变量 in 可迭代对象 if 条件]
squares = [x**2 for x in range(1, 11)]
print(squares) # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
even_squares = [x**2 for x in range(1, 11) if x % 2 == 0]
print(even_squares) # [4, 16, 36, 64, 100]
# 生成器表达式（内存效率高）
sum_squares = sum(x**2 for x in range(1000000))装饰器是Python中的高级特性，用于修改或增强函数的功能。
# 基本装饰器
def timer(func):
"""计时装饰器"""
def wrapper(*args, **kwargs):
import time
start_time = time.time()
result = func(*args, **kwargs)
end_time = time.time()
print(f"{func.__name__} 执行时间：{end_time - start_time:.4f}秒")
return result
return wrapper
@timer
def slow_function():
time.sleep(1)
return "完成"上下文管理器用于管理资源的获取和释放，使用with语句。
class FileManager:
def __enter__(self):
self.file = open(self.filename, self.mode)
return self.file
def __exit__(self, exc_type, exc_val, exc_tb):
if self.file:
self.file.close()
# 使用自定义上下文管理器
with FileManager("test.txt", "w") as f:
f.write("Hello, World!")掌握Python完整的异常处理机制，包括自定义异常类和异常处理最佳实践。
Python提供了完整的异常处理机制，包括try、except、else、finally等关键字。
def divide_numbers(a, b):
try:
result = a / b
except ZeroDivisionError as e:
print(f"除零错误：{e}")
return None
else:
print("计算成功，没有异常发生")
return result
finally:
print("无论是否发生异常，这里都会执行")创建自定义异常类，提供更精确的错误信息和处理机制。
class ValidationError(Exception):
"""自定义验证异常"""
def __init__(self, message, field=None):
self.message = message
self.field = field
super().__init__(self.message)
def validate_age(age):
if age < 0 or age > 150:
raise ValidationError("年龄必须在0-150之间", "age")探索Python丰富的标准库和第三方库，扩展程序功能，提高开发效率。
Python标准库提供了丰富的功能模块，无需安装即可使用。
import json
import csv
import re
import sqlite3
from collections import defaultdict, Counter
from datetime import datetime, timedelta
# JSON处理
data = {"name": "张三", "age": 25}
json_str = json.dumps(data, ensure_ascii=False)
print(json_str)虚拟环境是Python项目开发的重要工具，用于隔离不同项目的依赖。
掌握Python测试和调试技巧，确保代码质量和开发效率。
单元测试是确保代码质量的重要手段，Python提供了unittest模块。
import unittest
class Calculator:
"""计算器类"""
def add(self, a, b):
return a + b
def subtract(self, a, b):
return a - b
def multiply(self, a, b):
return a * b
def divide(self, a, b):
if b == 0:
raise ValueError("除数不能为零")
return a / b
class TestCalculator(unittest.TestCase):
"""计算器测试类"""
def setUp(self):
"""测试前的准备工作"""
self.calc = Calculator()
def test_add(self):
"""测试加法"""
self.assertEqual(self.calc.add(2, 3), 5)
self.assertEqual(self.calc.add(-1, 1), 0)
self.assertEqual(self.calc.add(0, 0), 0)
def test_subtract(self):
"""测试减法"""
self.assertEqual(self.calc.subtract(5, 3), 2)
self.assertEqual(self.calc.subtract(1, 1), 0)
def test_multiply(self):
"""测试乘法"""
self.assertEqual(self.calc.multiply(2, 3), 6)
self.assertEqual(self.calc.multiply(0, 5), 0)
def test_divide(self):
"""测试除法"""
self.assertEqual(self.calc.divide(6, 2), 3)
self.assertEqual(self.calc.divide(5, 2), 2.5)
def test_divide_by_zero(self):
"""测试除零异常"""
with self.assertRaises(ValueError):
self.calc.divide(10, 0)
def tearDown(self):
"""测试后的清理工作"""
pass
# 运行测试
if __name__ == '__main__':
unittest.main()Python提供了多种调试工具和方法。
import pdb
import logging
# 设置日志
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
filename='app.log'
)
logger = logging.getLogger(__name__)
def debug_function():
"""演示调试技巧的函数"""
x = 10
y = 20
# 方法1：print调试
print(f"x = {x}, y = {y}")
# 方法2：pdb调试器
pdb.set_trace() # 程序会在这里暂停，进入调试模式
# 方法3：日志记录
logger.info(f"开始计算，x={x}, y={y}")
result = x + y
logger.info(f"计算结果：{result}")
return result
# 调试命令示例
# n (next): 执行下一行
# s (step): 步入函数
# c (continue): 继续执行
# p variable: 打印变量值
# l (list): 显示当前代码
# q (quit): 退出调试器
# 使用断言进行调试
def calculate_average(numbers):
"""计算平均值"""
assert len(numbers) > 0, "列表不能为空"
assert all(isinstance(x, (int, float)) for x in numbers), "所有元素必须是数字"
return sum(numbers) / len(numbers)
# 测试断言
try:
result = calculate_average([])
except AssertionError as e:
print(f"断言失败：{e}")
综合运用所学知识，创建一个完整的学生管理系统。
import json
import os
from datetime import datetime
class Student:
"""学生类"""
def __init__(self, student_id, name, age, major):
self.student_id = student_id
self.name = name
self.age = age
self.major = major
self.courses = []
self.grades = {}
def add_course(self, course_name):
"""添加课程"""
if course_name not in self.courses:
self.courses.append(course_name)
self.grades[course_name] = None
return True
return False
def set_grade(self, course_name, grade):
"""设置成绩"""
if course_name in self.courses:
if 0 <= grade <= 100:
self.grades[course_name] = grade
return True
return False
def get_average_grade(self):
"""计算平均成绩"""
valid_grades = [g for g in self.grades.values() if g is not None]
return sum(valid_grades) / len(valid_grades) if valid_grades else 0
def to_dict(self):
"""转换为字典格式"""
return {
'student_id': self.student_id,
'name': self.name,
'age': self.age,
'major': self.major,
'courses': self.courses,
'grades': self.grades
}
@classmethod
def from_dict(cls, data):
"""从字典创建学生对象"""
student = cls(data['student_id'], data['name'], data['age'], data['major'])
student.courses = data['courses']
student.grades = data['grades']
return student
class StudentManager:
"""学生管理器"""
def __init__(self, filename="students.json"):
self.filename = filename
self.students = {}
self.load_data()
def add_student(self, student_id, name, age, major):
"""添加学生"""
if student_id not in self.students:
student = Student(student_id, name, age, major)
self.students[student_id] = student
self.save_data()
return True
return False
def remove_student(self, student_id):
"""删除学生"""
if student_id in self.students:
del self.students[student_id]
self.save_data()
return True
return False
def get_student(self, student_id):
"""获取学生信息"""
return self.students.get(student_id)
def list_students(self):
"""列出所有学生"""
return list(self.students.values())
def search_students(self, keyword):
"""搜索学生"""
results = []
for student in self.students.values():
if (keyword.lower() in student.name.lower() or
keyword in student.student_id or
keyword.lower() in student.major.lower()):
results.append(student)
return results
def save_data(self):
"""保存数据到文件"""
data = {sid: student.to_dict() for sid, student in self.students.items()}
with open(self.filename, 'w', encoding='utf-8') as f:
json.dump(data, f, ensure_ascii=False, indent=2)
def load_data(self):
"""从文件加载数据"""
if os.path.exists(self.filename):
try:
with open(self.filename, 'r', encoding='utf-8') as f:
data = json.load(f)
self.students = {sid: Student.from_dict(student_data)
for sid, student_data in data.items()}
except Exception as e:
print(f"加载数据失败：{e}")
def main():
"""主程序"""
manager = StudentManager()
while True:
print("\n=== 学生管理系统 ===")
print("1. 添加学生")
print("2. 删除学生")
print("3. 查询学生")
print("4. 列出所有学生")
print("5. 添加课程")
print("6. 设置成绩")
print("7. 搜索学生")
print("0. 退出")
choice = input("请选择操作：")
if choice == '1':
student_id = input("学号：")
name = input("姓名：")
age = int(input("年龄："))
major = input("专业：")
if manager.add_student(student_id, name, age, major):
print("添加成功！")
else:
print("学号已存在！")
elif choice == '2':
student_id = input("请输入要删除的学号：")
if manager.remove_student(student_id):
print("删除成功！")
else:
print("学号不存在！")
elif choice == '3':
student_id = input("请输入学号：")
student = manager.get_student(student_id)
if student:
print(f"学号：{student.student_id}")
print(f"姓名：{student.name}")
print(f"年龄：{student.age}")
print(f"专业：{student.major}")
print(f"课程：{student.courses}")
print(f"成绩：{student.grades}")
print(f"平均分：{student.get_average_grade():.2f}")
else:
print("学号不存在！")
elif choice == '4':
students = manager.list_students()
if students:
for student in students:
print(f"{student.student_id} - {student.name} - {student.major}")
else:
print("暂无学生信息")
elif choice == '5':
student_id = input("请输入学号：")
course = input("请输入课程名：")
student = manager.get_student(student_id)
if student and student.add_course(course):
manager.save_data()
print("课程添加成功！")
else:
print("操作失败！")
elif choice == '6':
student_id = input("请输入学号：")
course = input("请输入课程名：")
grade = float(input("请输入成绩："))
student = manager.get_student(student_id)
if student and student.set_grade(course, grade):
manager.save_data()
print("成绩设置成功！")
else:
print("操作失败！")
elif choice == '7':
keyword = input("请输入搜索关键词：")
results = manager.search_students(keyword)
if results:
for student in results:
print(f"{student.student_id} - {student.name} - {student.major}")
else:
print("未找到匹配的学生")
elif choice == '0':
print("感谢使用！")
break
else:
print("无效选择，请重试！")
if __name__ == "__main__":
main()
良好的代码规范是专业开发的基础。
# 良好的代码示例
"""
学生管理系统
作者：张三
日期：2024-01-01
"""
import json
import os
from datetime import datetime
from typing import List, Dict, Optional
class Student:
"""学生类，用于管理学生信息。"""
def __init__(self, student_id: str, name: str, age: int, major: str):
"""
初始化学生对象。
Args:
student_id: 学号
name: 姓名
age: 年龄
major: 专业
"""
self.student_id = student_id
self.name = name
self.age = age
self.major = major
self.courses: List[str] = []
self.grades: Dict[str, float] = {}
def add_course(self, course_name: str) -> bool:
"""
添加课程。
Args:
course_name: 课程名称
Returns:
bool: 添加是否成功
"""
if course_name not in self.courses:
self.courses.append(course_name)
self.grades[course_name] = None
return True
return False
def get_average_grade(self) -> float:
"""
计算平均成绩。
Returns:
float: 平均成绩
"""
valid_grades = [g for g in self.grades.values() if g is not None]
return sum(valid_grades) / len(valid_grades) if valid_grades else 0.0
def main():
"""主函数。"""
print("学生管理系统启动...")
# 主程序逻辑
if __name__ == "__main__":
main()
要求：请完成以下六个编程任务，综合运用本课程所学知识。
创建一个Python程序，完成以下操作：
type()函数检查每个变量的类型id()函数显示对象的内存地址a = [1, 2, 3]
b = a
print(id(a), id(b)) # 两个变量指向同一对象
b.append(4)
print(a) # a也会变化
is和==比较变量，体会它们的区别。
编写一个学生成绩管理系统，包含以下功能：
calculate_grade(score)，根据分数返回等级（A、B、C、D、F）process_students(student_scores)，接收学生成绩列表，使用循环处理每个学生def calculate_grade(score):
"""根据分数返回等级"""
if score >= 90:
return 'A'
elif score >= 80:
return 'B'
elif score >= 70:
return 'C'
elif score >= 60:
return 'D'
else:
return 'F'
students = [88, 92, 76, 54]
for s in students:
print(calculate_grade(s))
创建一个文件操作程序，实现以下功能：
create_sample_file(filename)，创建一个包含多行文本的示例文件analyze_file(filename)，分析文件内容并返回统计信息（行数、字符数、单词数）append_to_file(filename, text)，将文本追加到文件末尾with语句确保文件正确关闭def create_sample_file(filename):
with open(filename, 'w', encoding='utf-8') as f:
f.write("Hello, world!\nThis is a test file.\nPython is fun!\n")
def analyze_file(filename):
try:
with open(filename, 'r', encoding='utf-8') as f:
lines = f.readlines()
line_count = len(lines)
char_count = sum(len(line) for line in lines)
word_count = sum(len(line.split()) for line in lines)
return line_count, char_count, word_count
except Exception as e:
print("文件分析出错：", e)
return 0, 0, 0
创建一个图书管理系统，运用面向对象编程思想：
Book类，包含书名、作者、价格、库存等属性Library类，管理图书的增删改查功能EBook类继承Book类__str__、__repr__、__eq__等）class Book:
def __init__(self, title, author, price):
self.title = title
self.author = author
self.price = price
def __str__(self):
return f"《{self.title}》 作者：{self.author}"
def __eq__(self, other):
return (self.title == other.title and
self.author == other.author)
class Library:
def __init__(self):
self.books = []
def add_book(self, book):
self.books.append(book)
def find_book(self, title):
return [book for book in self.books if title in book.title]
运用Python高级特性完成以下任务：
# 列表推导式示例
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
squares = [x**2 for x in numbers if x % 2 == 0]
# 生成器函数
def fibonacci():
a, b = 0, 1
while True:
yield a
a, b = b, a + b
# 装饰器示例
def timer(func):
def wrapper(*args, **kwargs):
import time
start = time.time()
result = func(*args, **kwargs)
end = time.time()
print(f"{func.__name__} 执行时间：{end - start:.4f}秒")
return result
return wrapper
综合运用标准库和开发工具：
json模块处理数据序列化和反序列化csv模块读写CSV文件re模块进行正则表达式匹配collections模块的Counter、defaultdict等unittest模块logging模块记录程序日志import json
import csv
import re
from collections import Counter
import unittest
import logging
# JSON处理
data = {"name": "张三", "age": 25}
json_str = json.dumps(data, ensure_ascii=False)
# CSV处理
with open('data.csv', 'w', newline='', encoding='utf-8') as f:
writer = csv.writer(f)
writer.writerow(['姓名', '年龄'])
writer.writerow(['张三', 25])
# 正则表达式
text = "邮箱：zhang@example.com，电话：138-1234-5678"
emails = re.findall(r'\b\w+@\w+\.\w+\b', text)
# 计数器
words = ['apple', 'banana', 'apple', 'cherry']
word_count = Counter(words)
def f(a, b):
c = a + b
return c
x = 1
y = 2
z = f(x, y)
print(z)
lst = [1, 2, 3]
print(lst[5])
with open('nofile.txt') as f:
data = f.read()
# 原始脚本
name = input('请输入姓名: ')
age = int(input('请输入年龄: '))
print(f'姓名: {name}, 年龄: {age}')