Collections

1. namedtuple

1.1 namedtupled 的基本用法

from collections import namedtuple

User = namedtuple('U', ['name', 'heigh', 'age', 'edu'])
use1 = User("Boby", 175, 25, "master")

user_tuple = ("Boby1", 175, 25, "master")
use2 = User(*user_tuple)

user_tuple1 = ("Boby2", 175, 25 )
use3 = User(*user_tuple1, "master")

user_list = ["Boby3", 175, 25]
use4 = User(*user_list, "master")

user_dict = {'name':"Boby4", "heigh":175, "age": 25, "edu":"master"}
use5 = User(**user_dict)

print(use5.name)

1.2  _make 实现同1.1 一样的功能， _make 中的参数为iter：eg：tuple， list， dict（有一些问题）

# _make 里边的参数只要是 iter就可以，eg：tuple， list， dict
use6 = User._make(user_tuple)
user_list.append("master")
pass
use7 = User._make(user_list)
pass
# 注意：虽然_make 里边的参数也可以是dict 但是还是有一点问题的，use8={U}U(name='name', heigh='heigh',age='age',edu='edu')
# 与我们所想要的是不一致的
use8 = User._make(user_dict)
pass

注意：_make中参数的个数 需和初始定义的参数个数相同，不能像use4 = User(*user_list, "master")，再在后边添加一个元素

1.3 _asdict() 返回一个 orderedDict ,

如下，use9=OrderedDict([('name', 'Boby3'), ('heigh', 175), ('age', 25), ('edu', 'master')])

use9 = use7._asdict()

1.4 拆包

#注意，由于User = namedtuple('U', ['name', 'heigh', 'age', 'edu'])，所以下方age 中的值实际为heigh的数值

name, age, *other = use7
pass

# 注意：当拆包use9时， #name1 ： 'name', age1: 'heigh', other1:['age', 'edu'] 不是我们想要的结果
name1, age1, *other1 = use9
pass

2. defaultdict

2.1 对列表中的数据进行统计，最后以字典的形式呈现

eg：li = ['boby1', 'boby2', 'boby3', 'boby4', 'boby1', 'boby2']

返回：li_dict = {'boby1': 2, 'boby2': 2, 'boby3': 1, 'boby4': 1}

2.1.1 用普通的方法实现

li = ['boby1', 'boby2', 'boby3', 'boby4', 'boby1', 'boby2']
li_dict = {}
for user in li:
    if user not in li_dict:
        li_dict[user] = 1
    else:
        li_dict[user] += 1
print(li_dict)

2.1.2  用setdefault

若传入的key值不存在，则传入设置的默认值,且返回我们设置的默认值；若传入的key存在，不对字典进行更改，返回字典中key对应的value值。

#setdefault
li_dict2 = {}
for user in li:
    li_dict2.setdefault(user, 0)
    li_dict2[user] += 1
print(li_dict2)

2.1.3 用defaultdict实现

defaultdict中传入的是可调用对象，比如int，list，若key在default_dict = defaultdict(int)中不存在，则传入默认值0,返回传入的默认值；若key在default_dict 中存在，则不对字典进行更改，返回key所对应的value值。
 

default_dict = defaultdict(int)
for user in li:
    default_dict[user] += 1
print(default_dict)

# defaultdict中传入的是可调用对象，比如int，list，若key在default_dict中不存在，则传入默认值
default_dict1 = defaultdict(list)
print(default_dict1) # defaultdict(<class 'list'>, {})
print(default_dict1['boby'])  #返回list默认值 ：[]

2.2 用defaultdict实现 group_dict =

group_dict ={
    "group1":{
        "name":"",
        "num":0
    }
}

# 用defaultdict实现 group_dict
def gro_dict():
    return {
        "name":"",
        "num":0
    }
default_dict2 = defaultdict(gro_dict)
print(default_dict2["group1"]) # {'name': '', 'num': 0}
print(default_dict2) #{'group1': {'name': '', 'num': 0}})

 

3.deque

3.1 deque的基本实现

from collections import deque
li = ["boby1", "boby2", "boby3"]
li_1 = ["boby1", ["boby2", "boby3"]]
tu = ("boby1", "boby2", "boby3")
di = {"boby1":1, "boby2":2, "boby3":3}
deque_list1 = deque(li)
deque_list2 = deque(tu)
deque_list3 = deque(di)
deque_list4 = deque(li_1)

3.2  copy: shallow copy ,对于不可变的元素，原deque列表中不改变；对于可变的元素，原deque中的值改变

#注意 下边两组的区别

deque_list1_co = deque_list1.copy()
deque_list1_co[1] = "body2_co"
#deque_list1 = deque(['boby1', 'boby2', 'boby3'])；
#deque_list_co = deque(['boby1', 'body2_co', 'boby3'])

deque_list4_co = deque_list4.copy()
deque_list4_co[1][1] = "co"
#deque_list4 = deque(['boby1', ['boby2', 'co']])
#deque_list4_co = deque(['boby1', ['boby2', 'co']])

