python内置函数

map

用法

1

map(function, iterable, *iterables)

参数以及常用值

function: 一个函数，map会将此函数应用到每个可迭代对象的元素上。常用值：
- 内置函数（如int、str、float）
- lambda表达式（如lambda x: x * 2）
- 自定义函数（如def add_one(x): return x + 1）
iterable: 一个可迭代对象（如列表、元组、字符串等）。
*iterables: 可选，多个可迭代对象。如果提供了多个，function需要接受相应数量的参数。

最佳实践与常用搭配

单可迭代对象处理

将字符串列表转换为整数列表：

1

nums = list(map(int, ["1", "2", "3"]))

对列表元素进行平方运算：

1

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

多可迭代对象处理

对两个列表逐元素相加：

1

res = list(map(lambda x, y: x + y, [1, 2], [3, 4]))

与input结合使用
- 从输入中读取多个整数：
  1
  
  a, b, c = map(int, input().split())

与filter结合使用

对列表元素先筛选后处理：

1

res = list(map(lambda x: x * 2, filter(lambda x: x > 0, [-1, 2])))

注意事项

返回迭代器 map返回的是一个迭代器，不是列表。如果需要多次使用，需显式转换为列表或其他数据结构：
1 2

mapped = map(int, ["1", "2", "3"]) list(mapped) # 转换为列表
长度一致性 当处理多个可迭代对象时，它们的长度应相同，否则较长的可迭代对象中多余的元素会被忽略。
类型兼容性 确保函数与元素类型兼容，避免运行时错误。例如，对非数字字符串使用int会抛出ValueError。
性能考虑 对于简单操作，map可能不如列表推导式清晰或高效。例如，map(lambda x: x * 2, [1, 2, 3])可以写成[x * 2 for x in [1, 2, 3]]，后者更易读。

最常用法

1
2
3
4
5
6
7
8


# 从输入中读取多个整数并解包
a, b, c = map(int, input().split())

# 将字符串列表转换为整数列表
nums = list(map(int, ["1", "2", "3"]))

# 对两个列表逐元素相加
result = list(map(lambda x, y: x + y, [1, 2], [3, 4]))

divmod

用法

1

divmod(a, b)

参数以及常用值

a: 被除数，通常是一个整数或浮点数。
b: 除数，通常是一个整数或浮点数。

最佳实践与常用搭配

获取商和余数

对两个整数进行除法操作，返回商和余数：

1

quotient, remainder = divmod(10, 3)  # 返回 (3, 1)

对浮点数进行除法操作，返回商和余数：

1

quotient, remainder = divmod(10.5, 3)  # 返回 (3.0, 1.5)

处理时间和日期

将总秒数转换为小时、分钟和秒：

1
2
3
4


total_seconds = 3661
hours, remainder = divmod(total_seconds, 3600)
minutes, seconds = divmod(remainder, 60)
print(f"{hours}h {minutes}m {seconds}s")  # 输出 "1h 1m 1s"

处理大数分解

在算法中用divmod来分解大数，例如在进制转换中：

1
2
3
4
5
6
7


def convert_to_base(n, base):
    digits = []
    while n > 0:
        n, remainder = divmod(n, base)
        digits.append(remainder)
    return digits[::-1]
print(convert_to_base(42, 2))  # 输出 [1, 0, 1, 0, 1, 0]

注意事项

除数不能为零 如果b为0，divmod会抛出ZeroDivisionError异常。
返回类型
- 如果a和b都是整数，divmod返回的商和余数也是整数。
- 如果a或b是浮点数，返回的商和余数也是浮点数。

余数的符号 余数的符号与a的符号一致。例如：

1
2


divmod(-10, 3)  # 返回 (-4, 2)
divmod(10, -3)  # 返回 (-4, -2)

最常用法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


# 获取商和余数
quotient, remainder = divmod(10, 3)

