蓝桥杯竞赛（python组）常用函数_蓝桥杯python能直接用内置方法吗

map()函数

map()函数是 Python 内置函数之一，其作用是将一个函数（可以是内置函数或自定义函数）作用于一个可迭代对象（例如列表、元组、集合等）的每一个元素上，并返回一个迭代器。

map()函数的语法如下：

map(function, iterable, ...) 

其中，function是要执行的函数，iterable是要迭代的可迭代对象。map()函数的返回值是一个迭代器，可以使用 list()、tuple() 等函数转换为列表、元组等数据类型。

下面是一个示例，演示如何使用 map() 函数将列表中的每个元素都加1：

def add_one(x):
 
  return x + 1
 
lst = [1, 2, 3, 4, 5]
result = map(add_one, lst)
 
print(list(result))  # 输出 [2, 3, 4, 5, 6]` 

在上面的示例中，定义了一个函数 add_one，其功能是将输入的数字加1。然后使用 map() 函数将 add_one 函数作用于列表 lst 中的每个元素上，返回一个迭代器 result。最后，将 result 迭代器转换为列表并输出。

pow()函数

pow() 函数是 Python 内置函数之一，用于计算一个数的指数值，或者计算一个数对另一个数取模后的结果。

pow() 函数的语法如下：

pow(x, y[, z]) 

其中，x 为底数，y 为指数，z（可选）为模数。如果提供了模数 z，那么 pow() 函数将计算 (x ** y) % z 的结果，即底数 x 的 y 次幂对 z 取模的结果；如果未提供模数，则 pow() 函数将计算 x 的 y 次幂的结果。

下面是一些使用 pow() 函数的示例：

# 计算 2 的 3 次幂
print(pow(2, 3))  # 输出 8
 
# 计算 2 的 3 次幂对 5 取模的结果
 
print(pow(2, 3, 5))  # 输出 3
 
# 计算 2 的 3 次幂对 4 取模的结果
 
print(pow(2, 3, 4))  # 输出 0
 
# 计算 2 的 0 次幂，结果为 1
 
print(pow(2, 0))  # 输出 1` 

在上面的示例中，首先计算了 2 的 3 次幂，然后计算了 2 的 3 次幂对 5 和 4 取模的结果。最后，还演示了一个特殊情况，即计算任何数的 0 次幂，结果都为 1。

round()函数

round() 是 Python 的一个内置函数，用于对浮点数进行四舍五入操作。round() 函数可以接受两个参数：要进行四舍五入操作的数字和保留小数点后几位。如果只传递一个参数，则默认将小数点后第一位四舍五入。

以下是 round() 函数的语法：

round(number[, ndigits]) 

其中，number 是要进行四舍五入的数字，ndigits 是保留小数点后的位数，默认为 0。

下面是一些 round() 函数的示例：

round(3.14159)     # 输出 3 
 
round(3.14159, 2)  # 输出 3.14 
 
round(10.123456, 3)# 输出 10.123 

在上面的例子中，round(3.14159) 对 3.14159 进行四舍五入操作，返回结果为 3，因为默认情况下会将小数点后第一位四舍五入。round(3.14159, 2) 对 3.14159 进行四舍五入操作并保留两位小数，返回结果为 3.14。round(10.123456, 3) 对 10.123456 进行四舍五入操作并保留三位小数，返回结果为 10.123。

permutations()函数

Python排列函数permutations()：

功能：连续返回由iterable序列中的元素生成的长度为r的排列。

如果r未指定或为None，r默认设置为iterable 的长度，即生成包含所有元素的全排列。

# 开发时间2023/3/14 20:38
from itertools import *
 
s = ['a', 'b', 'c']
for element in permutations(s, 2):
    # 两种写法
    # a = element[0] + element[1]
    a = ''.join(element)
    print(a)
 

deque()函数

deque是Python标准库collections模块中的一个类，用于创建一个双向队列（double-ended queue）。与列表（list）相比，deque在两端添加或删除元素的时间复杂度为O(1)，而列表在首端添加或删除元素的时间复杂度为O(n)。

