python部分内置函数详解

原创于 2025-12-10 17:02:10 发布 · 861 阅读

CC 4.0 BY-SA版权

文章标签：

什么是内置函数?

从根本来说:被直接编译进 Python 解释器内核（CPython 中是 C 语言实现）、在解释器启动时就自动加载到「内置命名空间（builtins namespace）」中的函数 —— 它们属于 Python 解释器的 “原生基础功能”，而非通过模块导入的功能。

从简单来说就是:不需要pip安装和import导入模块,自身已经导入python内核,拿来就能用

有哪些内置函数?

sorted
zip
map
max
min
sum
id(获取地址)
round
range
enumerate(枚举)
len
isinstance(判断类型)

......(等等)

Sorted

概述:

sorted() 是 Python 中的一个内置函数，用于对可迭代对象进行排序并返回一个新的列表（与原地排序的 list.sort() 方法不同）

sorted(iterable, key=None, reverse=False)

iterable:可迭代对象

key:指定一个函数作为排序的关键字

reverse:布尔值,为True时降序排序,默认为False(升序)

返回值:一个新的已排序的列表(不修改原可迭代对象)

基本用法:

对列表排序:

numbers = [3, 1, 4, 1, 5, 9, 2]
sorted_numbers = sorted(numbers)
print(sorted_numbers)  # 输出: [1, 1, 2, 3, 4, 5, 9]
print(numbers)         # 原列表不变: [3, 1, 4, 1, 5, 9, 2]

降序排序

numbers = [3, 1, 4, 1, 5, 9, 2]
sorted_numbers = sorted(numbers, reverse=True)
print(sorted_numbers)  # 输出: [9, 5, 4, 3, 2, 1, 1]

对字符串排序

word = "python"
sorted_word = sorted(word)
print(sorted_word)  # 输出: ['h', 'n', 'o', 'p', 't', 'y']
print(''.join(sorted_word))  # 输出: 'hnopty'

使用key参数自定义排序(按照字符串的长度)

words = ["banana", "pie", "Washington", "book"]
# 按长度排序
sorted_words = sorted(words, key=len)
print(sorted_words)  # 输出: ['pie', 'book', 'banana', 'Washington']

对字典进行排序

students = [
    {"name": "Alice", "grade": 90},
    {"name": "Bob", "grade": 85},
    {"name": "Charlie", "grade": 92}
]

# 按成绩排序
sorted_students = sorted(students, key=lambda x: x["grade"])
print(sorted_students)
# 输出: [{'name': 'Bob', 'grade': 85}, {'name': 'Alice', 'grade': 90}, {'name': 'Charlie', 'grade': 92}]

多重排序条件

sorted(words, key=lambda x: (len(x), x))

# 先按长度排序，长度相同的按字母顺序排序
words = ["apple", "banana", "cherry", "date", "fig"]
sorted_words = sorted(words, key=lambda x: (len(x), x))
print(sorted_words)  # 输出: ['fig', 'date', 'apple', 'banana', 'cherry']

与list.sort()的区别

list1=[1,3,5,6,2]
print(list1.sort())

#输出:None 因为list1.sort的返回值为None

#正确打印list1打印后的值
list1=[1,3,5,6,2]
list1.sort()
print(list1)

#list1已被修改为已排好序的列表

性能考虑

对于小型列表，sorted() 和 list.sort() 性能差异不大
对于大型列表，list.sort() 通常稍快，因为它不需要创建新列表
当需要保留原序列不变时，必须使用 sorted()
如果要对其他的可迭代对象进行排序，比如字典，就使用 sorted()

sorted内置函数总结

sorted() 是 Python 中非常灵活和强大的排序工具，具有以下特点：

可以对任何可迭代对象进行排序
不修改原数据，返回一个新列表
通过 key 参数支持复杂的排序逻辑
支持升序和降序排序
可以与 lambda 函数或 operator 模块结合实现高级排序

map

概述

map() 是Python中的一个内置高阶函数，用于将一个函数应用于一个或多个可迭代对象（如列表、元组等）的每个元素，并返回一个迭代器。map() 是一个强大的函数式编程工具，可以简洁地对可迭代对象的每个元素应用函数。

基本语法:

map(function,iterable,...)

function:需要执行的函数

iterable:一个或多个可迭代对象

基本用法

对单个可迭代对象进行操作

numbers = [1, 2, 3, 4, 5]
# 将这个列表中的每个元素进行平方
[num**2 for num in numbers]
map(lambda x: x**2,numbers)

squared = map(lambda x: x**2, numbers)
print(list(squared))  # 输出: [1, 4, 9, 16, 25]

对多个可迭代对象进行操作

list1=[1,3,2,6,5]
list2=[0.1,0.2,0.3]
iter=map(lambda x,y:x+y,list1,list2)   #返回一个迭代器
print(list(iter)) #将迭代器转为列表形式

使用内置函数(len)


dict1={"name":"Bob","age":18,"gender":"male"}
iter=map(len, dict1) #将len映射到dict1,求键的长度,最终返回一个迭代器
print(iter)#如果直接打印迭代器会得到迭代器的内存地址,输出:<map object at 0x0000023B3FE54FD0>
print(list(iter))

高级用法:

使用自定义函数

def double(x):
    return x * 2

numbers = [1, 2, 3, 4]
doubled_numbers = map(double, numbers)

