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个元素

"""
deque() 双端队列，是一个容器 ，它接收一个可迭代的对象，这个对象可以是列表，元组，字典等
用来保存同类型的内容，可以把它当作一个对象来处理
deque包含的方法：
append(): 添加数据到队列
appendleft(): 添加数据到队列头部
clear(): 清空队列数据
copy(): 返回一个浅拷贝,浅拷贝只拷贝元素
count(): 返回队列中元素的数量
extend(): 将两个deque合并为一个
extendleft(): 从左边进行合并
index(): 查找元素
insert(): 在指定位置插入元素
pop(): 移除队列的尾部元素
popleft(): 移除队列的头部元素
remove(): 删除某个元素
reverse(): 将队列反转

deque 是线程安全的，由GIL保护
list 不是线程安全的
"""
from collections import deque
import copy  # 深拷贝

if __name__ == "__main__":
    user_list = ["张三","李四","王五", "赵六"]
    user_name = user_list.pop()  # 队尾出队
    print(user_name, user_list)
    print("----------------------------")

    user_tuple = deque(("张三", "李四"))   # 初始化
    print(user_tuple)
    user_list = deque(["赵六", "王八"])
    print(user_list)
    user_dict = deque({
        "苹果": 12,
        "雪梨": 15
    })
    print(user_dict)

    print("-------------------------")
    user_info_list = deque(["依依", 23, 171])
    user_info = ("C罩杯", "北京大学", "中国北京")
    user_info_list.append(user_info)   # 添加元素
    print(user_info_list)

    print("--------------")
    name_deque = deque(["苹果", "香蕉", "橘子"])
    name_deque.append("芒果")   # 添加元素到队列尾部
    name_deque.appendleft("哈密瓜")  # 添加元素到队列头部
    print(name_deque)

    fruits_deque = name_deque.copy()   # 浅拷贝
    print(fruits_deque)
    print(id(fruits_deque) , id(name_deque))

    name_deque[1] = "西瓜"
    print(fruits_deque, name_deque)

    print("------------------------")
    color_deque = deque(["yellow","red", "blue", "black", "red"])
    print(color_deque)
    print("元素个数：",color_deque.count("red"))
    color_deque.pop()   # 队尾元素出队
    print(color_deque)
    color_deque.popleft()  # 队列头部元素出队
    print(color_deque)
    color_deque.insert(0, "green")  # 队列的0号位置插入元素
    print(color_deque)

    color_deque.remove("red")  # 移除值为 red的元素
    print(color_deque)

    color_deque.reverse()  # 反转队列
    print(color_deque)

    print(color_deque[1])   # 获取下标为1的元素

dict 设置默认值的方法：

1、可以通过dict.setdefault(key,default_value)

2、通过defaultdict(可调用的对象)

    可调用的对象：list、str、int、dict、函数等

from collections import  defaultdict

def gen_default():
    return {
        "name": "",
        "nums": 0
    }

if __name__ == "__main__":
    # 统计出现的次数
    user_dict = {}  #空字典
    users = ["name1", "name2", "name3", "name1", "name2", "name1" ]
    print("方法1：")
    for user in users:
        if user not in user_dict:  # 判断是否存在
            user_dict[user] = 1
        else:
            user_dict[user] += 1
    print(user_dict)

    print("方法2：")
    for user in users:
        user_dict.setdefault(user, 0)
        user_dict[user] += 1
    print(user_dict)


    print("--------------------------------------")
    default_dict1 = defaultdict(list)  # defaultdict()函数接受一个可调用的对象，这个对象可以是list，str,int,dict等。
    print(default_dict1)

    # 统计颜色出现的次数
    default_dict2 = defaultdict(int)
    colors = ["red", "black", "red", "blue", "yellow", "green", "green"]
    for color in colors:
        default_dict2[color] += 1
    print(default_dict2)

    print("----------------------")
    default_dict3 = defaultdict(gen_default)
    default_dict3["group"]
    print(default_dict3)

    user_dict = {
        "name": "依依",
        "age": 24,
        "height": 171,
        "cupSize": "B罩杯",
        "hibbos": {
            "eat": ["火锅", "香蕉"],
            "sports": ["跑步","游泳"]
        }
    }
    print(user_dict)

namedtuple中的两个方法：
(1) _make(): 该方法接收一个可迭代的对象，这个对象可以是元组，列表，字典等，其中的参数要一一对应（数量，属性）
(2) _asdict():该方法可以将元组（tuple)转化为字典（dict)

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

tuple的子类namedtuple，使用namedtuple相当于定义了一个类。

可以将tuple作为参数传递给函数，只要在tuple名前面加一个星号（*）即可。

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(数组）

   
   

collections模块

tuple比list好的地方

拆包的用法2

拆包的用法