以下是deque的常用用法：

        创建一个空的deque:

from collections import deque
 
d = deque()

        创建一个带有初始元素的deque: 

d = deque([1, 2, 3])

        添加元素到deque的右侧： 

d.append(4) 

        添加元素到deque的左侧： 

d.appendleft(0) 

         弹出并返回deque的最右侧的元素：

d.pop() 

         弹出并返回deque的最左侧的元素：

d.popleft() 

        访问deque的最右侧的元素： 

d[-1]

        访问deque的最左侧的元素： 

d[0]

         获取deque中元素的数量：

len(d)

        判断deque是否为空： 

if not d:
  print("deque is empty")

deque还有其他方法和用法，可以查看官方文档或使用help(deque)来获取更多信息。

set集合

Python的set是一个无序的、可变的元素集合，其中不允许有重复的元素。Python中的set可以通过花括号 {} 或者使用 set() 函数进行创建。以下是一些常见的Python set的用法：

        创建一个set

my_set = {1, 2, 3, 4, 5}
print(my_set)  # 输出：{1, 2, 3, 4, 5}
 

        添加元素 

可以使用 add() 方法向set中添加元素，也可以使用 update() 方法向set中添加多个元素。

my_set = {1, 2, 3, 4, 5}
my_set.add(6)
print(my_set)  # 输出：{1, 2, 3, 4, 5, 6}
 
my_set.update([7, 8, 9])
print(my_set)  # 输出：{1, 2, 3, 4, 5, 6, 7, 8, 9}
 

        删除元素 

可以使用 remove() 方法删除set中的元素，如果元素不存在则会抛出异常。另外，还可以使用 discard() 方法删除set中的元素，如果元素不存在则不会抛出异常。

my_set = {1, 2, 3, 4, 5}
my_set.remove(3)
print(my_set)  # 输出：{1, 2, 4, 5}
 
my_set.discard(4)
print(my_set)  # 输出：{1, 2, 5}
 

        迭代set 

可以使用 for 循环来迭代set中的元素。

my_set = {1, 2, 3, 4, 5}
for num in my_set:
    print(num)
# 输出：
# 1
# 2
# 3
# 4
# 5
 

        set的操作 

可以使用set进行一些常见的集合操作，比如求并集、交集、差集等。

set1 = {1, 2, 3, 4, 5}
set2 = {3, 4, 5, 6, 7}
 
# 求并集
union_set = set1.union(set2)
print(union_set)  # 输出：{1, 2, 3, 4, 5, 6, 7}
 
# 求交集
intersect_set = set1.intersection(set2)
print(intersect_set)  # 输出：{3, 4, 5}
 
# 求差集
diff_set = set1.difference(set2)
print(diff_set)  # 输出：{1, 2}
 

字典

Python中的字典（Dictionary）是一种无序的、可变的数据类型，用于存储键-值（key-value）对。字典以大括号 {} 包含一组键值对，每个键值对之间用逗号分隔，键和值之间用冒号分隔。

以下是一个简单的字典例子：

my_dict = {"apple": 2, "banana": 3, "orange": 4} 

这个字典包含三个键值对，其中键分别是 "apple"、"banana" 和 "orange"，对应的值分别是 2、3 和 4。

要访问字典中的值，可以使用相应的键作为索引：

print(my_dict["apple"]) 

这将输出 2。

要添加新的键值对，可以使用以下语法：

my_dict["pear"] = 5 

这将在字典中添加一个新的键值对，其中键是 "pear"，值是 5。

要删除一个键值对，可以使用 del 关键字：

del my_dict["banana"] 

这将从字典中删除键为 "banana" 的键值对。

要遍历字典中的键值对，可以使用 for 循环：

for key, value in my_dict.items():
 
  print(key, value)

这将打印出所有的键值对。

combinations()

在Python中，combinations()函数是一个标准库函数，用于生成一个可迭代的对象，其中包含指定长度的所有可能的组合。它是 itertools 模块中的一个函数。

