蓝桥杯python组备赛笔记（赛前必看）

CONTENT

• 写在前面
• 
  

  一、输入框架

• 
  

  二、输出框架

• 
  

  三、IDLE的用法

• 
  

  四、常用标准库

• • 4.1 math
  • 4.2 random
  • 4.3 collections
  • • 4.3.1 Counter
    • 4.3.2 elements()
    • 4.3.3 most_common()
    • 4.3.4 subtract()
• 
  

  五、常用小技巧

• 
  

  六、各种算法

• 写在最后

写在前面

一年一度的蓝桥杯再过几个月就要开始了，博主去年参加了这个比赛拿了省二，多多少少也有一些心得。

虽然是很菜的一个奖项，但作为一个数学专业且几乎处处在学数学的蒟蒻，能拿到这个奖已经满意了。

本文实际上来源于我去年备赛的笔记，今天分享出来也是希望能够帮助到准备参加比赛的各位uu们。

个人觉得如果你能掌握本文的全部内容并拥有一定的刷题量，拿个奖还是不难的。

废话不多说，直接上干货！

一、输入框架

1. 单个整数输入

n = int(input())

2. 输入一行由空格隔开的整数

a, b = map(int, input().split())  # 用变量存储
arr = list(map(int, input().split()))  # 用列表存储

3. 输入大小为 m × n m\times n m×n 的二维整型数组

arr = []
for i in range(m):
    arr.append(list(map(int, input().split())))

二、输出框架

1. 输出一行由空格隔开的 n n n 个数

# 方法一
for i in range(n - 1):
    print(arr[i], end=' ')
print(arr[n - 1])

# 方法二(推荐)
print(*arr)

2. 输出大小为 m × n m\times n m×n 的二维数组

# 方法一
for i in range(m):
    for j in range(n - 1):
        print(arr[i][j], end=' ')
    print(arr[i][n - 1])

# 方法二(推荐)
for i in range(m):
	print(*arr[i])

3. print()的用法

print(*objects, sep=' ', end='\n')
# sep是分隔符，默认是空格. end是结尾，默认是换行符.

n = 123
print('|%5d|' % n)   # |  123|
print('|%-5d|' % n)  # |123  |
print('|%05d|' % n)  # |00123|

4. 格式化输出

方法一：

print('%c,%s,%f,%d' % (97, 'abc', 1.0, 2))  # a,abc,1.000000,2

方法二：

print('{} {} {}'.format('a', 'b', 'c'))  # a b c

5. 格式化输出浮点数

pi = 3.1415926
print('%.3f' % pi)  # 3.142

三、IDLE的用法

ctrl + n 新建 python 文件， F5 运行。

四、常用标准库 4.1 math

1. 数论

math.ceil(3.5)  # 4
math.floor(3.5)  # 3
math.fabs(-3)  # 3.0
math.factorial(4)  # 24
math.comb(4, 2)  # 6(组合数)
math.isqrt(5)  # 2(根号5向下取整)
math.gcd(4, 6)  # 2(最大公约数)
math.lcm(4, 6)  # 12(最小公倍数)
math.prod([2, 3, 5])  # 30
math.isfinite(x)  # x既不是无穷大也不是NaN返回True
math.isinf(x)  # x是正或负无穷大，返回True
math.isnan(x)  # x是NaN，返回True

2. 数学函数(结果均为浮点数)

math.exp(x)
math.log(x[, base])  # base默认为e
math.pow(x, y)  # x的y次方
math.sqrt(x)
math.sin(x)
math.cos(x)
math.tan(x)

3. 常数

math.pi
math.e
math.inf  # 浮点正无穷大，对于负无穷大，使用-math.inf，相当于float('inf')
math.nan  # 浮点非数字(NaN)值，相当于float('nan')

4.2 random

random.random()  # 返回[0.0, 1.0)范围内的一个随机浮点数
random.randint(a, b)  # 返回随机整数N满足a<=N<=b
random.choice(seq)  # 从非空序列seq中随机选取一个元素

4.3 collections 4.3.1 Counter

Counter 是 dict 的子类，是一个集合，元素像字典键(key)一样存储，它们的计数存储为值。

计数可以是任何整数值，包括0和负数。

collections.Counter('aabbccc')  # Counter({'c': 3, 'a': 2, 'b': 2})
collections.Counter(['a', 'a', 'b'])  # Counter({'a': 2, 'b': 1})
collections.Counter(cats=4, dogs=8)  # Counter({'dogs': 8, 'cats': 4})