print(list(doubled_numbers))  # 输出: [2, 4, 6, 8]

将列表数据转换为浮点类型的(float)

错误示范:

list1=[1,2,3]
new_one=float(list1)
print(new_one)

float() 函数的设计规则：它仅支持将「单个可转换的标量值」（如整数、合法的数字字符串）转为浮点数，不支持对列表（容器类型）直接转换。

使用map内置函数进行替换

mixed = ['1', '2.5', '3', '4.2']
numbers = map(float, mixed)
print(list(numbers))  # 输出: [1.0, 2.5, 3.0, 4.2]

注意事项:

map() 返回的是一个迭代器，不是列表。如果需要列表，可以使用 list() 转换。
当提供的可迭代对象长度不一致时，map() 会在最短的可迭代对象耗尽时停止。
对于简单的操作，列表推导式可能更直观

# 使用map
squared = map(lambda x: x**2, numbers)

# 使用列表推导式
squared = [x**2 for x in numbers]

zip

概述:

zip()是Python中一个非常有用的内置函数，用于将多个可迭代对象"压缩"成一个迭代器，其中每个元素都是来自各个可迭代对象的对应元素的元组

基本语法

zip(*iterables, strict=False)  					# Python 3.10+增加了strict参数

iterables:一个或多个可迭代对象(如:列表,元组,字符串,字典等)

strict:(Python 3.10+) 如果为True，当可迭代对象长度不一致时会引发ValueError

返回值:一个zip对象（迭代器），其中每个元素是一个元组

基本用法

合并两个列表

names = ['Alice', 'Bob', 'Charlie']
ages = [25, 30, 35]

#迭代器 = zip(names, ages)

zipped = zip(names, ages)
print(list(zipped))  
# 输出: [('Alice', 25), ('Bob', 30), ('Charlie', 35)]

合并多个可迭代对象

names = ['Alice', 'Bob', 'Charlie']
ages = [25, 30, 35]
cities = ['New York', 'London', 'Paris']

zipped = zip(names, ages, cities)
print(list(zipped))
# 输出: [('Alice', 25, 'New York'), ('Bob', 30, 'London'), ('Charlie', 35, 'Paris')]

不等长可迭代对象

names = ['Alice', 'Bob', 'Charlie', 'David']
ages = [25, 30]

zipped = zip(names, ages)
print(list(zipped))  # 输出: [('Alice', 25), ('Bob', 30)]

解压(逆向操作)

zipped_data = [('Alice', 25), ('Bob', 30), ('Charlie', 35)]
names, ages = zip(*zipped_data)
print(names)  # 输出: ('Alice', 'Bob', 'Charlie')
print(ages)   # 输出: (25, 30, 35)

创建字典:

keys = ['name', 'age', 'city']
values = ['Alice', 25, 'New York']

# 字典推导式
{key : value for key in keys for value in values}

person = dict(zip(keys, values))
print(person)
# 输出: {'name': 'Alice', 'age': 25, 'city': 'New York'}

使用strict参数(python 3.10+)

names = ['Alice', 'Bob', 'Charlie']
ages = [25, 30]

try:
    zipped = zip(names, ages, strict=True)
    print(list(zipped))
except ValueError as e:
    print(e)  # 输出: zip() argument 2 is shorter than argument 1

其他函数:

匿名函数:

在 Python 中，匿名函数（通常指 lambda 表达式创建的函数）属于“用户自定义函数”，而不是“内置函数”。

基本语法

lambda arguments: expression

arguments:函数参数,可以多个,用逗号分隔

expression:函数体,只能是一个表达式

基本用法

与sorted/sort配合使用

# 按姓名排序（不区分大小写）
contacts.sort(key=lambda x: x["name"].lower())

# 按多个条件排序（先按年龄，再按姓名）
people.sort(key=lambda p: (p["age"], p["name"]))

# 原始联系人数据
contacts = [
    {"name": "Zhang San", "phone": "13800138000", "email": "zhangsan@example.com", "age": 25},
    {"name": "alice", "phone": "13900139000", "email": "alice@work.com", "age": 30},
    {"name": "Bob Smith", "phone": "13700137000", "email": "bob.smith@gmail.com", "age": 22},
    {"name": "王五", "phone": "13600136000", "email": "wangwu@company.org", "age": None},
    {"name": "Aaron", "phone": "13500135000", "email": "aaron@test.com", "age": 30}
]

# 1. 按姓名排序（不区分大小写）
sorted_by_name = sorted(contacts, key=lambda x: x["name"].lower())

print("=== 按姓名排序 ===")
for contact in sorted_by_name:
    print(f"{contact['name']:10} | {contact['phone']} | {contact['email']}")

# 2. 多重条件排序（先按年龄，再按姓名）
sorted_by_age_name = sorted(
    contacts,
    key=lambda p: (p["age"] if p["age"] is not None else float('inf'), p["name"].lower())
)

print("\n=== 按年龄和姓名排序 ===")
for contact in sorted_by_age_name:
    age = contact['age'] if contact['age'] is not None else "N/A"
    print(f"年龄: {age:2} | {contact['name']:10} | {contact['phone']}")

与map配合使用

list1=[1,2,3,4,5]
iter=map(lambda x:x**2,list1)
print(list(iter))
#输出结果:[1, 4, 9, 16, 25]