系列文章目录

---

前言

一、python实战技巧

1. 求字符差值

python不可以直接进行字符减运算，当需要进行字符之间的减运算时，我们可以使用ord()函数，ord()函数是python自带的函数，无需导入。

print(ord('b')-ord('a'))
#result:1
1
2

2. 字符串反转

string = 'leetcode'
print(string[::-1])
#result:edocteel
1
2
3

3. 数组元素计数

import collections
li = [1,2,2,4,5,5]
cnt = collections.Counter(li)
print(cnt)
#result:Counter({2: 2, 5: 2, 1: 1, 4: 1})
1
2
3
4
5

4. 字典遍历

cnt = {1:4,2:3}
#遍历键值对
for item in cnt.items():
    print(item)
#遍历键
for item in cnt.keys():
    print(item)
#遍历值
for item in cnt.values():
    print(item)
1
2
3
4
5
6
7
8
9
10

result:

(1, 4)
(2, 3)
1
2
4
3
1
2
3
4
5
6

5. 初始化全0数组

li = [0]*length #第一种
li = [0 for i in range(length)] #第二种
li = [[0]*3 for i in range(4)] #二维数组
1
2
3

6. Counter计数

from collections import Counter
colors = ['red','blue','red','green','blue','blue']
c = Counter(colors)
print(c)
print(dict(c)) 
1
2
3
4
5

result:

Counter({'blue': 3, 'red': 2, 'green': 1})
{'red': 2, 'blue': 3, 'green': 1}
1
2

7. bisect的用法

bisect是python的内置模块，用于有序序列的插入和查找
查找：bisect(array,item)
插入：bisect(array,item)

import bisect 
a = [1,2,2,5,8]
position = bisect.bisect(a,7)
print(position)
#4
bisect.insort(a,4) #找到位置插入
print(a)
#[1,2,2,4,5,8]
bisect.bisect_left(a,2) #插到左侧
#1
bisect.bisect_right(a,2) #插到右侧
#3
1
2
3
4
5
6
7
8
9
10
11
12

8. 列表去重

l1 = [1,4,4,2,3,4,5,6,1]
l2 = list(set(l1))
print(l2)
#result:[1, 2, 3, 4, 5, 6]
1
2
3
4

9. 列表转化成字符串

li = ['a','b','c']
print(' '.join(str(i) for i in li))
1
2

10. map函数

def square(x):
    return x**2
a = list(map(square,[1,2,3,4,5])) #计算列表各元素的平方
b = list(map(lambda x:x**2,[1,2,3,4,5,])) #用lambda匿名函数
print(a,b)
#result:[1, 4, 9, 16, 25] [1, 4, 9, 16, 25]
1
2
3
4
5
6

11. collections.deque

deque是双端队列(double-ended queue)的缩写，由于两端都能编辑，deque既可以实现栈(stack),也可以实现队列(queue)

from collections import deque
# que = collections.deque()
a=deque([1,2,3])
a.pop()
# [1,2]
a.append(4)
# [1,2,4]
a.popleft()
# [2,4]
a.appendleft(0)
# [0,2,4]
1
2
3
4
5
6
7
8
9
10
11

相比list实现的队列，deque实现拥有更低的时间和空间复杂度。list实现出队(pop)和插入(insert)时的空间
复杂度大约为O(n),deque在出队(pop)和入队(append)时的时间复杂度是O(1)。

12. Priority Queue

from queue import PriorityQueue
Q = PriorityQueue()
Q.put(3)
Q.put(2)
Q.put(1)
Q.get()
1
2
3
4
5
6

优先级队列，默认是从小到大排序的

13. 二维list按某一列的值排序

li = [[1,3],[8,10],[2,6],[15,18]]
li.sort(key=lambda x:x[0])
li
print(li)
#result:[[1, 3], [2, 6], [8, 10], [15, 18]]
1
2
3
4
5

14. f-string的用法

name = 'python'
f'Hello {name}'
print(f'Hello {name}')
1
2
3

15. zip函数的用法

systems = ['windows','ubuntu','mac']
version = ['20.20','19.10','21.20']
countries = ['UK','Chinese','US']
for system,ver,country in zip(systems,version,countries):
    print(f'{system} plays in {ver}.country:{country}')
1
2
3
4
5

16. 利用get()方法获取字典value

person = {'name':'YQ','age':22}
print('Name:',person.get('name'))
print('Age:',person.get('age'))
print('Salary:',person.get('salary'))
1
2
3
4

result:

Name: YQ
Age: 22
Salary: None
1
2
3

