跳到主要内容

Python 内置函数

Python作为一种强大的编程语言,内置了许多实用函数,让开发者无需重复造轮子。这些函数可以直接使用,不需要额外导入任何模块,大大提高了编程效率。本文将全面介绍Python中常用的内置函数,帮助初学者掌握这些基础但强大的工具。

什么是Python内置函数?

Python内置函数是Python解释器自带的函数,无需导入任何模块即可直接使用。它们提供了从基本数据类型转换到复杂操作的各种功能,是Python编程的基础工具箱。

提示

Python 3中共有约70个内置函数,我们会重点介绍最常用的那些,并按功能分类讲解。

数据类型转换函数

这类函数用于在不同的数据类型之间进行转换,非常实用。

int(), float(), str()

这三个函数用于基本数据类型转换:

python
# 将其他类型转换为整数
x = int(3.9) # 结果: 3
y = int("123") # 结果: 123

# 将其他类型转换为浮点数
a = float(5) # 结果: 5.0
b = float("3.14") # 结果: 3.14

# 将其他类型转换为字符串
c = str(42) # 结果: "42"
d = str(3.14159) # 结果: "3.14159"

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

这些函数用于转换或创建集合类型:

python
# 从其他可迭代对象创建列表
my_list = list("hello") # 结果: ['h', 'e', 'l', 'l', 'o']
my_list2 = list((1, 2, 3)) # 结果: [1, 2, 3]

# 从可迭代对象创建元组
my_tuple = tuple([1, 2, 3]) # 结果: (1, 2, 3)

# 从可迭代对象创建集合(会去除重复元素)
my_set = set([1, 2, 2, 3, 3]) # 结果: {1, 2, 3}

# 创建字典
my_dict = dict(a=1, b=2, c=3) # 结果: {'a': 1, 'b': 2, 'c': 3}
my_dict2 = dict([('a', 1), ('b', 2)]) # 结果: {'a': 1, 'b': 2}

数学相关函数

Python提供了一系列内置的数学函数,满足基本的数学计算需求。

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

python
# 绝对值
abs(-5) # 结果: 5
abs(3.14) # 结果: 3.14

# 四舍五入
round(3.14159, 2) # 结果: 3.14(保留两位小数)
round(5.5) # 结果: 6

# 最大值和最小值
max(5, 10, 3) # 结果: 10
max([1, 2, 3, 4]) # 结果: 4
min(5, 10, 3) # 结果: 3
min([1, 2, 3, 4]) # 结果: 1

# 求和
sum([1, 2, 3, 4]) # 结果: 10
sum([0.1, 0.2, 0.3], 2) # 结果: 2.6(2是起始值)

pow(), divmod()

python
# 幂运算
pow(2, 3) # 结果: 8(等同于2**3)
pow(2, 3, 5) # 结果: 3(等同于(2**3) % 5)

# 同时获取商和余数
divmod(13, 5) # 结果: (2, 3)(商为2,余数为3)

序列操作函数

这些函数用于处理序列类型(如列表、元组、字符串等)。

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

python
# 获取序列长度
len("hello") # 结果: 5
len([1, 2, 3]) # 结果: 3

# 排序(返回新列表)
sorted([3, 1, 4, 2]) # 结果: [1, 2, 3, 4]
sorted("hello") # 结果: ['e', 'h', 'l', 'l', 'o']
sorted([3, 1, 4, 2], reverse=True) # 结果: [4, 3, 2, 1]

# 反转序列(返回迭代器)
list(reversed([1, 2, 3])) # 结果: [3, 2, 1]

# 枚举(添加索引)
list(enumerate(["a", "b", "c"])) # 结果: [(0, 'a'), (1, 'b'), (2, 'c')]
# 可以指定起始索引
list(enumerate(["a", "b", "c"], 1)) # 结果: [(1, 'a'), (2, 'b'), (3, 'c')]

# 将多个可迭代对象打包成元组的列表
list(zip([1, 2, 3], ['a', 'b', 'c'])) # 结果: [(1, 'a'), (2, 'b'), (3, 'c')]

range(), slice()

