蓝桥杯——python组——常用内置函数、语法

蓝桥杯——python——常用内置函数库、语法

1、Sort

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

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

key=lambda x: x[0] 按列表中第一个元素升序排列

key=lambda x: -x[0] 按列表中第一个元素降序排列

key=lambda x: (x[0],x[1]) 先按列表中第一个元素升序排列，若第一个元素相等，则按列表中第二个元素升序排列

key=lambda x: x*-1 按x*-1的大小升序排列

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

2、Enumerate

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

enumerate(sequence, [start=0])

sequence -- 一个序列、迭代器或其他支持迭代对象。

start -- 下标起始位置。(下标起始位置可省略)

Eg:

seq = ['one', 'two', 'three']

for i, element in enumerate(seq):

    print(i, element)

3、Map、input、list、int

3.1、map() 函数会根据提供的函数对指定序列做映射。

第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

map(function, iterable, ...)

function -- 函数

iterable -- 一个或多个序列

3.2、Python3.x 中 input() 函数接受一个标准输入数据，返回为 string 类型

3.3、list() 方法用于将元组或字符串转换为列表

3.4、int() 函数用于将一个字符串或数字转换为整型

蓝桥杯Map、input、list、int

函数常用于输入中

Eg

输入整数N，M

M=map(int,input().split())

(split() 通过指定分隔符对字符串进行切片，如果参数 num 有指定值，则分隔 num+1 个子字符串

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

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

num -- 分割次数。默认为 -1, 即分隔所有。)

Eg

输入列表lst=[[],[],[]...]

Lst=[list(map(int,input().split()))  for _ in range(N)]

输入列表lst=[...]

Lst=list(map(int,input().split()))

（上述为整型列表）

4、format

数字	格式	输出	描述
3.1415926	{:.2f}	3.14	保留小数点后两位
3.1415926	{:+.2f}	+3.14	带符号保留小数点后两位
-1	{:-.2f}	-1.00	带符号保留小数点后两位
2.71828	{:.0f}	3	不带小数
5	{:0>2d}	05	数字补零 (填充左边, 宽度为2)
5	{:x<4d}	5xxx	数字补x (填充右边, 宽度为4)
10	{:x<4d}	10xx	数字补x (填充右边, 宽度为4)
1000000	{:,}	1,000,000	以逗号分隔的数字格式
0.25	{:.2%}	25.00%	百分比格式
1000000000	{:.2e}	1.00e+09	指数记法
13	{:>10d}	13	右对齐 (默认, 宽度为10)
13	{:<10d}	13	左对齐 (宽度为10)
13	{:^10d}	13	中间对齐 (宽度为10)
11	'{:b}'.format(11) '{:d}'.format(11) '{:o}'.format(11) '{:x}'.format(11) '{:#x}'.format(11) '{:#X}'.format(11)	1011 11 13 b 0xb 0XB	进制

^, <, > 分别是居中、左对齐、右对齐，后面带宽度， : 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。

+ 表示在正数前显示 +，负数前显示 -；  （空格）表示在正数前加空格

b、d、o、x 分别是二进制、十进制、八进制、十六进制。

此外我们可以使用大括号 {} 来转义大括号。

———————————————————————————————————————————补加（在不使用numpy情况下完成矩阵转置）

nums=[[2,3],[3,4],[5,6]]
nums_1=list(map(list,zip(*nums)))

单调队列使用

form queue import deque
## deque操作比list方便
## 例如在做滑动窗口类型题时
## 如果使用list进行暴搜大概率会超时.
## 但是可以使用deque，每次只维护需要的元素，可以减少时间复杂度
## deque可以进行头、尾、中间操作
dp=deque()
## 右侧弹出
dp.pop()
## 左侧弹出
dp.popleft()
## append()、appendleft()操作同上
##insert指定位置插入
dp.insert(index，num)
## 头、尾添加序列
dp.extend([...])
dp.extendleft([...])
## 旋转
dq.rotate(num)
# 若num>=1，表示从右向左的num个数，与其左边的所有数顺时针旋转
# 若num<=-1，表示从左向右的-num个数，与其右边的所有数逆时针旋转

zip()函数

#zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成#的对象，这样做的好处是节约了不少的内存。

#我们可以使用 list() 转换来输出列表。

#如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压##为列表。
zip([iterable, ...])
#iterable -- 一个或多个迭代器
>>> a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b)     # 返回一个对象
>>> zipped
<zip object at 0x103abc288>
>>> list(zipped)  # list() 转换为列表
[(1, 4), (2, 5), (3, 6)]
>>> list(zip(a,c))              # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]

>>> a1, a2 = zip(*zip(a,b))          # 与 zip 相反，zip(*) 可理解为解压，返回二维矩阵式
>>> list(a1)
[1, 2, 3]
>>> list(a2)
[4, 5, 6]
>>>