dict 订阅
Dict
信息
操作系统
未知
开发语言
开源协议
未知
Dict
“划词翻译”就是指在网页中选中单词或词组,就会立即在鼠标旁出现该词组的翻译(中英)。 请在状态栏 Dict 项处切换词典开启/关闭。 使用方法: 点击状态栏大写'D'字样图标开启和关闭翻译(开启时图标为蓝色,关闭为灰色),快捷键 ctrl+alt+d。 用鼠标选中单词或者直接指向单词,稍等片刻,翻译结果将直接在鼠标旁出现。 鼠标划过翻译结果可听到单词发音,点击结果即跳转到详细结果页面。
收起全文
精华内容
下载资源
问答
  • pytorch 中的 state_dict 是一个简单的python的字典对象,将每一层与它的对应参数建立映射关系.(如model的每一层的weights及偏置等等) (注意,只有那些参数可以训练的layer才会被保存到模型的state_dict中,如卷积层,...
  • python实现字典包裹字典的替换key。python代码,如果有需要,请自行下载。
  • 简介:pandas 中的to_dict 可以对DataFrame类型的数据进行转换 可以选择六种的转换类型,分别对应于参数 ‘dict’, ‘list’, ‘series’, ‘split’, ‘records’, ‘index’,下面逐一介绍每种的用法 Help on ...
  • dict字典.rar

    2021-02-10 21:21:07
    python破解pdf文件密码字母测试库,如果密码是单词组合的可以尝试破解.
  • 今天小编就为大家分享一篇python 实现dict转json并保存文件,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 盘古分词字典dict.dct 以及bin下面dict文件夹下面的txt文件 包含 ChsDoubleName1.txt ChsDoubleName2.txt ChsSingleName.txt Stopword.txt Synonym.txt Wildcard.txt
  • list和dict的应用

    2021-01-20 03:20:11
    给定一个list和dict,返回list中元素不存在dict的key、存在dict但是value为空、存在dict但是value为0的结果。 直接上代码 def isnotexsit(dict1, list1): ''' 给一个字典,列表,返回字典对应key不存在列表的结果集 ...
  • 字典 由 c 实现的简单字典。 修改自 。 应用程序接口 以下是“dict”当前提供的公共api。 dict_t *dict_new(); 分配并初始化一个dict 。... dict_t *mydict = dict_new();... dict_pair_t *pair = dict_get(dict, " some
  • Dict打开工具

    2015-04-12 22:01:14
    用于打开dict格式的词典,方便查词操作
  • dict转txt工具

    2015-04-12 22:03:00
    用于将dict格式的词典转化为txt文本文件,方便程序调用
  • Python 函数dict() 和 dict

    千次阅读 2018-12-21 23:24:03
    dict() 作用:dict() 函数用于创建一个字典。返回一个字典。 语法: class dict(**kwarg) class dict(mapping, **kwarg) class dict(iterable, **kwarg) 参数说明: **kwargs -- 关键字 mapping -- 元素的...

     dict()

    作用:dict() 函数用于创建一个字典。返回一个字典。

    语法:

    class dict(**kwarg)
    class dict(mapping, **kwarg)
    class dict(iterable, **kwarg)
    

    参数说明:

    • **kwargs -- 关键字
    • mapping -- 元素的容器。
    • iterable -- 可迭代对象

    实例:

    >>>dict()                        # 创建空字典
    {}
    >>> dict(a='a', b='b', t='t')     # 传入关键字
    {'a': 'a', 'b': 'b', 't': 't'}
    >>> dict(zip(['one', 'two', 'three'], [1, 2, 3]))   # 映射函数方式来构造字典
    {'three': 3, 'two': 2, 'one': 1} 
    >>> dict([('one', 1), ('two', 2), ('three', 3)])    # 可迭代对象方式来构造字典
    {'three': 3, 'two': 2, 'one': 1}
    >>>

    python中的dict的详细介绍

    一、dict的特性

      dict是python中的一个可变的数据类型,用{}表示,dict的key必须是不可变的数据类型,而value的数据类型可以任意

      格式:{key:value,key:value,key:value}

      注:键值对如果是字符串使用单引号,最后一个键值对没有逗号

        不可变数据类型: 元组,bool,int , str 可以hash
        可变数据类型: dict ,list, set

    二、dict的方法:

      (1)增加的方法:dict有两种增加的方法

       ①第一种:如果没有的键值对,则进行添加,如果有,则将值进行覆盖

    dict1={'name':'jinxin','age':18,'male':'男'}
    print(dict1)
    dict1['high']=185
    print(dict1)  # {'name': 'jinxin', 'age': 18, 'male': '男', 'high': 185}
    dict1['age']=16
    print(dict1) #  {'name': 'jinxin', 'age': 16, 'male': '男', 'high': 185}

       ②:第二种:如果有键值对,不做任何改变,没有键值对,才进行添加

    dict1.setdefault("weight")
    print(dict1)  #{'name': 'jinxin', 'age': 16, 'male': '男', 'high': 185, 'weight': None}
    dict1.setdefault('weight','65kg')
    print(dict1)  #{'name': 'jinxin', 'age': 16, 'male': '男', 'high': 185, 'weight': None}
    dict1.setdefault('address','北京')
    print(dict1)  #{'name': 'jinxin', 'age': 16, 'male': '男', 'high': 185, 'weight': None, 'address': '北京'}

      (2)dict的删除方法

       ①:使用pop()删除,如果有键,则删除,如果没有则会报错,如果不希望出现报错信息,可以在删除的后面添加信息

    delDict={'name': 'jinxin', 'age': 16, 'male': '男', 'high': 185, 'weight': None, 'address': '北京'}
    # delDict.pop('age')  #dict的删除操作是有返回值的
    print(delDict.pop('age'))  # 16
    print(delDict)  #{'name': 'jinxin', 'male': '男', 'high': 185, 'weight': None, 'address': '北京'}
    print(delDict.pop('职业','没有此键'))  #没有此键

       ②:使用popitem()删除,随机删除,返回的是一个元组,元组里面存储的删除的键值,推荐使用pop()方法进行删除

    print(delDict.popitem())  # ('address', '北京') 随机删除,返回值是删除的键值对
    print(delDict)  #{'name': 'jinxin', 'male': '男', 'high': 185, 'weight': None}

       ③:使用del()删除,del()可以删除整个字典,也可以删除字典的某个键,如果删除的键不存在,则会出现报错

    del delDict['name']
    print(delDict)  #{'male': '男', 'high': 185, 'weight': None}
    
    #使用del清空列表
    del delDict
    print(delDict)  #delDict已经删除,报错

       ④:清空列表也可以使用clear()

     (3)dict的修改

      使用update()方法修改字典

    updateDict1={'name':'jinxin','age':18,'male':'男'}
    updateDict2={'name':'jordan','address':'北京海淀'}
    updateDict2.update(updateDict1)
    print(updateDict1) #{'name': 'jinxin', 'age': 18, 'male': '男'}
    print(updateDict2) #{'name': 'jinxin', 'address': '北京海淀', 'age': 18, 'male': '男'}

    (4)字典的查询

      ①:查询字典的键:调用keys()方法

        查询字典的值:调用values()方法

    # 字典的查
    dict1={'name':'jinxin','age':18,'male':'男'}
    print(dict1.keys()) #dict_keys(['name', 'age', 'male'])
    print(dict1.values()) #dict_values(['jinxin', 18, '男'])
    print(dict1.items())# dict_items([('name', 'jinxin'), ('age', 18), ('male', '男')])
    
    #打印dict1的键
    for i in dict1.keys():
        print(i )  # name age value
    
    #打印dict的值
    for v  in dict1.values():
        print(v) #jinxin 18 男

        打印字典的键值:

    dict1={'name':'jinxin','age':18,'male':'男'}
    
    for i in dict1.items():
        print(i)  # ('name', 'jinxin') ('age', 18) ('male', '男')
        
    for k,v in dict1.items():
        print(k,v)  # name jinxin  age 18   male 男

      ②:字典的get()方法:使用get()方法可以查询某个键是否存在,如果不存在此键,则会返回None,但是可以在get()方法中添加信息避免出现None

    dict1={'name':'jinxin','age':18,'male':'男'}
    print(dict1.get('name')) #jinxin
    print(dict1.get('address')) # None
    print(dict1.get('address','没有此键'))  #没有此键
    

    以下转自廖雪峰


    dict

    Python内置了字典:dict的支持,dict全称dictionary,在其他语言中也称为map,使用键-值(key-value)存储,具有极快的查找速度。

    举个例子,假设要根据同学的名字查找对应的成绩,如果用list实现,需要两个list:

    names = ['Michael', 'Bob', 'Tracy']
    scores = [95, 75, 85]
    

    给定一个名字,要查找对应的成绩,就先要在names中找到对应的位置,再从scores取出对应的成绩,list越长,耗时越长。

    如果用dict实现,只需要一个“名字”-“成绩”的对照表,直接根据名字查找成绩,无论这个表有多大,查找速度都不会变慢。用Python写一个dict如下:

    >>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
    >>> d['Michael']
    95
    

    为什么dict查找速度这么快?因为dict的实现原理和查字典是一样的。假设字典包含了1万个汉字,我们要查某一个字,一个办法是把字典从第一页往后翻,直到找到我们想要的字为止,这种方法就是在list中查找元素的方法,list越大,查找越慢。

    第二种方法是先在字典的索引表里(比如部首表)查这个字对应的页码,然后直接翻到该页,找到这个字,无论找哪个字,这种查找速度都非常快,不会随着字典大小的增加而变慢。

    dict就是第二种实现方式,给定一个名字,比如'Michael',dict在内部就可以直接计算出Michael对应的存放成绩的“页码”,也就是95这个数字存放的内存地址,直接取出来,所以速度非常快。

    你可以猜到,这种key-value存储方式,在放进去的时候,必须根据key算出value的存放位置,这样,取的时候才能根据key直接拿到value。

    把数据放入dict的方法,除了初始化时指定外,还可以通过key放入:

    >>> d['Adam'] = 67
    >>> d['Adam']
    67
    

    由于一个key只能对应一个value,所以,多次对一个key放入value,后面的值会把前面的值冲掉:

    >>> d['Jack'] = 90
    >>> d['Jack']
    90
    >>> d['Jack'] = 88
    >>> d['Jack']
    88
    

    如果key不存在,dict就会报错:

    >>> d['Thomas']
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    KeyError: 'Thomas'
    

    要避免key不存在的错误,有两种办法,一是通过in判断key是否存在:

    >>> 'Thomas' in d
    False
    

    二是通过dict提供的get方法,如果key不存在,可以返回None,或者自己指定的value:

    >>> d.get('Thomas')
    >>> d.get('Thomas', -1)
    -1
    

    注意:返回None的时候Python的交互式命令行不显示结果。

    要删除一个key,用pop(key)方法,对应的value也会从dict中删除:

    >>> d.pop('Bob')
    75
    >>> d
    {'Michael': 95, 'Tracy': 85}
    

    请务必注意,dict内部存放的顺序和key放入的顺序是没有关系的。

    和list比较,dict有以下几个特点:

    1. 查找和插入的速度极快,不会随着key的增加而增加;
    2. 需要占用大量的内存,内存浪费多。

    而list相反:

    1. 查找和插入的时间随着元素的增加而增加;
    2. 占用空间小,浪费内存很少。

    所以,dict是用空间来换取时间的一种方法。

    dict可以用在需要高速查找的很多地方,在Python代码中几乎无处不在,正确使用dict非常重要,需要牢记的第一条就是dict的key必须是不可变对象

    这是因为dict根据key来计算value的存储位置,如果每次计算相同的key得出的结果不同,那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法(Hash)。

    要保证hash的正确性,作为key的对象就不能变。在Python中,字符串、整数等都是不可变的,因此,可以放心地作为key。而list是可变的,就不能作为key:

    >>> key = [1, 2, 3]
    >>> d[key] = 'a list'
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: unhashable type: 'list'
    

    展开全文
  • python-object与dict互转

    千次阅读 2020-06-27 09:52:26
    obj转dict有哪些方式?各有啥特点? dict又如何转化为obj呢? 上面的json格式化对象场景,如何实现? 如果上面几点问题都能回答上,那么可以跳过本篇文章了。本篇相关文章共三连弹。(端午节在家整理,有帮助记得点...

    先举个使用场景:python处理完业务逻辑,将一个结果封装成统一格式对象,然后json格式返回给客户端。

    本文概要

    1. python标准类型有哪些?哪些是可变和不可变的,如何转化?
    2. obj转dict有哪些方式?各有啥特点?
    3. dict又如何转化为obj呢?
    4. 上面的json格式化对象场景,如何实现?

    如果上面几点问题都能回答上,那么可以跳过本篇文章了。本篇相关文章共三连弹。(端午节在家整理,有帮助记得点个👍,就是对我最大的肯定😘😘😘)

    浩瀚的网络中,你我的相遇也是种缘分,看你天资聪慧、骨骼精奇,就送你一场大造化吧,能领悟多少就看你自己了。㊙传承之地🙇

    1.python类型

    标准数据类型

    • 不可变
      • Number(数字) int、float、bool、complex
      • String(字符串)
      • Tuple(元组)
    • 可变
      • List(列表)
      • Set(集合)
      • Dictionary(字典)

    相互转化

    函数描述
    int(x)将x转换为一个整数
    float(x)将x转换到一个浮点数
    complex(real)创建一个复数
    str(x)将对象 x 转换为字符串
    repr(x)将对象 x 转换为表达式字符串
    eval(str)用来计算在字符串中的有效Python表达式,并返回一个对象
    tuple(s)将序列 s 转换为一个元组
    list(s)将序列 s 转换为一个列表
    set(s)转换为可变集合
    dict(d)创建一个字典。d 必须是一个 (key, value)元组序列。
    frozenset(s)转换为不可变集合
    chr(x)将一个整数转换为一个字符
    ord(x)将一个字符转换为它的整数值
    hex(x)将一个整数转换为一个十六进制字符串
    oct(x)将一个整数转换为一个八进制字符串

    2.对象转dict

    python的dict只能采用obj["name"]的方式来写入和读取

    python的ojb只能采取obj.name的方式来读取和写入

    三种方式

    • __dict__

    __init__方法和对象显示赋值的属性才会转化

    • dict函数

    需要定义keys__getitem__方法,所有属性都会转化dict

    • 取出对象里属性名和值,塞到dict中

    需要遍历对象的属性

    三种方式以1千万的量,测试下它们性能

    方式耗时性能
    __dict__0.7秒
    dict函数11秒
    属性3分12秒

    直接取属性值最快,自定义__getitem__方法次之,遍历属性最慢

    如何对__init____dict__vars__getitem__不太了解的,可以分别查看下这两篇文章

    2-1.dict

    # 对象类
    class User:
        is_admin = False
        desc = ''
    
        def __init__(self, name) -> None:
            self.name = name
            self.age = 1
    
    # 测试方法
    class MyTestCase(unittest.TestCase):
        def test_user(self):
            user = User('iworkh')
            user.is_admin = True
            # 只有塞值的时候,才会转化为dic
            # desc没有塞值,dic中没有
            print(user.__dict__)
            pass
    

    结果:

    {‘name’: ‘iworkh’, ‘age’: 1, ‘is_admin’: True}
    name和age在init函数里定义,is_admin通过对象塞值了,三个属性值都显示。
    desc不在init函数中,也没有塞值,没有显示

    2-2.dict函数

    # 对象类
    class Product:
        price = 10
        desc = ''
    
        def __init__(self, name) -> None:
            self.name = name
    
        def keys(self):
            '''当对实例化对象使用dict(obj)的时候, 会调用这个方法,这里定义了字典的键, 其对应的值将以obj['name']的形式取,
           但是对象是不可以以这种方式取值的, 为了支持这种取值, 可以为类增加一个方法'''
            return ('name', 'price', 'desc')
    
        def __getitem__(self, item):
            '''内置方法, 当使用obj['name']的形式的时候, 将调用这个方法, 这里返回的结果就是值'''
            return getattr(self, item)
            
    # 测试方法
    class MyTestCase(unittest.TestCase):
    
        def test_product(self):
            product = Product('book')
            print(dict(product))
            pass
    

    结果:

    {‘name’: ‘book’, ‘price’: 10, ‘desc’: ‘’}
    都显示,但是需要定义keys__getitem__函数,上卖弄都有注释就不解释了

    2-3.属性方式

    工具类

    class objDictTool:
        @staticmethod
        def to_dic(obj):
            dic = {}
            for fieldkey in dir(obj):
                fieldvaule = getattr(obj, fieldkey)
                if not fieldkey.startswith("__") and not callable(fieldvaule) and not fieldkey.startswith("_"):
                    dic[fieldkey] = fieldvaule
            return dic
    

    这只取了不是___开头的属性,如需要可以修改代码

    # 对象类
    class Order:
        order_no: str = ''
        desc = ''
    
        def __init__(self, name) -> None:
            self.name = name
            self.age = 1
    
    # 测试方法
    class MyTestCase(unittest.TestCase):
        def test_order_by_attr(self):
            user = User('iworkh')
            dic = objDictTool.to_dic(user)
            print(dic)
            pass
    

    结果:

    {‘age’: 1, ‘desc’: ‘’, ‘is_admin’: False, ‘name’: ‘iworkh’}

    2-4.总结

    三种方式各特点,使用时要注意不同的场合

    三种方法以1千万的量测了下它们性能

    方式耗时性能
    __dict__0.7秒
    dict函数11秒
    属性3分12秒

    使用场景:

    • 如果您能保证对的属性值都塞了,或者没有的值属性不转化到dict也没关系,那么可以选择__dict__方式
    • 如果要obj转dict的对象不多,整个项目中就几个类对应的对象,而且要全部属性(即使没塞值的,也要转到dict中),那么可以选择dict函数方式
    • 如果要obj转dict的类很多,但是不会频繁转化(因为效率低),那么可以选择属性方式。

    3.dict转对象

    工具类

    class objDictTool:
        @staticmethod
        def to_obj(obj: object, **data):
            obj.__dict__.update(data)
    

    通过对象的__dict__属性,然后调用update更新方法,将data的值赋给obj

    class MyTestCase(unittest.TestCase):
        def test_dict_to_obj(self):
            product_dic = {'name': 'python', 'price': 10, 'desc': 'python对象和dic转化'}
            product_obj = Product('test')
            objDictTool.to_obj(product_obj, **product_dic)
            print("名称: {}, 价格: {},  描述: {}".format(product_obj.name, product_obj.price, product_obj.desc))
            pass
    

    结果:

    名称: python, 价格: 10, 描述: python对象和dic转化

    objDictTool里的一个to_dicto_obj就组成了obj和dict互转的工具类型了。

    4.peewee转化model

    如果项目中使用的了peewee的话,那么可以使用model_to_dictdict_to_model,将model和dict项目转化

    model定义

    class UserModel(BaseModel):
        user_name = CharField(max_length=20, null=True, verbose_name="用户名")
        nick_name = CharField(max_length=20, null=True, verbose_name="昵称")
        password = CharField(max_length=20, null=True, verbose_name="密码")
        phone = CharField(max_length=11, index=True, unique=True, verbose_name="手机号码")
        sex = CharField(max_length=1, choices=SEXES, verbose_name="性别")
    
        class Meta:
            table_name = 'T_ACTION_USER'
    

    转化使用

    from playhouse.shortcuts import model_to_dict
    
    class UserService:
        async def create(self, userModel):
            await objects.create(UserModel, **model_to_dict(userModel))
    

    注意:

    dict_to_model使用和model_to_dict类似,注意:项目项目使用peewee才可以用

    5.应用

    我们来解决,文章开始抛出的使用场景:

    python处理完业务逻辑,将一个结果封装成统一格式对象返回给前台,以json格式。json格式化需要是python的基本。

    比如我们需要每次返回的结果都下:

    • 错误时:success为false, errorCode和message有值
    • 正常时:success为true, data有的数据

    json格式

    {
        "success": true,
        "errorCode": 0,
        "message": "",
        "data": {
            "id": 2,
            "created_date": "2020-06-24T14:47:21",
            "update_date": "2020-06-24T14:47:21",
            "user_name": "iworkh",
            "nick_name": "沐雨云楼"
        }
    }
    

    实体类

    class Comment:
        title: str = ''
        author: str = ''
        desc: str = ''
        create_time: datetime = datetime.now()
    

    5-1.json序列化

    开始之前,还是先讲得解下json的序列化知识

    使用 JSON 函数需要导入 json 库:import json

    函数描述
    json.dumps将 Python 对象编码成 JSON 字符串
    json.loads将已编码的 JSON 字符串解码为 Python 对象

    python 原始类型向 json 类型的转化对照表:

    PythonJSON
    dictobject
    list, tuplearray
    str, unicodestring
    int, long, floatnumber
    Truetrue
    Falsefalse
    Nonenull

    json 类型转换到 python 的类型对照表:

    JSONPython
    objectdict
    arraylist
    stringunicode
    number (int)int, long
    number (real)float
    trueTrue
    falseFalse
    nullNone

    那下面我们来看下如何处理上我们上面的场景

    5-2.简单版

    警告

    注意下面代码层层迭代过程,从出错到正确的演变,最终达到可用代码。不要只追求结果,要知道其步步演变的过程。

    测试类

    class MyTestCase(unittest.TestCase):
        def test_json(self):
            # 返回json时,序列化对象要是python原始类型:
            # dict, list, tuple, str, unicode, int, long, float, True, False, None
            comment = Comment()
            comment.title = 'python工具类-obj转dict'
            comment.author = '沐雨云楼'
            comment.desc = '怎么玩呢?'
            result = {'success': True, 'data': comment}
            json_str = json.dumps(result)
            print(json_str)
            pass
    

    思考有没问题?能得到预期的结果嘛?

    结果:

    报错:Object of type Comment is not JSON serializable

    如果有java基础肯定直到,一个对象要虚拟化得实现serializable接口,为什么?

    可以查看这篇文章 java序列化

    解决办法:

    就是本文前面将的如何将obj转化为dict的知识了,修改代码如下

    class MyTestCase(unittest.TestCase):
        def test_json(self):
            # 返回json时,序列化对象要是 python原始类型:
            # dict, list, tuple, str, unicode, int, long, float, True, False, None
            comment = Comment()
            comment.title = 'python工具类-obj转dict'
            comment.author = '沐雨云楼'
            comment.desc = '怎么玩呢?'
            result = {'success': True, 'data': comment}
            json_str = json.dumps(result, default=lambda obj: obj.__dict__, sort_keys=True, indent=4, ensure_ascii=False)
            print(json_str)
            pass
    

    dumps几个参数说明

    • default: 指定如何任意一个对象变成一个可序列为JSON的对象的函数,这使用的是lambda表达式
    • sort_keys : 安装对象的属性字母顺序排序
    • indent: json格式化时,使用的空格数
    • ensure_ascii: False不转换为asccii码

    结果

    {
        "data": {
            "author": "沐雨云楼",
            "desc": "怎么玩呢?",
            "title": "python工具类-obj转dict"
        },
        "success": true
    }
    

    下面的写法跟上面是完全等效的

    class MyTestCase(unittest.TestCase):
        def test_json(self):
            # 返回json时,序列化对象要是 python原始类型:
            # dict, list, tuple, str, unicode, int, long, float, True, False, None
            comment = Comment()
            comment.title = 'python工具类-obj转dict'
            comment.author = '沐雨云楼'
            comment.desc = '怎么玩呢?'
            result = {'success': True, 'data': comment.__dict__}
            json_str = json.dumps(result, sort_keys=True, indent=4, ensure_ascii=False)
            print(json_str)
            pass
    

    不使用default,将data设置为dict

    我们有没发现,这种方式,如果没有塞值的话,那么dict里是没有,比如这里create_time,json格式化没出来

    塞create_time值

    class MyTestCase(unittest.TestCase):
        def test_json(self):
            # 返回json时,序列化对象要是 python原始类型:
            # dict, list, tuple, str, unicode, int, long, float, True, False, None
            comment = Comment()
            comment.title = 'python工具类-obj转dict'
            comment.author = '沐雨云楼'
            comment.desc = '怎么玩呢?'
            comment.create_time=datetime.now()
            result = {'success': True, 'data': comment}
            json_str = json.dumps(result, default=lambda obj: obj.__dict__, sort_keys=True, indent=4, ensure_ascii=False)
            print(json_str)
            pass
    

    这样create_time时间就能出来了嘛?

    结果:

    不好意思,还是没有。报错了: ‘datetime.datetime’ object has no attribute ‘dict

    json格式化,要对时间类型特殊处理

    文件名json_tool.py的工具类

    from datetime import datetime, date
    
    def json_serial(obj):
        if isinstance(obj, (datetime, date)):
            return obj.isoformat()
        raise TypeError("Type {} s not serializable".format(type(obj)))
    

    对对象是datetime和date特殊处理

    修改代码如下:

    class MyTestCase(unittest.TestCase):
       def test_json(self):
            # 返回json时,序列化对象要是 python原始类型:
            # dict, list, tuple, str, unicode, int, long, float, True, False, None
            comment = Comment()
            comment.title = 'python工具类-obj转dict'
            comment.author = '沐雨云楼'
            comment.desc = '怎么玩呢?'
            comment.create_time = datetime.now()
    
            result = {'success': True, 'data': comment.__dict__}
            json_str = json.dumps(result, default=json_serial, sort_keys=True, indent=4, ensure_ascii=False)
            print(json_str)
            pass
    

    这就没有问题了,最后结果也包含了时间

    {
        "data": {
            "author": "沐雨云楼",
            "create_time": "2020-06-24T22:30:56.890901",
            "desc": "怎么玩呢?",
            "title": "python工具类-obj转dict"
        },
        "success": true
    }
    

    5-3.封装对象版

    我们先上面简化的缺点,主要以这两行代码来说:

    简单版代码片段

    result = {'success': True, 'data': comment.__dict__}
    json_str = json.dumps(result, default=json_serial, sort_keys=True, indent=4, ensure_ascii=False)
    

    缺点:

    • result是自己定义的一个{}dict,每个人可能不一样,而且可能写错,比如success写错了sucesss,那么跟前台接受数据格式对比不上;data换成了result等,所有用到的地方都得修改
    • json.dumps的参数,每次都要写一长串

    因此,需要对result进一步封装,封装一个对象JsonDataResult,将对象转为json再传递。

    将result封装为JsonDataResult

    import json
    import 省略
    
    class JsonDataResult:
        success: bool = False
        errorCode: int = 0
        message: str = ''
        data: dict = None
    
        def keys(self):
            return ('success', 'errorCode', 'message', 'data')
    
        def __getitem__(self, item):
            return getattr(self, item)
    
        def to_json(self):
            return json.dumps(dict(self), default=json_serial, sort_keys=True, indent=4, ensure_ascii=False)
    

    思考:为啥这用dict函数方式来将obj转为dict?

    因为: 只有JsonDataResult这一个对象转化,且返回给前台都保持数据结构一样,不管有没塞值。

    使用代码测试

    class MyTestCase(unittest.TestCase):
        def test_json_data_result(self):
            comment = Comment()
            comment.title = 'python工具类-obj转dict'
            comment.author = '沐雨云楼'
            comment.desc = '怎么玩呢?'
    
            result = JsonDataResult()
            result.success = True
            result.data = objDictTool.to_dic(comment)
            print(result.to_json())
            pass
    

    注意几点:

    • 对象都使用JsonDataResult封装的类,不用担心变量写错了,而且大家都一样对象,返回结构是一样。
    • result.to_json里的to_json方法,都调用这个函数,不用每次写一大段,修改的时候,也只要修改一处即可
    • 只要保证data的能够被json转化即可(data如果是类对象,记得要转化为dict类型,具体要看需求,选择obj转dict哪一种方式。如项目中使用了peewee的话,那么可以使用model_to_dict)

    结果:

    {
        "data": {
            "author": "沐雨云楼",
            "create_time": "2020-06-25T10:17:43.412471",
            "desc": "怎么玩呢?",
            "title": "python工具类-obj转dict"
        },
        "errorCode": 0,
        "message": "",
        "success": true
    }
    

    5-4.代码

    源码坐标

    如需要源码,可以查看。(关键代码都贴在文章里,不用看也行)

    下面贴出最终版的代码片段,供阅读

    json_tool.py

    from datetime import datetime, date
    
    def json_serial(obj):
        if isinstance(obj, (datetime, date)):
            return obj.isoformat()
        raise TypeError("Type {} s not serializable".format(type(obj)))
    

    obj_dict_tool.py

    class objDictTool:
        @staticmethod
        def to_dic(obj):
            dic = {}
            for fieldkey in dir(obj):
                fieldvaule = getattr(obj, fieldkey)
                if not fieldkey.startswith("__") and not callable(fieldvaule) and not fieldkey.startswith("_"):
                    dic[fieldkey] = fieldvaule
            return dic
    
        @staticmethod
        def to_obj(obj: object, **data):
            obj.__dict__.update(data)
    

    json_data_result.py

    importclass JsonDataResult:
        success: bool = False
        errorCode: int = 0
        message: str = ''
        data: dict = None
    
        def keys(self):
            return ('success', 'errorCode', 'message', 'data')
    
        def __getitem__(self, item):
            return getattr(self, item)
    
        def to_json(self):
            return json.dumps(dict(self), default=json_serial, sort_keys=True, indent=4, ensure_ascii=False)
    
    

    测试类

    class Comment:
        title: str = ''
        author: str = ''
        desc: str = ''
        create_time: datetime = datetime.now()
        
        
    class MyTestCase(unittest.TestCase):
        def test_json_data_result(self):
            comment = Comment()
            comment.title = 'python工具类-obj转dict'
            comment.author = '沐雨云楼'
            comment.desc = '怎么玩呢?'
            result = JsonDataResult()
            result.success = True
            result.data = objDictTool.to_dic(comment)
            print(result.to_json())
            pass
    

    6.推荐

    能读到文章最后,首先得谢谢您对本文的肯定,你的肯定是对我们的最大鼓励。

    你觉本文有帮助,那就点个👍
    你有疑问,那就留下您的💬
    怕把我弄丢了,那就把我⭐
    电脑不方便看,那就把发到你📲

    展开全文
  • dict_字典文件

    2013-01-02 10:07:48
    dict字典文件,单词本,xml格式,关键字为单词
  • Tcl字典命令之dict

    千次阅读 2019-05-28 20:17:33
    Tcl字典命令之dict

    dict

    dict option arg1 ?arg2 ... argN?

    操作字典,具体操作由option决定,option支持以下选项:

    create

    dict create ?key1 value1 key2 value2 ...keyN valueN?

     返回一个新字典,包含传入的key、value映射。

    append

     dict append dictName key ?string ...? 

    将给定的string追加到字典dictName中键key的值后面。如果key不存在,则相当于新增一个key的映射。如果未指定string,则视为空字符串。多个string会合并为一个字符串。此命令返回更新后的字典。

    lapend

    dict lappend dictName key ?value ...? 

    将给定的value追加到dictName中指定key对应的列表中,可以同时追加多个value,如果key对应的值不是列表,会创建一个列表,并将原有值和追加的值放到列表中。如果key存在,但没有指定value,则不做任何操作。如果dictName中不存在key,则视为空列表,若此时value也未指定则会添加一个键为key值为空列表的元素,若指定了value则会将value作为列表的元素。如果key对应的值不能表示为列表则会报错。

    exists

    dict exists dictValue key ?key ...?

    判断给定的键key是否存在于给定的字典dictValue中,如果存在返回true,否则返回false。exists只能判断一个键是否存在,当传入多个key时,会将多个key作为嵌套字典的键路径进行查找。

    get

    dict get dictValue ?key ...? 

    获取dictValue中指定key的值,如果想获取嵌套字典中的值,则需要传入多个key作为键的路径。如果没有指定key则返回包含所有键值对的列表。如果字典中不存在指定的键则会报错。

    incr

    dict incr dictName key ?increment?

    将字典dictName中指定key对应的值增加increment。如果未指定increment,则默认增加1。如果不存在指定的key,则视为0。如果key对应的值不是整数则会报错。

    keys

     dict keys dictValue ?globPattern? 

    返回包含dictValue所有键的列表。如果指定了globPattern,则只返回与之匹配的键的列表。列表中的键按其插入字典的顺序返回。

    values

    dict values dictValue ?globPattern?

    返回包含字典dictValue的值的列表。如果指定了globPattern,则只返回根据string match规则与其匹配的值的列表。返回值按其插入字典dictValue的顺序排列。

    set

    dict set dictName key ?key ...? value

     使用value替换字典dictName中key对应的值。如果dictName中不存在key,则值会新增key到value的映射。当存在多个键时表示更新嵌套字典,此时如果第一个key不存在,则会新增一个嵌套字典。如果第一个key存在但是后面的key不存在则会报错missing value to go with key。

    update

    dict update dictName key varName ?key varName ...? body

    使用映射dictName中key对应的值的变量varName执行body中的脚本。如果dictName没有指定的key,则其对应的变量varname为未设置。当body终止时,对varName所做的更改都会被会写到字典内即使body的结果是一个错误或其他异常,除非字典不可读所有的更新都被静默的丢弃。除非发成异常,否则dict update的结果是body的执行结果。建议只在本地作用域内使用此命令,因为dict update命令中的变量varName在命令完成后,除非显示的执行unset,否则仍然存在。此外,只有当body终止时,才会更改dictName中的内容。

    replace

     dict replace dictValue ?key value ...?

    返回一个新的字典,包括传入的dictValue以及一些额外的或不同的键值对。如果不传如键值对key、value,则返回的新字典与dictValue相同。键值对必须是成对出现,否则会报错。dictValue中存在的key会用心的value替换,不存在的key会新增到新的字典。

    unset

    dict unset dictName key ?key ...?

    删除字典dictName中key对应的值。如果dictName中不存在key,则不进行任何操作。当存在多个键时表示删除嵌套字典中的元素,此时的键路径上除了最后一个key可以不存在外,前面的key必须存在,否则会报错key "xxx" not known in dictionary。

    remove

    dict remove dictValue ?key ...?
    

    返回一个新的字典,字典包括键为key以外的所有dictValue中的键值对。如果不指定任何键则返回的字典与dictValue相同,如果key不在dictValue中,则不进行任何操作。

    size

    dict size dictValue

    返回dictValue中键值对的数量,不包括值中嵌套的字典中的键值对。

    merge

    dict merge ?dictValue ...?

     返回一个新的字典,包含dictValue中的所有元素,多个dictValue具有相同的key的元素的时,最后一次出现的key对应的值会出现在新的字典中。

    info

    dict info dictValue

    返回字典信息,信息的具体格式取决于字典的实现方式。由于字典是散列表实现的,所以放回结果类似于array statistics命令。

    with

    dict with dictName ?key ...? body

    与update类似,使用dictName中key对应的值执行body中的脚本。如果key为多个表示嵌套字典的键路径,此时会使用键路径对应的字典执行body中的脚本。字典中key对应的值会映射到与key同名的变量中。与dict update一样,如果dictName不可读或者字典调整导致键路径没有对应的值,则会静默丢弃字典的更新。除非发成异常,否则dict with的结果是body的执行结果。建议只在本地作用域内使用此命令,因为dict with命令中的变量在命令完成后,除非显示的执行unset,否则仍然存在。此外,只有当body终止时,才会更改dictName中的内容。当body终止时如果dictName不是字典则会产生错误。因此当字典中的键与字典变量dictName有冲突时不建议使用此命令。

    for

     dict for {keyName valueName} dictValue body

    用于遍历字典dictValue,在执行body中脚本时,字典中每个键值对的键和值会分别分配给名为指定的keyName和valueName变量。dict for命令的结果为空字符串。当在body执行过程中遇到break时,会中止循环,结束dict for命令。当遇到continue命令时,会结束本轮循环。字典按键值对的插入顺序进行遍历。

    filter

    dict filter dictValue filterType arg ?arg ...?

    返回一个新的与指定过滤类型匹配的键值对的字典。filterType支持三种类型:

    key

     dict filter dictValue key ?globPattern ...?

     返回以stirng match的方式键与模式globPattern匹配的键值对。

    value

    dict filter dictValue value ?globPattern ...?

    返回以stirng match的方式值与模式globPattern匹配的键值对。

    script

     dict filter dictValue script {keyName valueName} script

    通过将键赋值给变量keyName,值赋值给变量valueName,根据srcipt脚本的布尔值结果来确定键值对是否匹配。当脚本结果为true时,表示键值对匹配。字典按键值对的插入顺序进行遍历。当在srcipt执行过程中遇到break时,会中止循环,结束dict filter命令。当遇到continue命令时,会结束本轮循环。

    map

    dict map {keyName valueName} dictValue body

    Tcl8.6新增的命令。此命令通过执行body中的命令,对字典dictValue中的键值进行转换,然后返回一个新的包含转换后的键值对的字典。名为keyName、valueName对应于dictValue中键值对的键与值。每次body执行完后,变量keyName、valueName的值即为新字典的键值。当在body执行过程中遇到break时,会中止循环,结束dict map命令。当遇到continue命令时,会结束本轮循环。另外要注意的是,如果不想对值做改变,需要对其进行显示的set操作,否则值会被设置为body中最后一个命令的返回值。

    简单示例

    set dic [dict create a 1 b 2 c 3]
    dict append dic ab 4 5
    dict append dic a 6
    dict append dic ab
    dict exists $dic a
    dict get $dic b
    dict incr dic a
    dict incr dic a 2
    dict lappend dic a
    dict lappend dic a 1
    dict lappend dic e
    dict lappend dic e 1 2 3 4 5
    dict keys $dic
    dict keys $dic a*
    dict set dic a 19 2
    dict set dic f g h 8
    dict unset dic i
    dict unset dic f g h
    dict unset dic f h
    dict size $dic
    dic update dic a varA b varB h varH { dict set varA 19 3;incr varB;set varH "H" }
    puts $dic
    puts $varA
    set newDic [dict replace $dic a 1 b 2 d 4]
    puts $newDic
    puts $dic
    set newDic [dict remove $dic a e g]
    puts $newDic
    puts $dic
    dict values $dic
    dict values $dic 3
    dict values $dic 4*
    dict remove $dic a e i
    puts $newDic
    puts $dic
    set newDic [dict merge {a 1 b 2} {c 3 d 4 b 5}]
    puts $newDic
    dict info $dic
    dict with dic a { incr 19;puts $19;}
    puts $dic
    dict for {k v} $dic {puts "$k--$v";}
    dict filter $dic key a*
    dict filter $dic value 4*
    dict filter $dic script {k v} { expr { $k < "e"} }
    dict map { k v } $dic { set k $k$k; set v $v;}
    dict map { k v } $dic { set k $k$k;}
    展开全文
  • python之Dict操作(中)

    千次阅读 2019-10-17 16:07:19
    文章目录python之Dict操作(中)6. Dict更新1) 更新指定key的value7. Dict查找1) 获取value的最大值/最小值2) 获取指定key的value3) 获取键值对列表4) 获取key列表5) 获取value列表6) 从字典中提取符合条件的子集8. ...

    python之Dict操作(中)

    6. Dict更新

    1) 更新指定key的value

    Dict更新指定key对应的value
    推荐写法: 使用方括号dict1[key]=value直接更新,指定键和值

    • 若key已存在,则会修改相应的值,若key不存在,则添加元素
    • 性能比update函数高
    dict1 = {"one": 1, "two": 2, "three": 3}
    
    dict1["one"] = 111
    print(dict1)  # {'one': 111, 'two': 2, 'three': 3}
    
    dict1["four"] = 4
    print(dict1)  # {'one': 111, 'two': 2, 'three': 3, 'four': 4}
    

    一般写法: 使用Python3的标准库,dict类内置函数:update([other]),other指代一个字典对象或一个键值对的迭代

    • 若key已存在,则会修改相应的值,若key不存在,则添加元素
    • 性能比直接赋值低
    dict1 = {"one": 1, "two": 2, "three": 3}
    
    # 通过关键字形式的参数更新
    dict1.update(one=111)
    print(dict1)  # {'one': 111, 'two': 2, 'three': 3}
    
    # 通过元组列表参数更新
    dict1.update([("two", 222)])
    print(dict1)  # {'one': 111, 'two': 222, 'three': 3}
    
    # 通过字典参数更新
    dict1.update({"three": 333})
    print(dict1)  # {'one': 111, 'two': 222, 'three': 333}
    
    # 可以使用以上任意方法添加一个键值对
    dict1.update(four=4)
    print(dict1)  # {'one': 111, 'two': 222, 'three': 333, 'four': 4}
    

    7. Dict查找

    1) 获取value的最大值/最小值

    获取value的最大值/最小值
    推荐写法: 使用Python3的标准库,内置函数:max/min(iterable, *[, key, default])和zip(*iterables)

    • 返回value的最大值/最小值及其对应的key构成的元组
    dict1 = {"a": 123, "b": 321, "c": 200}
    
    # 获取max value及其对应的key
    max_tuple = max(zip(dict1.values(), dict1.keys()))
    print(max_tuple)  # (321, 'b')
    
    # 获取min value及其对应的key
    min_tuple = min(zip(dict1.values(), dict1.keys()))
    print(min_tuple)  # (123, 'a')
    

    一般写法: 使用Python3的标准库,内置函数:max/min(iterable, *[, key, default])

    • 获取value的最大值/最小值对应的key,再根据key获取对应的value
    dict1 = {"a": 123, "b": 321, "c": 200}
    
    # 在一个字典上执行普通的数学运算,它们仅仅作用于键,而不是值
    max_key = max(dict1)
    print(max_key)  # 返回key的最大值 'c'
    
    # 获取最大值对应的键
    max_value_key = max(dict1, key=lambda k: dict1[k])
    print(max_value_key)  # 'b'
     
    # 根据键获取对应的值
    max_value = dict1[max_key]
    print(max_value)  # 321
    

    2) 获取指定key的value

    获取指定key的value
    推荐写法: 使用Python3的标准库,dict类内置函数:get(key[, default]),key指定键,default是可选参数

    • default指定默认返回值
    • 若key已存在,则返回其对应的值,default不生效
    • 若key不存在,若给定default返回值,则返回该值,否则返回None
    • 所以该方法永远不会引发KeyError
    dict1 = {"one": 1, "two": 2, "three": 3}
    
    value = dict1.get("one", 111)
    print(value)  # key"one"存在 default不生效 1
    
    none_value = dict1.get("four")
    print(none_value)  # key"four"不存在 None
    
    default_value = dict1.get("four", 4)
    print(default_value)  # key"four"不存在 返回default给定值 4
    

    一般写法: 使用方括号dict1[key]直接获取,指定键

    • 若key已存在,则返回其对应的值
    • 若key不存在,则抛出KeyError
    dict1 = {"one": 1, "two": 2, "three": 3}
    
    value = dict1["one"]
    print(value)  # 1
    
    none_value = dict1["four"]  # key"four"不存在 抛出KeyError: 'four'
    

    3) 获取键值对列表

    获取(键, 值)元组列表动态视图
    推荐写法: 使用Python3的标准库,dict类内置函数:items()

    • 返回Dict键值对的视图对象,当Dict更改时,会动态反映这些变化
    dict1 = {"one": 1, "two": 2, "three": 3}
    
    items = dict1.items()
    print(items)  # dict_items([('one', 1), ('two', 2), ('three', 3)])
    
    dict1.clear()
    print(items)  # dict_items([])
    

    4) 获取key列表

    获取key列表动态视图
    推荐写法: 使用Python3的标准库,dict类内置函数:keys()

    • 返回Dict键的视图对象,当Dict更改时,会动态反映这些变化
    dict1 = {"one": 1, "two": 2, "three": 3}
    
    keys = dict1.keys()
    print(keys)  # dict_keys(['one', 'two', 'three'])
    
    dict1.clear()
    print(keys)  # dict_keys([])
    

    5) 获取value列表

    获取value列表动态视图
    推荐写法: 使用Python3的标准库,dict类内置函数:values()

    • 返回Dict值的视图对象,当Dict更改时,会动态反映这些变化
    dict1 = {"one": 1, "two": 2, "three": 3}
    
    values = dict1.values()
    print(values)  # dict_values([1, 2, 3])
    
    dict1.clear()
    print(values)  # dict_values([])
    

    6) 从字典中提取符合条件的子集

    从字典中过滤/映射符合条件的Dict
    推荐写法: 使用推导式

    prices = {
    "a": 45.23,
    "b": 612.78,
    "c": 205.55,
    "d": 37.20,
    "e": 10.75
    }
    
    # ---过滤---
    # 1. 获取value>200的键值对构成的字典
    dict1 = {key: value for key, value in prices.items() if value > 200}
    print(dict1)  # {'b': 612.78, 'c': 205.55}
    
    # 2. 获取names中的key对应的键值对构成的字典
    names = {"d", "e"}
    
    # 以下方法1,2都可以满足要求,但运行时间测试结果显示,方法2比方法1所花费的时间更多。
    # 方法1
    dict2 = {key: value for key, value in prices.items() if key in names}
    print(dict2)  # {'d': 37.2, 'e': 10.75}
    
    # 方法2
    dict3 = {key: prices[key] for key in prices.keys() & names}
    print(dict3)  # {'d': 37.2, 'e': 10.75}
    
    # ---映射---
    # 1. 将value转换成整数
    dict4 = {key: int(value) for key, value in prices.items()}
    print(dict4)  # {'a': 45, 'b': 612, 'c': 205, 'd': 37, 'e': 10}
    

    8. Dict判断

    1) 判断key是否在字典中

    判断key是否在字典中
    推荐写法: 使用运算符“in”

    • 对大小写敏感
    if key in dict1:
    	"""do something"""
    if key not in dict1:
    	"""do something"""
    	
    dict1 = {"one": 1, "two": 2, "three": 3}
    print("one" in dict1)  # True
    print("one" not in dict1)  # False
    print("One" in dict1)  # False
    

    9. Dict排序

    1) 根据key对字典排序

    根据key,对字典进行排序
    推荐写法: 使用Python3的标准库,内置函数:sorted(iterable[, key=None[, reverse=False]),key和reverse是可选参数

    • 返回一个排序列表
    • iterable用于指定一个可迭代对象,这里是一个字典实例
    • key用于指定排序规则,默认是None,语法是key=lambda elem:xxx
    • reverse用于指定排序方向,默认是升序,语法是reverse=False/True
    dict1 = {"a": 3, "c": 1, "b": 2}
    
    # item指代(键,值)元组,item[0]是键, item[1]是值
    # 正序
    dict_sorted = sorted(dict1.items(), key=lambda item: item[0])
    print(dict_sorted)  # [('a', 3), ('b', 2), ('c', 1)]
    
    # 逆序
    dict_sorted_rev = sorted(dict1.items(), key=lambda item: item[0], reverse=True)
    print(dict_sorted_rev)  # [('c', 1), ('b', 2), ('a', 3)]
    
    # ------
    # 注意:sorted(dict1)默认是对key排序,而不是对整个字典
    sorted1 = sorted(dict1)
    print(sorted1)  # ['a', 'b', 'c']
    

    2) 根据key对value排序

    根据字典的键,对值进行排序
    推荐写法

    • 先使用内置函数sorted,根据key对字典排序
    • 再使用推导式,获取value列表
    • 关于sorted函数的用法,参看章节“根据key对字典排序”
    dict1 = {"a": 3, "c": 1, "b": 2}
    
    list1 = sorted(dict1.items(), key=lambda item: item[0])
    print(list1)  # 根据key对字典排序 [('a', 3), ('b', 2), ('c', 1)]
    
    list2 = [value for key, value in list1]
    print(list2)  # [3, 2, 1]
    

    推荐写法

    • 先使用内置函数sorted,对字典的键列表排序
    • 再使用推导式,获取key对应的value
    dict1 = {"a": 3, "c": 1, "b": 2}
    keys = sorted(dict1.keys())
    list1 = [dict1[k] for k in keys]
    print(list1)  # [3, 2, 1]
    

    推荐写法

    • 先使用内置函数sorted,对字典的键列表排序
    • 再使用内置函数map,获取key对应的value
    • 由于Python3.x版本中,map函数的返回一个迭代器(Python2.x版本中map返回一个列表),需要使用内置类list(iterable)进行转换
    dict1 = {"a": 3, "c": 1, "b": 2}
    keys = sorted(dict1.keys())
    list1 = list(map(dict1.get, keys))
    print(list1)  # [3, 2, 1]
    

    3) 根据value对字典排序

    根据value,对字典进行排序
    推荐写法: 使用Python3的标准库,内置函数:sorted(iterable[, key=None[, reverse=False]),key和reverse是可选参数

    • 用法同上
    dict1 = {"a": 3, "c": 1, "b": 2}
    
    # item指代(键,值)元组,item[0]是键, item[1]是值
    # 正序
    dict_sorted = sorted(dict1.items(), key=lambda item: item[1])
    print(dict_sorted)  # [('c', 1), ('b', 2), ('a', 3)]
    
    # 逆序
    dict_sorted_rev = sorted(dict1.items(), key=lambda item: item[1], reverse=True)
    print(dict_sorted_rev)  # [('a', 3), ('b', 2), ('c', 1)]
    

    4) 根据某个key对应的value对字典列表排序

    根据字典中某个key对应的value,对字典列表进行排序
    *推荐写法: 使用Python3的标准库,operator模块的类:itemgetter(keys)

    • 需要导入operator模块的itemgetter
    • keys用于指定键,接受多个key参数,多个参数使用逗号”,“隔开
    from operator import itemgetter
    
    stu = [
    	{"id": 3, "name": "Tom", "score": 82},
    	{"id": 2, "name": "Jerry", "score": 67},
    	{"id": 1, "name": "Pig", "score": 82},
    	{"id": 4, "name": "Dog", "score": 98},
    ]
    # 根据key"score"对应的value 对stu正序排序
    '''
    [{'id': 2, 'name': 'Jerry', 'score': 67},
    {'id': 3, 'name': 'Tom', 'score': 82},
    {'id': 1, 'name': 'Pig', 'score': 82},
    {'id': 4, 'name': 'Dog', 'score': 98}]
    '''
    
    sorted_by_score = sorted(stu, key=itemgetter("score"))
    print(sorted_by_score)
    
    # 根据key"score"对应的value 对stu逆序排序
    '''
    [{'id': 4, 'name': 'Dog', 'score': 98},
    {'id': 3, 'name': 'Tom', 'score': 82},
    {'id': 1, 'name': 'Pig', 'score': 82},
    {'id': 2, 'name': 'Jerry', 'score': 67}]
    '''
    sorted_by_score_rev = sorted(stu, key=itemgetter("score"), reverse=True)
    print(sorted_by_score_rev)
    
    # 根据key"score"和"id" 对stu正序排序(先根据"score"排序,"score"相同的情况下根据"id"排序)
    '''
    [{'id': 2, 'name': 'Jerry', 'score': 67},
    {'id': 1, 'name': 'Pig', 'score': 82},
    {'id': 3, 'name': 'Tom', 'score': 82},
    {'id': 4, 'name': 'Dog', 'score': 98}]
    '''
    rows_by_score_id = sorted(stu, key=itemgetter("score", "id"))
    print(rows_by_score_id)
    

    *推荐写法: 使用Python3的标准库,内置函数:sorted(iterable, , key=None, reverse=False)

    • 接受多个key参数,多个参数使用逗号”,“隔开
    展开全文
  • 参考链接: torch.nn.Module.load_state_dict(state_dict, strict=True)
  • dict常见方法

    千次阅读 2019-08-26 09:32:20
    1> str(dict) 输出字典可以打印的字符串表示, 将字典转化为字符串输出 d6 = { 'Year' : 2018 , 'Month' : 3 , 'Day' : 18 } content = str ( d6 ) print ( content ) 打印结果:{ 'Year'...
  • Python字典(dict)详解

    千次阅读 2020-07-19 22:32:29
    字典(dict)的概念:二.字典(dict)的定义:1.一般格式:2.空字典:3.举例:注意:三.字典(dict)的一些基本操作:1.增:2.删:3.查:4.改:四.字典(dict)的常见操作:五.字典三种取值方式:1.value=字典名[key]:2.setdefault:3.get:...
  • 模态字典(state_dict)的保存(model是一个网络结构类的对象) 1.1)仅保存学习到的参数 1.2)加载model.state_dict 2.1)保存整个model的状态 2.2)加载整个model的状态 如何仅加载某一层的训练的到的参数(某一层的...
  • 一、关于dict()函数 二、代码(结果) 一、关于dict()函数 1.详情看网址:https://mail.python.org/pipermail/python-dev/2016-September/146327.html 2.3.6版本的Python已经使得dict变得紧凑以及关键字变得有序 ...
  • Python dict()函数

    千次阅读 多人点赞 2019-10-24 17:41:42
    dict 函数,用于创建一个新的字典(dictionary),返回一个新的字典 语法:dict(key/value) 参数说明:key/value -- 用于创建字典的键/值对,可以表示键/值对的方法有很多。 用法: dict0 = dict() # 1、传一个...
  • 之前一直不太搞明白浅拷贝和赋值、深拷贝到底有什么区别,直到被pytorch的model.state_dict()给坑了 今天在和实验室同学讨论联邦学习框架代码的时候,终于明白了他们之间的区别,这里做个记录。
  • pytorch 状态字典:state_dict

    千次阅读 2019-01-24 11:24:38
    pytorch 中的 state_dict 是一个简单的python的字典对象,将每一层与它的对应参数建立映射关系.(如model的每一层的weights及偏置等等) (注意,只有那些参数可以训练的layer才会被保存到模型的state_dict中,如卷积层,...
  • Redis源码分析(dict

    千次阅读 2017-11-07 14:35:08
    一、dict 简介dict (dictionary 字典),通常的存储结构是Key-Value形式的,通过Hash函数对key求Hash值来确定Value的位置,因此也叫Hash表,是一种用来解决算法中查找问题的数据结构,默认的算法复杂度接近O(1),...
  • Python - Dict(字典)

    千次阅读 2019-03-01 15:01:33
    目录 字典的创建 字典的访问 ( List转换 ) 字典的遍历 字典的添加 字典的合并 字典的删除(清空) 字典的其他操作 实例(字符频率统计) 字符串转字典(eval) ...字典的创建方式dict1 = { ...
  • python dict常用

    千次阅读 2017-12-14 20:31:18
    本文主要是python中dict常用的方法: list 转化为 dict dict遍历删除指定条件的元素 dict安装key或者value排序 dict的value统计计数 两个list转化为dictdef lst_2_dict(): """ combine two list to dict ...
  • dict的一些用法

    千次阅读 2018-10-16 12:16:04
    (1) dict2 = dict1  如果你修改a,那你就同时修改了b,因为它们指向同一个列表: >>> a = {'f': 1, 'b':2, 'c':[1, 2]} >>> b = a >>> a['f'] = 3 >>> print a {'f': 3, 'b':2, 'c':[1, 2]} >>> print b {'f'...
  • 简介:pandas 中的to_dict 可以对DataFrame类型的数据进行转换 可以选择六种的转换类型,分别对应于参数 ‘dict’, ‘list’, ‘series’, ‘split’, ‘records’, ‘index’,下面逐一介绍每种的用法 Help on ...
  • 什么?python dict字典有序了?!

    千次阅读 2020-07-30 11:53:26
    从python3.6开始,dict的插入变为有序,即字典整体变的有序; 而之前的版本,比如python2.7,对于字典的插入是乱序的,即插入a,b,c,返回结果顺序可能是a,c,b。 文章目录 结论 ~~太长不看系列~~ 背景 基础知识 什么...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 510,180
精华内容 204,072
关键字:

dict