# 将总秒数转换为小时、分钟和秒
total_seconds = 3661
hours, remainder = divmod(total_seconds, 3600)
minutes, seconds = divmod(remainder, 60)
print(f"{hours}h {minutes}m {seconds}s")  # 输出 "1h 1m 1s"

# 在算法中分解大数
def convert_to_base(n, base):
    digits = []
    while n > 0:
        n, remainder = divmod(n, base)
        digits.append(remainder)
    return digits[::-1]
print(convert_to_base(42, 2))  # 输出 [1, 0, 1, 0, 1, 0]

input

用法

1

input(prompt=None)

参数以及常用值

prompt: 可选参数，用于在控制台显示提示信息，提示用户输入内容。常用值：
- 字符串（如"请输入你的名字："）
- 空字符串（默认值，None，表示不显示任何提示）

最佳实践与常用搭配

基本输入

获取用户输入并返回一个字符串：

1
2


name = input("请输入你的名字：")
print(f"你好, {name}!")

类型转换

将输入转换为整数：

1

age = int(input("请输入你的年龄："))

将输入转换为浮点数：

1

height = float(input("请输入你的身高（米）："))

结合map和split处理多值输入

从输入中读取多个整数：

1

a, b, c = map(int, input("请输入三个整数，用空格分隔：").split())

从输入中读取多个浮点数：

1

x, y, z = map(float, input("请输入三个浮点数，用空格分隔：").split())

循环输入

循环获取用户输入直到满足条件：

1
2
3
4
5


while True:
    num = input("请输入一个正整数：")
    if num.isdigit() and int(num) > 0:
        break
    print("输入无效，请重新输入！")

文件路径输入

获取文件路径并打开文件：

1
2
3
4


file_path = input("请输入文件路径：")
with open(file_path, 'r') as file:
    content = file.read()
print(content)

注意事项

输入永远返回字符串 input函数返回的永远是字符串类型，如果需要其他类型（如整数、浮点数），需显式转换。
输入安全性 尽量避免直接将用户输入用于敏感操作（如文件操作、数据库查询等），建议进行验证和清理。

异常处理 在进行类型转换时，可能会抛出异常（如ValueError），建议使用try-except处理：

1
2
3
4


try:
    age = int(input("请输入你的年龄："))
except ValueError:
    print("输入无效，请输入一个整数！")

平台兼容性 input函数在Python 2和Python 3中行为不同。在Python 2中，input会尝试将输入作为Python表达式执行，建议使用raw_input代替。在Python 3中，input行为与Python 2的raw_input一致。

最常用法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


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

# 将输入转换为整数
age = int(input("请输入你的年龄："))

# 从输入中读取多个整数
a, b, c = map(int, input("请输入三个整数，用空格分隔：").split())

# 循环获取有效输入
while True:
    num = input("请输入一个正整数：")
    if num.isdigit() and int(num) > 0:
        break
    print("输入无效，请重新输入！")

print

用法

1

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

参数以及常用值

*objects: 要打印的对象，可以是多个，用逗号分隔。
sep: 分隔符，默认为一个空格。
end: 结束符，默认为换行符\n。
file: 输出的文件对象，默认为sys.stdout（标准输出）。
flush: 是否强制刷新输出流，默认为False。

最佳实践与常用搭配

基本用法

打印多个值：
1

print("Hello", "World", sep=", ")

打印到文件：

1
2


with open("output.txt", "w") as f:
    print("Hello World", file=f)

格式化输出

使用f-strings：

1
2
3


name = "Alice"
age = 25
print(f"Name: {name}, Age: {age}")

使用format方法：

1

print("Name: {}, Age: {}".format(name, age))

控制输出格式

使用end参数控制换行：

1
2


print("Hello", end=" ")
print("World")  # 输出为 "Hello World"

使用flush参数强制刷新输出：

1

print("Loading...", end="", flush=True)

注意事项

性能考虑 频繁调用print可能会影响性能，特别是在循环中。可以考虑使用StringIO或logging模块。
文件输出 打印到文件时，确保文件是以写模式打开的，否则会抛出IOError。
格式化字符串 使用f-strings或format方法可以让代码更易读，特别是在处理复杂格式时。