3.3 deque 中一些简单的方法

#方法：append， appendleft; pop, popleft; insert

3.4 reserve 和 extend

#reserve, extend 没有返回值，直接在原deque list 中进行更改

deque_list1_re = deque_list1.reverse()
#deque_lis1_re = None,  deque_list1 = deque(['boby3', 'boby2', 'boby1'])

deque_list2_ex = deque_list2.extend(deque_list3)
#deque_lis2_ex = None,  deque_list2 = deque(['boby1', 'boby2', 'boby3', 'boby1', 'boby2', 'boby3'])

3.5  Last but very important: deque GIl 是线程安全的；list 不是线程安全的

4. Counter

4.1 Counter 的基本使用方法：Counter 中传入的参数是iter eg：list， tuple等

#1.Counter 中传入list
user = ["boby1", "boby2", "boby3", "boby4", "boby1", "boby2"]
user_count = Counter(user)
#2. Counter 中传入str
str1 = "awetrhsrew"
str1_count = Counter(str1)
print('str1_count', str1_count)

4.2 Counter 中的update（）， update 传入的参数也是 iter

str1_count_up = str1_count.update('saswedwse')
print('str1_count_up', str1_count_up)
print('str1_count', str1_count)

str2 = 'swe'
str1_str2_count = str1_count.update(str2)
print('sstr1_str2_count', str1_count_up)
print('str1_count', str1_count)

4.3  most_common: 解决top_n 的问题（底层使用堆这种数据结构来实现的）

top_2 = str1_count.most_common(2)

5.  OrderedDict

OrderedDict 继承了 dict， 故dict有的属性，OrderedDict都有，且OrderedDict 还有一些其它的特有属性

5.1 OrderedDict 的基本实现

注意： python3 之后，dict默认的是有序的，故 or_dict 与 u_dict 的输出结果应该是相同的

from collections import OrderedDict
# OrderedDict 继承了 dict， 故dict有的属性，OrderedDict都有，且OrderedDict 还有一些其它的特有属性
or_dict = OrderedDict()
or_dict['a'] = "boby1"
or_dict['b'] = "boby2"
or_dict['c'] = "body3"
or_dict['d'] = "body4"

u_dict = {}
u_dict['a'] = "boby1"
u_dict['b'] = "boby2"
u_dict['c'] = "body3"
u_dict['d'] = "body4"

# python3 之后，dict默认的是有序的，故 or_dict 与 u_dict 的输出结果应该是相同的
print('or_dict', or_dict)
print('u_dict', u_dict)

5.2 pop() 与 popitem()

pop(key),返回对应的value值 ；popitem() 默认的删除最后一个item，返回值为删除的那个item（key， value）

or_re1 = or_dict.pop('a')
or_re2 = or_dict.popitem()

u_re1 = u_dict.pop('a')
u_re2 = u_dict.popitem()

5.3 move_to_end(key), 将key所对应的item 移动到字典的末尾

# 注意：move_to_end() 方法 是OrderedDict 中特有的，dict中没有此种方法

or_dict.move_to_end('b')
#u_dict.move_to_end('b')
print('or_dict', or_dict)

6. ChainMap

6.1 使用ChainMap 可以减少循环次数，使代码更简洁

ChainMap 将多个 dict 组合到一起，进行迭代

dict1 = {'a':'boby1', 'b':'boby2'}
dict2 = {'b':'boby3', 'd':'boby4'}

当我们想要遍历dict1 和dict2 中的元素时，我们可能需要写两个for循环（如下所示），但是，如果有100个dict呢，这样就很麻烦了

for key, value in dict1.items():
    print(key, value)

for key, value in dict2.items():
    print(key, value)

用ChainMap 无论有多少个dict，一个for循环就可以搞定
ChainMap()返回一个新的dict，故具有dict属性，即key值肯定不能重复，若链接的dict有key值重复的话，调用时只会
调用第一次出现的key和value

new_dict = ChainMap(dict1, dict2)
for key,value in new_dict.items():
    print(key, value)

6.2 ChainMap()的属性：maps， 

maps以列表的形式 将dict中的数据展示出来，这里只是指向了原始数据，而不是拷贝。故改变数据时，原始dict中的数据也会变化,如下所示，new_dict_maps，new_dict，dict1中的数据都有所变化

new_dict_maps = new_dict.maps
new_dict_maps[0]['a'] = 'boby_map'
print(new_dict_maps)
print(new_dict)
print(dict1)

6.3 new_child() 方法，向ChainMap 组合的 dict中添加新的元素。

注意：原始dict中的元素个数并不变，而是在原始的dict中添加元素之后，返回添加元素后的结果， 如下所示，new_dict和 new_dict_add输出是不同的

new_dict_add = new_dict.new_child({'e':'boby5','f':'boby6'})
print(new_dict)
print(new_dict_add)