如果引用的键没有任何记录，并不会报错，而是返回 0：

from collections import Counter
c = Counter(['eggs', 'ham'])
print(c['bacon'])  # 0

如果需要删除元素，需使用 del：

del c['eggs']

计数器对象除了字典方法以外，还提供了以下三个方法。

4.3.2 elements()

返回一个迭代器，其中每个元素将重复出现计数值所指定次。

元素会按首次出现的顺序返回。

如果一个元素的计数值小于一，elements() 将会忽略它。

c = Counter(a=4, b=2, c=0, d=-2)
print(list(c.elements()))  # ['a', 'a', 'a', 'a', 'b', 'b']

4.3.3 most_common()

返回一个列表，其中包含 n 个最常见的元素及出现次数，按常见程度由高到低排序。

如果 n 被省略或为 None，most_common() 将返回计数器中的 所有 元素。

计数值相等的元素按首次出现的顺序排序：

c = Counter('abracadabra')
print(c.most_common(3))  # [('a', 5), ('b', 2), ('r', 2)]

4.3.4 subtract()

从 迭代对象 或 映射对象 减去元素。

输入和输出都可以是0或者负数。

c = Counter(a=4, b=2, c=0, d=-2)
d = Counter(a=1, b=2, c=3, d=4)
print(c.subtract(d))  # Counter({'a': 3, 'b': 0, 'c': -3, 'd': -6})

五、常用小技巧

1. 创建全 0 0 0 的 m × n m\times n m×n 数组

A = [[0] * n for i in range(m)]  # 较快
A = [[0 for j in range(n)] for i in range(m)]  # 较慢

2. split()

str.split(str="", num=string.count(str)).

• str – 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
  

  
  

• num – 分割次数。
  

  
  

  默认为 -1, 即分隔所有。
  

  
  

3. 进制转换

有前缀：

x = 123
print(bin(x))  # 0b1111011(二进制)
print(oct(x))  # 0o173(八进制)
print(hex(x))  # 0x7b(十六进制)

没有前缀：

x = 123
print(format(x, 'b'))  # 1111011
print(format(x, 'o'))  # 173
print(format(x, 'x'))  # 7b

任意进制转换为10进制：

int(x, a)

x 为字符串， 且是 a 进制数。

4. 字符与ASCII码相互转换

print(ord('A'))  # 65
print(chr(65))  # A

5. 程序计时

import time
start = time.time()
# 程序
end = time.time()
print(end - start)

6. join()

str.join(seq)

字符串与列表的互相转化：

string = 'abc'
seq = list(string)
print(''.join(seq))

7. lambda函数

语法：

lambda argument_list:expression

argument_list是参数列表，它的结构与Python中函数的参数列表是一样的。

expression是一个关于参数的表达式，表达式中出现的参数需要在argument_list中有定义，并且表达式只能是单行的。

下面两个等价：

f = lambda argument_list:expression

def f(argument_list):
	return expression

8. filter()

filter(function, iterable)  # 返回的是filter类，需要用list转化

例如：

print(list(filter(lambda x: x % 2 == 1, range(1, 10))))
# [1, 3, 5, 7, 9]

9. sorted()

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

• iterable – 可迭代对象。
  

  
  

• key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
  

  
  

• reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
  

  
  

dic = [('a', 3), ('c', 1), ('b', 2)]
print(sorted(dic, key=lambda x: x[0])) 
print(sorted(dic, key=lambda x: x[1]))
# [('a', 3), ('b', 2), ('c', 1)]
# [('c', 1), ('b', 2), ('a', 3)]

10. 三元表达式

语法：

为真时的结果 if 判断条件 else 为假时的结果

下面两个等价：

c = max(a, b)
c = a if a >= b else b  # if 左边是 a 而不是 c = a

11. exit()

exit()常用于多层循环的退出，它可直接将python程序终止，之后的所有代码都不会继续执行。

12. 遍历列表

假设我们事先不知道数组 nums 的大小，那么有以下两种方法遍历该列表：

# 方法一
n = len(nums)
for i in range(n):
    ...
    
# 方法二
for i in range(len(nums)):
    ...

事实上，方法二比方法一稍微快一点。

六、各种算法

本章节整理了蓝桥杯中各种常见的算法并给出了相应的答题框架。

整理不易，若需继续学习，可前往下载地址支持作者。

写在最后

• 如果这篇文章有帮助到你，还想请你点个赞支持一下博主~
• 可能会有部分地方有笔误，如有发现可以在评论区留言
• 文章版权归博主所有，如需转载请注明出处