Python 内置函数（一文讲透）

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战 / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

• 新项目:《从零手撸：仿小红书（微服务架构）》 正在持续爆肝中，基于 Spring Cloud Alibaba + Spring Boot 3.x + JDK 17...，点击查看项目介绍 ;
• 《从零手撸：前后端分离博客项目（全栈开发）》 2 期已完结，演示链接： http://116.62.199.48/ ;

截止目前， 星球 内专栏累计输出 82w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 2900+ 小伙伴加入学习 ，欢迎点击围观

前言

在 Python 编程的世界里，Python 内置函数就像一把把经过精心打磨的瑞士军刀——它们简洁、多功能且随时可用。无论是处理数据、操作对象，还是构建复杂逻辑，这些函数都能帮助开发者快速解决问题，避免重复造轮子。对于编程初学者而言，掌握核心的内置函数是迈向高效编码的第一步；对于中级开发者，则可以通过深入理解这些函数的原理与应用场景，进一步优化代码结构和性能。

本文将从基础到进阶，系统性地介绍 Python 中最常用的内置函数，并通过实际案例解析其用法。通过本文的学习，读者不仅能快速上手这些工具，还能学会如何根据需求灵活组合它们，从而提升编程效率和代码质量。

一、基础数据处理类函数

1. print()：输出信息的万能接口

print() 是 Python 中最基础的输出函数，但它功能远不止“打印”那么简单。通过调整参数，它可以控制输出格式、合并多个对象，甚至实现动态日志记录。

语法示例：

print("Hello, World!")  # 基础用法  
print("数值为：", 42, "，类型是：", type(42))  # 合并多个对象输出  
print("进度条：", "■" * 30)  # 通过重复字符生成图形  

进阶技巧：

• 使用 end 参数修改默认换行符：

  print("同一行输出", end=" | ")  
  print("第二个 print")  # 输出结果：同一行输出 | 第二个 print  
  

• 结合 sep 参数自定义分隔符：

  print("姓名", "年龄", "城市", sep="\t")  # 输出为制表符分隔的表格  
  

2. len()：快速获取对象长度

len() 函数能返回字符串、列表、元组、字典等可迭代对象的元素个数。它是判断数据规模、循环边界控制的核心工具。

案例场景：

text = "Python 是一门优雅的语言"  
print(len(text))  # 输出：15（中文字符按单个计数）  

for i in range(len(text)):  
    print(text[i], end=" ")  

注意点：

• 对字典而言，len() 返回键值对的数量，而非键或值单独的长度。
• 不可迭代对象（如整数）会引发 TypeError，需先转换为字符串或其他类型。

3. type()：动态类型检测的“望远镜”

Python 是动态类型语言，type() 函数帮助开发者随时查看变量或对象的类型，尤其在调试和多态场景中至关重要。

典型用法：

num = 42  
print(type(num))  # 输出：<class 'int'>  

def process_data(data):  
    if type(data) == list:  
        return sum(data)  
    elif type(data) == str:  
        return data.upper()  

扩展思考：
通过 isinstance() 函数可以更灵活地判断继承关系，例如：

isinstance("Hello", str)  # True  
isinstance(42, (int, float))  # True  

二、类型转换与数据构建类函数

1. int(), float(), str()：数据类型的“变形金刚”

这三个函数允许开发者在数值、字符串之间自由转换，是处理用户输入、文件读写等场景的必备工具。

常见场景示例：

num_str = "123"  
num_int = int(num_str)  
print(num_int + 10)  # 输出：133  

price = 19.999  
formatted = str(round(price, 2))  
print(f"价格为：{formatted}")  # 输出：价格为：20.0  

陷阱与解决方案：

• 转换失败时（如非数字字符串转 int()），会抛出 ValueError，需用 try-except 捕获。
• 对于科学计数法字符串（如 "1e-3"），float() 可直接解析，但 int() 会报错。

2. range()：序列生成的“自动化生产线”

range() 函数生成整数序列，是循环和索引操作的核心工具。它支持三个参数：起始值、结束值（不包含）、步长。

基础用法：

for i in range(5):  
    print(i, end=" ")  # 输出：0 1 2 3 4  

for num in range(10, 0, -2):  
    print(num, end=" ")  # 输出：10 8 6 4 2  

高级技巧：

• 结合 len() 实现安全的列表索引访问：

  my_list = ["apple", "banana", "cherry"]  
  for index in range(len(my_list)):  
      print(f"索引 {index}: {my_list[index]}")  
  

• 转换为列表（Python 3 中 range 是惰性对象）：

  list(range(3))  # [0, 1, 2]  
  

3. list(), tuple(), dict()：容器类型的“快速成型”

这些函数将其他数据结构（如字符串、迭代器）转换为对应的容器类型，简化数据处理流程。

案例解析：

chars = list("hello")  
print(chars)  # ['h', 'e', 'l', 'l', 'o']  

pairs = [("name", "Alice"), ("age", 30)]  
user_dict = dict(pairs)  # {'name': 'Alice', 'age': 30}  

coordinates = tuple([0, 0, 0])  # (0, 0, 0)  

注意事项：

• list() 可接受任何可迭代对象（如文件、生成器）。
• 字典的 dict() 构造需传入键值对元组或关键字参数。

