蓝桥杯考前必看知识点【python 代码详解】

文章目录

• 前言
• 一、基本知识点
• • 1.基本输入输出
  • 2.列表转字符串
  • 3.字符串大小写转换
  • 4.匿名函数lambda
  • 5.二/八/十六进制
  • 6.chr/ord转换
  • 7.保留小数点后几位
  • 8.排序
• 二、python常用内置库模块
• • 1.factorial阶乘
  • 2.Counter计数器
  • 3.defaultdict默认字典
  • 4.deque双向队列
  • 5.permutation全排列
  • 6.combinations组合
  • 7.accumulate累加
  • 8.heapq堆
  • 9.datetime时间
• 三、常用算法模板
• • 1.最大公约数 / 最小公倍数
  • 2.质数判断 / 质数个数
  • 3.快速幂
  • 4.bisect二分
• 总结

---

前言

最近一直在准备蓝桥杯，看了很多知识点及模板，考前几天就来个总结笔记巩固一下吧。写的还是比较全面的，希望也能帮助到其他备考的小伙伴呀>_<。

---

一、基本知识点

1.基本输入输出

s = input() # 一个字符串 n = int(input()) # 单个数 a, b, c = map(int, input().split()) # 多个数 l_1 = list(map(int, input().split())) # 整个列表（空格分隔） l_2 = [int(i) for i in input().split()] # 整个列表（空格分隔，和上一个差不多） print(s, n, a, b, c) print(l_1, l_2) """ 输入如下： abc 10 1 2 3 4 5 6 1 2 3 5 6 输出如下： abc 10 1 2 3 [4, 5, 6] [1, 2, 3, 5, 6] """

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

2.列表转字符串

l_3 = ['a', 'b', 'c'] print(''.join(l_3)) # 输出结果：abc

• 1
• 2

3.字符串大小写转换

a = "abcd" b = "ABCD" print(a.upper(), b.lower()) # ABCD abcd print(a, b) # abcd ABCD

• 1
• 2
• 3
• 4

4.匿名函数lambda

lambda的“：”左边是输入右边是输出，尤其和排序函数放在一起真的很好用啊！

def square(a): return a ** 2 print(list(map(square, [1, 2, 3]))) # [1, 4, 9] print(list(map(lambda x: x ** 2, [1, 2, 3]))) # [1, 4, 9] h = [[2, 4], [8, 9], [4, 5], [5, 10]] print(sorted(h, key=lambda x: x[0], reverse=True)) # 按照每个列表的第一个元素倒序排序 # [[8, 9], [5, 10], [4, 5], [2, 4]]

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11

5.二/八/十六进制

print(hex(17), oct(9), bin(3)) # 0x11 0o11 0b11 print(int('11', 2), int('11', 8), int('11', 16)) # 3 9 17

• 1
• 2

6.chr/ord转换

ord()就是得到字符的ASCII值，chr()是通过ASCII值找到字符。

print(chr(97), ord('a')) # a 97

• 1

7.保留小数点后几位

整理了三种方法如下：

x = 1.321 print(round(x, 2)) # 1.32 print('%.2f' % x) # 1.32 print('{:.2f}'.format(x), f'{x:.2f}') # 1.32 1.32

• 1
• 2
• 3
• 4

8.排序

1. nums.sort()：在原列表上直接排序
2. sorted(nums)：不改动原列表，生成新列表

nums = [5, 2, 7, 1, 3] nums1 = sorted(nums, reverse=True) # 倒序 print(nums1) # [7, 5, 3, 2, 1] nums.sort() print(nums) # [1, 2, 3, 5, 7]

• 1
• 2
• 3
• 4
• 5

二、python常用内置库模块

1.factorial阶乘

可以使用factorial阶乘求排列组合的结果（不要忘了import math）：

def c(m, n): # 是在m个数中取出n个 return math.factorial(m) // (math.factorial(n) * math.factorial(m-n)) print(c(5, 2)) # 10 print(math.factorial(5)) # 120

• 1
• 2
• 3
• 4

2.Counter计数器

使用计数器可以直接算出每个元素出现的次数，就不需要我们遍历啦。需要获得列表的话，直接在前面套一个list()就可以了。

from collections import Counter l2 = ['a', 'b', 'b', 'c', 'c', 'c'] d1 = Counter(l2) print(d1) # 输出结果：Counter({'c': 3, 'b': 2, 'a': 1}) d1['d'] = 1 # 加一个键值对 print(d1) # 输出结果：Counter({'c': 3, 'b': 2, 'a': 1, 'd': 1}) print(list(d1)) # 输出结果：['a', 'b', 'c', 'd'] print(d1.keys()) # dict_keys(['a', 'b', 'c', 'd']) print(d1.values()) # dict_values([1, 2, 3, 1]) print(d1.items()) # dict_items([('a', 1), ('b', 2), ('c', 3), ('d', 1)])

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10

3.defaultdict默认字典

我们用哈希表计数的时候，若当前元素不存在，则置为1；但是用defaultdict直接+1就行，不需要判断，因为创建defaultdict的时候已经规定了默认值类型。

from collections import defaultdict d2 = defaultdict(int) # 默认是int型，就默认值为0 for i, x in enumerate(l2): d2[x] += 1 # 省去一步判断存在的情况 print(list(d2.items())) # [('a', 1), ('b', 2), ('c', 3)] print(d2['a'], d2['d']) # 1 0

• 1
• 2
• 3
• 4
• 5
• 6

4.deque双向队列

找到一张对双向队列解释的非常好的图片（原文在这里）：

