Dq的方法自己要学着看一下。

Dq也是c语言写的性能非常的高。

_asdict会得到一个有序的字典，这个有序指的是将key进行排序。

Python是一门解释性语言，也就是会将程序先编译成字节码PyC，PVC的加载速度会比较快。

Pupil的进阶讲解。

deque双端队列

list和deque通常被当作容器，存储相同类型元素；tuple通常被当作一个类对象，存储不同类型元素

deque创建：

deque(iterable)（list, tuple, dict都是iterable的，传入dict时key作为deque中的元素）

deque方法：

pop(),popleft(),index(),clear(),insert(),remove(),extend(),extendleft(),count()...

最关键的：

deque是线程安全的（多线程编程时，往里put元素无需加锁），list不是线程安全的

count_dict = {}
all = ['a','b','c','a','b','b']
for i in all:
    if i not in count_dict:
        count_dict[i] = 0
    count_dict[i] += 1
print(count_dict)
==>{'a': 2, 'b': 3, 'c': 1}

当dict中没有对应的key时会抛出keyError异常，所以一般做法是先判断dict中是否有该key，若没有先初始化

忘记判断怎么办？defaultdict会解决

count_dict = defaultdict(int)
all = ['a','b','c','a','b','b']
for i in all:
    count_dict[i] += 1
print(count_dict)
==>defaultdict(<class 'int'>, {'a': 2, 'b': 3, 'c': 1})

defaultdict：

当你访问一个不存在的key时==>dict[key]，defaultdict会自动创建键值对，value根据创建defaultdict时传入的类型对象或函数对象决定

类型对象：

dic_1 = defaultdict(int)
dic_2 = defaultdict(tuple)
dic_3 = defaultdict(list)
dic_4 = defaultdict(str)
dic_5 = defaultdict(set)

print(dic_1['a'])
print(dic_2['a'])
print(dic_3['a'])
print(dic_4['a'])
print(dic_5['a'])
==>
0
()
[]

set()

函数对象：

可以定义嵌套结构，如下dict嵌套dict

def gen_default():
    return {
        'name':'',
        'member_nums':0
    }

default_dict = defaultdict(gen_default)     #注意不能加()，因为是对象不是方法
print(default_dict['group1'])
==>{'name': '', 'member_nums': 0}

namedtuple是一个类

User = namedtuple('User',['name','age','height']) #类名，[属性]
user = User(name='bobby',age=29,height=175)
print(user.name,user.age,user.height)
==>bobby 29 175

为什么不直接class一个类，还要弄一个namedtuple出来？

1、class一个类要定义很多变量，代码量增加，空间复杂

2、在数据处理时，经常需要从数据库中读入数据，从数据库中读出的数据其实就是一个tuple

复习一下*args，**kwargs

如果不指明参数名称，全部算在args这个tuple中

如果指明参数名称，就算在kwargs这个dict中

def ask(*args,**kwargs):   kwargs:{}    args:('bobby',29)
    pass

ask('bobby',29)

def ask(*args,**kwargs):   args:()    kwargs:{'name':'bobby','age':29}
    pass
    
ask(name='bobby',age=29)

def ask(*args,**kwargs):   kwargs:{'age':29}    args:('bobby')
    pass

ask('bobby',age=29)

所以创建类的时候，参数也可以这样写：

user_tuple = ('bobby',29,175)
user = User(*user_tuple)

user_dict = {
    'name':'bobby',
    'age':29,
    'height':175
}
user = User(**user_dict)

namedtuple的常用函数

1、_make(iterable)（list, tuple, dict都是iterable的）创建namedtuple

user_list = ["bobby",29,175]
user_tuple = ("bobby",29,175)
user_dict = {
    'name':'bobby',
    'age':29,
    'height':175
}
user = User._make(user_list/user_tuple/user_dict)

和上面*args，**kwargs的区别在哪里呢？