三、逻辑控制与函数式编程类函数

1. min(), max(), sum()：数据统计的“速算包”

这三个函数分别返回可迭代对象的最小值、最大值和总和，是数据分析和条件判断的基础。

实战案例：

numbers = [5, 3, 9, 1, 7]  
print(min(numbers))   # 1  
print(max(numbers))   # 9  
print(sum(numbers))   # 25  

print(min([-2, 5, -3], key=abs))  # 输出：-2（绝对值为2最小）  

关键点：

• key 参数允许通过函数定义比较依据，例如按字符串长度排序：

  words = ["apple", "banana", "cherry"]  
  shortest = min(words, key=len)  # "apple"  
  

2. sorted()：灵活排序的“万能钥匙”

sorted() 函数返回排序后的列表副本，支持反向排序、自定义规则，并且兼容任何可迭代对象。

经典用法：

sorted_list = sorted([3, 1, 4, 1, 5], reverse=False)  # [1, 1, 3, 4, 5]  

sorted_list_desc = sorted("Python", reverse=True)  # ['y', 't', 'o', 'n', 'P']  
print("".join(sorted_list_desc))  # 输出：ytonP  

进阶技巧：

• 对复杂对象排序：

  students = [{"name": "Bob", "age": 20}, {"name": "Alice", "age": 18}]  
  sorted_students = sorted(students, key=lambda x: x["age"])  
  # 按年龄从小到大排序  
  

3. map() 与 filter()：函数式编程的“流水线”

这两个函数将函数应用于可迭代对象，实现简洁高效的批量处理。

对比示例：

squares = list(map(lambda x: x**2, [1, 2, 3]))  # [1, 4, 9]  

even_numbers = list(filter(lambda x: x % 2 == 0, range(10)))  # [0, 2, 4, 6, 8]  

场景应用：

• 结合 str.upper() 快速转换列表中所有字符串为大写：

  words = ["hello", "world"]  
  upper_words = list(map(str.upper, words))  # ["HELLO", "WORLD"]  
  

四、对象操作与内存管理类函数

1. id()：追踪对象的“身份证”

id() 函数返回对象的内存地址，帮助开发者理解变量的引用关系和对象生命周期。

案例解析：

a = [1, 2, 3]  
b = a  
print(id(a) == id(b))  # True（指向同一内存地址）  

c = [1, 2, 3]  
print(id(a) == id(c))  # False（不同对象，即使内容相同）  

应用场景：

• 调试时判断两个变量是否指向同一对象。
• 验证函数参数传递的“传值”特性：

  def modify_list(lst):  
      lst.append(4)  # 修改原对象  
      print(id(lst))  # 与外部传入的列表id相同  
  
  my_list = [1, 2]  
  print(id(my_list))  
  modify_list(my_list)  
  

2. globals() 和 locals()：窥探变量的“藏宝图”

这两个函数返回当前全局或局部命名空间的字典，是调试和动态编程的强力工具。

基础用法：

print(globals().keys())  # 包含所有全局定义的变量和函数名  

def my_function():  
    x = 10  
    print(locals())  # 输出：{'x': 10}  

my_function()  

高级技巧：

• 动态执行代码：

  exec("print('动态执行成功')", globals())  # 输出：动态执行成功  
  

3. eval()：谨慎使用的“代码执行器”

eval() 函数将字符串作为 Python 表达式执行，但需注意其安全风险（如注入攻击）。

简单用例：

result = eval("2 + 3 * 5")  # 17  
expression = input("请输入数学表达式：")  
print("结果为：", eval(expression))  

安全建议：

• 避免对不可信输入使用 eval()。
• 用 ast.literal_eval() 替代，限制仅解析安全的字面量（如数字、列表）。

五、进阶技巧与最佳实践

1. 函数组合：构建“乐高式”解决方案

通过组合内置函数，可以快速实现复杂逻辑。例如，统计列表中偶数的平方和：

numbers = [1, 2, 3, 4, 5]  
sum_of_squares = sum(map(lambda x: x**2, filter(lambda x: x % 2 == 0, numbers)))  
print(sum_of_squares)  # 输出：20（2² + 4²）  

2. 列表推导式 vs 内置函数：性能与可读性的平衡

列表推导式通常比 map() 更直观，但在需要复杂转换时，两者可互补：

squares = [x**2 for x in range(5)]  

squares = list(map(lambda x: x**2, range(5)))  

3. 文档与调试：善用 help() 和 dir()

• help(function_name) 查看函数详细文档。
• dir(object) 列出对象的所有属性和方法：

  print(dir([]))  # 查看列表的所有可用方法  
  

结论

Python 内置函数是语言生态中的核心组件，它们的设计体现了 Python 的简洁高效哲学。通过本文的系统性梳理，读者不仅能掌握基础函数的用法，还能学会如何根据需求灵活组合这些工具，甚至通过高级技巧解决复杂问题。

对于编程初学者，建议从 print()、len() 等高频函数入手，逐步构建知识网络；中级开发者则可以深入探索 map()、filter() 等函数的函数式编程潜力。记住，熟练使用内置函数不仅能提升代码质量，更能帮助开发者形成更优雅的编程思维模式——毕竟，Python 的强大，往往就藏在这些看似简单却深藏智慧的内置函数中。

（全文约 2200 字）