17. collections.OrderedDict有序字典

from collections import OrderedDict
mydict = OrderedDict({'a':2,'b':1,'c':0})
for key,value in mydict.items():
    print(key,value)
1
2
3
4

result:

a 2
b 1
c 0
1
2
3

18. 取字典最大value值对应key

nums = [1,2,2,2,3,4,4]
from collections import Counter
cnt = Counter(nums)
print(max(cnt.keys(),key = cnt.get))
#result:2
1
2
3
4
5

19. @lru_cache 装饰器用法

NameError: name 'lru_cache' is not defined
from functools import lru_cache
1
2

一个为函数提供缓存功能的装饰器，直接用于一个用户自定义函数，在下次以相同参数调用时直接返回上一次的结果
lru_cache maxsize 参数默认值为128.如果设为None，缓存可无限增长

from functools import lru_cache
@lru_cache(maxsize = None)
def fib(n):
    if n < 2:
        return n
    return fib(n-1) + fib(n-2)
1
2
3
4
5
6

20. 字典的排序

#字典排序
a = {'a':3,'c':89,'b':0,'d':34}
#按照字典的值进行排序
a1 = sorted(a.items(),key = lambda x: x[1])
#按照字典的键进行排序
a2 = sorted(a.items(),key = lambda x: x[0])
print('按值排序后结果',a1)
print('按键排序后结果',a2)
print('结果转为字典格式',dict(a1))
print('结果转为字典格式',dict(a2))
1
2
3
4
5
6
7
8
9
10

result：

按值排序后结果 [('b', 0), ('a', 3), ('d', 34), ('c', 89)]
按键排序后结果 [('a', 3), ('b', 0), ('c', 89), ('d', 34)]
结果转为字典格式 {'b': 0, 'a': 3, 'd': 34, 'c': 89}
结果转为字典格式 {'a': 3, 'b': 0, 'c': 89, 'd': 34}
1
2
3
4

21. 判断字符串是否全部有字母组成

my_str = 'python'
my_str.isalpha()
print(my_str.isalpha())
1
2
3

22. 对某个可迭代对象（字典，列表，元组，等）进行多步排序

多步排序，例如：先按内容进行排序，如果内容一样再按照ID排序

my_test = ["b:7","a:7","c:4","d:3"]
def f(log):
    id_,rest = log.split(":",1)
    return (rest,id_)
print(sorted(my_test,key=f))
#result:['d:3', 'c:4', 'a:7', 'b:7']
1
2
3
4
5
6

比如上面的例子，先按照字符串值进行排序，再按照字符串的id排序

23. 列表不能作为字典的键，但是元组可以

有时候需要用字典来统计一个列表中相同的元素的个数，但是可能元素也是一种列表，这种时候就不能直接使用
collections.Counter来统计，需要把原列表的元素转为tuple

1、数组操作

1.1. 遍历数组，枚举索引和值

for i,j in enumerate([1,2,34,5,56,4]):
#i为索引
#j为值
1
2
3

1.2. 数组反转

a = [1,2,3,4,5]
a[::-1]
a.reverse()
1
2
3

1.3. 数组排序

a = [1,2,6,8,0,3,4]
a.sort()
a = [[1,3],[2,4],[5,0]]
sort(key = lambda x:x[0]) #根据第一个数为key进行排序
1
2
3
4

1.4. 数组合并

a = [1,2,6,8,0,3,4]
b = [2,5,9]
a.extend(b)
a.[len(a):]=b
1
2
3
4

1.5. 构建栈和队列

a = [1,2,6,8,0,3,4]
a.append() #数组尾部添加
a.insert(x,3) #在索引为x的位置插入3
a.pop() #删除尾部元素
a.pop(0) #删除索引为0的元素
a = [] #构建栈
a.append()
a.pop()
a = []
a.append()
a.pop(0)
1
2
3
4
5
6
7
8
9
10
11

1.6. 数组去重

#转化为set,再转化为list
a = [1,1,1,3,4,4]
a = list(set(a))
1
2
3

1.7. 查找数组

a.index(3)
1

2、字符串操作

2.1. 去除空格

a = '  hello  world  '
a.strip() #去除两边所有空格
a.lstrip() #去除左边空格
a.rstrip() #去除右边空格
1
2
3
4

2.2. 替换字符

#将a中的x替换为yyy，可以将空格' '替换为''等于去除空格
a.replace('x','yyy')
1
2

2.3. 合并字符

a = 'hello'
b = 'world'
c = a + b
1
2
3

2.4. 判断字符组成