combinations() 函数有两个必需的参数：一个可迭代的对象和一个整数 r，用于指定生成的组合的长度。该函数将返回一个包含所有可能组合的迭代器。

以下是 combinations() 函数的基本语法：

import itertools
combinations(iterable, r)

其中：

• iterable：要生成组合的可迭代对象，例如列表、元组、集合等。
• r：要生成的组合的长度。

以下是一个简单的例子，展示如何使用 combinations() 函数生成包含三个元素的所有组合：

import itertools
 
my_list = [1, 2, 3, 4]
comb = itertools.combinations(my_list, 3)
 
for c in comb:
  print(c)

输出：

(1, 2, 3) 
(1, 2, 4) 
(1, 3, 4) 
(2, 3, 4) 

在这个例子中，我们使用 combinations() 函数生成包含三个元素的所有组合，并使用 for 循环迭代这些组合并打印出来。

请注意，由于 combinations() 函数返回一个迭代器，因此我们必须使用 for 循环或将其转换为列表或其他可迭代对象来访问它。

heap

在 Python 中，heap 模块提供了一个实现了堆数据结构的类 heapq，可以使用它来进行堆操作，例如将一个列表转换为堆、在堆中添加元素、从堆中弹出最小值等等。

以下是 heapq 模块中一些常用的函数和方法：

• heapify(iterable)：将一个可迭代对象转换为一个堆结构。时间复杂度为 O(n)，其中 n 是可迭代对象的长度。
• heappush(heap, item)：将一个元素插入到堆中。插入后，堆仍然保持不变。时间复杂度为 O(log n)，其中 n 是堆的长度。
• heappop(heap)：从堆中弹出最小的元素。弹出后，堆将自动重新调整为正确的顺序。时间复杂度为 O(log n)，其中 n 是堆的长度。
• heapreplace(heap, item)：弹出并返回堆中最小的元素，并将新的元素插入到堆中。相当于执行 heappop() 和 heappush()。时间复杂度为 O(log n)，其中 n 是堆的长度。
• nlargest(k, iterable, key=None)：返回一个列表，其中包含可迭代对象中的 k 个最大元素。可选参数 key 指定一个函数，用于从可迭代对象的每个元素中提取一个比较键（默认为 None，表示直接比较元素）。
• nsmallest(k, iterable, key=None)：返回一个列表，其中包含可迭代对象中的 k 个最小元素。可选参数 key 指定一个函数，用于从可迭代对象的每个元素中提取一个比较键（默认为 None，表示直接比较元素）。

以下是一个简单的例子，展示如何使用 heapq 模块将一个列表转换为堆并从中弹出最小的元素：

import heapq
 
my_list = [4, 1, 7, 3, 8, 5]
heapq.heapify(my_list)
 
print(heapq.heappop(my_list)) # 1

在这个例子中，我们首先使用 heapify() 函数将 my_list 列表转换为一个堆，然后使用 heappop() 函数从堆中弹出最小的元素，即 1。

请注意，由于堆是一种特殊的树形数据结构，它具有一些特殊的性质，例如最小（或最大）元素总是位于根节点。因此，使用堆可以快速找到最小（或最大）元素，而不必对整个列表进行排序。

setrecursionlimit()

setrecursionlimit()是Python标准库sys模块中的一个函数，用于设置Python解释器的最大递归深度。递归是一种编程技术，其中一个函数调用自身或者调用其他函数，以解决问题或完成某个任务。

默认情况下，Python解释器的最大递归深度为1000。如果一个程序的递归深度超过了这个限制，Python解释器将引发RecursionError异常，表示递归太深了，需要停止。

setrecursionlimit()函数可以用于修改Python解释器的最大递归深度。该函数接受一个整数参数，表示新的最大递归深度。例如，以下代码将Python解释器的最大递归深度设置为3000：

import sys 
sys.setrecursionlimit(3000) 

但是，增加最大递归深度可能会导致栈溢出错误，因为程序可能使用了大量的栈空间，从而超出了操作系统的栈大小限制。因此，应该谨慎使用setrecursionlimit()函数，并确保程序的递归深度不会超过操作系统的栈大小限制。