python
# 生成一系列整数
list(range(5)) # 结果: [0, 1, 2, 3, 4]
list(range(2, 8)) # 结果: [2, 3, 4, 5, 6, 7]
list(range(1, 10, 2)) # 结果: [1, 3, 5, 7, 9]

# 创建切片对象
s = slice(1, 5, 2)
[1, 2, 3, 4, 5][s] # 结果: [2, 4](等同于[1, 2, 3, 4, 5][1:5:2])

对象检查和操作函数

这类函数用于检查对象的类型、属性或进行类型相关操作。

type(), isinstance(), issubclass(), id()

python
# 获取对象类型
type(42) # 结果: <class 'int'>
type("hello") # 结果: <class 'str'>
type([1, 2, 3]) # 结果: <class 'list'>

# 检查对象是否是某类型的实例
isinstance(42, int) # 结果: True
isinstance("hello", (str, int)) # 结果: True(是否为字符串或整数)

# 检查是否为子类
issubclass(bool, int) # 结果: True(布尔是整数的子类)

# 获取对象的唯一标识符
x = [1, 2, 3]
id(x) # 返回x对象的内存地址

dir(), help(), hasattr(), getattr()

python
# 列出对象的所有属性和方法
dir(str) # 列出字符串类的所有属性和方法
dir([]) # 列出列表对象的所有属性和方法

# 获取帮助文档
# help(str) # 显示字符串类的帮助文档
# help(print) # 显示print函数的帮助文档

# 检查对象是否有指定属性
hasattr(str, "upper") # 结果: True

# 获取对象的属性
my_list = [1, 2, 3]
getattr(my_list, "append")([4]) # 等同于my_list.append([4])
print(my_list) # 结果: [1, 2, 3, [4]]

输入输出函数

这些函数用于处理输入和输出。

python
# 打印输出
print("Hello, World!") # 结果: Hello, World!
print("x =", 10, "y =", 20) # 结果: x = 10 y = 20
print("a", "b", "c", sep="-") # 结果: a-b-c
print("Hello", end="! ") # 结果: Hello! (不换行)
print("World") # 结果: World

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

内置函数的实际应用案例

案例1:数据分析基本操作

python
# 假设我们有一组销售数据
sales = [120, 85, 190, 145, 95, 110, 75, 200, 160, 130]

# 基本统计分析
print(f"销售总额: {sum(sales)}")
print(f"最高销售额: {max(sales)}")
print(f"最低销售额: {min(sales)}")
print(f"平均销售额: {sum(sales) / len(sales)}")

# 排序分析
print(f"销售额从高到低排序: {sorted(sales, reverse=True)}")

# 数据转换
# 假设需要计算销售额的15%作为提成
commissions = list(map(lambda x: round(x * 0.15, 2), sales))
print(f"各销售额对应的提成: {commissions}")

# 销售与提成打包在一起
sales_and_comm = list(zip(sales, commissions))
print("销售额和对应提成:")
for sale, comm in sales_and_comm:
print(f"销售额: {sale}, 提成: {comm}")

输出示例:

销售总额: 1310
最高销售额: 200
最低销售额: 75
平均销售额: 131.0
销售额从高到低排序: [200, 190, 160, 145, 130, 120, 110, 95, 85, 75]
各销售额对应的提成: [18.0, 12.75, 28.5, 21.75, 14.25, 16.5, 11.25, 30.0, 24.0, 19.5]
销售额和对应提成:
销售额: 120, 提成: 18.0
销售额: 85, 提成: 12.75
销售额: 190, 提成: 28.5
...

案例2:文件处理

假设我们有一个包含学生成绩的CSV文件,需要处理并分析:

python
# 这里仅做示例,实际应用需要文件存在
def analyze_grades():
students = []

# 模拟从文件读取数据
data = [
"姓名,数学,英语,科学",
"张三,90,85,92",
"李四,75,80,85",
"王五,95,92,88",
"赵六,70,65,75",
"钱七,88,90,85"
]

# 解析数据
headers = data[0].split(',')
for line in data[1:]:
values = line.split(',')
student = {
headers[0]: values[0],
headers[1]: int(values[1]),
headers[2]: int(values[2]),
headers[3]: int(values[3])
}
students.append(student)