#如果string只包含数字则返回true,否则返回False
a.isdigit()
#如果string至少有一个字符并且所有字符都是字母或数字则返回True，否则返回False
a.isalnum()
#如果string至少有一个字符并且所有字符都是字母则返回True，否则返回False
a.isalpha()
1
2
3
4
5
6

2.5. 数组转化为字符

#以string作为分隔符，将seq中所有的元素（的字符串表示）合并为一个新的字符串
#string.join(seq)
a = [1,2,3,4]
#''.join(a) #结果为'1234'
print(' '.join('%s' %id for id in a))
1
2
3
4
5

24. 原地交换两个数字

python 提供了一个直观的在一行代码中赋值与交换（变量值）的方法

x,y = 10,20
print(x,y)
x,y = y,x
print(x,y)
1
2
3
4

赋值的右侧形成了一个新的元组，左侧立即解析（unpack）那个（未被引用的）元组到变量和，一旦赋值完成，新的元组变成了未被引用状态并且被标记为可被垃圾回收，最终完成了变量的交换

25. 链状比较操作符

比较操作符的聚合是另一个有时很方便的技巧：

n = 10
result =  1<n<20
print(result) #True
result = 1>n<=9
print(result) #False
1
2
3
4
5

26. 存储列表元素到新的变量中

我们可以使用列表来初始化多个变量，在解析列表时，变量的数目不应该超过列表中元素个数：[元素个数与列表长度应该严格相同]

testList =[1,2,3]
x,y,z = testList
print(x,y,z) #1 2 3
1
2
3

27. 打印引入模块的文件路径

如果你想知道引用到代码中模块的绝对路径可以使用

import threading
import socket
print(threading)
print(socket)
1
2
3
4

28. 交互环境下的“—”操作符

这是一个我们大多数人不知道的有用特性，在python控制台，不论何时我们测试一个表达式或调用一个方法，结果都会分配一个临时变量：_

29. 如何用input输入多个数据

#方法一：
#List = eval(input('输入若干个数字，用逗号分隔：'))
#方法二：
#List = List(map(int,input('输入数字，以空格分隔').split()))
#int可以换为float等，得到的数据也随之为相应类型

#解释：
#1. map()
#map()函数接受两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回
#2. split()
#拆分字符串，通过指定分隔符对字符串进行切片，并返回分隔后的字符串列表
#3. map(function,input("以空格分开").split())
#由于input()输出的是用空格分开的字符串，split()会分隔开各个值并放到列表中，此时在列表中的值是字符串，如果要运算，那么必须在map()中利用int()或float()等处理再赋值
1
2
3
4
5
6
7
8
9
10
11
12
13

30. 同时获取索引和下标

List = [1,2,3,4,5,6]
for i,j in enumerate(List): #i为下标，j为相应的数据
    print("data:",end=' ')
    print("index",i)
1
2
3
4

result:

data: index 0
data: index 1
data: index 2
data: index 3
data: index 4
data: index 5
1
2
3
4
5
6

31. 内存地址查询

a = 123
b = 'blue'
print(id(a)) #不同电脑，值应该不同
print(id(b))
1
2
3
4

32. 将两个列表转换为字典

a = ['A','B','C','D','E']
b = [1,2,3,4,5]
#方法一：
c1 = dict(zip(a,b))
#方法二
c2 = {key:value for key,value in zip(a,b)}
#方法三
c3 = {} #初始化一个空字典
for k,v in zip(a,b):
    if k not in c3.keys(): #判断k是否在c3字典的键中
        c3[k] = v
print(c1)
print(c2)
print(c3)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

result:

{'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 5}
{'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 5}
{'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 5}
1
2
3

33. 列表元素频率统计（利用字典）

a = [1,2,3,1,2,4,6,5,6,6,7,9,10,10]
b = {}
for i in a:
    if i not in b.keys():
        b[i] = 1
    else:
        b[i] =b[i] + 1
print(b)
#result:{1: 2, 2: 2, 3: 1, 4: 1, 6: 3, 5: 1, 7: 1, 9: 1, 10: 2}
1
2
3
4
5
6
7
8
9

34. 对象占用内存量查询

from sys import getsizeof
a = 100
b = 'green'
print(getsizeof(a)) #28
print(getsizeof(b)) #54
1
2
3
4
5

35. 检查是否有重复元素

List1 = [1,2,3,4,56]
List2 = [1,1,3,4,5,5]
print("有重复元素:",len(List1) != len(set(List1))) #有重复元素：False
print("有重复元素:",len(List2) != len(set(List2))) #有重复元素：True
1
2
3
4

解释：set(x)函数可以用于集合生成，其中的参数可以为任意数据类型，返回结果是一个无重复且排序任意的集合，
也就是说，如果输入数据有重复，那么返回的结果也会把重复的数据变得不重复

36. 查找列表中出现次数最多的数

#方法一：
List1 = [1,2,3,4,56,11,2,3,4,5,6,7,1,2,3,1,1,1,19]
print(max(set(List1),key = List1.count)) #1
#方法二：
from collections import Counter  #python的内置库
ct = Counter(List1)
print(ct.most_common(1)) #输出频率最高的一个 #[(1,5)] 1出现5次
1
2
3
4
5
6
7

37. 反转列表

List1 = [1,2,5,4,7,6]
List2 = List1[::-1]
print(List2) #[6, 7, 4, 5, 2, 1]
1
2
3

38. 合并列表的两种方法

list1=[1,2,5,4,7,6]
list2=['A','B','C','D']
list3=list1+list2#直接加
list4=list1.extend(list2)#调用列表的extend方法
print(list3) #[1, 2, 5, 4, 7, 6, 'A', 'B', 'C', 'D']
print(list4) #None
print(list1) #[1, 2, 5, 4, 7, 6, 'A', 'B', 'C', 'D']
1
2
3
4
5
6
7

解释：为什么list4为None？其实，这里非常重要，列表的append和extend方法都会对原有列表进行修改，是不会返回一个新的列表的，返回值为None。

39. 字典推导（Dictionary comprehensions）和集合推导（Set comprehensions）

大多数的python程序员都知道且使用过列表推导list comprehensions，如果你对list comprehensions不熟，更简短：

some_list = [1,2,3,4,5]
another_list = [x + 1 for x in some_list]
print(another_list) #[2, 3, 4, 5, 6]
1
2
3

40. 自从python3.1起，我们可以使用同样的语法来创建集合和字典表

some_list = [1,2,3,4,5,2,5,1,4,8]
even_set = {x for x in some_list if x %2 == 0}
print(even_set) #{8, 2, 4}
set([8,2,4])
d = {x: x%2 == 0 for x in range(1,11)}
print(d) #{1: False, 2: True, 3: False, 4: True, 5: False, 6: True, 7: False, 8: True, 9: False, 10: True}
1
2
3
4
5
6

在第一个例子里，我们以some_list为基础，创建了一个具有不重复元素的集合，而且集合里只包含偶数，而在字典表中，我们创建了
一个key是不重复复的1到10之间的整数，value是布尔型，用来指示key是否是偶数
这里另一个值得注意的是集合的字面量表示法，我们可以简单的用这种方法创建一个集合

my_set = {1,2,1,2,3,4}
print(my_set) #{1, 2, 3, 4}
1
2

41. 迭代工具

和collections库一样，还有一个库较itertools，对某些问题真能高效的解决，其中一个用例是查找所有组合

from itertools import combinations
teams = ["Packers","49ers","Ravens","Patriots"]
for game in combinations(teams,2):
    print(game)
1
2
3
4

result:

('Packers', '49ers')
('Packers', 'Ravens')
('Packers', 'Patriots')
('49ers', 'Ravens')
('49ers', 'Patriots')
('Ravens', 'Patriots')
1
2
3
4
5
6

42. 调试脚本

我们可以在模块的帮助下在python脚本中设置断点

import pdb
pdb.set_trace()
1
2

43. 如何用input输入多个数据

#方法一：
#List = eval(input('输入若干个数字，以逗号分隔：')) #输入个数任意，都保存到list中
#方法二：
#List = list(map(int(input('输入数字，以空格隔开').split())))
#int可以换成float等，得到的数据也随之为相应类型

#解释：

1.map()
map函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回
2.split()
split拆分字符串，通过指定分隔符对字符串进行切片，并返回分割后的字符串列表
3.map(function,input("以空格分开").split())
由于input()输出的是用空格分开的字符串，split()会分割开各个值并放到列表中，此时在列表中的值是字符串\
如果要用于运算，那么必须在map()中利用int()或float()等处理，再赋值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

---

总结

分享：
经验是我们创新的一个潜在条件。严格地说，有经验而不受经验制约时，经验才是创新的一个条件，否则，经验就会成为阻碍创新的障碍。经验是有不同层次的。为了升华智慧，应尽可能借鉴高层次的经验—
这不仅为我们提供了前进的方向，还提供了选择的思路，使之成为触发新成功的起点。