使用Python做算法题的时候一些笔记/trick,不定时更新

写在前面 ,因为本来以为都得用C++的,所以前面记录了一点简单的C++知识, 后来基本上都在使用Python写算法题,所以都在记录Python了，具体看目录吧。

Python的format可以在输出的时候补0或补未知数

<向右补齐，>向左补齐
Python的format

Python可以直接实现进制的转换

int('数值',进制)，将指定进制的数值转化为10进制整数。
hex(10进制数)，将10进制数转化为16进制数。
oct(10进制数)， 将10进制数转化为8进制数。
bin(10进制数)， 将10进制数转化为2进制数。

print("{:d}".format(int('0xAA',16)))
print("{:s}".format(hex(10)))
print("{:s}".format(oct(10)))
print("{:s}".format(bin(10)))

Python实现对字典、列表的特殊排序

sorted可以对任意的迭代器实现排序
key是连接函数，此函数用来接收迭代器的每个元素进行处理。这里使用lambda匿名函数，key=lambda x:x[0]的目的就是接收x并且返回x[0],也就是索引，所以这里是根据索引来排序。
注意使用dict.items()迭代键值对，直接对dict迭代只能迭代出索引。

#dic为一个字典，返回值是一个列表，列表中的元素都是元组，也就是键值对。
dic = sorted(dic.items(),key=lambda x:x[0],reverse=False)
#这里则是根据列表中
lst = sorted(lst.items(),key=lambda x:x[2],reverse=False)

列表的排序也是同理
这里假设每个列表中有3个元素,要求按照它们的求和大小排序
注意，如果使用列表中自带的函数sort,则会直接将列表排序，并且不返回任何值。

lst.sort(key=lambda x:sum(x))
#使用sorted也是可以的
lst = sorted(lst,key=lambda x:sum(x))

Python对一个序列实现反向索引

使用切片操作就可以了

s='123dz'
s= s[::-1]

Python实现字符串、列表、字典之间的转换

将字符串的每个字符拆分为列表中的元素
使用list(str)

s='asd'
list(s)
#输出:['a', 's', 'd']

将字符串的按照特殊字符作为分隔符拆分为列表中的元素
使用str.split()

s='das xcz nmb'
s.split(' ')
#输出:['das', 'xcz', 'nmb']

将列表中的元素转化为字符串
使用'char'.join() char为需要添加在中间的间隔符
(注:此方法是为传入数据的每个元素之间加间隔符转化为字符串,如果输入的是一个字符串,那么将会导致每个字符之间都添加分隔符)

l =['das', 'xcz', 'nmb']
' '.join(l)
#输出:'das xcz nmb'

#对字符串使用
s='das xcz nmb'
' '.join(s)
#输出:'d a s   x c z   n m b'

列表转化为字典
使用dict([装有两个元素的数据，装有两个元素的数据,...]) ,传入一个列表,列表中的每一个元素都是一个两个元素的值，以此来作为键值对。

l =[(1,'a'),'2b',[3,'c']]
dict(l)
#输出:{1: 'a', '2': 'b', 3: 'c'}

#可以直接压缩的方式将两个列表转化为字典
l1 = [1,2,3]
l2 = ['a','b','c']
dict(zip(l1,l2))
#输出:{1: 'a', 2: 'b', 3: 'c'}

Python改变递归最大深度（recursion）

Python限制了递归算法的最大深度大概1000次左右, 有时我们的算法要超过此限制, 可以用以下语法。

import sys
sys.setrecursionlimit(100000000)

Python的堆模块----heapq

具体可以参考这两个博客:
Python heapq库的用法介绍
python高级（堆heapq模块

L = [1,2,3]
print(L)
heapify(L)  #堆区的是树结构,父节点小于叶子节点
print(L)
heappop(L)
print(L)
heappush(L,1)
print(L)

用途：数据较多时，使用堆区可以以更快地速度来从堆区提取最小值并放入数据。

Python的Counter函数—统计列表中所有元素出现的次数并排序

from collections import Counter
nums=[5,5,5,2,2,2,3,3,3,4]
L = Counter(nums)
print("根据次数排序:",L)
print("根据次数排序:",L.most_common()) #转化为列表,每个列表元素都是(值,次数)
print("返回出现次数最多的2个值:",L.most_common(2))  #返回的是列表
print("返回出现次数最少的值:",L.most_common()[-1]) #查看次数出现最少的值组成的元组,相当于从列表中取元素
'''
输出
根据次数排序: Counter({5: 3, 2: 3, 3: 3, 4: 1})
根据次数排序: [(5, 3), (2, 3), (3, 3), (4, 1)]
返回出现次数最多的2个值: [(5, 3), (2, 3)]
返回出现次数最少的值: (4, 1)
'''

Python的filter函数—过滤掉不符合条件的元素，返回由符合条件元素组成的新列表

w=['dasdasd','dasd','das','1563132132']
print(list(filter(lambda x: len(x) < 5, w)))
def fun(a):
    return (1 if len(a)<5 else 0)
print(list(filter(fun, w)))
'''
输出
['dasd', 'das']
['dasd', 'das']

Python中的 * 和 **, *可以用来解压

python的*和**的完全详解
同时还有一个常用的功能就是 zip() 和 * 操作符一起操作可以起到 unzip 的作用。

x1 = [1, 2, 3]
x2 = ['a', 'b', 'c']
zipped = zip(x1,x2)
zipped = list(zipped)
print(zipped)
a,b = zip(*zipped)
print(a,b)
输出：
[(1, 'a'), (2, 'b'), (3, 'c')]
(1, 2, 3) ('a', 'b', 'c')

原理其实就是zip原理，首先 zipped 就是按照索引将输入的多个迭代器（这个例子中是2个列表）中对应索引元素取出然后组成一个元组，从而形成多个元组。
那么在所谓的 “unzip” 的时候，用*zipped就是将这3个迭代器（元组）传入到zip函数中，然后按照索引将这3个元组中对应元素取出就OK了。(注意不能直接传入zipped，因为zipped是一个列表，相当于只是1个迭代器)。
可以通过这个代码进一步验证想法：

#上面代码忽略不加了
a,b,c = zipped
print(list(zip(a,b,c)))
输出：
[(1, 2, 3), ('a', 'b', 'c')]

Python使用@staticmethod和@classmethod可以不初始化类就直接调用函数.

@staticmethod和@classmethod
@staticmethod：使函数成为静态函数，不强制要求传递参数，不能调用类的成员。
@classmethod：使函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等(cls().成员)。

class C(object):
    @staticmethod
    def f():
        print('runoob');
 
C.f();          # 静态方法无需实例化
cobj = C()
cobj.f()  

class A(object):
    bar = 1
    def func1(self):
        print('foo')
    @classmethod
    def func2(cls):
        print('func2')
        print(cls.bar)  #直接调用成员
        cls().func1()  # 调用 foo 方法
A.func2()

python中的排列组合

python中的排列组合