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

迭代: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 +左键 模块名

抽象基类