基础语法

函数

设置递归深度：

sys.setrecursionlimit(3000)

sum() 函数 ：求和计算

round() 函数： 四舍五入

pow(a,b) 函数 ：计算任意N次方值

min() max()

bool() 函数 ：将指定的参数转换成布尔类型

ord() 函数 ：获取单个字符的ASCII数值

list() 函数： 将可迭代对象转换为列表。list(range(1,10))

sorted() 函数： 对可迭代对象进行排序

len()函数： 返回一个对象的元素或项目个数

map(fun, it) 函数：对it中所有元素依次作为fun函数的参数

向上取整 math.ceil(3.1)

向下取整 math.floor(3.1)

切片

简单切片

简单切片指的是这样的切片形式：a[start:stop]，其行为是得到下标在这样一个前闭后开区间范围内的元素

扩展切片

扩展切片指的是这样的切片形式：a[start:stop:step]，其中step是一个非零整数，即比简单切片多了调整步长的功能，此时切片的行为可概括为：从start对应的位置出发，以step为步长索引序列，直至越过stop对应的位置，且不包括stop本身。

1
2
3
4
5
6
7
8
9
10
11
12
13
>>> a = list(range(10))
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> a[:5]
[0, 1, 2, 3, 4]
>>> a[5:]
[5, 6, 7, 8, 9]
>>> a[2:8]
[2, 3, 4, 5, 6, 7]
>>> a[::2]
[0, 2, 4, 6, 8]
>>> a[::-1]
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

字符串

返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数

1
string.count(str, beg=0, end=len(string))

检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1

1
string.find(str, beg=0, end=len(string))

以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串

1
string.join(seq)

转换 string 中的小写字母为大写

string.upper() string.lower()

怎样将以下列表转化为整数？

1
2
3
4
5
6
7
a=[1, 3, 5]
b=['4', '5', '6']
r1 = int("".join(map(str, a))) 
r2 = int("".join(map(str, b))) 

123
456

输入输出

两种输入方式，两种输出方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# 循环读取到文件末尾
try:
    while True:
        s = input()
        print(s)
except:
    pass

## 读取n,m，再读取n个数，m行
n, m = (int(_) for _ in input().strip().split(" "))
a = [int(_) for _ in input().strip().split(" ")]
for i in range(m):
    s = input()

## 读取的第二种方法，map映射
a1 = list(map(int, input().split()))

## 输出n个数在一行（无行尾空格）
ans = [1, 2, 3, 4]
for j in ans[:-1]:
    print(j, end=" ")
print(ans[-1])

## 格式化输出
print("{} {}".format("hello", "world))
print("{:.2f}".format(3.1415926));

快速读入

sys.stdin.readline()，和input()一样，需要import sys

常用模板

stack

用一个数组list和一个top指针标志栈顶，通过top指针的前后移动来模拟stack的出队和入队。

queue

在python就有Queue这个库，但速度较慢，且不能不出栈地访问头部元素，想要访问头部元素，只能用get方法出栈首部获取方法返回值的来进行访问，非常不方便。

Queue的底层实现用的是collections.deque，这是一个双端队列，大概同C++中的deque，首尾都可以添加删除元素，可以用来模拟queue。

1
2
3
4
5
6
7
8
9
10
11
q = collections.deque()
q.appendleft(10)
q.appendleft(4)
q.appendleft(11)
print("top:{}".format(q[0]))
q.popleft()
print("after_pop_top:{}".format(q[0]))

# 运行结果：
# top:11
# after_pop_top:4
名称 作用
q.append() 右边加入
q.appendleft() 左边加入
q.pop() 右边弹出
q.popleft() 左边弹出

优先队列

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import heapq


class PriorityQueue:
    def __init__(self):
        self.__queue = []

    def push(self, priority):
        heapq.heappush(self.__queue, priority)

    def pop(self):
        return heapq.heappop(self.__queue)

    def front(self):
        return self.__queue[0]


q = PriorityQueue()
q.push(2)
q.push(1)
q.push(3)
q.push(1)
print(q.front())
print(q.pop())
print(q.pop())
print(q.pop())
print(q.pop())

排序

Python列表有一个list.sort()方法可以直接修改原列表对象进行排序，Python还内置了一个sorted()函数对可迭代对象排序并返回新的列表对象。

1
2
3
4
b = sorted([5, 2, 3, 1, 4])

a = [5, 2, 3, 1, 4]
a.sort()

可以使用 functools.cmp_to_key( mycp ) 自定义排序函数，函数返回正、负、0表示三种状态。

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


def mycomp(x, y):
    if x[2] == y[2]:
        if x[1] == y[1]:
            return x[0] - y[0]
        else:
            return x[1] - y[1]
    else:
        return x[2] - y[2]


a = [(1, 3, 5), (2, 2, 2), (4, 7, 8), (10, 8, 1), (3, 8, 1)]
a.sort(key=functools.cmp_to_key(mycomp))
print(a)

二分

bisect是python内置模块，用于有序序列的插入和查找。

  • 查找： bisect(array, item)
  • 插入： insort(array,item)

bisect还有bisect_left，insort_left的用法，和不带left的用法的区别是：当插入的元素和序列中的某一个(多个)元素相同时，该插入到该元素的前面（左边，left），还是后面（右边）；如果是查找，则返回该元素（第一次出现）的位置还是该元素（最后一次出现）之后的位置。

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

li = [21, 4, 5, 61, 45, 45, 100]
li.sort()
print(li)
print(bisect.bisect(li, 1000))
print(bisect.bisect(li, 45))
print(bisect.bisect_left(li, 45))
print(li)

bisect.insort(li, 5)
print(li)

# 说明
# [4, 5, 21, 45, 45, 61, 100]
# 7
# 5
# 3
# [4, 5, 21, 45, 45, 61, 100]
# [4, 5, 5, 21, 45, 45, 61, 100]

与C++不同的操作

  1. 判断是否为数字是否为字母，C++中一般用ascii码来比较，python中可以使用str的isdigit和isalpha方法直接判断
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 获取数字长度
n = 119849
len1 = len(str(n))

# 判断是否为数字
str1 = ",123d{"
num1 = 0
for j in str1:
    if j.isdigit():
        num1 += 1
str2 = ",abc3{"
num2 = 0
for j in str2:
    if j.isalpha():
        num2 += 1
print("digit:{},aplha:{}".format(num1, num2))

digit:3,aplha:3
10
  1. python的def函数中假如想要使用外部全局变量，必须global说明，这点非常要当心
1
2
3
4
5
6
7
8
9
10
# 使用全局变量
def jishu():
    global cnt1
    cnt1 += 1


cnt1 = 0
for i in range(10):
    jishu()
print(cnt1)
  1. deepcopy深拷贝的问题，关于这一点，可以尝试一下下面的代码，深刻体会一下浅拷贝和深拷贝的区别
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import copy

list1 = [1, 2, 3, 4, 5, 5, 4, 3, 2, 1]

for i, x in enumerate(list1):
    print("{},{}".format(i, x))

list1 = [1, 2, 3]
list2 = list1
list3 = copy.deepcopy(list1)
list1[0] = 10
print(list2)
print(list3)


0,1
1,2
2,3
3,4
4,5
5,5
6,4
7,3
8,2
9,1
[10, 2, 3]
[1, 2, 3]