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

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}

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

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

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

nametuple

1，可以创建类对象

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名前面加一个星号（*）即可。

实例：
from collections import namedtuple


key_s = ("name", "age", "gender", "birthday")
User = namedtuple("User", key_s)
value_s = ("lewin", 29, "male")

value_dict = {
    "name": "tim",
    "age": 19,
    "gender": "male"
}

value_make = ("lily", "18", "female", "2001-02-02")

user_tuple = User(*value_s, "1990-01-01")
user_dict = User(**value_dict, birthday="2000-02-28")
user_make = User._make(value_make)
user_order = user_make._asdict()

print("user_tuple: {0}\nuser_dict: {1}\nuser_make: {2}\nuser_order: {3}".format(user_tuple, user_dict, user_make, user_order))

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

namedtule创建tuple类

将tuple作为参数传递到函数中，直接在tuple变量名前面加上一个*就ok比如

user_tuple=("bobby",29,176)

User(*user_tuple)

字典则加两个*号

但是有一点值得注意的是User函数必须能支持传递tuple，而namedtuple能将User设置成为一个可以传递tuple和dict的函数，具体的操作方位为

User = nn

_make函数，省去*和**，简单很多

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

exec():执行以string类型存储的Python代码。

解释器遇到exec函数时，会独立执行字符串内的语句。如果还有传参，那都是定义变量的字典。解释器不会寻找字符串外的语法结构。