Python字典的常见操作

1.在leetcode上刷题的时候，经常需要使用统计元素个数，例如

• words = [“a”,“b”,“c”,“d”,“a”,“c”,“r”]
• 统计列表words中每个元素及其出现的次数

words = ["a","b","c","d","a","c","r","r"]

#方法1，用Counter
from collections import Counter
words_dict_1 = Counter(words)
##还可以使用dict(Counter(words))将结果转化为字典
#将dict按value的值从高到低进行排序
print(words_dict_1.most_common())
# [('a', 2), ('c', 2), ('b', 1), ('d', 1), ('r', 1)]
#只输出前三个
print(words_dict_1.most_common(3))
# [('r', 2), ('a', 2), ('c', 2)]


#方法2，用字典
words_dict_2 = {}
for word in words:
	#当word不在words_dict_2中的时候，会出现KeyError，所以要单独判断
	if word not in words_dict_2:
		words_dict_2[word] = 1
	else:
		words_dict_2[word] += 1
		
#方法3，用默认字典
words_dict_3 = collections.defaultdict(int)
for word in words:
	#words_dict_3是默认字典，且里面是int，所以当key不在字典中时，返回int的默认值，是0
	words_dict_3[word] += 1

#方法4，用字典+get方法
words_dict_4 = {}
for word in words:
	#get方法，当key不在字典中时，默认返回None，不过这里将默认值改为了0，即key不在字典中时，返回0
	words_dict_4[word] = words_dict_4.get(word,0) + 1



print(words_dict_1==words_dict_2==words_dict_3==words_dict_4)
#True
print(words_dict_2)
#{'a': 2, 'c': 2, 'b': 1, 'r': 1, 'd': 1}

• 1.1 在用1中的方法统计好了每个元素出现的次数的时候，有时需要按某个顺序来遍历dict中的元素。

#如果是用Counter()，那么有现成的most_common方法可以使用，剩余的几种写法，若想排序，见3.字典的排序
print(words_dict_1.most_common())

• 1.2 关于添加元素到dict中，若元素不在字典中的情况，以leetcode-49为例

class Solution(object):
    def groupAnagrams(self, strs):
        """
        :type strs: List[str]
        :rtype: List[List[str]]
        """
        # 方法1，用defaultdict并且里面是list类型
        # ans = collections.defaultdict(list)
        # for s in strs:
        #     #如果当前遍历到的s不在ans中，那么其对应的默认值为[]，所以可以直接append
        #     ans[tuple(sorted(s))].append(s)
        # return ans.values()
        
        #方法2，还是使用一般的dict
        ans = {}
        for s in strs:
            #如果当前遍历到的s不在ans中，那么其对应的默认值为[]，注意：下面的写法中正确的
            #是第二种，第一种是不对的
            #ans[tuple(sorted(s))] = ans.get(tuple(sorted(s)),[]).append(s)
            ans[tuple(sorted(s))] = ans.get(tuple(sorted(s)),[])+[s]
        return ans.values()

2.字典的查找

min(record, key=record.get)， 返回最小的value对应的key，如果有多个value相同，只返回第一个。
max(record, key=record.get)，返回最大的value对应的key，如果有多个value相同，只返回第一个。

3.字典的排序

• sort()方法只能用于list的排序，具体用法为:

alist = [1,2,3,4,2,1,5,6,7]
#原地排序，不返回值
alist.sort()
#[1, 1, 2, 2, 3, 4, 5, 6, 7]
print(alist)

• 要想对字典，字符串，set等进行排序，可以使用sorted()函数，sorted 可以对所有可迭代的对象进行排序操作。返回一个新的list(注意，不管操作什么对象，都返回list)

>>>alist = [1,5,4,3,2]
>>>sorted(alist)
[1, 2, 3, 4, 5]
>>>strs = "15423aweffASW"
>>>sorted(strs) #字符按ASCII码排序
['1', '2', '3', '4', '5', 'A', 'S', 'W', 'a', 'e', 'f', 'f', 'w']
>>>record = {1:4,6:3,2:8,9:1,4:10}
>>>sorted(record) #默认按key进行排序(默认只返回包含key的list)
[1, 2, 4, 6, 9]
>>>sorted(record.items()) #默认按key进行排序(返回包含每一个item的list)
[(1, 4), (2, 8), (4, 10), (6, 3), (9, 1)]

