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

实际应用示例

# 在实际应用中,我们经常需要处理用户输入的数据类型转换
user_input = input("请输入你的年龄:")
# 输入的内容是字符串,需要转换为整数才能进行数值比较
age = int(user_input)
if age >= 18:
print("你已经成年了!")
else:
print("你还未成年。")

数学函数

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]

  1. 使用内置函数计算列表中所有元素的和、平均值
  2. 找出列表中的最大值和最小值
  3. 对列表进行排序并打印结果
  4. 计算列表中大于50的元素个数

作业2:学生信息管理

给定以下学生信息:

students = ["张三", "李四", "王五", "赵六"]
scores = [88, 92, 78, 95]
  1. 使用zip函数将学生姓名和成绩配对
  2. 使用enumerate函数为每个学生添加排名(从1开始)
  3. 找出成绩最高的学生和成绩最低的学生
  4. 计算班级的平均成绩

作业3:文件操作

编写一个程序,实现以下功能:

  1. 创建一个文本文件,写入5个城市的名称和人口数量(每行一个城市)
  2. 关闭文件并重新打开,读取文件内容
  3. 统计文件中有多少行数据
  4. 找出人口最多的城市

示例格式:北京,21540000

作业4:数据类型转换

编写一个程序,实现以下功能:

  1. 获取用户输入的三个数字(可能是整数或小数)
  2. 将这些输入转换为合适的数值类型
  3. 计算这三个数字的和、平均值、最大值和最小值
  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}
]
  1. 计算这些模型的平均参数量(单位:十亿)
  2. 找出参数量最大的模型
  3. 统计开源模型的数量
  4. 按发布年份对模型进行排序
  5. 将所有模型的名称和年份信息写入到一个文本文件中