python知识点笔记

记录一些python上遇到的知识点方便日后查询。

1. lambda

lambda本质上是一个写在一行中的函数， 冒号左侧为函数输入值，右侧为返回值，可以有多个输入和返回。

lambda x:x+1

lambda x, y:x+y

2. map()

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

第一个参数 function 以参数序列中的每一个元素调用 function 函数，相当于对后续输入的可迭代对象中的每一个元素做函数的操作。
返回一个map迭代器，可使用list()或set()转换为list和set对象进行查看。
map(function, iterable, …)

list(map(lambda x:x+1, [1, 2, 3]))

list(map(lambda x, y:x+y, [1, 2, 3], [4, 5, 6]))

3. python使用map并行操作

多线程map使用方式的教程。
https://www.cnblogs.com/wangxusummer/p/4835929.html
https://www.cnblogs.com/sthu/p/9355759.html

4. 使用*解包和使用zip()打包

当输入是一个未定长度的列表，而函数输入要求所有变量分别输入时，使用*将列表中的每个元素单独展开作为变量输入。
在numpy库的部分函数中，有时候需要使用这种方式输入。

zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同。

# 使用python一行完成矩阵旋转
# 转自https://leetcode-cn.com/problems/rotate-image/comments/712701

nums = [[1,2,3],[4,5,6],[7,8,9]]
# 使用*反序解包
print(*nums[::-1])
# [7, 8, 9] [4, 5, 6] [1, 2, 3]

# 使用zip将元素挨个打包
nums[:] = zip(*nums[::-1])
print(nums)
# [(7, 4, 1), (8, 5, 2), (9, 6, 3)]

5. reduce() 函数

会对参数序列中元素进行累积。

函数将一个数据集合（链表，元组等）中的所有数据进行下列操作：用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。
例：对列表中的每个数字进行求和

from functools import reduce

def get_sum(nums):
    return reduce(lambda x, y: x + y, nums)		
	
print(get_sum([1,3,5,6]))

6. 位运算符

& 按位与运算符
| 按位或运算符
^ 按位异或运算符：当两对应的二进位相异时，结果为1
~ 按位取反运算符
<< 左移动运算符：运算数的各二进位全部左移若干位，由 << 右边的数字指定了移动的位数，高位丢弃，低位补0。
同：>> 右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，>> 右边的数字指定了移动的位数

例：给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。使用异或运算得到结果。

def singleNumber(nums):
	return reduce(lambda x, y: x ^ y, nums)

7. 使用[:]在函数不返回的情况下对列表本身的值进行改变

def merge(a, b):
		a = a + b
		
a = [1, 2, 3]
b = [4, 5, 6]

merge(a, b)
print(a)

[1, 2, 3]

def merge(a, b):
		a[:] = a + b
		
a = [1, 2, 3]
b = [4, 5, 6]

merge(a, b)
print(a)

[1, 2, 3, 4, 5, 6]

8. 查询列表中第一个指定元素的索引

# 查询第一个指定元素的位置
index = list_1.index(element)

9. 正则表达式

识别字符串开头的数字，代码与说明转自leetcode

def myAtoi(self, s):
        return int(*re.findall('^[\+\-]?\d+', s.lstrip()))

作者：QQqun902025048
链接：https://leetcode-cn.com/problems/string-to-integer-atoi/solution/python-1xing-zheng-ze-biao-da-shi-by-knifezhu/
来源：力扣（LeetCode）

^：匹配字符串开头
[\+\-]：代表一个+字符或-字符
?：前面一个字符可有可无
\d：一个数字
+：前面一个字符的一个或多个
\D：一个非数字字符
*：前面一个字符的0个或多个

10. enumerate() 函数

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

seasons = ['Spring', 'Summer', 'Fall', 'Winter']
print(list(enumerate(seasons)))

[(0, ‘Spring’), (1, ‘Summer’), (2, ‘Fall’), (3, ‘Winter’)]

11. 堆heapq

# 导入库
from heapq import * 

# 用一个列表充当堆
heap = [] 

# 加入元素
for i in range(10):
	heappush(heap, i)
	
# 取出最小元素
min_val = heappop(heap)

# 将普通列表整理为一个最小堆
list1 = [4, 3, 1, 2, 7]
heapify(list1)
# list1 = [1, 2, 4, 3, 7]

# 将所有数字取负输入，再取负输出，即可将其作为最大堆使用。
list2 = list(map(lambda x:-x,[4, 3, 1, 2, 7]))
heapify(list2)
# list2 = [-7, -4, -1, -2, -3]

# 也可以按照元素的顺序进行对第一个元素的排序
list3 = [(4,1), (3,9), (1,4), (2,3), (7,2)]
heapify(list3)
print(list3)
# list3 = [(1, 4), (2, 3), (4, 1), (3, 9), (7, 2)]

12. 使用sorted()与reversed()对列表进行局部排序或局部反转

a = [4, 3, 1, 2, 0]

a[:4] = reversed(a[:4]) 
print(a)
# [2, 1, 3, 4, 0]

a[:4] = sorted(a[:4]) 
print(a)
# [1, 2, 3, 4, 0]

13. filter()

filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。

该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

def is_odd(n):
    return n % 2 == 1
 
newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(newlist)

[1, 3, 5, 7, 9]

14. 排列与组合

itertools.permutations()罗列排列可能性。
itertools.combinations()罗列组合可能性。

import itertools

list1 = [1, 2, 3]

# 包含3个值的情况下所有的排列可能性
list2 = list(itertools.permutations(list1,3))
print(list2)
# [(1, 2, 3), (1, 3, 2), (2, 1, 3), (2, 3, 1), (3, 1, 2), (3, 2, 1)]