最常用法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


# 基本打印
print("Hello World")

# 使用f-strings格式化输出
name = "Alice"
age = 25
print(f"Name: {name}, Age: {age}")

# 打印到文件
with open("output.txt", "w") as f:
    print("Hello World", file=f)

filter

用法

1

filter(function, iterable)

参数以及常用值

function: 一个函数，用于测试可迭代对象的每个元素。如果返回True，则该元素被保留；否则被过滤掉。常用值：
- 内置函数（如bool, int）
- lambda表达式（如lambda x: x > 0）
- 自定义函数（如def is_even(x): return x % 2 == 0）
iterable: 可迭代对象（如列表、元组、字符串等）。

最佳实践与常用搭配

基本过滤

过滤掉列表中的None值：

1

result = list(filter(None, [1, None, 2, None, 3]))

过滤掉所有非正整数：

1

result = list(filter(lambda x: x > 0, [-1, 2, -3, 4]))

与map结合使用

先筛选后处理：

1
2


result = list(map(lambda x: x * 2, 
                  filter(lambda x: x > 0, [-1, 2, 3])))

与input结合使用

从输入中过滤出偶数：

1
2


nums = map(int, input().split())
evens = list(filter(lambda x: x % 2 == 0, nums))

与自定义函数结合

使用自定义函数筛选满足条件的元素：

1
2
3
4
5
6
7
8
9


def is_prime(n):
    if n <= 1:
        return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False
    return True

primes = list(filter(is_prime, range(1, 20)))

注意事项

返回迭代器 filter返回的是一个迭代器，不是列表。如果需要多次使用，需显式转换为列表或其他数据结构：
1 2

filtered = filter(lambda x: x > 0, [-1, 2, -3]) list(filtered) # 转换为列表
函数返回值 如果function为None，则filter会直接使用布尔值判断元素是否保留，相当于filter(bool, iterable)。
性能考虑 对于简单过滤条件，filter可能不如列表推导式清晰或高效。例如，filter(lambda x: x > 0, [-1, 2, -3])可以写成[x for x in [-1, 2, -3] if x > 0]，后者更易读。

最常用法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


# 过滤掉列表中的None值
result = list(filter(None, [1, None, 2, None, 3]))

# 过滤掉所有非正整数
result = list(filter(lambda x: x > 0, [-1, 2, -3, 4]))

# 从输入中过滤出偶数
nums = map(int, input().split())
evens = list(filter(lambda x: x % 2 == 0, nums))

# 使用自定义函数筛选满足条件的元素
def is_prime(n):
    if n <= 1:
        return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False
    return True

primes = list(filter(is_prime, range(1, 20)))

`sort` 和 `sorted`

`sort`

用法

1

list.sort(key=None, reverse=False)

参数以及常用值

key: 一个函数，用于生成排序的比较键。常用值：
- lambda表达式（如lambda x: x[1]）
- 内置函数（如len、str.lower）
- 自定义函数（如def get_second(elem): return elem[1]）
reverse: 布尔值，决定排序顺序。True表示降序，False表示升序（默认）。

最佳实践与常用搭配

按默认方式排序
- 对列表进行升序排序：
  1 2
  
  nums = [3, 1, 2] nums.sort()

按指定条件排序

按元素的第二个值排序：

1
2


tuples = [(1, 'b'), (2, 'a')]
tuples.sort(key=lambda x: x[1])

降序排序

对列表进行降序排序：

1
2


nums = [1, 2, 3]
nums.sort(reverse=True)

注意事项

原地修改 sort会直接修改原列表，不返回任何值。
不可用于不可变序列 sort只能用于可变序列（如列表），不能用于不可变序列（如元组、字符串）。
性能考虑 对于大型列表，sort的性能通常优于sorted，因为它不需要创建新的列表。

最常用法

1
2
3
4
5
6
7


# 按默认方式排序
nums = [3, 1, 2]
nums.sort()

