python常用模块——collections

python

好久没学习了,简单了解下

Ⅰ、namedtuple

1.1 简单回顾一下tuple

tuple是一个不可变的可迭代对象

①可迭代

In [1]: test_tuple = (1,2,3,4,5)

In [2]: for i in test_tuple:

...: print(i)

...:

1

2

3

4

5

②不可变

In [3]: test_tuple[0] = 5

---------------------------------------------------------------------------

TypeError Traceback (most recent call last)

<ipython-input-3-8e5f1b05e43e> in <module>()

----> 1 test_tuple[0] = 5

TypeError: 'tuple' object does not support item assignment

不可变指的是其中的元素不可变

In [4]: test_tuple = (6,7,8)

其元素不可变也不是绝对的

In [5]: test_tuple = (1,[2,3])

In [6]: test_tuple[1].append(4)

In [7]: print(test_tuple)

(1, [2, 3, 4])

③拆包

In [8]: user_tuple = ("allen", 29, 175)

In [9]: name, age, height = user_tuple

In [10]: print(name, age, height)

allen 29 175

In [11]: name, *other = user_tuple

In [12]: print(name, other)

allen [29, 175]

1.2 tuple对比list的优势

  • 性能更好
  • 线程安全
  • 拆包特性
  • 可以作为dict的key(可hash),如下:

In [14]: user_info_dict = {}

In [15]: user_info_dict[user_tuple] = "allen"

In [16]: user_info_dict

Out[16]: {('allen', 29, 175): 'allen'}

In [17]: user_info_dict[[1,2,3]] = "Kobe"

---------------------------------------------------------------------------

TypeError Traceback (most recent call last)

<ipython-input-17-a32e731657ac> in <module>()

----> 1 user_info_dict[[1,2,3]] = "Kobe"

TypeError: unhashable type: 'list'

对应C语言来说,tuple对应的是struct,而list对应的是array

1.3 nametuple创建一个User类

In [23]: from collections import namedtuple

In [24]: User = namedtuple("User", ["name", "age", "height", "edu"])

In [25]: user = User(name="Allen", age=29, height=175, edu="master")

In [26]: print(user.age, user.name, user.height, user.edu)

29 Allen 175 master

# 加一个字段

In [29]: user_tuple = ("Allen", 29, 175)

In [30]: user = User(*user_tuple, "master")

# user = User("Allen", 29, 175, "master")

In [31]: user

Out[31]: User(name='Allen', age=29, height=175, edu='master')

In [33]: user_dict = {"name":"allen","age":19,"height":175}

In [34]: user = User(**user_dict, edu="master")

In [35]: user

Out[35]: User(name='allen', age=19, height=175, edu='master')

1.4 看两个方法

  • _make() 传入一个可迭代对象初始化namedtuple,灵活性不如前面直接传参

In [36]: user_tuple = ("Allen", 29, 175, "edu")

In [37]: user = User._make(user_tuple)

In [38]: user_list = ["Allen", 29, 175, "edu"]

In [39]: user = User._make(user_list)

In [42]: user_dict = {"name":"allen","age":19,"height":175, "edu":"master"}

In [43]: user = User._make(user_dict)

  • _asdict() 将tuple转为dict

- In [46]: user = User(name="Allen", age=29, height=175, edu="master")

In [47]: user_info_dict = user._asdict()

In [48]: user_info_dict

Out[48]:

OrderedDict([('name', 'Allen'),

('age', 29),

('height', 175),

('edu', 'master')])

tips:namedtuple也可以拆包,如下

In [49]: name, age, *other =user

In [50]: print(name, age, other)

Allen 29 [175, 'master']

Ⅱ、defaultdict

需求:统计一个列表中每个元素的个数

  • 老式方法

In [70]: a = [1,2,3,2,3,2,3,2,4,4,4,5]

In [71]: c_dict = {}

In [72]: for i in a:

...: if i not in c_dict:

...: c_dict[i] = 1

...: else:

...: c_dict[i] += 1

...:

In [73]: c_dict

Out[73]: {1: 1, 2: 4, 3: 3, 4: 3, 5: 1}

  • 另一个方法:

In [63]: a = [1,2,3,2,3,2,3,2,4,4,4,5]

In [64]: c_dict = {}

In [65]: for i in a:

...: c_dict.setdefault(i,0)

...: c_dict[i] += 1

...:

In [66]: c_dict

Out[66]: {1: 1, 2: 4, 3: 3, 4: 3, 5: 1}

  • 最好的方法

In [77]: from collections import defaultdict

In [78]: c_dict = defaultdict(int)

In [79]: a = [1,2,3,2,3,2,3,2,4,4,4,5]

In [80]: for i in a:

...: c_dict[i] += 1 #当key不存在时不会报错,绑一个0

...:

In [81]: c_dict

Out[81]: defaultdict(int, {1: 1, 2: 4, 3: 3, 4: 3, 5: 1})

弄个自定义的带嵌套的玩一下

In [82]: def gen_default():

...: return {

...: "name":"",

...: "nums":0

...: }

...:

...:

In [83]: default_dict = defaultdict(gen_default)

In [85]: default_dict["test"]

Out[85]: {'name': '', 'nums': 0}

Ⅲ、deque

deque GIL是线程安全的,list不是

deque叫做双端队列,那我们就得和list一起看,先看下list

In [86]: a_list = [1,2]

In [87]: t = a_list.pop()

In [88]: print(t, a_list)

