Python内置函数
学习Python中常用的内置函数,提升编程效率和代码质量
内置函数概述
Python内置函数是Python解释器自带的函数,无需导入任何模块即可直接使用。这些函数覆盖了编程中常见的操作,大大提高了编程效率。
为什么要学习内置函数?
- 内置函数是Python的核心功能,无需额外导入
- 它们经过优化,通常比自定义函数效率更高
- 使用内置函数可以使代码更简洁、更易读
- 掌握内置函数是Python编程的基础
提示
Python有60多个内置函数,我们将重点学习最常用、最实用的一部分。使用内置函数时,注意区分大小写。
类型转换函数
类型转换函数用于在不同的数据类型之间进行转换,是Python中最常用的内置函数之一。
常用类型转换函数详解
int(x, base=10)
- 将x转换为整数类型
将数字或字符串转换为整数。可以指定进制(默认为十进制),常用于处理用户输入的数字字符串。
# 基础用法:将浮点数转换为整数(向下取整)
print(int(3.9)) # 输出: 3
# 将字符串转换为整数
print(int("42")) # 输出: 42
# 指定进制转换
print(int("1010", 2)) # 二进制转十进制,输出: 10
print(int("FF", 16)) # 十六进制转十进制,输出: 255
# 实际应用:计算商品总价
price_str = "99.99"
quantity_str = "3"
# 先将价格转为浮点数计算,再转为整数表示总价(分)
total_cents = int(float(price_str) * 100 * int(quantity_str))
print(f"总价:{total_cents}分") # 输出: 总价:29997分
float(x)
- 将x转换为浮点数类型
将整数或字符串转换为浮点数,常用于需要小数精度的计算场景。
# 基础用法:将整数转换为浮点数
print(float(42)) # 输出: 42.0
# 将字符串转换为浮点数
print(float("3.14")) # 输出: 3.14
# 实际应用:计算折扣价格
original_price = "199"
discount_rate = "0.8"
discounted_price = float(original_price) * float(discount_rate)
print(f"折扣后价格:{discounted_price:.2f}元") # 输出: 折扣后价格:159.20元
str(object='')
- 将对象转换为字符串类型
将任何Python对象转换为字符串表示形式,是字符串拼接和格式化的基础。
# 基础用法:将数字转换为字符串
print(str(123)) # 输出: "123"
# 将列表转换为字符串
print(str([1, 2, 3])) # 输出: "[1, 2, 3]"
# 实际应用:构建用户欢迎信息
user_id = 1001
username = "小明"
login_count = 5
welcome_msg = "欢迎回来," + str(username) + "!您是用户ID: " + str(user_id) + ",这是您第" + str(login_count) + "次登录。"
print(welcome_msg) # 输出: 欢迎回来,小明!您是用户ID: 1001,这是您第5次登录。
bool(x)
- 将x转换为布尔值(True或False)
根据Python的真假规则将值转换为布尔类型。在Python中,0、空序列、空字典等被视为False,其他值一般视为True。
# 基础用法:检查值的真假
print(bool(0)) # 输出: False
print(bool("hello")) # 输出: True
print(bool([])) # 输出: False
print(bool([1])) # 输出: True
# 实际应用:验证用户输入是否为空
user_input = input("请输入您的名字:")
if bool(user_input):
print(f"您好,{user_input}!")
else:
print("您没有输入名字!")
list(x)
将可迭代对象转换为列表。
# 将字符串转为列表
print(list("abc")) # ['a', 'b', 'c']
# 将元组转为列表
t = (1, 2, 3)
print(list(t)) # [1, 2, 3]
tuple(x)
将可迭代对象转换为元组(不可变序列)。
# 将列表转为元组
l = [1, 2, 3]
print(tuple(l)) # (1, 2, 3)
# 将集合转为元组
s = {1, 2, 3}
print(tuple(s)) # (1, 2, 3) 顺序可能不同
set(x)
将可迭代对象转换为集合(无重复元素)。
# 去除列表中的重复元素
l = [1, 2, 2, 3, 3, 3]
print(set(l)) # {1, 2, 3}
# 实际应用:统计不同单词数量
text = "hello world hello python"
words = text.split()
unique_words = set(words)
print(f"不同单词数量:{len(unique_words)}") # 输出: 不同单词数量:3
实际应用示例
数学函数
Python提供了一些基本的数学运算内置函数,用于处理数值计算。
常用数学函数详解
abs(x)
- 返回x的绝对值
计算并返回一个数的绝对值,即距离0的距离,常用于处理可能为负数的数值。
# 基础用法:计算绝对值
print(abs(-5)) # 输出: 5
print(abs(3.14)) # 输出: 3.14
# 实际应用:计算温度差异
current_temp = 25
target_temp = 20
temp_diff = abs(current_temp - target_temp)
print(f"温度差异为:{temp_diff}°C") # 输出: 温度差异为:5°C
# 实际应用:计算距离
x1, y1 = 3, 5 # 点1坐标
x2, y2 = 7, 2 # 点2坐标
# 计算横向和纵向距离(绝对值)
dx = abs(x2 - x1)
dy = abs(y2 - y1)
print(f"横向距离:{dx},纵向距离:{dy}") # 输出: 横向距离:4,纵向距离:3
round(x[, n])
- 将x四舍五入到n位小数
将数字四舍五入到指定的小数位数,默认为整数。常用于金融计算和数据展示。
# 基础用法:四舍五入
print(round(3.14159)) # 输出: 3
print(round(3.14159, 2)) # 输出: 3.14
print(round(2.5)) # 输出: 2 (注意:Python中0.5会舍入到最近的偶数)
# 实际应用:计算商品价格和税费
price = 99.99
tax_rate = 0.13 # 13%的税率
tax = price * tax_rate
total = price + tax
# 保留两位小数,符合货币显示习惯
print(f"商品价格:{price:.2f}元") # 输出: 商品价格:99.99元
print(f"税额:{round(tax, 2):.2f}元") # 输出: 税额:12.99元
print(f"总价:{round(total, 2):.2f}元") # 输出: 总价:112.98元
max(x1, x2, ...) 或 max(iterable)
- 返回最大值
返回多个值或可迭代对象中的最大值,常用于比较数据和寻找极值。
# 基础用法:比较多个值
print(max(1, 3, 2)) # 输出: 3
# 在列表中找最大值
numbers = [5, 8, 3, 12, 7]
print(max(numbers)) # 输出: 12
# 实际应用:找出考试最高分
scores = [85, 92, 78, 90, 88]
highest_score = max(scores)
print(f"本次考试最高分:{highest_score}分") # 输出: 本次考试最高分:92分
# 实际应用:找出价格最高的商品
products = [
{"name": "手机", "price": 3999},
{"name": "平板", "price": 2999},
{"name": "笔记本", "price": 5999}
]
# 使用key参数指定比较的依据
most_expensive = max(products, key=lambda p: p["price"])
print(f"最贵的商品:{most_expensive['name']},价格:{most_expensive['price']}元") # 输出: 最贵的商品:笔记本,价格:5999元
min(x1, x2, ...) 或 min(iterable)
- 返回最小值
返回多个值或可迭代对象中的最小值,与max()函数相对应,同样用于比较数据和寻找极值。
# 基础用法:比较多个值
print(min(1, 3, 2)) # 输出: 1
# 在列表中找最小值
temperatures = [25, 18, 30, 22, 15]
print(min(temperatures)) # 输出: 15
# 实际应用:找出最优惠的价格
prices = [99.99, 89.50, 120.00, 75.25, 89.50]
cheapest_price = min(prices)
print(f"最优惠的价格:{cheapest_price}元") # 输出: 最优惠的价格:75.25元
# 实际应用:找出最早注册的用户
users = [
{"name": "小明", "registration_date": 20230115},
{"name": "小红", "registration_date": 20230322},
{"name": "小华", "registration_date": 20221205}
]
# 使用key参数指定比较的依据
earliest_user = min(users, key=lambda u: u["registration_date"])
print(f"最早注册的用户:{earliest_user['name']},注册日期:{earliest_user['registration_date']}") # 输出: 最早注册的用户:小华,注册日期:20221205
sum(iterable[, start])
- 返回可迭代对象中元素的和
计算可迭代对象中所有元素的总和,可以指定起始值(默认为0),是数据分析和统计计算的基础函数。
# 基础用法:计算列表元素和
numbers = [1, 2, 3, 4, 5]
print(sum(numbers)) # 输出: 15
# 指定起始值
print(sum(numbers, 10)) # 输出: 25 (15 + 10)
# 实际应用:计算月支出总额
expenses = [
{"category": "餐饮", "amount": 1200},
{"category": "交通", "amount": 300},
{"category": "购物", "amount": 800},
{"category": "房租", "amount": 3500}
]
# 使用列表推导式提取金额并求和
total_expense = sum(item["amount"] for item in expenses)
print(f"本月总支出:{total_expense}元") # 输出: 本月总支出:5800元
# 实际应用:计算平均值
scores = [85, 92, 78, 90, 88]
if len(scores) > 0:
average_score = sum(scores) / len(scores)
print(f"平均分数:{average_score:.2f}") # 输出: 平均分数:86.60
pow(x, y[, z])
- 返回x的y次方,可选对z取模
计算x的y次方,也可以计算x的y次方对z取模的结果,常用于数学计算和加密算法。
# 基础用法:计算幂
print(pow(2, 3)) # 输出: 8
print(pow(5, 2)) # 输出: 25
# 计算幂并取模
print(pow(2, 10, 1000)) # 输出: 24 (1024 % 1000 = 24)
# 实际应用:计算复利
principal = 10000 # 本金
rate = 0.05 # 年利率5%
years = 5 # 存5年
# 复利计算公式:本金 * (1 + 年利率) ** 年数
future_value = principal * pow(1 + rate, years)
print(f"{years}年后的本息和:{future_value:.2f}元") # 输出: 5年后的本息和:12762.82元
# 实际应用:计算正方形面积
side_length = 5
area = pow(side_length, 2)
print(f"边长为{side_length}的正方形面积:{area}") # 输出: 边长为5的正方形面积:25
实际应用示例
# 计算一组考试成绩的统计信息
scores = [85, 92, 78, 90, 88]
# 计算总分
total = sum(scores)
# 计算平均分
average = total / len(scores)
# 最高分
highest = max(scores)
# 最低分
lowest = min(scores)
print(f"总分: {total}")
print(f"平均分: {average:.2f}")
print(f"最高分: {highest}")
print(f"最低分: {lowest}")
序列操作函数
序列操作函数用于处理Python中的列表、元组、字符串等序列类型的数据。
常用序列操作函数详解
len(s)
- 返回对象的长度或元素个数
计算并返回容器类型对象(如字符串、列表、元组、字典等)中元素的数量,是最常用的内置函数之一。
# 基础用法:计算不同类型对象的长度
print(len("hello")) # 输出: 5
print(len([1, 2, 3, 4])) # 输出: 4
print(len({"name": "小明", "age": 18})) # 输出: 2
# 实际应用:检查列表是否为空
shopping_cart = []
if len(shopping_cart) == 0:
print("购物车为空,请添加商品!")
else:
print(f"购物车中有{len(shopping_cart)}件商品")
# 实际应用:验证用户名长度
username = input("请输入用户名(3-10个字符):")
if len(username) < 3:
print("用户名太短!")
elif len(username) > 10:
print("用户名太长!")
else:
print(f"用户名'{username}'长度合适")
sorted(iterable, key=None, reverse=False)
- 返回排序后的新列表
对可迭代对象进行排序,返回一个新的已排序列表,不会修改原对象。可以指定排序键和排序方向。
# 基础用法:对数字列表排序
numbers = [5, 2, 9, 1, 5, 6]
print(sorted(numbers)) # 输出: [1, 2, 5, 5, 6, 9]
# 降序排序
print(sorted(numbers, reverse=True)) # 输出: [9, 6, 5, 5, 2, 1]
# 实际应用:对学生成绩排序
scores = [85, 92, 78, 90, 88]
sorted_scores = sorted(scores, reverse=True)
print(f"成绩从高到低排序:{sorted_scores}") # 输出: 成绩从高到低排序:[92, 90, 88, 85, 78]
# 实际应用:对字典列表按指定键排序
students = [
{"name": "小明", "score": 85},
{"name": "小红", "score": 92},
{"name": "小华", "score": 78}
]
# 按成绩排序(使用key参数)
sorted_students = sorted(students, key=lambda s: s["score"], reverse=True)
print("按成绩排序的学生列表:")
for student in sorted_students:
print(f"{student['name']}: {student['score']}分")
enumerate(iterable, start=0)
- 返回索引-元素对的迭代器
将一个可迭代对象转换为索引-元素对的形式,常用于需要跟踪元素位置的循环中。
# 基础用法:获取索引和元素
fruits = ["苹果", "香蕉", "橙子"]
for index, fruit in enumerate(fruits):
print(f"索引 {index}: {fruit}")
# 输出:
# 索引 0: 苹果
# 索引 1: 香蕉
# 索引 2: 橙子
# 指定起始索引
for index, fruit in enumerate(fruits, start=1):
print(f"第{index}个水果: {fruit}")
# 输出:
# 第1个水果: 苹果
# 第2个水果: 香蕉
# 第3个水果: 橙子
# 实际应用:给学生排名
scores = [85, 92, 78, 90, 88]
# 先排序(降序)
sorted_scores = sorted(scores, reverse=True)
print("成绩排名:")
for rank, score in enumerate(sorted_scores, start=1):
print(f"第{rank}名: {score}分")
zip(*iterables)
- 将多个可迭代对象的元素配对
将多个可迭代对象中对应位置的元素打包成元组,返回这些元组的迭代器,常用于组合相关数据。
# 基础用法:配对两个列表
s_names = ["张三", "李四", "王五"]
s_scores = [88, 92, 78]
for name, score in zip(s_names, s_scores):
print(f"{name}: {score}分")
# 输出:
# 张三: 88分
# 李四: 92分
# 王五: 78分
# 实际应用:创建学生信息字典
s_students = []
for name, score in zip(s_names, s_scores):
student = {"name": name, "score": score}
s_students.append(student)
print("学生信息列表:")
for student in s_students:
print(student)
# 实际应用:多学科成绩配对
math_scores = [85, 92, 78]
english_scores = [88, 85, 90]
chinese_scores = [90, 88, 82]
print("各科成绩汇总:")
for name, math, english, chinese in zip(s_names, math_scores, english_scores, chinese_scores):
total = math + english + chinese
average = total / 3
print(f"{name}: 数学{math}, 英语{english}, 语文{chinese}, 总分{total}, 平均分{average:.2f}")
any(iterable)
检查可迭代对象中是否至少有一个元素为真。
# 基础用法
print(any([False, True, False])) # 输出: True
print(any([0, "", None])) # 输出: False
# 实际应用:检查是否有不及格的成绩
exam_scores = [85, 72, 90, 68, 95]
has_failed = any(score < 60 for score in exam_scores)
print(f"是否有不及格:{has_failed}") # 输出: 是否有不及格:False
all(iterable)
检查可迭代对象中是否所有元素都为真。
# 基础用法
print(all([True, True, False])) # 输出: False
print(all([1, "hello", [2, 3]])) # 输出: True
# 实际应用:检查是否所有学生都及格
exam_scores = [85, 72, 90, 68, 95]
all_passed = all(score >= 60 for score in exam_scores)
print(f"是否全部及格:{all_passed}") # 输出: 是否全部及格:True
reversed(seq)
- 返回反向迭代器
返回一个反向序列的迭代器,常用于需要逆序处理数据的场景。
# 基础用法:反转列表
numbers = [1, 2, 3, 4, 5]
reversed_numbers = list(reversed(numbers))
print(reversed_numbers) # 输出: [5, 4, 3, 2, 1]
# 实际应用:逆序显示历史记录
browsing_history = ["首页", "产品页", "购物车", "结算页", "订单确认页"]
print("最近浏览记录(倒序):")
for i, page in enumerate(reversed(browsing_history), 1):
print(f"{i}. {page}")
# 实际应用:生成倒计时
def countdown(n):
print("倒计时开始:")
for i in reversed(range(1, n+1)):
print(i)
print("时间到!")
countdown(5) # 从5开始倒计时到1
输入输出函数
除了常用的print和input函数,Python还提供了其他一些用于文件操作和数据序列化的内置函数。
常用输入输出函数详解
open(file, mode='r', encoding=None)
- 打开文件并返回文件对象
用于打开或创建文件,是文件操作的基础函数,支持多种文件访问模式。
# 基础用法:读取文件
with open("example.txt", "r", encoding="utf-8") as f:
content = f.read()
print(content)
# 基础用法:写入文件
with open("output.txt", "w", encoding="utf-8") as f:
f.write("这是写入的内容\n")
f.write("第二行内容")
# 实际应用:学生成绩记录系统
students = [
{"name": "小明", "score": 85},
{"name": "小红", "score": 92},
{"name": "小华", "score": 78}
]
# 将学生成绩保存到文件
with open("student_scores.txt", "w", encoding="utf-8") as f:
f.write("姓名,分数\n") # 写入表头
for student in students:
f.write(f"{student['name']},{student['score']}\n")
# 从文件读取学生成绩
saved_students = []
with open("student_scores.txt", "r", encoding="utf-8") as f:
lines = f.readlines()
# 跳过表头
for line in lines[1:]:
name, score = line.strip().split(",")
saved_students.append({"name": name, "score": int(score)})
print("从文件读取的学生成绩:")
for student in saved_students:
print(f"{student['name']}: {student['score']}分")
常见文件模式:
'r'- 只读模式(默认)'w'- 写入模式,会覆盖已有内容'a'- 追加模式,在文件末尾添加内容'x'- 独占创建模式,文件不存在时才创建'b'- 二进制模式(与其他模式组合使用,如 'rb', 'wb')'+'- 读写模式(与其他模式组合使用,如 'r+', 'w+')
help([object])
- 显示对象的帮助信息
获取关于Python对象、函数、模块等的帮助信息,是学习和理解Python功能的重要工具。
# 基础用法:获取内置函数的帮助
help(print)
help(len)
# 获取数据类型的帮助
help(str)
help(list)
# 实际应用:学习新模块
import math
help(math)
help(math.sqrt) # 获取特定函数的帮助
# 获取自定义函数的帮助
def calculate_area(radius):
"""计算圆的面积
参数:
radius -- 圆的半径
返回:
圆的面积
"""
return math.pi * radius ** 2
help(calculate_area) # 将显示我们定义的文档字符串
dir([object])
- 显示对象的属性和方法
列出对象的所有属性和方法,帮助开发者了解对象可以执行哪些操作。
# 基础用法:查看字符串对象的方法和属性
print(dir(str))
# 查看列表对象的方法和属性
print(dir(list))
# 实际应用:探索未知对象
unknown_obj = "这是一个字符串"
# 列出对象的所有属性和方法
available_methods = dir(unknown_obj)
print(f"'{unknown_obj}'对象可用的方法和属性:")
# 筛选出非私有方法(不以__开头和结尾的)
public_methods = [method for method in available_methods if not method.startswith('__')]
for method in public_methods:
print(f"- {method}")
# 查看自定义对象的属性
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def greet(self):
return f"你好,我是{self.name}"
p = Person("小明", 18)
print(dir(p)) # 将显示name、age属性和greet方法等
type(object)
- 返回对象的类型
用于确定对象的确切类型,在调试和类型检查时非常有用。
# 基础用法:检查数据类型
print(type(42)) # 输出:
print(type(3.14)) # 输出:
print(type("hello")) # 输出:
print(type([1, 2, 3])) # 输出:
print(type({"name": "小明"})) # 输出:
# 实际应用:根据数据类型执行不同操作
def process_data(data):
data_type = type(data)
if data_type == int:
print(f"整数处理: {data}的平方是{data**2}")
elif data_type == float:
print(f"浮点数处理: {data}四舍五入为{round(data)}")
elif data_type == str:
print(f"字符串处理: '{data}'的长度是{len(data)}")
elif data_type == list:
print(f"列表处理: 列表有{len(data)}个元素")
else:
print(f"未知类型: {data_type}")
# 测试不同类型的数据
process_data(5)
process_data(3.14)
process_data("hello")
process_data([1, 2, 3])
process_data({"name": "小明"})
下面是一个综合使用输入输出函数的实际案例:
# 学生成绩管理系统
import os
# 定义文件路径
file_path = "student_grades.txt"
# 检查文件是否存在,如果不存在则创建
if not os.path.exists(file_path):
with open(file_path, "w", encoding="utf-8") as f:
f.write("学号,姓名,数学,语文,英语\n")
# 显示菜单
while True:
print("\n===== 学生成绩管理系统 =====")
print("1. 添加学生成绩")
print("2. 查看所有成绩")
print("3. 退出系统")
choice = input("请选择操作(1-3): ")
if choice == "1":
# 添加学生成绩
student_id = input("请输入学号: ")
name = input("请输入姓名: ")
math = input("请输入数学成绩: ")
chinese = input("请输入语文成绩: ")
english = input("请输入英语成绩: ")
# 写入文件
with open(file_path, "a", encoding="utf-8") as f:
f.write(f"{student_id},{name},{math},{chinese},{english}\n")
print("成绩添加成功!")
elif choice == "2":
# 查看所有成绩
print("\n所有学生成绩:")
print("=" * 50)
调试函数
Python提供了一些内置函数,帮助开发者进行代码调试和错误处理。
常用调试函数详解
print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
- 打印输出,用于简单调试
最基础的调试工具,可以将变量值、表达式结果等输出到控制台,帮助追踪程序执行流程和变量状态。
# 基础用法:打印变量和表达式
x = 10
y = 20
print("x的值:", x) # 输出: x的值: 10
print("x + y =", x + y) # 输出: x + y = 30
# 实际应用:调试循环
for i in range(5):
result = i * i
print(f"当i={i}时,i*i={result}")
# 实际应用:调试函数执行
def calculate_area(radius):
print(f"计算半径为{radius}的圆的面积")
area = 3.14 * radius ** 2
print(f"计算结果: {area}")
return area
# 调用函数并查看中间结果
result = calculate_area(5)
print(f"最终返回结果: {result}")
eval(expression[, globals[, locals]])
- 执行字符串表达式并返回结果
执行以字符串形式表示的Python表达式,并返回表达式的结果。在动态执行代码和调试时非常有用。
# 基础用法:执行简单表达式
result = eval("1 + 2 * 3")
print(result) # 输出: 7
# 计算数学表达式
math_expr = "2 ** 10 + 5"
result = eval(math_expr)
print(f"表达式 {math_expr} 的结果是: {result}") # 输出: 表达式 2 ** 10 + 5 的结果是: 1029
# 实际应用:简单计算器
def simple_calculator():
expression = input("请输入数学表达式: ")
try:
result = eval(expression)
print(f"计算结果: {result}")
except Exception as e:
print(f"计算错误: {e}")
# 测试计算器
simple_calculator()
安全警告:eval()函数会执行任何传入的Python代码,因此不要用于处理不可信的输入(如用户输入),这可能导致严重的安全问题。
下面是一个综合使用各种调试函数来解决问题的案例:
# 模拟一个有问题的程序
def calculate_average(numbers):
# 这个函数有bug,我们需要调试它
total = sum(numbers)
count = len(numbers)
average = total / count # 这里可能会有除零错误
return average
# 测试数据
# 正常情况
normal_data = [10, 20, 30, 40, 50]
# 边界情况
empty_data = []
# 异常情况
mixed_data = [10, 20, "30", 40, 50]
# 使用调试函数来分析和修复问题
print("=== 调试 calculate_average 函数 ===")
# 1. 测试正常情况
print("\n1. 测试正常情况:")
try:
result = calculate_average(normal_data)
print(f"正常数据的平均值: {result}")
except Exception as e:
print(f"错误: {type(e).__name__}: {e}")
# 2. 测试边界情况(空列表)
print("\n2. 测试边界情况(空列表):")
try:
result = calculate_average(empty_data)
print(f"空列表的平均值: {result}")
except Exception as e:
print(f"错误: {type(e).__name__}: {e}")
# 分析错误原因
print(f"空列表的长度: {len(empty_data)}")
# 3. 测试异常情况(混合类型)
print("\n3. 测试异常情况(混合类型):")
try:
result = calculate_average(mixed_data)
print(f"混合类型数据的平均值: {result}")
except Exception as e:
print(f"错误: {type(e).__name__}: {e}")
# 分析错误原因
for i, item in enumerate(mixed_data):
print(f"索引 {i}: 值='{item}', 类型={type(item)}")
# 4. 修复函数
print("\n4. 修复函数:")
def fixed_calculate_average(numbers):
# 添加类型检查
if type(numbers) is not list:
print("错误: 输入必须是列表类型")
return None
# 检查列表是否为空
if len(numbers) == 0:
print("错误: 列表不能为空")
return None
# 检查元素类型
for i, num in enumerate(numbers):
if type(num) not in (int, float):
print(f"错误: 索引 {i} 处的元素 '{num}' 不是数字类型")
return None
# 计算平均值
total = sum(numbers)
count = len(numbers)
average = total / count
return average
# 测试修复后的函数
print("\n5. 测试修复后的函数:")
print(f"正常数据结果: {fixed_calculate_average(normal_data)}")
print(f"空列表结果: {fixed_calculate_average(empty_data)}")
print(f"混合类型结果: {fixed_calculate_average(mixed_data)}")
实战案例
让我们通过一个实际案例来综合运用所学的内置函数。
案例:学生成绩管理系统
我们将创建一个简单的学生成绩管理系统,使用多种内置函数来实现数据处理和展示功能。
# 学生成绩管理系统
# 学生数据
students = [
{"name": "小明", "math": 85, "english": 92, "chinese": 78},
{"name": "小红", "math": 90, "english": 88, "chinese": 95},
{"name": "小华", "math": 78, "english": 82, "chinese": 88}
]
# 计算每个学生的总分和平均分
for student in students:
scores = [student["math"], student["english"], student["chinese"]]
total = sum(scores)
average = total / len(scores)
student["total"] = total
student["average"] = round(average, 2)
# 按总分排序学生列表
sorted_students = sorted(students, key=lambda s: s["total"], reverse=True)
# 显示学生信息和排名
print("\t学生成绩排名\n")
print("排名\t姓名\t数学\t英语\t语文\t总分\t平均分")
print("=" * 60)
for index, student in enumerate(sorted_students, 1):
print(f"{index}\t{student['name']}\t{student['math']}\t{student['english']}\t{student['chinese']}\t{student['total']}\t{student['average']}")
# 计算各科目的平均分
math_scores = [s["math"] for s in students]
english_scores = [s["english"] for s in students]
chinese_scores = [s["chinese"] for s in students]
print("\n各科目平均分:")
print(f"数学:{sum(math_scores)/len(math_scores):.2f}")
print(f"英语:{sum(english_scores)/len(english_scores):.2f}")
print(f"语文:{sum(chinese_scores)/len(chinese_scores):.2f}")
案例分析
在这个案例中,我们综合运用了多个内置函数:sum()计算总分,len()获取数量,round()四舍五入,sorted()排序,enumerate()获取索引等。这些内置函数使我们的代码更加简洁、高效。
作业
完成以下作业,巩固所学的Python内置函数知识:
作业1:数据处理
给定一个列表:numbers = [12, 45, 23, 67, 34, 89, 56, 78, 90, 32]
- 使用内置函数计算列表中所有元素的和、平均值
- 找出列表中的最大值和最小值
- 对列表进行排序并打印结果
- 计算列表中大于50的元素个数
作业2:学生信息管理
给定以下学生信息:
students = ["张三", "李四", "王五", "赵六"]
scores = [88, 92, 78, 95]
- 使用zip函数将学生姓名和成绩配对
- 使用enumerate函数为每个学生添加排名(从1开始)
- 找出成绩最高的学生和成绩最低的学生
- 计算班级的平均成绩
作业3:文件操作
编写一个程序,实现以下功能:
- 创建一个文本文件,写入5个城市的名称和人口数量(每行一个城市)
- 关闭文件并重新打开,读取文件内容
- 统计文件中有多少行数据
- 找出人口最多的城市
示例格式:北京,21540000
作业4:数据类型转换
编写一个程序,实现以下功能:
- 获取用户输入的三个数字(可能是整数或小数)
- 将这些输入转换为合适的数值类型
- 计算这三个数字的和、平均值、最大值和最小值
- 将结果格式化为字符串并打印,保留2位小数
作业5:结合热点
最近,AI技术发展迅速。请编写一个程序,使用所学的内置函数来处理一些与AI相关的数据:
ai_models = [
{"name": "ChatGPT", "year": 2022, "parameters": 175, "open_source": False},
{"name": "Llama 2", "year": 2023, "parameters": 70, "open_source": True},
{"name": "Claude", "year": 2023, "parameters": 100, "open_source": False},
{"name": "Gemini", "year": 2023, "parameters": 140, "open_source": False}
]
- 计算这些模型的平均参数量(单位:十亿)
- 找出参数量最大的模型
- 统计开源模型的数量
- 按发布年份对模型进行排序
- 将所有模型的名称和年份信息写入到一个文本文件中