当前位置:   article > 正文

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

蓝桥杯python列表


前言

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


一、基本知识点

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

总结

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

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/我家自动化/article/detail/64173
推荐阅读
相关标签
  

闽ICP备14008679号