Python2:sorted(iterable, cmp=None, key=None, reverse=False)

Python3:sorted(iterable, key=None, reverse=False)

• 注：cmp可以传入两个参数进行比较，key只能传入一个参数进行比较

>>>record = {1:4,6:3,2:8,9:1,4:10,5:4,8:1,10:1}
>>>sorted(record.items(),key=lambda x:x[1]) #按value从小到大进行排序
[(8, 1), (9, 1), (10, 1), (6, 3), (1, 4), (5, 4), (2, 8), (4, 10)]
#上面的用key等价于下面这一句，不过下面这一句只能在Python2中用
>>>sorted(record.items(),cmp=lambda x,y:cmp(x[1],y[1])) #按value从小到大进行排序
>[(8, 1), (9, 1), (10, 1), (6, 3), (1, 4), (5, 4), (2, 8), (4, 10)]
#在python3中，要想使用cmp，可以用functools.cmp_to_key
>>>import functools
>>> sorted(record.items(),key=functools.cmp_to_key(lambda x,y:x[1]-y[1])) #按value从小到大进行排序
[(8, 1), (9, 1), (10, 1), (6, 3), (1, 4), (5, 4), (2, 8), (4, 10)]




>>>sorted(record.items(),key=lambda x:x[0]) #按key从小到大进行排序
[(1, 4), (2, 8), (4, 10), (5, 4), (6, 3), (8, 1), (9, 1), (10, 1)]

>>>sorted(record.items(),key=lambda x:(x[0],-x[1])) #按key从小到大,value从大到小
#(只有在key相等的时候，才看value的顺序，不过key是不同的，所以没有意义)进行排序
[(1, 4), (2, 8), (4, 10), (5, 4), (6, 3), (8, 1), (9, 1), (10, 1)]

>>> sorted(record.items(),key=lambda x:(-x[0],x[1])) #按key从大到小,value从大到小
[(10, 1), (9, 1), (8, 1), (6, 3), (5, 4), (4, 10), (2, 8), (1, 4)]

>>> sorted(record.items(),key=lambda x:(x[1],x[0])) #value从小到大，key从小到大
[(8, 1), (9, 1), (10, 1), (6, 3), (1, 4), (5, 4), (2, 8), (4, 10)]

>>> sorted(record.items(),key=lambda x:(x[1],-x[0])) #value从小到大，key从大到小
[(10, 1), (9, 1), (8, 1), (6, 3), (5, 4), (1, 4), (2, 8), (4, 10)]

>>>sorted(record.items(),key=lambda x:(x[0]+x[1],-x[0])) #先按key+value从小到大排序，再按key从大到小排序
[(1, 4), (8, 1), (6, 3), (5, 4), (9, 1), (2, 8), (10, 1), (4, 10)]



#用sorted排序解决leetcode-179
# python2
class Solution(object):
    def largestNumber(self, nums):
        """
        :type nums: List[int]
        :rtype: str
        """
        if not nums:
            return ""
        numbers = [str(number) for number in nums]
        # python2,不支持python3，因为python3中没有cmp参数了
        numbers.sort(cmp=lambda x, y: cmp(y + x, x + y))
        return "".join(numbers).lstrip('0') or '0'


# python3
class Solution:
    def largestNumber(self, nums: List[int]) -> str:
        import functools
        if not nums:
            return ""
        numbers = [str(number) for number in nums]
        # python3中可以使用functools.cmp_to_key
        # python中不支持两个str直接做减法，所以先要转换成int类型
        numbers.sort(key=functools.cmp_to_key(lambda x, y: int(y + x) - int(x + y)))
        return "".join(numbers).lstrip('0') or '0'

## 现在有一道题，给定一个list，其中可能含有重复元素，现在要求重复元素只保留一个，
## 返回新的list，并且保持原来的顺序。

## 例如：
a = [5,5,4,4,6,7,5,8,9,9,2,3,1]
返回的结果是:[5, 4, 6, 7, 8, 9, 2, 3, 1]

使用下面语句即可:
#先将a转换为set，再转回list，这样可以去重，然后排序，并且排序的规则是按照a原来的顺序进行排序(使用a.index)。
sorted(list(set(a)),key=a.index)

参考：为什么Python 3.6以后字典有序并且效率更高？