from collections import deque d3 = deque([1, 2, 3], maxlen=4) # 初始化一个最大长度为maxlen的队列 d3.append(4) print(d3) # deque([1, 2, 3, 4], maxlen=4) d4 = deque() # 初始化一个无固定长度的队列 d4.append(1) # 添加元素到队尾 d4.append(2) d4.append(3) d4.appendleft(0) # 添加元素到队首 print(d4, list(d4)) # deque([0, 1, 2, 3]) [0, 1, 2, 3] print(d4.popleft(), d4.pop()) # 弹出队首/队尾元素 0 3 print(d4) # deque([1, 2])

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12

5.permutation全排列

from itertools import permutations l1 = list(permutations([1, 2, 3])) print(l1) # [(1, 2, 3), (1, 3, 2), (2, 1, 3), (2, 3, 1), (3, 1, 2), (3, 2, 1)]

• 1
• 2
• 3

6.combinations组合

from itertools import combinations l3 = list(combinations([1, 2, 3], 2)) # 第二个参数为选择组合的个数 print(l3) # [(1, 2), (1, 3), (2, 3)]

• 1
• 2
• 3

7.accumulate累加

accumulate在求前缀和时很好用，不需要自己遍历一遍数组了。
accumulate函数创建一个迭代器，返回累积汇总值或其他双目运算函数的累积结果值（通过可选的 func 参数指定）。如果提供了 func，它应当为带有两个参数的函数但是，如果提供了关键字参数 initial，则累加会以 initial值开始，这样输出就比输入的可迭代对象多一个元素。

from itertools import accumulate a = [1, 2, 3, 4] print(list(accumulate(a))) # [1, 3, 6, 10] print(list(accumulate(a, initial=0))) # [0, 1, 3, 6, 10] print(list(accumulate(a, initial=1))) # [1, 2, 4, 7, 11]

• 1
• 2
• 3
• 4
• 5

8.heapq堆

python中的堆是小顶堆，如果是二维列表，默认以每个列表的第一个元素来排序。
1）heapify让列表具有堆的特征；
2）heappop弹出最小的元素（总是位于索引0处）；
3）heappush用于在堆中添加一个元素；
4）从堆中弹出最小的元素，再压入一个新元素。

from heapq import * h = [[2, 4], [8, 9], [4, 5], [5, 10]] heapify(h) print(h) # [[2, 4], [5, 10], [4, 5], [8, 9]] print(heappop(h)) # [2, 4] print(h) # [[4, 5], [5, 10], [8, 9]] heappush(h, [1, 2]) print(h) # [[1, 2], [4, 5], [8, 9], [5, 10]] heapreplace(h, [3, 2]) print(h) # [[3, 2], [4, 5], [8, 9], [5, 10]] print(heappop(h)) # [3, 2]

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

9.datetime时间

差点忘了这个，时间模块之前也是经常考的。

from datetime import * start = date(year=2023, month=4, day=4) end = date(year=2023, month=4, day=8) t = timedelta(days=1) while start <= end: print(start, start.weekday()) # 0-6 代表周一到周日 start += t print(end.year, end.month, end.day) """ 2023-04-04 1 2023-04-05 2 2023-04-06 3 2023-04-07 4 2023-04-08 5 2023 4 8 """

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

---

三、常用算法模板

1.最大公约数 / 最小公倍数

最大公约数在math中可以写，也可以直接使用math.gcd(x, y)调用，调用的时候不要忘了import math :

import math def gcd(n1, n2): # 自己写 if n2 > n1: n1, n2 = n2, n1 while n2: n1, n2 = n2, n1 % n2 print(n1, n2) return n1 # return math.gcd(n1, n2) if n2 > 0 else n1 # 调用 # print(gcd(6, 81))

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10

最小公倍数就是两数乘积再除以最大公约数：

def lcm(n1, n2): return n1 * n2 // gcd(n1, n2) # return n1 * n2 // math.gcd(n1, n2) # print(lcm(6, 81))

• 1
• 2
• 3
• 4

2.质数判断 / 质数个数

判断数n是否为质数：

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

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8

判断1到n之间（不包括n这个数）有多少个素数（厄拉多塞筛法）：

def countPrim(n): count = 0 signs = [True] * n # 先假设全为质数 for i in range(2, n): if signs[i]: count += 1 for j in range(i+i, n, i): # 质数的倍数一定不是质数，置为False signs[j] = False return count # print(countPrim(5)) # 2 3

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10

3.快速幂

参考了一位大佬的文章，想深入了解戳这里哦，一步一步带你去理解，真的写的非常非常好！

def normalPower(base, power): result = 1 while power: if power % 2 == 1: result = result * base % 1000 base = base * base % 1000 power //= 2 return result # print(normalPower(2, 1000000000))

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9

4.bisect二分

其实这一部分也可以放在上面内置模块部分。二分法当然可以自己写的，但是现成的库是真好用啊，做题时省时省力！
1)查找：
bisect：查找目标元素右侧插入点
bisect_left：查找目标元素左侧插入点
bisect_right：查找目标元素右侧插入点
2)插入：
insort：查找目标元素右侧插入点，并保序地插入元素
insort_left： 查找目标元素左侧插入点，并保序地插入元素
insort_right：查找目标元素右侧插入点，并保序地插入元素

from bisect import * l4 = [1, 2, 3, 3, 3, 4, 5] pos = bisect(l4, 3) # 只查找，不改变列表 pos_left = bisect_left(l4, 3) pos_right = bisect_right(l4, 3) print(pos, pos_left, pos_right) # 5 2 5 insort(l4, 4.5) print(l4) # [1, 2, 3, 3, 3, 4, 4.5, 5] insort(l4, 2.5) print(l4) # [1, 2, 2.5, 3, 3, 3, 4, 4.5, 5]

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10

总结

好啦，今天就暂时到这里了，要是再想起什么我会继续补充的。如果大家发现有不妥之处或者有想补充的，欢迎留言哦。