# 计算每个学生的平均分
for student in students:
grades = [student[subject] for subject in headers[1:]]
student['平均分'] = round(sum(grades) / len(grades), 1)

# 按平均分排名
ranked_students = sorted(students, key=lambda x: x['平均分'], reverse=True)

# 输出结果
print("学生成绩分析:")
print(f"{'姓名':<5} {'数学':<5} {'英语':<5} {'科学':<5} {'平均分':<5} {'排名':<5}")
print("-" * 35)

for i, student in enumerate(ranked_students, 1):
print(f"{student['姓名']:<5} {student['数学']:<5} {student['英语']:<5} {student['科学']:<5} {student['平均分']:<5} {i:<5}")

analyze_grades()

输出示例:

学生成绩分析:
姓名 数学 英语 科学 平均分 排名
-----------------------------------
王五 95 92 88 91.7 1
张三 90 85 92 89.0 2
钱七 88 90 85 87.7 3
李四 75 80 85 80.0 4
赵六 70 65 75 70.0 5

内置函数的高级应用

map(), filter(), reduce()

这些是函数式编程的核心工具,可以很优雅地处理数据:

python
# map: 对每个元素应用函数
numbers = [1, 2, 3, 4, 5]
squares = list(map(lambda x: x**2, numbers)) # 结果: [1, 4, 9, 16, 25]

# filter: 过滤符合条件的元素
even_numbers = list(filter(lambda x: x % 2 == 0, numbers)) # 结果: [2, 4]

# reduce: 从functools模块导入,用于累积计算
from functools import reduce
product = reduce(lambda x, y: x * y, numbers) # 结果: 120 (1*2*3*4*5)

any(), all()

这两个函数用于检查可迭代对象中的元素是否满足条件:

python
# any: 至少有一个元素为True
any([False, False, True, False]) # 结果: True
any([0, '', False]) # 结果: False

# all: 所有元素都为True
all([True, True, True]) # 结果: True
all([True, 0, True]) # 结果: False

# 实际应用
numbers = [10, 20, 30, 40, 50]
print(all(n > 5 for n in numbers)) # 结果: True (所有数都大于5)
print(any(n > 45 for n in numbers)) # 结果: True (至少一个数大于45)

总结

Python内置函数提供了丰富而强大的工具集,帮助开发者高效地处理各种编程任务。熟练掌握这些内置函数,将大大提高你的编程效率和代码质量。本文介绍了最常用的内置函数,包括:

  1. 数据类型转换函数:int(), float(), str(), list(), tuple(), set(), dict()
  2. 数学相关函数:abs(), round(), max(), min(), sum(), pow(), divmod()
  3. 序列操作函数:len(), sorted(), reversed(), enumerate(), zip(), range()
  4. 对象检查和操作函数:type(), isinstance(), dir(), help(), hasattr()
  5. 输入输出函数:print(), input()
  6. 函数式编程工具:map(), filter(), reduce()
  7. 逻辑函数:any(), all()
备注

Python还有更多内置函数,如globals(), locals(), compile(), eval(), exec()等,但它们较为高级或特定场景使用,初学者可以随着学习的深入再逐步了解。

练习题

为了巩固所学知识,试着完成以下练习:

  1. 使用内置函数优化下面的代码:

    python
    # 将下面的代码优化为使用内置函数的一行代码
    total = 0
    for num in [1, 2, 3, 4, 5]:
    total += num
    # 优化后: total = sum([1, 2, 3, 4, 5])
  2. 使用内置函数计算列表中所有偶数的平方和:

    python
    numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    # 提示: 可以使用filter和map函数
  3. 使用zip函数将两个列表合并成字典:

    python
    keys = ['name', 'age', 'job']
    values = ['Alice', 28, 'Engineer']
    # 结果应该是: {'name': 'Alice', 'age': 28, 'job': 'Engineer'}

通过实践这些练习,你将更深入地理解Python内置函数的强大之处!

延伸阅读

  1. Python 官方文档 - 内置函数
  2. Python函数式编程

继续学习和练习,你将能够更加自如地运用这些内置函数,写出更加简洁、高效的Python代码。