*args，**kwargs灵活性更强，但_make()不用加*/**且多一个list参数方式

例：数据库中user表中的数据全部取出然后再加一个列

User = namedtuple('User',['name','age','height','edu']) 
user = User(*user_tuple,'master')

User = namedtuple('User',['name','age','height','edu']) 
user = User(**user_dict,edu='master')

_make()不行

2、_asdict()将namedtuple转为dict

User = namedtuple("User",["name","age","height"])
user_tuple = ("bobby",29,175)
user = User(*user_tuple)
user_dict = user._asdict()
print(user_dict)
==>{'name': 'bobby', 'age': 29, 'height': 175}

tuple的功能：

• 不可变、iterable

• 拆包

• tuple不可变性不是绝对的（所以放进tuple中的元素最好是不可变的）

• tuple比list好的地方

            immutable（不可变）的重要性

                    性能优化：元素全为immutable的tuple会作为常量在编译时确定

                    线程安全（tuple本身加锁）

                    可以作为dict的key

                    拆包特性

user_tuple = ("bobby",29)
name,age = user_tuple
==>bobby 29
user_tuple = ("bobby",29,175,"beijing","edu")
name, *other = user_tuple
print(name,other)
==>bobby [29, 175, 'beijing', 'edu']

tuple：不可变，可迭代对象iterable（实现了__iter__或者__getitem__魔法函数）

元祖的拆包:

用法：

user_tuple = ("bobby", 28, 178)

name, age, height = user_tuple

只想提取第一个参数：

name, *other = user_tuple

输出：

bobby, [29, 175]

tuple的不可变不是绝对的：

tuple内部嵌套了可变对象（不太建议使用），嵌套对象可修改

tuple比list好用的地方:

immutable（不可变对象）的重要性：

①性能优化（元素全部为不可变对象的tuple会作为常量在编译时确定，因此产生如此显著的速度差异）

②线程安全

③可以作为dict的key（immutable对象是可哈希的，dict key也是可哈希的，适合做字典的key）

使用list做key会报错提示：TypeError: unhashable type: 'list'

④拆包特性

如果拿c语言类比，tuple好比struct，list对应的是array

from collections import namedtuple

使用namedtuple可以创建一个类，返回一个带有命名字段的新元祖子类

# namedtuple 相当于创建了一个User类，里面含有name，age，height成员变量

# namedtuple是tuple的子类，

# 1、代码比直接定义类更简单

# 2、namedtuple比较节省空间，少了class里面很多内置的变量

# 3、非常适用于创建简单对象，特别用作数据处理

User = namedtuple("User",["name", "age", "height"])

user = User(name="bobby", age=29, height=178)

print(user.age, user.name, user.height)

# 应用场景：user表数据全部取出然后加一个列edu，比较方便（pymysql，查询返回结果是tuple）

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

user = User(name="bobby", age=29, height=178)

user.edu = "master"

# 也可以通过传入tuple或者dict来初始化namedtuple

User = namedtuple("User",["name", "age", "height"])

user_tuple = ("bobby", 29, 175)

user = User(*user_tuple)

user_dict = {

        "name":"bobby",

        "age":29,

        "height":175

}

user = User(**user_dict)

#namedtuple实现原理：

点击进去namedtuple类看，找到python的一个内置函数方法：

exec(class_definition, namespace) #把字符串当做代码执行

继续点击class_definition，有个_class_template，点击进去，这个就是namedtuple的实质

内部代码实现原理实际上是生成一个class，里面的方法就是namedtuple具有的所有方法

其中包括_make、_replace、__repr__、_asdict、__getnewargs__方法

重点介绍_make、_asdict方法

_make方法可传递一个iterable可迭代对象

实际前面例子创建User对象时，也可以用_make方法

User = namedtuple("User",["name", "age", "height"])

user_tuple = ("bobby", 29, 175)

user = User._make(user_tuple)

_asdict方法, 可以将tuple转换成OrderedDict

User = namedtuple("User",["name", "age", "height"])

user_tuple = ("bobby", 29, 175)

user = User(*user_tuple)

user_info_dict = user._asdict()

因为namedtuple是继承自tuple，所以它也支持拆包功能：

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

user = User(name="bobby", age=29, height=178, edu="master")

name, age, *other = user

有大量数据需要做统计代码量会比较大，可使用Counter类

from collections import Counter

users = ['bobby1','bobby2','bobby1','bobby2','bobby2','bobby3']

users_counter = Counter(users)

print(users_counter )

Counter可以传递任何可迭代对象

users_counter = Counter("asdasdgdfwee")

Counter是dict子类，继承自dict，它返回dict类型统计结果

users_counter.update("asdasdg") # 也可以进行合并统计，使用update方法

它也可以传递另外一个Counter对象

users_counter1 = Counter("asdasdgdfwee")

users_counter2 = Counter("sdf342zz")

users_counter1.update(users_counter2 )

users_counter.most_common(2) # 统计出现次数最多的前n个元素

它的内部是通过_heapq堆数据结构实现的，这个堆是专门解决这个topn问题，性能比自己遍历更高

ChainMap

from collections import ChainMap

user_dict1 = {'a':"rio1", "b":"rio2"}

user_dict2 = {'b':"rio3", "d":"rio3"}

for key, value in user_dict1.item():

    print(key,value)

for key, value in user_dict2.item():

    print(key,value)

如果类似上面的dict定义了多个，就需要分别去遍历多次item

ChainMap可以把所有dict连接起来一起遍历。

new_dict = ChainMap(user_dict1,user_dict2)

for key, value in new_dict.item():

    xxxxxx

如果两个字典存在相同的key，只会遍历先找到的key，后面出现相同的key都不会遍历

在原来的chainmap字典中再动态新增字典，返回一个新的ChainMap

new_chainmap = new_dict.new_child( {"aa"：11，“bb":22} )

以列表形式把数据展示出来

print(new_dict.maps)

=> [{'a':"rio1", "b":"rio2"}, {'b':"rio3", "d":"rio3"}]

ChainMap并不是把多个数据合并变成一个dict，而是在上面加了一个访问迭代器，并没有拷贝到新的变量里。

new_dict.maps[0]['a'] = 'rio'

for key, value in new_dict.item():

    print(key,value)

OrderedDict：有序字典

from collections import OrderedDict

它是dict的子类，它是有序的，其顺序是：先添加的在前边，后添加的在后

user_dict = OrderedDict()

user_dict['a'] = "rio1"

user_dict['c"] = "rio2"

user_dict["b"] = "rio3"

python3下dict和OrderedDict都是有序的，OrderedDict提供了额外的函数

pop_item可以不需要传递key并删除最后一个item，pop需要传递key

user_dict.popitem()

user_dict.pop(key)

move_to_end("key")，把指定元素移到最后

拓展：

前面小结namedtuple的_asdict()返回的就是orderedDict

from collections import defaultdict

传统dict类型使用setdefault方法更加高效

defaultdict是dict的扩展子类，它还会在键不存在的时候赋予默认值

# defaultdict需要传递进来一个可调用的对象，list和int都是可调用对象

default_dict = defaultdict(list)

default_dict['bobby']

key不存在时不会抛出异常，会在key不存在时调用传递进来的可调用对象（以上例子为list），给key添加value。值是list的空数组。

如果传递的是int对象，则默认值为0；

如果需要传嵌套dict，定义一个函数return实现

users = ['bobby1','bobby2','bobby3','bobby1','bobby2','bobby2']

for user in users:

    default_dict[user] +=1

def gen_default():

    return {

        "name":"",

        "age":""

    }

default_dict = defaultdict(gen_default)

default_dict['group_01']

# 会返回生成嵌套dict结构

"group1":{

    "name":"",

    "nums":0

}

defaultdict是通过__missing__魔术方法实现原理的

deque是双端队列，可以对两端进行操作。

初始化队列：

ulist = deque(("xxx1","xxx2"))，参数接收一个可迭代对象，

尽量用deque保存相同类型的数据

方法：append加到队列尾部、appendleft加到队列头部

copy浅拷贝，队列里面有不可变元素会直接赋值，可变元素（例如列表）会直接指向原来地址

extend在原来元素上动态扩容，接收可迭代对象

extendleft

insert(索引,元素)

pop、popleft、remove、reverse

应用场景：

python3里，from queue import Queue

Queue里面实际上是通过双端队列完成（put方法调用是append，get方法调用的是popleft）

多线程：deque是线程安全的（由GIL保护的），list非线程安全

tuple的优点：

可以作为dict的key,

*可以接收任意多个参数放入一个tuple中

**可以接收类似于参数赋值形式的实参放入dict中

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))