2 [1]

可以看到最后一个元素被弹出来了

3.1 弄最左边

  • 插左边

In [94]: from collections import deque

In [95]: a_deque = deque([1, [2, 3], 4])

In [96]: a_deque.appendleft(5)

In [97]: a_deque

Out[97]: deque([5, 1, [2, 3], 4])

  • 弹左边

In [97]: a_deque

Out[97]: deque([5, 1, [2, 3], 4])

In [98]: a_deque.popleft()

Out[98]: 5

3.2 copy()

In [99]: a = deque([1,[2, 3], 4])

In [100]: b = a.copy()

In [101]: print(a, b)

deque([1, [2, 3], 4]) deque([1, [2, 3], 4])

In [102]: print(id(a), id(b))

139908896451392 139908896452328

In [103]: b[1].append(5)

In [104]: print(a, b)

deque([1, [2, 3, 5], 4]) deque([1, [2, 3, 5], 4])

由上可知,这种copy是浅拷贝

  • 深拷贝怎么弄?

    deque本身没提供,需要用到copy这个包

In [106]: import copy

In [107]: a = deque([1,[2, 3], 4])

In [108]: b = copy.deepcopy(a)

In [109]: b[1].append(5)

In [110]: print(a, b)

deque([1, [2, 3], 4]) deque([1, [2, 3, 5], 4])

3.3 extend()

In [111]: a = deque([1,2,3])

In [112]: b = deque([4,5,6])

In [113]: a.extend(b)

In [114]: a

Out[114]: deque([1, 2, 3, 4, 5, 6])

注意:这是直接在a上动态扩容,并不会返回一个新的列表,所以c = a.extend(b)是错的

3.4 其他方法

In [114]: a

Out[114]: deque([1, 2, 3, 4, 5, 6])

In [115]: a.insert(1,888)

In [116]: a.reverse()

In [117]: print(a)

deque([6, 5, 4, 3, 2, 888, 1])

extendleft(),index(),count(),clear()等这里就不演示了

Ⅳ、Counter()

In [122]: from collections import Counter

In [123]: tmp = "132531321059823"

In [124]: t_count = Counter(tmp)

In [125]: t_count

Out[125]: Counter({'1': 3, '3': 4, '2': 3, '5': 2, '0': 1, '9': 1, '8': 1})

# 找top

In [126]: t_count.most_common(2)

Out[126]: [('3', 4), ('1', 3)]

两个串合起来统计

In [126]: t_count.most_common(2)

Out[126]: [('3', 4), ('1', 3)]

In [127]: t_count.update("3311")

In [128]: t_count.most_common(2)

Out[128]: [('3', 6), ('1', 5)]

再来一把

In [129]: tmp2 = "3311"

In [130]: t_count.update(tmp2)

In [131]: t_count.most_common(2)

Out[131]: [('3', 8), ('1', 7)]

Ⅴ、OrderedDict

字典中的元素本来是无序的,下面这个用了OrderedDict,有序了(添加顺序),python2中和原来的Dict对比就能看出区别,3看不出来

In [141]: from collections import OrderedDict

In [142]: t_dict = OrderedDict()

In [143]: t_dict["b"] = "2b"

In [144]: t_dict["a"] = "1a"

In [145]: t_dict["c"] = "3c"

In [146]: t_dict

Out[146]: OrderedDict([('b', '2b'), ('a', '1a'), ('c', '3c')])

5.1 一些方法

In [146]: t_dict

Out[146]: OrderedDict([('b', '2b'), ('a', '1a'), ('c', '3c')])

In [147]: print(t_dict.pop("a"))

1a

In [149]: print(t_dict.popitem())

('c', '3c')

pop()必须指定key,popitem()不用,默认弹出最后一组key:value

把指定元素放到最后

In [155]: t_dict

Out[155]: OrderedDict([('a', '1a'), ('c', '3c'), ('b', '2b')])

In [156]: t_dict.move_to_end("a")

In [157]: t_dict

Out[157]: OrderedDict([('c', '3c'), ('b', '2b'), ('a', '1a')])

Ⅵ、ChainMap

实现访问多个dict就像访问一个dict一样(在多个字典上套一个迭代器)

In [160]: from collections import ChainMap

In [161]: dt1 = {"a":"bb1","b":"bb2"}

In [162]: dt2 = {"a":"bb1","b":"bb2"}

In [163]: n_dt = ChainMap(dt1, dt2)

In [164]: n_dt

Out[164]: ChainMap({'a': 'bb1', 'b': 'bb2'}, {'a': 'bb1', 'b': 'bb2'})

# 加一个新的字典

In [165]: n_dt = n_dt.new_child({"e":"ee5"})

In [166]: n_dt

Out[166]: ChainMap({'e': 'ee5'}, {'a': 'bb1', 'b': 'bb2'}, {'a': 'bb1', 'b': 'bb2'})

# 将字典变成列表(maps指向原来的字典,并不是新生成的一个数据)

In [168]: n_dt.maps

Out[168]: [{'e': 'ee5'}, {'a': 'bb1', 'b': 'bb2'}, {'a': 'bb1', 'b': 'bb2'}]

In [171]: n_dt.maps[1]["a"] = "ahaha"

In [173]: for key, value in n_dt.items():

...: print(key, value)

...:

a ahaha

b bb2

e ee5

以上是 python常用模块——collections 的全部内容, 来源链接: utcz.com/z/389187.html

回到顶部