# # 包含3个值的情况下所有的组合可能性
list3 = list(itertools.combinations(list1,2))
print(list3)
# [(1, 2), (1, 3), (2, 3)]

15. 阶乘factorial()

import math
num = math.factorial(6)
print(num)

16. repr()处理转义字符

当遇到需要从cmd或者文件输入路径，例如路径"E:\V1R2\product\fpgadrive.c"，然后需要截取出最后的文件名时，可能遇到/f被判断为单个字符，导致无法正确识别出最后一个/的位置。
对代码中的字符串，可以简单地通过在代码前方加入r来解决，但是对于读取的字符串，只能使用变量名对其进行操作。
此时可以使用repr(input)来获取原始字符串输入然后通过搜索//来获取文件名。
注：repr(input)会导致字符串开头和最后的字符变为’，可以通过[1:-1]的方式去除。

a = repr(input())
# 输入E:\V1R2\product\fpgadrive.c
print(a)
# 'E:\\V1R2\\product\\fpgadrive.c'
a = a[1:-1]
print(a)
# E:\\V1R2\\product\\fpgadrive.c
for i in range(len(a)-1,-1,-1):
	if a[i] == "\\":
		print(a[i+1:])
		# fpgadrive.c
		break

17. 未知输入行数的cmd输入中止判断

基于异常捕获

while True:
    try:
        deal_with(input())
    except:
        break

基于sys
注：该方法会导致读取到的line在末尾有一个\n的换行符，可能导致某些题目中输出出现额外的换行错误。

import sys
while True:
    line = sys.stdin.readline()
    if not line:
        break
    deal_with(line)

18. 高阶矩阵深拷贝

在不使用Numpy的情况下，对python原本的列表可以使用[:]进行深拷贝，但如果列表为二阶矩阵及以上时，深拷贝对内部的元素产生的效果依然只是浅拷贝，这时候可以通过调用copy库解决。

import copy
a = [[1,2],[3,4]]
b = copy.deepcopy(a）

19. 字符串大小写转换

s.upper() #把所有字符中的小写字母转换成大写字母
s.lower() #把所有字符中的大写字母转换成小写字母
s.capitalize() #把第一个字母转化为大写字母，其余小写
s.title() #把每个单词的第一个字母转化为大写，其余小写 

20. 随机数生成

# 生成 0 ~ 2 之间的随机数
import random
 
print(random.randint(0,2))

21. 进制转换

十进制转换到其它进制
二进制：bin(）
八进制：oct(）
十六进制：hex(）

22. 统计每个元素的出现次数

from collections import Counter
string = "asfhaisfhaoif"
res = Counter(string)
print(res)
# Counter({'a': 3, 'f': 3, 's': 2, 'h': 2, 'i': 2, 'o': 1})

23. 用位运算判断奇数偶数

'''
判断奇偶  （二进制数以1结尾是奇数，以0结尾是偶数）

奇数&1==1

偶数&1==0
'''
print(6&1)
# 0
print(9&1)
# 1

24. 将对象储存在磁盘上

使用pickle将任意python对象保存在磁盘上用于下次调用。

pickle.dump(obj, file[, protocol])
　　序列化对象，并将结果数据流写入到文件对象中。参数protocol是序列化模式，默认值为0，表示以文本的形式序列化。protocol的值还可以是1或2，表示以二进制的形式序列化。

pickle.load(file)
　　反序列化对象。将文件中的数据解析为一个Python对象。

import pickle  

a = ["fafa",(24,55)]
# 写入二进制文件
with open("pickle_test.pkl","wb") as f:
	pickle.dump(a,f,1)
	
# 读出二进制文件
with open("pickle_test.pkl","rb") as f:
	b=pickle.load(f)

print(b)
# ['fafa', (24, 55)]

25. 用字典的值进行排序

原文链接：https://blog.csdn.net/u013193903/article/details/81096367

# 现在想对字典进行排序，根据value的第一个值，即列表的第一个数字
test_dict = {
    
    
    'a': [1, 'n'],
    'b': [2, 'k', 'b'],
    'c': [5, 'h1', 'h2', 'h3', 'h4', 'h5'],
    'd': [3, 'dfg1', 'dfg2', 'df3'],
    'e': [4, 'dfg1', 'dfg2', 'dfg3', 'dfg4'],
    'f': [2, 'dfgl', 'dfg2'],
    'g': [2, 'f1', 'f2'],
}

tmp = sorted(test_dict.items(), reverse=True, key=lambda x: x[1][0])

# >>> test_dict.items()
# dict_items([('a', [1, 'n']), ('b', [2, 'k']), ('c', [5, 'h']), ('d', [10, 'dfg']), ('e', [4, 'dfg']), ('f', [2, 'dfgl']), ('g', [2, 'f'])])
# 这里的test_dict.items()实际上是将test_dict转换为可迭代对象
# ('a', [1, 'n']), ('b', [2, 'k']), ('c', [5, 'h']), ('d', [10, 'dfg']), ('e', [4, 'dfg']), ('f', [2, 'dfgl']), ('g', [2, 'f'])

# 用的是元组的第二值，即列表，取列表的第一个值，就是需要排列的数字，key=lambda x: x[1][0]

26. ASCII码与字符相互转换

# 用户输入字符
c = input("请输入一个字符: ")
 
# 用户输入ASCII码，并将输入的数字转为整型
a = int(input("请输入一个ASCII码: "))
 
 
print( c + " 的ASCII 码为", ord(c))
print( a , " 对应的字符为", chr(a))