LeetCode刷题值得推荐几个Python库

约定不等于承诺〃 2023-02-21 06:40 37阅读 0赞

原文链接:https://blog.csdn.net/weixin\_43352942/article/details/102882517

from collections import defaultdict，Counter
    from functools import lru_cache
    from itertools import combinations, permutations
    import bisect,heapq
    
       
        
       
        
         1
         2
         3
         4

## **1、collections模块** ##

使用defaultdict和Counter可以节省很多步骤，Counter统计列表的值出现的次数，并按多到少排序输出。

from collections import defaultdict,Counter
    #defaultdict默认字典的键和值可以不存在
    dic1 = defaultdict(int)     #{:0}
    dic1[1]+1
    print(dic1)
    #dic1 = {1:1}
    dic2 = defaultdict(list)    #{:[]}
    dic2[1].append(1)
    print(dic2)
    #dic2 = {1:[1]}
    #dic3 = defaultdict(set) #{:{}}
    nums = [1,2,3,3,2,3,1,1,5,4,4,1,1]
    count = Counter(nums)
    print(count)
    #count = Counter({1: 5, 3: 3, 2: 2, 4: 2, 5: 1})
    
       
        
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15

**collections.Orderdict()** 能够对添加进来的键值对按添加先后的顺序排序，在LeetCode第146题LRU缓存机制中用到，很巧妙。

import collections
    d1 = collections.OrderedDict()
    d1['a'] = 'A'
    d1['b'] = 'B'
    d1['2'] = '2'
    d1['c'] = 'C'
    d1['1'] = '1'
    print(d1,'\n')

d1.move\_to\_end(‘a’) \#把key=‘a’的值移到d1最后  
print(d1,’\\n’)

d1.pop(‘c’) \#弹出key=‘c’的值  
print(d1,’\\n’)

d1.popitem(last=False) \#弹出d1第一个值，last=True弹出最后一个值  
print(d1)

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM1Mjk0Mg_size_16_color_FFFFFF_t_70]  
python字典现在是有序的了，除了上面的move\_to\_end()外，pop(),popitem()功能dict都能实现

## 2、itertools模块 ##

itertools模块有很多功能，这里只讲常用的两个，combinations和permutations

import itertools
    #combinations生成的子列表不重复，第一个参数为iterable对象，第二个参数为子列表的长度
    x = list(itertools.combinations('ABC',2))
    print(x)
    #x = [('A', 'B'), ('A', 'C'), ('B', 'C')]
    
     
      
     
      
       1
       2
       3
       4
       5

import itertools
    #permutations生成的子列表包括重复，第一个参数为iterable对象，第二个参数为子列表的长度
    x = list(itertools.permutations('ABC',2))
    print(x)
    # x = [('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'C'), ('C', 'A'), ('C', 'B')]
    
     
      
     
      
       1
       2
       3
       4
       5

## 3、functools模块 ##

functools.lru\_cache()是非常实用的装饰器，它实现了备忘功能，把函数的结果保存起来，避免函数传入相同的参数时重复计算,lru\_cache(maxsize,typed=False)有两个可选的参数，第一个是指定储存多少个调用函数的结果，第二个设为True,会把不同参数类型的结果分开保存，即把通常认为相等的浮点数和整数参数区分开。这两个参数一般都用不到。  
在LeetCode中斐波那契数列的计算中使用lru\_cache比没使用的快了40倍

#使用lru_cache()装饰器，参数必须是可散列值，
    #可散列值例如int,str,float,不可散列如list,dict,set
    import functools
    class Solution:
        @functools.lru_cache()      
        def fib(self, N: int) -> int:
            if N < 2: return N
            return self.fib(N-1) + self.fib(N-2)
    
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8

## 4、bisect模块 ##

bisect采用二分查找法返回排序数组指定值的下标，如果指定值不存在，返回应该插入的下标位置

import bisect
    arr = [1,2,3,4,6,7]
    x1 = bisect.bisect_left(arr,3)	#返回arr中3的下标，不存在则返回应该插入的位置下标
    #x1 = 2
    x2 = bisect.bisect_right(arr,3)
    #x2 = 3
    bisect.insort_left(arr,3)	#向arr左边插入值3
    print(arr)
    #arr = [1, 2, 3, 3, 4, 6, 7]
    # bisect.insort_right(arr,3)
    
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10

暂时只有这么多。

## 5、gcd(), ord(), chr() ##

math.gcd(a,b)用来求a和b两个数的最大公约数，刷LeetCode时有些题需要求公约数，使用gcd()会方便很多。

ord() 函数是 chr() 函数的配对函数，它以一个字符（长度为1）作为参数，返回对应的数值。chr()则以数值作为参数，返回字符。

# from fractions import gcd 
    import math
    x = math.gcd(18,12)     #求最大公约数
    print(x)    #x = 6

\# ord(‘a’)~ord(‘z’) => 97~122 大写字母A–Z => 65–90  
print(ord(‘a’)) \#ord(‘a’) => 97  
print(ord(‘z’)) \#ord(‘z’) => 122  
\#更多符号  
for i in range(33,128):  
print(chr(i),end=’ ‘)  
\#输出如下注释：  
‘’’! " \# $ % & ’ ( ) \* + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = >  
? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z \[ \\ \]  
^ \_ \` a b c d e f g h i j k l m n o p q r s t u v w x y z \{ | \} ~  ‘’’

\#chr()函数则反过来  
print(chr(65)) \# => ‘A’  
print(chr(90)) \# => ‘Z’

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

## 6、heapq ##

*  heappush(heap, x) ：将x压入堆中
 *  heappop(heap) ： 从堆中弹出最小的元素
 *  heapify(heap) ：让列表具备堆特征
 *  heapreplace(heap, x) ：弹出最小的元素，并将x压入堆中
 *  nlargest(n, iter)：返回iter中n个最大的元素
 *  nsmallest(n, iter)：返回iter中n个最小的元素

</div>
                <link href="https://csdnimg.cn/release/phoenix/mdeditor/markdown_views-60ecaf1f42.css" rel="stylesheet">
                                </div>

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM1Mjk0Mg_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191119155336623.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM1Mjk0Mg==,size_16,color_FFFFFF,t_70