ChainMap(dict1, dict2)

会跳过相同的键

生成迭代器而不是生成新拷贝

new_dict.maps

python3默认dict有序

popitem

move_to_end

deque双端队列

线程安全

counter.update()

counter.most_common()  堆实现

from collections import ChainMap
d1 = {"a": "aa", "b": "bb"}
d2 = {"b": "bbb", "c": "cc"}
new_dict = ChainMap(d1, d2)
print(new_dict.maps)
new_dict.maps[0]["a"] = "aaa"
for k, v in new_dict.items():
    print(k, v)

from collections import Counter
x = Counter("aaabbcccddd")
print(x, x.most_common(2))

迭代:python中可以用for循环使用取值操作过程.

可迭代对象:可以使用for循环遍历的对象,我们称之为可迭代对象.

迭代器:提供数据和记录位置.

生成器:如果函数中有yield我们称之为生成器

如果在同一时间执行多个任务我们可以使用多进程和多线程,如果你想使用一个线程或进程然后让多个任务一次执行按顺序执行一个线程或者一个进程.  如果你在一个线程内部,想使用让多个任务交替执行,那么可以使用协程

1）在python中以双下滑线开头并且以双下滑线结尾的函数

    2）魔法函数可以随意定义某个类的特性，这些方法在进行特定的操作时会自动被调用

直接赋值，浅拷贝，深拷贝的区别

# copy()方法
# 浅拷贝，拷贝的是元素，当有地址时拷贝地址
import copy
mydeque1 = deque([1,[2,3],4,[5,6]])
mydeque2 = mydeque1.copy()  # 浅拷贝 (这是deque的copy不是copy库的)
mydeque3 = mydeque1         # 直接复制，指向mydeque1
mydeque4 = copy.deepcopy(mydeque1) # 深拷贝，完全不会随着变化

# 1赋新值
mydeque1[0] = 9   # mydeque2不变,mydeque3变

#[2,3]增加
mydeque1[1].append(8)   # mydeque2，mydeque3都跟着变，

#[5,6]赋新值
mydeque1[3] = [9,9] # 改变指向地址，mydeque3变
print(mydeque1,mydeque2,mydeque3,mydeque4)

out:

deque([9, [2, 3, 8], 4, [9, 9]]) # mydeque1
deque([1, [2, 3, 8], 4, [5, 6]]) # mydeque2
deque([9, [2, 3, 8], 4, [9, 9]]) # mydeque3
deque([1, [2, 3], 4, [5, 6]])    # mydeque4

ctrl +左键 模块名

抽象基类

nametuple

1，可以创建类对象

collections模块

"""
ChainMap将多个字典连接起来，让我们可以很方便的遍历这些字典
其子方法：
items(): 遍历这个字典
new_child(): 添加字典元素
maps属性：以列表的形式将字典数据展示出来
"""

from collections import ChainMap


if __name__ == "__main__":
    user_dict1 = {"a": "AA", "b": "BB"}
    user_dict2 = {"b": "BBB", "c": "CC", "d": "DD"}
    for key, value in user_dict1.items():  # 遍历字典
        print(key, value)

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

    print("-----------------")
    new_dict = ChainMap(user_dict1, user_dict2)
    for key,value in new_dict.items():
        print(key, value)
    print(new_dict)
    print(new_dict["c"])   # 取值key对应的值
    new_dict.new_child({"aa":"AAAAA", "bb":"BBBBB"})
    print(new_dict)

    print(new_dict.maps)  # 以列表的形式将字典数据展示出来
    new_dict.maps[0]["a"] = "Hello World"  # 将字典的第0个元素的a的值变为Hello World
    print(new_dict)

"""
OrderedDict是dict的子类
OrderedDict 保证添加的顺序一致,先添加的在前面，后添加的在后面
python2与python3结果不一致，注意版本问题
在python3中，OrderedDict和dict是一样的
在python2和python3中，OrderedDict都是一样的，建议使用OrderedDict
OrderedDict的子方法：
clear(): 清除
pop(key): 移除指定key对应的元素
popitem(): 移除最后一个元素
move_to_end(key, last):  将key对应的元素移动到last指定的位置
"""

from collections import OrderedDict


if __name__ == "__main__":
    user_dict = dict()
    user_dict["b"] = "小二"
    user_dict["g"] = "田七"
    user_dict["c"] = "张三"
    user_dict["d"] = "李四"
    user_dict["a"] = "刘一"
    user_dict["f"] = "赵六"
    user_dict["e"] = "王五"
    print(user_dict)

    user_dict = OrderedDict()
    user_dict["b"] = "小二"
    user_dict["g"] = "田七"
    user_dict["c"] = "张三"
    user_dict["d"] = "李四"
    user_dict["a"] = "刘一"
    user_dict["f"] = "赵六"
    user_dict["e"] = "王五"
    print(user_dict)
    print(user_dict.move_to_end("b"))  # 将key为b对应的元素移动到最后位置
    print(user_dict)
    print(user_dict.pop("a"))  # 移除key为a的元素
    print(user_dict.popitem())   # 移除最后一个
    print(user_dict)

"""
Counter()函数接收一个可以迭代的对象，这个对象可以是列表，元组，字典，字符串等,返回一个字典
其子方法：
update(): 追加
most_common(n):  统计出出现次数最多的前n个元素

"""
from collections import  Counter

if __name__ == "__main__":
    users = ["李四", "张三", "李四", "王五", "张三", "田七"]
    user_counter = Counter(users)   # 统计
    print(user_counter)

    str_counter = Counter("ajkdihtdajkgybuatyaytayrtvaunywywghab")   # 统计字符串
    print(str_counter)
    str_counter.update("agafadadaaaaaassdss")  # 追加
    print(str_counter)

    user_counter.update(str_counter)  # 追加统计
    print(user_counter)

    print(str_counter.most_common(4))   # 返回出现次数最多的前4个元素