精华内容
下载资源
问答
  • 这篇文章的内容主要包括:抽象mapping基类字典的构造方法字典中的细节和技巧为什么字典的效率高——散列表的原理抽象mapping基类dict对象在python中属于mapping对象,且目前仅有的一种标准映射类型。这类对象...

    字典这个数据结构活跃活跃在所有的Python程序背后,即使源码里没有直接用到他。

    ——《代码之美》

    很久没写python的文章啦,这次讲一讲Python中很重要的模块,dict。这篇文章的内容主要包括:抽象mapping基类

    字典的构造方法

    字典中的细节和技巧

    为什么字典的效率高——散列表的原理

    抽象mapping基类

    dict对象在python中属于mapping对象,且是目前仅有的一种标准映射类型。这类对象被定义为支持任意键查找并实现了Mapping或MutableMapping抽象基类中所规定方法的容器对象。而Mapping和MutableMapping则在collections.abc模块中被定义(python 3.2之后)。抽象基类的并不会实际被继承,而是会作为一个形式化文档,定义了构建某个类型所需要的最基本的接口。同时支持isinstance 方法来判断某个映射是否属于广义映射类型。例如:

    >>> from collections.abc import Mapping

    >>> a=dict()

    >>> isinstance(a,Mapping)

    True

    >>>

    Mapping类直接继承自Collections, 包含的方法包括:__contains__,keys,items,values,get,__eq__, and__ne__

    MutableMapping 类则继承自Mapping类,除包含所有的Mapping类中的方法外,还包括:

    pop,popitem,clear,update,和setdefault

    字典的构造方法

    字典可以通过花括号内包含的key: value对进行创建,例如:{4098:'jack',4127:'sjoerd'}。也可以通过dict构造器来创建。

    dict 构造器的包括一个可选的位置参数和可以为空的关键字参数。位置参数可以为空,此时将创建一个空的字典,否则则需要是mapping类型或者iterable类型。构造器将首先根据位置参数创建一个字典,并在创建完成后将关键字参数中的关键字作为key,对应的值作为value加入到创建完成的字典中。

    以下是几个例子:

    不使用位置参数,直接使用关键字参数进行创建:

    a = dict(one=1, two=2, three=3)

    使用花括号进行创建:

    b = {'one': 1, 'two': 2, 'three': 3}

    使用可迭代类型zip进行创建:

    c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))

    使用可迭代类型list进行创建:

    d = dict([('two', 2), ('one', 1), ('three', 3)])

    使用映射类型dict进行创建:

    e = dict({'three': 3, 'one': 1, 'two': 2})

    以上5种方法生成的dict是相等的,同时需要注意,当位置参数为iterable对象时,每一项本身必须时恰好包含两个元素的iterable对象,如c, d的这两种生成方式。

    同时,和list类似,dict本身也有字典推导的方法来生成,如果熟悉列表推导,这种方法就相当好理解,例如:

    f={i:str(i) for i in range(10)}

    字典中的细节和技巧

    字典中键的顺序

    在3.7 版本之后,字典类型将会保留插入的顺序,同时对键值的更新不会影响顺序。删除并再次添加的键将被插入到末尾。在之前的版本中则不保证顺序,不过可以使用OrderedDict.

    如何判断两个字典是否相等

    两个字典是否相等可以通过'=='比较,当且仅当他们具有完全相同的(键:值)时才成立,在比较的过程中不会考虑顺序。需要注意的是,在使用视图对象dict.values()进行相等性判断时,总是返回False,即使这两个values()来自同一个dict.

    什么是字典视图

    由dict.keys(), dict.values(), dict.items()返回的对象是视图对象,他们将分别返回键,值,(键,值)的视图。当字典改变时,视图也会发生相应改变。视图对象支持迭代,成员检测,但无法通过改变视图对象来操纵字典。

    需要注意的是,在添加或删除字典中的条目期间对视图进行迭代可能引发

    dict.keys()所返回的视图类似集合,抽象基类collections.abc.set中定义的所有操作都是有效的。例如:

    >>> dishes = {'eggs': 2, 'sausage': 1, 'bacon': 1, 'spam': 500}

    >>> keys = dishes.keys()

    >>> keys & {'eggs', 'bacon', 'salad'}

    {'eggs','bacon'}

    字典是可逆的吗

    在3.8版本之后字典视图和字典都是可逆的,可以通过reversed关键字返回字典,字典视图的逆序。对字典进行逆序时,将返回键的逆序的迭代器。

    从字典中删除项

    使用 del d[key] 可以将d[key]从d中移除,如果d中不存在key时则会引发KeyError。

    如果想要不返回KeyError则可以使用 pop(key [, default]),这个操作相比于del 不同在于会返回被删除的值,同时如果default被指定且key不存在d中时不会报错,而会返回default.

    popitem()将从字典中删除一个(键,值)对,在python 3.7 之后的版本键值将按照LIFO的顺序进行返回,在之前的版本则会返回一个任意的键值对。

    字典中的默认值

    在字典中指定默认值可以减少插入时的查找次数,很多方法都可以指定默认值,例如:get(key[,default]), setdefault(key[,default]), pop(key[,default]) ,分别用于获取,设置,删除值,当key不存在且指定了default时,将不会返回KeyError,而是返回默认值。这可以使得在操作前不用提前判断key是否在dict中,从而减少一次查找。

    同时,在自定义的映射类型中,也可以通过__missing__来设置默认值来处理找不到键的情况,这个方法更加灵活。

    更新多个键值对

    使用d[key]=value的方式可以更新一个键值对,如果想更新多个键值对则可以使用update函数,这个方法将更新另一个mapping对象或者dict对象中的所有键值对,或者使用关键字参数。

    为什么字典的效率高——散列表的原理

    字典和集合是python中出现次数非常高的数据结构,本身经过了高度的优化,主要基于散列表的方法。可以这样认为,如果程序包含磁盘I/O,则一个存储在内存中的任意大小的字典或集合的查询操作所需要的时间都是可以忽略不记的。

    散列表本身是一个稀疏的数组,在dict中,每一个键值对都占用一个表元,表元大小一致,内部包含的是对键值的分别引用。表元的大小一致决定了散列表本身能够通过偏移量来读取某个表元。

    Python会设法保证大概1/3的表元是空的,这样设计来保证散列表的冲突概率降低。即使有数百万个元素的dict,整个搜索平均的冲突次数可能仅有1-2次。当这个阈值到达时,原来的散列表会被复制到更大的空间里。这个复制的过程不保证顺序,所以当使用视图迭代时,可能会因为插入操作而改变顺序,导致部分值无法被遍历或者runtime error.

    python 内置的hash()方法可以用于所有的内置类型对象,如果是自定义类型的话,这个过程调用的则是__hash__ 方法,如果两个对象在比较时是相等的,那么他们的hash值也需要是相等的。例如 hash(1)==hash(1.0) 即使这两个数字一个是整型一个是浮点型。这也表明,使用d[1], 和d[1.0]将返回的是同一个value.

    如果一个类没有定义x.__hash__()会返回一个恰当的值以确保x==y同时意味着x is y且hash(x)==hash(y)

    从Python 3.3开始str, bytes, datetime过程包含了加盐的步骤,所加的盐值是python进程中的一个常量,但每次启动python解释器都会生成不同的盐值。

    由于字典使用了散列表,且保证了散列表的稀疏性,字典本身占用的空间较大,因此如果是数量巨大的记录,使用元组或者具名元组将占用更少的空间,这部分的优化主要用于生产环境。

    展开全文
  • 前面这几天写关于描述器的博客,了解描述器的机制的时候,翻了很多博客里面都提到了__dict__, 我想更多的了解一点描述器的...python __dict__存储了该对象的一些属性类和实例分别拥有自己的__dict____i...

    写在前面

    这几天在写关于描述器的博客,在了解描述器的机制的时候,翻了很多博客里面都提到了__dict__, 我想更多的了解一点描述器的机制,所以我得先弄清楚这个__dict__到底是干啥的。

    计算机语言学的越久,越是觉得各个知识点之间都有着千丝万缕的关系。

    1. __dict__ 有什么用?基本定义是啥?

    python 中__dict__存储了该对象的一些属性

    类和实例分别拥有自己的__dict__

    在__init__中声明的变量,会存到实例的__dict__中

    2.举个例子

    类的静态函数、类函数、普通函数、全局变量以及一些内置的属性都是放在类__dict__里的

    3.Python里哪些没有__dict__属性

    虽然说一切皆对象,但对象也有不同,就好比不是每个人的女朋友都是一个人一样,一些内置的数据类型是没有__dict__属性的

    int, list, dict等这些常用的数据类型是没有__dict__属性的,其实这是可预料的,就算给了它们dict属性也没啥用,毕竟它们只是用来做数据容器的。

    4.有继承关系的时候,来看看各自的__dict__

    参考:

    https://www.cnblogs.com/alvin2010/p/9102344.html

    https://www.jianshu.com/p/cf8450b4b537

    展开全文
  • 在python中写中文注释会报错,这时只要在头部加上# coding=gbk即可#字典的添加、删除、修改操作dict = {"a" : "apple", "b" : "banana", "g" : "grape", "o" : "orange"}dict["w"] = "watermelon"...

    python3.0以上,print函数应为print(),不存在dict.iteritems()这个函数。

    在python中写中文注释会报错,这时只要在头部加上# coding=gbk即可

    #字典的添加、删除、修改操作

    dict = {"a" : "apple", "b" : "banana", "g" : "grape", "o" : "orange"}

    dict["w"] = "watermelon"

    del(dict["a"])

    dict["g"] = "grapefruit"

    print dict.pop("b")

    print dict

    dict.clear()

    print dict

    #字典的遍历

    dict = {"a" : "apple", "b" : "banana", "g" : "grape", "o" : "orange"}

    for k in dict:

    print "dict[%s] =" % k,dict[k]

    #字典items()的使用

    dict = {"a" : "apple", "b" : "banana", "c" : "grape", "d" : "orange"}

    #每个元素是一个key和value组成的元组,以列表的方式输出

    print dict.items()

    #调用items()实现字典的遍历

    dict = {"a" : "apple", "b" : "banana", "g" : "grape", "o" : "orange"}

    for (k, v) in dict.items():

    print "dict[%s] =" % k, v

    #调用iteritems()实现字典的遍历

    dict = {"a" : "apple", "b" : "banana", "c" : "grape", "d" : "orange"}

    print dict.iteritems()

    for k, v in dict.iteritems():

    print "dict[%s] =" % k, v

    for (k, v) in zip(dict.iterkeys(), dict.itervalues()):

    print "dict[%s] =" % k, v

    #使用列表、字典作为字典的值

    dict = {"a" : ("apple",), "bo" : {"b" : "banana", "o" : "orange"}, "g" : ["grape","grapefruit"]}

    print dict["a"]

    print dict["a"][0]

    print dict["bo"]

    print dict["bo"]["o"]

    print dict["g"]

    print dict["g"][1]

    dict = {"a" : "apple", "b" : "banana", "c" : "grape", "d" : "orange"}

    #输出key的列表

    print dict.keys()

    #输出value的列表

    print dict.values()

    #每个元素是一个key和value组成的元组,以列表的方式输出

    print dict.items()

    dict = {"a" : "apple", "b" : "banana", "c" : "grape", "d" : "orange"}

    it = dict.iteritems()

    print it

    #字典中元素的获取方法

    dict = {"a" : "apple", "b" : "banana", "c" : "grape", "d" : "orange"}

    print dict

    print dict.get("c", "apple")

    print dict.get("e", "apple")

    #get()的等价语句

    D = {"key1" : "value1", "key2" : "value2"}

    if "key1" in D:

    print D["key1"]

    else:

    print "None"

    #字典的更新

    dict = {"a" : "apple", "b" : "banana"}

    print dict

    dict2 = {"c" : "grape", "d" : "orange"}

    dict.update(dict2)

    print dict

    #udpate()的等价语句

    D = {"key1" : "value1", "key2" : "value2"}

    E = {"key3" : "value3", "key4" : "value4"}

    for k in E:

    D[k] = E[k]

    print D

    #字典E中含有字典D中的key

    D = {"key1" : "value1", "key2" : "value2"}

    E = {"key2" : "value3", "key4" : "value4"}

    for k in E:

    D[k] = E[k]

    print D

    #设置默认值

    dict = {}

    dict.setdefault("a")

    print dict

    dict["a"] = "apple"

    dict.setdefault("a","default")

    print dict

    #调用sorted()排序

    dict = {"a" : "apple", "b" : "grape", "c" : "orange", "d" : "banana"}

    print dict

    #按照key排序

    print sorted(dict.items(), key=lambda d: d[0])

    #按照value排序

    print sorted(dict.items(), key=lambda d: d[1])

    #字典的浅拷贝

    dict = {"a" : "apple", "b" : "grape"}

    dict2 = {"c" : "orange", "d" : "banana"}

    dict2 = dict.copy()

    print dict2

    #字典的深拷贝

    import copy

    dict = {"a" : "apple", "b" : {"g" : "grape","o" : "orange"}}

    dict2 = copy.deepcopy(dict)

    dict3 = copy.copy(dict)

    dict2["b"]["g"] = "orange"

    print dict

    dict3["b"]["g"] = "orange"

    print dict

    补充:

    1 初始化

    >>> d = dict(name='visaya', age=20)

    >>> d = dict(zip(['name', 'age'], ['visaya', 20]))

    #dict.fromkeys(listkeys, default=0) 把listkeys中的元素作为key均赋值为value,默认为0

    >>> d = dict.fromkeys(['a', 'b'], 1)

    >>> d

    {'a': 1, 'b': 1}

    2 字典视图和几何

    dict.keys()类似信使可以进行交集和并集等集合操作(类似集合,因为不存在重复的项),但dict.values()不可以进行如上操作。

    >>> k = d.keys()

    >>> k

    dict_keys(['a', 'b'])

    >>> list(k)

    ['a', 'b']

    >>> k | {'x': 3}

    {'a', 'x', 'b'}

    >>> k | {'x'}

    {'a', 'x', 'b'}

    >>> k | {'x', 'y'}

    {'a', 'y', 'b', 'x'}

    >>> k & {'x'}

    set()

    >>> v = d.values()

    >>> v

    dict_values([1, 2])

    >>> v | {'x'}

    Traceback (most recent call last):

    File "", line 1, in

    TypeError: unsupported operand type(s) for |: 'dict_values' and 'set'

    3 排序字典键

    两种方法:

    3.1 sort:

    >>> Ks = list(d.keys())

    >>> Ks.sort()

    >>> for k in Ks:

    ...     print(k, d[k])

    ...

    a 1

    b 2

    3.2 sorted:

    >>> for k in sorted(d.keys()):

    ...     print(k, d[k])

    ...

    a 1

    b 2

    3.3 注意

    >>> for k in list(d.keys()).sort():

    ...     print(k, d[k])

    ...

    Traceback (most recent call last):

    File "", line 1, in

    TypeError: 'NoneType' object is not iterable

    出错原因:

    list.sort() list.append()函数都是对自身的操作,没有返回值,故需先将list(d.keys())的结果保存下来,在结果上进行sort()

    4 常用函数

    4.1 get()

    D.get(k[, d])   => D[k] if k in D else d. d defaults to none.

    4.2 pop()

    D.pop(value[, d])   => Remove specified key and return the

    corresponding value. If key is not found, d is returned if given,

    otherwise KeyError is raised.

    4.3 udpate()

    D.update(E, **F) -> None.  Update D from dict/iterable E and F.

    If E has a .keys() method, does:     for k in E: D[k] = E[k]

    If E lacks .keys() method, does:     for (k, v) in E: D[k] = v

    In either case, this is followed by: for k in F: D[k] = F[k]

    >>> d = dict(name='visaya', age=21)

    >>> d1= {'age': 20, 'sex': 'male'}

    >>> d2 = zip(['a', 'b'], [1, 2])

    >>> d.update(d1)

    >>> d

    {'age': 20, 'name': 'visaya', 'sex': 'male'}

    #for k in d1: d[k] = d1[k]

    >>> d.update(d2)

    >>> d

    {'age': 20, 'name': 'visaya', 'sex': 'male'}

    #for (k, v) in d2: d[k] = v

    4.4 del()

    del D[key]

    4.5 clear()

    4.6 copy()

    Python中的dict

    初始化

    构造方法创建

    Python代码

    d = dict()

    d = dict(name="nico", age=23)

    d = dict((['name', "nico"], ['age', 23]))

    当然还有更方便,简单的

    Python代码

    d = {}

    d = {"name":"nico", "age":23}

    遍历

    通过对key的遍历,遍历整个dict

    Python代码

    d = {"name":"nico", "age":23}

    for key in d:

    print "key=%s, value=%s" % (key, d[key])

    for key in d.iterkeys():

    print "key=%s, value=%s" % (key, d[key])

    for key in d.keys():

    print "key=%s, value=%s" % (key, d[key])

    for key in iter(d):

    print "key=%s, value=%s" % (key, d[key])

    for key,item in d.items():

    print "key=%s, value=%s" % (key, item)

    当然也可以直接遍历value

    Python代码

    d = {"name":"nico", "age":23}

    for value in d.values():

    print value

    for key,value in d.viewitems():

    print "key=%s, value=%s" % (key, value)

    for value in d.viewvalues():

    print "value=%s" % (value)

    这里values和viewvalues的区别

    后者返回的是该字典的一个view对象,类似数据库中的view,当dict改变时,该view对象也跟着改变

    常用方法

    Python代码

    d = {"name":"nico", "age":23}

    d["name"] = "aaaa"

    d["address"] = "abcdefg...."

    print d   #{'age': 23, 'name': 'aaaa', 'address': 'abcdefg....'}

    获取dict值

    Python代码

    print d["name"]               #nico

    print d.get("name")         #nico

    如果key不在dict中,返回default,没有为None

    Python代码

    print d.get("namex", "aaa")       #aaa

    print d.get("namex")                  #None

    排序sorted()

    Python代码

    d = {"name":"nico", "age":23}

    for key in sorted(d):

    print "key=%s, value=%s" % (key, d[key])

    #key=age, value=23

    #key=name, value=nico

    删除del

    Python代码

    d = {"name":"nico", "age":23}

    Python代码

    del d["name"]

    #如果key不在dict中,抛出KeyError

    del d["names"]

    Python代码

    Traceback (most recent call last):

    File "F:\workspace\project\pydev\src\ddd\ddddd.py", line 64, in

    del d["names"]

    KeyError: 'names'

    清空clear()

    Python代码

    d = {"name":"nico", "age":23}

    d.clear()

    print d                                                    #{}

    copy()

    Python代码

    d1 = d.copy()               #{'age': 23, 'name': 'nico'}

    #使用返回view对象

    d2 = d1.viewitems()    #dict_items([('age', 23), ('name', 'nico')])

    #修改字典d1,新增元素

    d1["cc"] = "aaaaaa"

    print d2

    #dict_items([('cc', 'aaaaaa'), ('age', 23), ('name', 'nico')])

    pop(key[, default])

    如果key在dict中,返回,不在返回default

    Python代码

    #如果key在dict中,返回,不在返回default

    print d.pop("name", "niccco")                #nico

    print d.pop("namezzz", "niccco")           #niccco

    #key不在dict中,且default值也没有,抛出KeyError

    print d.pop("namezzz")                         #此处抛出KeyError

    popitem()

    删除并返回dict中任意的一个(key,value)队,如果字典为空会抛出KeyError

    Python代码

    d = {"name":"nico", "age":23}

    print d.popitem()       #('age', 23)

    print d.popitem()       #('name', 'nico')

    #此时字典d已为空

    print d.popitem()      #此处会抛出KeyError

    update([other])

    将字典other中的元素加到dict中,key重复时将用other中的值覆盖

    Python代码

    d = {"name":"nico", "age":23}

    d2 = {"name":"jack", "abcd":123}

    d.update(d2)

    print d     #{'abcd': 123, 'age': 23, 'name': 'jack'}

    原文出处:http://blog.csdn.net/tianmo2010/article/details/7621424

    展开全文
  • Python内置了字典:dict的支持,dict全称dictionary,其他语言也称为map,使用键-值(key-value)存储,具有极快的查找速度。举个例子,假设要根据同学的名字查找对应的成绩,如果用list实现,需要两个list:names...

    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 "", line 1, in

    KeyError: 'Thomas'

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

    False

    展开全文
  • So many questions here. I see at least two, maybe three:What does pop(a,b) do?/Why are there a second argument?What is *args being used ...The first question is trivially answered in the Python Stand...
  • map()用法map()是python的内置函数,会根据提供的函数对指定序列做映射。语法:map(func, iter, ...)其中func为一个功能函数,iter表示可迭代参数序列。map()将把func作用于参数列表的每个元素上,并返回一个新的list...
  • 这篇文章之我们来了解一下关于python字典之pythonget函数的相关知识,get函数是什么意思,他有什么作用都将会接下来的文章之得到解答。描述Python 字典(Dictionary) get() 函数返回指定键的值,如果值不...
  • ?先说答案,根据代码中的上下文,这里的temp一个字典dict对象,而且它通过for循环每次获取可迭代对象(Iterable)中...下面对几个概念进行介绍可迭代对象(Iterable)Python中可以直接作用于for循环的对象统称为...
  • Python中的keyPython字典中的键。字典另一种可变容器模型,且可存储任意类型对象。字典的每个键值key=>value对用冒号 : 分割,每个键值对之间用逗号 , 分割,整个字典包括花括号 {} 中 ,格式如下所示:d = {...
  • hashable ≈ imutable 可哈希 ≈ 不可变在Python中:list、set和dictionary 都可改变的,比如可以通过list.append(),set.remove(),dict[‘key‘] = value对其进行修改,所以它们都不可哈希的;而tuple和string...
  • Python中的keyPython字典中的键。字典另一种可变容器模型,且可存储任意类型对象。字典的每个键值key=>value对用冒号 : 分割,每个键值对之间用逗号 , 分割,整个字典包括花括号 {} 中 ,格式如下所示:d = {...
  • python中type()是什么意思type()是一个内建的获取变量类型的函数。type()函数有两个用法,当只有一个参数的时候,返回对象的类型。当有三个参数的时候返回一个类对象。语法:type(object)type(name, bases, dict)...
  • python中的set介绍:set:类似dict一组dict的集合,不存储value。本质:无序(没有下标)无重复的元素的集合。1、创建set创建set需要一个list或者tuple或者dict作为输入集合。重复元素色中会被自动过滤。s1=[1,2,...
  • 属性的lookup顺序如下:如果重载了__getattribute__,则调用.a.__dict__, 实例中是不允许有descriptor的,所以不会遇到descriptorA.__dict__, 也即a.__class__.__dict__ .如果遇到了descriptor,优先调用descriptor.沿着...
  • hashable ≈ imutable 可哈希 ≈ 不可变在Python中:list、set和dictionary 都可改变的,比如可以通过list.append(),set.remove(),dict[‘key‘] = value对其进行修改,所以它们都不可哈希的;而tuple和string...
  • 容器(Collections)Python附带一个... 我们将讨论的: - defaultdict - counter - deque - namedtuple - enum.Enum (包含在Python 3.4以上)defaultdict我个人使用defaultdict较多,与dict类型不同,你不需要检查k...
  • 在以下的文章之中我们来了解一下什么是python中的序列化。了解一下python序列化的相关知识,以及python序列化在python编程之中能起到什么样的作用。在程序运行的过程中,所有的变量都在内存中,比如,定义一个dict...
  • 先说答案,根据代码的上下文,这里的temp一个字典dict对象,而且它通过for循环每次获取可迭代对象(Iterable)的一个值.该代码就是每次获取student_infos(字典列表)的每一个字典对象(student_...
  • Python 的字典是Python中一个键值映射的数据结构,下面介绍一下如何优雅的操作字典.1.1 创建字典Python有两种方法可以创建字典,第一种使用花括号,另一种使用内建 函数dict>>> info = {}>>> ...
  • Python字典另一种可变容器模型,且可存储任意类型对象,如字符串、数字、元组等其他容器模型。一、创建字典字典由键和对应值成对组成。字典也被称作关联数组或哈希表。基本语法如下:dict = {'Alice': '2341', '...
  • 容器(Collections)Python附带一个... 我们将讨论的: - defaultdict - counter - deque - namedtuple - enum.Enum (包含在Python 3.4以上)defaultdict我个人使用defaultdict较多,与dict类型不同,你不需要检查k...
  • strncmp函数用法详解_后端开发strncmp函数为字符串比较函数,其函数语法为“int strncmp ( ...描述Python 字典 get() 函数返回指定键的值,如果值不字典返回默认值。语法get()方法语法:dict.get(key, defaul...
  • 前几天看了些python的代码,发现有些函数的参数前带有(*)号,有的甚至有两个(*)号,不清楚它们代表什么意思。 解释 查阅资料后发现,参数前面加上* 号 ,意味着参数的个数不止一个,另外带一个星号(*)参数的...
  • 看django的django.contrib.auth.forms的表单,看到一个字典是这么写的,请问这里出现的下划线是什么意思?我error_messages = dict(SetPasswordForm.error_messages, **{'password_incorrect': _("Your old ...
  • 首先需要知道的,dir()是Python提供的一个API函数,dir()函数会自动寻找一个对象的所有属性,包括搜索__dict__列出的属性。不是所有的对象都有__dict__属性。例如,如果你一个类添加了__slots__属性,那么这...

空空如也

空空如也

1 2 3 4
收藏数 67
精华内容 26
关键字:

在python中dict是什么意思

python 订阅