跳到主要内容

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代码。