tuple:元组，不可变，可迭代，可拆包

girl = ("珊珊", 21, 170, "B罩杯")
name,age,height,cupSize = girl   # 元组拆包
print(name, age, height, cupSize)

其不可变不是绝对的，当元组中包含数组或其他可变数据对象时，就可以改变元组的内容。

tuple比list好，原因：

1. 其不可变性，可以保证在编译时确定其值，使得性能优化，线程安全，可以作为dict的key，具有拆包特性

2. 如果要拿C语言来类比，Tuple对应的是struct(结构体），而list对应的是array(数组）

   
   

def ask(*args, **kwargs):

      pass

函数参数说明：*args参数可以接收元组（tuple)

**kwargs参数接收的是字典（key-value)形式的参数

# 函数参数 *args接收元组参数， **kwargs接收字典参数
def ask(*args, **kwargs): 
    print(type(args))
    print(type(kwargs))
    print(args, kwargs)

if __name__ == "__main__":
    ask("六月飞雪", 6)   # 元组参数
   ask(name = "刘豆豆", age = 22)   # 字典参数

namedtuple中的_make()函数接收一个可迭代的对象，这个对象可以是元组，列表，字典，其参数一一对应。

from collections import namedtuple

if __name__ == "__main__":
    User = namedtuple("User", ["name", "age", "height", "cupSize", "edu"])  # 使用namedtuple就相当于创建了一个User类
   user = User(name="彤彤", age=23, height=172, cupSize="C罩杯", edu = "清华大学")
    print(user.name, user.age, user.height,user.cupSize)

    girl_tuple1 = ("依依", 22, 171, "B罩杯", "北京大学")
    user1 = User(*girl_tuple1)   # 将元组作为一个参数传递给函数，其前面加个星号即可
   print(user1.name, user1.age, user1.height, user1.cupSize)

    girl_tuple2 = ("倩倩", 23, 171, "B罩杯")
    user2 = User(*girl_tuple2, "北京大学")   # 元组作为参数传递
   print(user2.name, user2.age, user2.height, user2.cupSize, user2.edu)

    print("-------------------------------")
    # 字典
    user_dict = {
        "name":"悠悠",
        "age": 24,
        "height": 171,
        "cupSize": "C罩杯"
    }

    user3 = User(**user_dict, edu="南开大学")   # 字典作为参数传递，其前加两个星号
   print(user3.name, user3.age, user3.height, user3.cupSize, user3.edu)

    user4 = User._make(girl_tuple1)  #元组作为其参数 参数一定要对应，否则报错
    print(user4.name, user4.age, user4.height, user4.cupSize, user4.edu)

    user_list = ["可可", 24, 172, "B罩杯", "浙江大学"]
    user5 = User._make(user_list)   # 列表作为其参数   使用  _make()函数你不需要关心数据类型，只要传递一个可迭代的对象即可
   print(user5.name, user5.age, user5.height, user5.cupSize, user5.edu)

    print("------------------")
    user_dict1 = {
        "name": "玉玉",
        "age": 23,
        "height": 173,
        "cupSize": "C罩杯",
        "edu": "武汉大学"
    }
    user6 = User._make(user_dict1)   # 字典作为其参数，使用 _make()函数其参数是一个可迭代的对象，数据类型任意
   print(user_dict1)
    print(user_dict1.values())

namedtuple 是 tuple的子类

namedtuple 省资源。节省了Class初始化 和参数检查的过程

例：

b = ("name", "age", "gender")
b_k = namedtuple("user_02", b)
b_v = ("tom", 19)
print(b_k(*b_v, "male"))

常用方法：

_make(iterable)   生成对应关系

_asdict() 

user_dict = {}
users = ["bobby1", "bobby2", "bobby3", "bobby1", "bobby2", "bobby2"]
#第一种形式
for user in users:
    if user not in user_dict:
        user_dict[user] = 1
    else:
        user_dict[user] += 1
        
#第二种形式
for user in users:
    user_dict.setdefault(user, 0) #若user键不存在，设为默认值0
    user_dict[user] += 1
    

from collections import defaultdict
default_dict = defaultdict(list) #在bobby键不存在时，调用传递对象的名称list，生成空数组
default_dict["bobby"]
#第三种形式
default_dict = defaultdict(int) #默认传递0
for user in users:
    default_dict[user] += 1

#如果生成嵌套的dict   
def gen_default():
    return {"name":"", "nums":0}
default_dict = defaultdict(gen_default)
default_dict["group1"] #没有group1时传递gen_default函数

*args存储函数传参的值（未指明变量名的情况），**kwargs存储的是指明变量名和值的情况 前者是tuple，后者是dict

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中