python 中容器的源码分析

python 中容器

一. python 中colletions.Counter 的源码分析

https://blog.csdn.net/Shiroh_ms08/article/details/52653385

核心知识点：

1）Counter是对可进行哈希的对象进行计数
2）Counter的父类是dict
3) 可传入3种输入参数：列表，字典和k-v格式的参数
4）most_common(n):可输出迭代对象中出现次数最多的top n的对象和其次数，默认的参数是None，即返回出现次数从大到小排列的所有元素
5）get(elem):返回某元素出现的次数，当元素不存在时返回0
6）update():更新原Counter()的结果

二. sort()和sorted()源码分析：

https://blog.csdn.net/da_kao_la/article/details/104649307

核心知识点：

1)sort()是list特有的方法，也就是说只能对列表进行比较；而sorted()除了可对列表进行排序，其他任何的可迭代对象都可对其进行排序
2）sort()是对原列表进行排序，排序后原列表会发生变化；而sorted()是对原可迭代对象的副本进行排序，排序后原可迭代对象不变
3）在python3中sort()移出了cmp关键字，只能使用key关键字来自定义比较,如果想使用cmp的话，可使用functools的cmp_to_key来转换

#将列表中的数字转化成整体最大(小）的数字
from functools import cmp_to_key
nums = [3, 30, 34, 5, 9]
# nums.sort(cmp=lambda x,y: cmp(str(x) + str(y), str(y) + str(x)))
nums.sort(key = cmp_to_key(lambda x,y: int(str(x) + str(y)) - int(str(y) + str(x))), reverse=True)
print(nums) #[9, 5, 34, 3, 30]
nums.sort(key = cmp_to_key(lambda x,y: int(str(x) + str(y)) - int(str(y) + str(x))))
print(nums) #[30, 3, 34, 5, 9]

#将字符串中的字符按照出现的频率从大到小排序，如果出现的频率相同则按照字典顺序从小到大排列
class Solution:
    def frequencySort(self, s):
        import collections
        s = sorted(s)
        # s = list(s)
        count = collections.Counter(s)
        s.sort(key=count.get, reverse = True)
        return "".join(s)
sol = Solution()
s= "acccaa"
ret = sol.frequencySort(s)
print(ret)

三. python的内置数据结构的时间复杂度分析：

1. list列表

   平均情况假设参数是随机均匀生成的。

   1)在内部，列表被表示为一个数组；
   2) 最大的成本来自于超出当前分配大小的增长（因为所有东西都必须移动），或者来自于在靠近开始的地方插入或删除（因为之后的所有东西都必须移动）。
   3) 如果需要在两端添加/删除，请考虑改用collections.deque（双向链表）

   数组的优点：可用通过下标来直接索引数据

   缺点：插入和删除比较麻烦，需要移动之后所有的元素, 因此，当涉及到在两端插入或者删除元素时，可以使用链表

   Operation	Average Case	备注
   Copy	O(n)
   Append[1]	O(1)	在数组的尾部添加元素很快
   Pop last	O(1)	同上
   Pop intermediate	O(k)	在list中删除元素的时间复杂度根据元素所在的位置，当元素越靠前时间越长，（就需要移动后面所有的元素）
   Insert	O(n)	同上
   Get Item	O(1)	根据索引获取元素很快
   Set Item	O(1)
   Delete Item	O(n)	同pop
   Iteration	O(n)
   Get Slice	O(k)
   Del Slice	O(n)
   Set Slice	O(k+n)
   Extend[1]	O(k)
   Sort	O(n log n)
   Multiply	O(nk)
   x in s	O(n)	在list中查找元素的时间复杂度是n，因此当要频繁查找元素时，可以改用set或者字典，最好不要用list
   min(s), max(s)	O(n)
   Get Length	O(1)

2. collections.deque

   deque（双端队列）在内部表示为一个双链表。（为了更高的效率，是数组而不是对象的列表。）两端都可以访问，但即使是看中间也是很慢的，添加到中间或从中间移除也更慢。

Operation	Average Case	备注
Copy	O(n)
append	O(1)	在两端插入、删除元素很快
appendleft	O(1)
pop	O(1)
popleft	O(1)
extend	O(k)
extendleft	O(k)
rotate	O(k)
remove	O(n)

3. set

   请参见dict—故意将set跟字典弄的很相似。

Operation	Average case	Worst Case	notes
x in s	O(1)	O(n)
Union s|t	O(len(s)+len(t))
Intersection s&t	O(min(len(s), len(t))	O(len(s) * len(t))	replace “min” with “max” if t is not a set
Multiple intersection s1&s2&…&sn		(n-1)*O(l) where l is max(len(s1),…,len(sn))
Difference s-t	O(len(s))
s.difference_update(t)	O(len(t))
Symmetric Difference s^t	O(len(s))	O(len(s) * len(t))
s.symmetric_difference_update(t)	O(len(t))	O(len(t) * len(s))

4. dict

   为dict对象列出的平均事例时间假定对象的哈希函数足够健壮，使冲突不常见。平均情况下，假设参数中使用的关键点是从所有关键点集中均匀随机选择的。

   注意，dict有一个快速路径（在实践中）只处理str键；这不会影响算法的复杂性，但会显著影响常量因素：典型程序完成的速度。

   Operation	Average Case	Amortized Worst Case
   Copy[2]	O(n)	O(n)
   Get Item	O(1)	O(n)
   Set Item[1]	O(1)	O(n)
   Delete Item	O(1)	O(n)
   Iteration[2]	O(n)	O(n)