# 按指定条件排序
data = [{'name': 'Alice', 'age': 25}, {'name': 'Bob', 'age': 30}]
data.sort(key=lambda x: x['age'])

`sorted`

用法

1

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

参数以及常用值

iterable: 一个可迭代对象（如列表、元组、字符串等）。
key: 一个函数，用于生成排序的比较键。常用值：
- lambda表达式（如lambda x: x[1]）
- 内置函数（如len、str.lower）
- 自定义函数（如def get_second(elem): return elem[1]）
reverse: 布尔值，决定排序顺序。True表示降序，False表示升序（默认）。

最佳实践与常用搭配

按默认方式排序
- 对列表进行升序排序并返回新列表：
  1 2
  
  nums = [3, 1, 2] sorted_nums = sorted(nums)

按指定条件排序

按元素的第二个值排序：

1
2


tuples = [(1, 'b'), (2, 'a')]
sorted_tuples = sorted(tuples, key=lambda x: x[1])

降序排序

对列表进行降序排序：

1
2


nums = [1, 2, 3]
sorted_nums = sorted(nums, reverse=True)

对字符串排序

按字母顺序排序字符串列表：

1
2


words = ['apple', 'banana', 'cherry']
sorted_words = sorted(words)

注意事项

返回新列表 sorted返回一个新的排序后的列表，原列表不会被修改。
适用于所有可迭代对象 sorted可以用于任何可迭代对象，包括不可变序列（如元组、字符串）。
性能考虑 对于大型列表，sorted会因为创建新列表而比sort占用更多的内存。

最常用法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


# 按默认方式排序并返回新列表
nums = [3, 1, 2]
sorted_nums = sorted(nums)

# 按指定条件排序
data = [{'name': 'Alice', 'age': 25}, {'name': 'Bob', 'age': 30}]
sorted_data = sorted(data, key=lambda x: x['age'])

# 对字符串列表进行排序
words = ['apple', 'banana', 'cherry']
sorted_words = sorted(words)

总结

如果你需要在原地排序并且不关心返回新列表，使用list.sort()
如果你需要一个新排序列表，或者需要对不可变序列进行排序，使用sorted()

sum

用法

1

sum(iterable, start=0)

参数以及常用值

iterable: 一个可迭代对象（如列表、元组、集合等），包含需要求和的元素。常用值：
- 列表（如[1, 2, 3]）
- 元组（如(1, 2, 3)）
- 集合（如{1, 2, 3}）
- 生成器表达式（如(x for x in range(5))）
start: 可选，求和的初始值。如果未指定，默认值为0。常用值：
- 数值（如100）
- 字符串（如""，用于连接字符串列表）

最佳实践与常用搭配

数值求和

对整数列表求和：
1

total = sum([1, 2, 3, 4, 5])

使用生成器表达式求和：

1

total = sum(x for x in range(10) if x % 2 == 0)

字符串连接
- 使用start参数连接字符串列表：
  1
  
  s = sum(["Hello", "World", "!"], "")

自定义对象求和

自定义类实现__add__方法后使用sum：

1
2
3
4
5
6
7
8


class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    def __add__(self, other):
        return Point(self.x + other.x, self.y + other.y)
points = [Point(1, 2), Point(3, 4)]
total = sum(points, Point(0, 0))

注意事项

可迭代对象的元素类型 sum要求可迭代对象的元素类型支持加法运算。如果元素类型不支持加法（如字符串与整数的混合列表），会抛出TypeError。
start参数类型 start参数的类型应与其他元素兼容。例如，对数值列表求和时，start应为数值；对字符串列表求和时，start应为字符串。
性能考虑 对于大型数据集，sum在性能上通常优于循环累加。但如果处理的是自定义对象或复杂操作，可能需要考虑其他优化方法。

最常用法

1
2
3
4
5
6
7
8


# 对整数列表求和
total = sum([1, 2, 3, 4, 5])

# 使用生成器表达式求和偶数
total = sum(x for x in range(10) if x % 2 == 0)

# 连接字符串列表
s = sum(["Hello", "World", "!"], "")

count

用法

1

iterable.count(value)

参数以及常用值

value: 需要计数的元素。常用值：
- 任何可哈希的类型（如整数、字符串、元组等）
- 自定义对象（需实现__eq__方法）

最佳实践与常用搭配

统计列表中元素的出现次数

1
2


lst = [1, 2, 3, 2, 1]
count = lst.count(2)  # 返回 2

统计字符串中字符的出现次数

1
2


s = "hello"
count = s.count('l')  # 返回 2

统计元组中元素的出现次数

1
2


tup = (1, 2, 3, 2, 1)
count = tup.count(1)  # 返回 2

统计子字符串的出现次数

1
2


s = "hello world"
count = s.count('lo')  # 返回 1

统计自定义对象的出现次数

1
2
3
4
5
6


class Person:
    def __init__(self, name):
        self.name = name

people = [Person("Alice"), Person("Bob"), Person("Alice")]
count = people.count(Person("Alice"))  # 返回 2

注意事项

性能考虑 count方法的时间复杂度为O(n)，因为它需要遍历整个可迭代对象来计算指定元素的出现次数。
不可哈希类型 对于不可哈希的类型（如列表、字典等），count方法无法使用。
自定义对象的__eq__方法 如果自定义对象需要被count方法正确识别，需确保实现了__eq__方法。

最常用法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


# 统计列表中元素的出现次数
lst = [1, 2, 3, 2, 1]
count = lst.count(2)  # 返回 2

# 统计字符串中字符的出现次数
s = "hello"
count = s.count('l')  # 返回 2

# 统计子字符串的出现次数
s = "hello world"
count = s.count('lo')  # 返回 1

list

用法

1

list([iterable])

参数以及常用值

iterable: 可选，一个可迭代对象（如列表、元组、字符串、字典、集合、生成器等）。常用值：
- 字符串（如"hello"）
- 元组（如(1, 2, 3)）
- 字典（如{"a": 1, "b": 2}，转换时会提取字典的键）
- 集合（如{1, 2, 3}）
- 生成器（如(x for x in range(5))）
- 其他可迭代对象

最佳实践与常用搭配

创建空列表
- 创建一个空列表：
  1
  
  lst = list()
将可迭代对象转换为列表
- 将字符串转换为字符列表：
  1
  
  chars = list("hello")
- 将元组转换为列表：
  1
  
  lst = list((1, 2, 3))
- 将字典转换为列表（提取键）：
  1
  
  keys = list({"a": 1, "b": 2})
- 将集合转换为列表：
  1
  
  lst = list({1, 2, 3})
- 将生成器转换为列表：
  1
  
  lst = list((x for x in range(5)))

与map、filter结合使用

将map结果转换为列表：

1

nums = list(map(int, ["1", "2", "3"]))

将filter结果转换为列表：

1

evens = list(filter(lambda x: x % 2 == 0, [1, 2, 3, 4]))

注意事项

性能考虑 对于大容量数据，list会一次性将所有元素加载到内存中，可能导致内存占用过高。对于大数据集，可以考虑使用生成器或懒加载的方式处理。
类型转换 确保转换的对象是可迭代的，否则会抛出TypeError。例如，list(123)会报错。
字典转换 list转换字典时，默认只提取字典的键。如果需要提取键值对，可以使用dict.items()：
1

items = list({"a": 1, "b": 2}.items())
空参数 不传递参数时，list会返回一个空列表，这是创建空列表的常见方式：
1

lst = list()

最常用法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


# 创建空列表
lst = list()

# 将字符串转换为字符列表
chars = list("hello")

# 将元组转换为列表
lst = list((1, 2, 3))

# 将`map`结果转换为列表
nums = list(map(int, ["1", "2", "3"]))

map

divmod

input

print

filter

sort 和 sorted

sort

sorted

总结

sum

count

list

`sort` 和 `sorted`

`sort`

`sorted`