dict_dictionary - CSDN
  • python--dict方法总结

    千次阅读 2019-08-07 23:41:20
    优点: 1:查找速度快 2:浪费空间 3:key不可以重复,且不可变 4:数据无序排放 注意: 1.任何不可变对象都可用作字典的键,如字符串、数字、元组等 2.包含可变对象的列表、字典和元组...dict {}

    一、为什么使用dict?

    1. 优点

    1:查找速度快
    2:浪费空间
    3:key不可以重复,且不可变
    4:数据无序排放

    2. 特点

    1.任何不可变对象都可用作字典的键,如字符串、数字、元组等
    2.包含可变对象的列表、字典和元组不能用作键
    3.引用不存在的键会引发KeyError异常
    4.value可以是字符,数字,列表,元组,字典

    二、dict的函数使用

    1. 构造

    dict  {}                            #空字典
    dict={key:value}                    #经典定义
    dict2 = dict(x=1,y=2,z=3)           #定义字典另一种方式 //  {'y': 2, 'x': 1, 'z': 3}
    Dict1=dict2                         #浅复制,只是引用而已id(dict1)==id(dict2)
    Dict1=dict2.copy()                  #深复制,2个不同ID的字典id(dict1)!=id(dict2)
    Dict=dict.fromkeys(seq,val=None)    #创建并返回一个新字典,以 seq 中的元素做该字典的键,val 做该字典中所有键对应的初始值(如果不提供此值,则默认为 None)
    dict([container])                   #创 建 字 典 的 工 厂 函 数 。 如 果 提 供 了 容 器 类 (container) 就用其中的条目填充字典,否则就创建一个空字典。
    

    2. 基本操作(增,删,查,改)

    • 增加
    dict[key]=value
    dict.update(dict2)                  #将字典 dict2 的键-值对添加到字典 dict
    result = dict(dict1,**dict2)        #将字典 dict2 的键-值对与字典dict1的键-值对合并为新的dict
    dict.setdefault(key,default=None)   #和方法 set()相似,如果字典中不存在 key 键,由 dict[key]=default 为它赋值。
    
    • 删除
    del d[key]                        #删除指定key
    d.clear()                         #清空字典
    dict.popc(key[, default])         #和方法 get()相似,如果字典中 key 键存在,删除并返回 dict[key],如果 key 键不存在,且没有给出 default 的值,引发 KeyError 异常。
    dict.popitem()                    #随机弹出(key,value)元组 
    
    • 查询
    key in dict                        #判断键(key)是否在字典中存在,是返回 True, 否则返回 False
    a=dict[key]                        #获取指定key的值,如果key不存在,会抛出异常
    dict.get(key,[default])            #如果有这个key,返回value,没有这个key,则赋予默认值
    len(dict)                          #返回映射的长度(键-值对的个数)
    dict.cmp(dict1,dict2)              #比较字典,(优先级为元素个数、键大小、键值大小)  #第一个大返回1,小返回-1,一样返回0 
    dict.items()                       #返回一个包含字典中(键, 值)对元组的列表
    dict.keys()                        #返回一个包含字典中键的列表
    dict.values()                      #返回一个包含字典中所有值的列表
    dict.iter()                        #方法 iteritems(), iterkeys(), itervalues()与它们对应的非迭代方法一样,不同的是它们返回一个迭代子,而不是一个列表。
    dict.iteritems()                   #返回一个dict中(key,value)元组的迭代器对象
    d1 = { 'x':1,'y':2,'z':3 }  //i1 = d1.iteritems() //i1.next()  >>('y', 2)使用next方式遍历每一个元素
    dict.iterkeys()                    #返回dict中key的迭代器对象
    dict.itervalues()                  #返回dict中value的迭代器对象
    dict.viewvalues()                  #返回类似集合方式的字典(值组成)
    d1.viewvalues()    //dict_values([2, 1, 3])
    dict.viewitems()                   #返回类似集合方式的字典(值组成)(key,value)元组组成
    d1.viewitems()     //dict_items([('y', 2), ('x', 1), ('z', 3)])
    dict.viewkeys()                    #返回类似集合方式的字典(键组成)
    d1.viewkeys()      //dict_keys(['y', 'x', 'z'])
    
    • 修改
    d[key] = value
    

    3. 旋转构造

    zip返回元组组成的列表
    zip('xyz','123')                   #[('x', '1'), ('y', '2'), ('z', '3')]对应生成列表
    zip('xyzm','123')                  #[('x', '1'), ('y', '2'), ('z', '3')]多余项被舍弃
    zip('xyz','123','qer')             #[('x', '1', 'q'), ('y', '2', 'e'), ('z', '3', 'r')]        
    dict(zip('xyz','123'))             #{'y': '2', 'x': '1', 'z': '3'}构造字典
    格式化输出字典
    import jsonprint   json.dumps(d,indent=2)     #不同层级以2个空格缩进
    

    4. dict持久化

    先把字典转换成字符串,然后把字符串写入文件,读出来时再把字符串为字典
    写
    import json  
    data = json.dumps(d)with open(f,'wb') as f:
      f.write(data)import json  
    with open(f,'wb') as f:
      data = f.read()
    d = json.loads(data)
    

    5. defaultdict

    from collections import defaultdict
    d=defaultdict(内建函数)
    内建函数有:int(), long(), float(), complex()str(), unicode(), basestring()list(), tuple()type()dict()bool()set(), frozenset()object()classmethod() staticmethod()super()property()file()
    功能:dict中value默认值为内建函数的默认值,且value的类型为内建函数的类型,如果是普通的dict,则对于不存在的key,其value是不存在的,访问会报错,但对于defaultdict,对于不存在的key,其value存在,为内建函数的默认值
    d=defaultdict(lambda:0)          初始化为0
    d=defaultdict(int)               初始值为int()的初始值0
    d=defaultdict(list)              初始值为list()的初始值[]
    d=defaultdict(dict)              初始值为dict()的初始值{}
    

    如有任何问题,欢迎留言.

    展开全文
  • Python中dict详解

    万次阅读 2016-03-25 16:04:00
    #字典的添加、删除、...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()
    #字典的添加、删除、修改操作
    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 "<stdin>", line 1, in <module>
    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 "<stdin>", line 1, in <module>
    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 <module>  
        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'}  


    ======================

    补充知识

    一: dictionary 操作:

         Dictionary:定义了键和值之间一对一的关系,像 Visual Basic 中的 Scripting.Dictionary 对象的实例;像 Java 中的 Hashtable 类的实例;像 Perl 中的 hash (哈希数组)。在 Perl 中,存储哈希值的变量总是以 % 字符开始;在 Python 中,变量可以任意取名,并且 Python 在内部会记录下其数据类型。
         1.定义 Dictionary:
              >>> d = {"server":"mpilgrim", "database":"master"} 

              >>> d
               {'server': 'mpilgrim', 'database': 'master'}
              >>> d["server"]                                    

               'mpilgrim'
              >>> d["database"]                                 

               'master'
        新 dictionary,它有两个元素,将其赋给变量 d 。每一个元素都是一个 key-value 对;整个元素集合用大括号括起来。
    'server' 是一个 key,它所关联的值是通过 d["server"] 来引用的,为 'mpilgrim'。
    'database' 是一个 key,它所关联的值是通过 d["database"] 来引用的,为 'master'。
          可以通过 key 来引用其值,但是不能通过值获取 key,
             >>> d["mpilgrim"]                                  (4)
              Traceback (innermost last):
                 File "<interactive input>", line 1, in ?
              KeyError: mpilgrim

          2.修改 Dictionary
     
           >>> d["database"] = "pubs" (1)
           >>> d
            {'server': 'mpilgrim', 'database': 'pubs'}
           >>> d["uid"] = "sa"        (2)
           >>> d
            {'server': 'mpilgrim', 'uid': 'sa', 'database': 'pubs'}

      一个 dictionary 中不能有重复的 key。给一个存在的 key 赋值会覆盖原有的值。Dictionary 没有元素顺序的概念,它们只是序偶的简单排列。dictionary 的 key 是大小写敏感的。

           >>> d = {}
           >>> d["key"] = "value"
           >>> d["key"] = "other value" (1)
           >>> d
             {'key': 'other value'}
           >>> d["Key"] = "third value" (2)
           >>> d
             {'Key': 'third value', 'key': 'other value'}
    为一个已经存在的 dictionary key 赋值,将简单覆盖原有的值。这不会为一个已经存在的 dictionary key 赋值,因为在 Python 中是区分大小写的,也就是说 'key' 与 'Key' 是不同的。所以这种情况将在 dictionary 中创建一个新的 key-value 对。Dictionary 不只是用于存储字符串。Dictionary 的值可以是任意数据类型,包括字符串、整数、对象,甚至其它的 dictionary。在单个 dictionary 里,dictionary 的值并不需要全都是同一数据类型,可以根据需要混用和匹配。

        3.dictionary 中删除元素
        >>> d
         {'server': 'mpilgrim', 'uid': 'sa', 'database': 'master',42: 'douglas', 'retrycount': 3}
        >>> del d[42] (1)
        >>> d
         {'server': 'mpilgrim', 'uid': 'sa', 'database': 'master', 'retrycount': 3}
        >>> d.clear() (2)
        >>> d
         {}

    del 允许您使用 key 从一个 dictionary 中删除独立的元素。
    clear 从一个 dictionary 中清除所有元素。注意空的大括号集合表示一个没有元素的 dictionary。

     

    二、List 操作

        List 是 Python 中使用最频繁的数据类型, 如同 Perl 中的数组。在 Perl 中,用来保存数组的变量总是以 @ 字符开始;在 Python 中,变量可以任意取名,并且 Python 在内部会记录下其数据类型。 更像 Java 中的数组 (您可以简单地这样理解,但 Python 中的 list 远比 Java 中的数组强大)。一个更好的类比是 ArrayList 类,它可以保存任意对象,并且可以在增加新元素时动态扩展。
        1. 定义 List
         >>> li = ["a", "b", "mpilgrim", "z", "example"] 

         >>> li
          ['a', 'b', 'mpilgrim', 'z', 'example']
         >>> li[0]                                      

          'a'
         >>> li[4]                                     

          'example'
    List 是一个用方括号包括起来的有序元素的集合。
    List 可以作为以 0 下标开始的数组。任何一个非空 list 的第一个元素总是 li[0]。
    这个包含 5 个元素 list 的最后一个元素是 li[4],因为列表总是从 0 开始。

         2.list负索引
           >>> li
            ['a', 'b', 'mpilgrim', 'z', 'example']
           >>> li[-1] (1)
            'example'
           >>> li[-3] (2)
            'mpilgrim'
    负数索引从 list 的尾部开始向前计数来存取元素。任何一个非空的 list 最后一个元素总是 li[-1]。如果负数索引使您感到糊涂,可以这样理解:li[-n] == li[len(li) - n]。所以在这个 list 里,li[-3] == li[5 - 3] == li[2]

         3.list 的索引
          >>> li
           ['a', 'b', 'mpilgrim', 'z', 'example']
          >>> li[1:3]  (1)
           ['b', 'mpilgrim']
          >>> li[1:-1] (2)
           ['b', 'mpilgrim', 'z']
          >>> li[0:3]  (3)
           ['a', 'b', 'mpilgrim']

    (1):您可以通过指定 2 个索引得到 list 的子集,叫做一个 “slice” 。返回值是一个新的 list,它包含了 list 中按顺序从第一个 slice 索引 (这里为 li[1]) 开始,直到但是不包括第二个 slice 索引 (这里为 li[3]) 的所有元素。

    (2):如果一个或两个 slice 索引是负数,slice 也可以工作。如果对您有帮助,您可以这样理解:从左向右阅读 list,第一个 slice 索引指定了您想要的第一个元素,第二个 slice 索引指定了第一个您不想要的元素。返回的值为在其间的每个元素。

    (3):List 从 0 开始,所以 li[0:3] 返回 list 的前 3 个元素,从 li[0] 开始,直到但不包括 li[3]。

           4.list 的索引简写

            >>> li
             ['a', 'b', 'mpilgrim', 'z', 'example']
            >>> li[:3] (1)
             ['a', 'b', 'mpilgrim']
            >>> li[3:] (2) (3)
             ['z', 'example']
            >>> li[:]  (4)
             ['a', 'b', 'mpilgrim', 'z', 'example']

    (1):如果左侧分片索引为 0,您可以将其省略,默认为 0。所以 li[:3] 同 例 3.8 中的li[0:3] 是一样的。
    (2):同样的,如果右侧分片索引是 list 的长度,可以将其省略。所以 li[3:] 同 li[3:5] 是一样的,因为这个 list 有 5 个元素。
    (3):请注意这里的对称性。在这个包含 5 个元素的 list 中,li[:3] 返回前 3 个元素,而 li[3:] 返回后 2 个元素。实际上,li[:n] 总是返回前 n 个元素,而 li[n:] 将返回剩下的元素,不管 list 有多长。
    (4):如果将两个分片索引全部省略,这将包括 list 的所有元素。但是与原始的名为 li 的 list 不同,它是一个新 list,恰好拥有与 li 一样的全部元素。li[:] 是生成一个 list 完全拷贝的一个简写。

             5. list 中增加元素

               >>> li
                 ['a', 'b', 'mpilgrim', 'z', 'example']
               >>> li.append("new")               (1)
               >>> li
                 ['a', 'b', 'mpilgrim', 'z', 'example', 'new']
               >>> li.insert(2, "new")            (2)
               >>> li
                 ['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new']
               >>> li.extend(["two", "elements"]) (3)
               >>> li
               ['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', 'two', 'elements']

    append 向 list 的末尾追加单个元素。
    insert 将单个元素插入到 list 中。数值参数是插入点的索引。请注意,list 中的元素不必唯一,现在有两个独立的元素具有 'new' 这个值,li[2] 和 li[6]。
    extend 用来连接 list。请注意不要使用多个参数来调用 extend,要使用一个 list 参数进行调用。在本例中,这个 list 有两个元素。

     注:extend (扩展) 与 append (追加) 的差别:

            >>> li = ['a', 'b', 'c']
           >>> li.extend(['d', 'e', 'f']) (1)
           >>> li
            ['a', 'b', 'c', 'd', 'e', 'f']
          >>> len(li)                    (2)
            6
          >>> li[-1]
           'f'
         >>> li = ['a', 'b', 'c']
         >>> li.append(['d', 'e', 'f']) (3)
         >>> li
           ['a', 'b', 'c', ['d', 'e', 'f']]
         >>> len(li)                    (4)
          4
         >>> li[-1]
         ['d', 'e', 'f']

    Lists 的两个方法 extend 和 append 看起来类似,但实际上完全不同。extend 接受一个参数,这个参数总是一个 list,并且把这个 list 中的每个元素添加到原 list 中。在这里 list 中有 3 个元素 ('a'、'b' 和 'c'),并且使用另一个有 3 个元素('d'、'e' 和 'f') 的 list 扩展之,因此新的 list 中有 6 个元素。
    另一方面,append 接受一个参数,这个参数可以是任何数据类型,并且简单地追加到 list 的尾部。在这里使用一个含有 3 个元素的 list 参数调用 append 方法。原来包含 3 个元素的 list 现在包含 4 个元素。为什么是 4 个元素呢?因为刚刚追加的最后一个元素本身是个 list。List 可以包含任何类型的数据,也包括其他的 list。这或许是您所要的结果,或许不是。如果您的意图是 extend,请不要使用 append。

     

         6.在 list 中搜索

              >>> li
                ['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', 'two', 'elements']
              >>> li.index("example") (1)
                 5
              >>> li.index("new")     (2)
                 2
             >>> li.index("c")       (3)
               Traceback (innermost last):
                 File "<interactive input>", line 1, in ?
               ValueError: list.index(x): x not in list
             >>> "c" in li           (4)
               False

    index 在 list 中查找一个值的首次出现并返回索引值。
    index 在 list 中查找一个值的首次 出现。这里 'new' 在 list 中出现了两次,在 li[2] 和 li[6],但 index 只返回第一个索引,2。如果在 list 中没有找到值,Python 会引发一个异常。为它说明您的程序会由于源代码的问题而崩溃,好于在后面当您使用无效索引而引起崩溃。
    要测试一个值是否在 list 内,使用 in。如果值存在,它返回 True,否则返为 False 。


             7.从 list 中删除元素

                 >>> li
                   ['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', 'two', 'elements']
                 >>> li.remove("z")   (1)
                 >>> li
                   ['a', 'b', 'new', 'mpilgrim', 'example', 'new', 'two', 'elements']
                 >>> li.remove("new") (2)
                 >>> li
                   ['a', 'b', 'mpilgrim', 'example', 'new', 'two', 'elements']
                 >>> li.remove("c")   (3)
                   Traceback (innermost last):
                     File "<interactive input>", line 1, in ?
                   ValueError: list.remove(x): x not in list
                 >>> li.pop()         (4)
                   'elements'
                 >>> li
                   ['a', 'b', 'mpilgrim', 'example', 'new', 'two']

    remove 从 list 中删除一个值的首次出现。
    remove 仅仅 删除一个值的首次出现。在这里,'new' 在 list 中出现了两次,但 li.remove("new") 只删除了 'new' 的首次出现。
    如果在 list 中没有找到值,Python 会引发一个异常来响应 index 方法。
    pop 是一个有趣的东西。它会做两件事:删除 list 的最后一个元素,然后返回删除元素的值。请注意,这与 li[-1] 不同,后者返回一个值但不改变 list 本身。也不同于 li.remove(value),后者改变 list 但并不返回值。

     

           8.使用 list 的运算符

               >>> li = ['a', 'b', 'mpilgrim']
               >>> li = li + ['example', 'new'] (1)
               >>> li
                ['a', 'b', 'mpilgrim', 'example', 'new']
               >>> li += ['two']                (2)
               >>> li
                ['a', 'b', 'mpilgrim', 'example', 'new', 'two']
               >>> li = [1, 2] * 3              (3)
               >>> li
                [1, 2, 1, 2, 1, 2]

    Lists 也可以用 + 运算符连接起来。list = list + otherlist 相当于 list.extend(otherlist)。但 + 运算符把一个新 (连接后) 的 list 作为值返回,而 extend 只修改存在的 list。也就是说,对于大型 list 来说,extend 的执行速度要快一些。
    Python 支持 += 运算符。li += ['two'] 等同于 li.extend(['two'])。+= 运算符可用于 list、字符串和整数,并且它也可以被重载用于用户自定义的类中。
    * 运算符可以作为一个重复器作用于 list。li = [1, 2] * 3 等同于 li = [1, 2] + [1, 2] + [1, 2],即将三个 list 连接成一个。

     

    三、Tuple 介绍
        Tuple 是不可变的 list。一旦创建了一个 tuple,就不能以任何方式改变它。 Tuple 没有方法,您不能向 tuple 增加元素。Tuple 没有 append 或 extend 方法。您不能从 tuple 删除元素。Tuple 没有 remove 或 pop 方法。您不能在 tuple 中查找元素。Tuple 没有 index 方法。然而,您可以使用 in 来查看一个元素是否存在于 tuple 中。

         1.定义 tuple
            >>> t = ("a", "b", "mpilgrim", "z", "example") (1)
            >>> t
             ('a', 'b', 'mpilgrim', 'z', 'example')
            >>> t[0]                                       (2)
             'a'
            >>> t[-1]                                      (3)
             'example'
            >>> t[1:3]                                     (4)
             ('b', 'mpilgrim')

    定义 tuple 与定义 list 的方式相同,但整个元素集是用小括号包围的,而不是方括号。
    Tuple 的元素与 list 一样按定义的次序进行排序。Tuples 的索引与 list 一样从 0 开始,所以一个非空 tuple 的第一个元素总是 t[0]。
    负数索引与 list 一样从 tuple 的尾部开始计数。
    与 list 一样分片 (slice) 也可以使用。注意当分割一个 list 时,会得到一个新的 list ;当分割一个 tuple 时,会得到一个新的 tuple。
    那么使用 tuple 有什么好处呢?
    1.Tuple 比 list 操作速度快。如果您定义了一个值的常量集,并且唯一要用它做的是不断地遍历它,请使用 tuple 代替 list。
    2.如果对不需要修改的数据进行 “写保护”,可以使代码更安全。使用 tuple 而不是 list 如同拥有一个隐含的 assert 语句,说明这一数据是常量。如果必须要改变这些值,则需要执行 tuple 到 list 的转换 (需要使用一个特殊的函数)。
    3.Tuples 可以在 dictionary 中被用做 key,但是 list 不行。实际上,事情要比这更复杂。Dictionary key 必须是不可变的。Tuple 本身是不可改变的,但是如果您有一个 list 的 tuple,那就认为是可变的了,用做 dictionary key 就是不安全的。只有字符串、整数或其它对 dictionary 安全的 tuple 才可以用作 dictionary key。
    4.Tuples 可以用在字符串格式化中。

    Tuple 可以转换成 list,反之亦然。内置的 tuple 函数接收一个 list,并返回一个有着相同元素的 tuple。而 list 函数接收一个 tuple 返回一个 list。从效果上看,tuple 冻结一个 list,而 list 解冻一个 tuple。


    ======================

    list 和 tuple 的相互转化

    tuple(ls) 
    list(ls)


    展开全文
  • 什么是dict

    千次阅读 2016-04-02 14:13:41
    什么是dict 我们已经知道,list 和 tuple 可以用来表示顺序集合,例如,班里同学的名字: ['Adam', 'Lisa', 'Bart'] 或者考试的成绩列表: [95, 85, 59] 但是,要根据名字找到对应的成绩,用两个 ...

    什么是dict

    我们已经知道,list 和 tuple 可以用来表示顺序集合,例如,班里同学的名字:

    ['Adam', 'Lisa', 'Bart']

    或者考试的成绩列表:

    [95, 85, 59]

    但是,要根据名字找到对应的成绩,用两个 list 表示就不方便。

    如果把名字和分数关联起来,组成类似的查找表:

    'Adam' ==> 95
    'Lisa' ==> 85
    'Bart' ==> 59

    给定一个名字,就可以直接查到分数。

    Python的 dict 就是专门干这件事的。用 dict 表示“名字”-“成绩”的查找表如下:

    d = {
        'Adam': 95,
        'Lisa': 85,
        'Bart': 59
    }

    我们把名字称为key,对应的成绩称为value,dict就是通过 key来查找 value

    花括号 {} 表示这是一个dict,然后按照 key: value, 写出来即可。最后一个 key: value 的逗号可以省略。

    由于dict也是集合,len() 函数可以计算任意集合的大小:

    >>> len(d)
    3

    注意: 一个 key-value 算一个,因此,dict大小为3。

    任务

    新来的Paul同学成绩是 75 分,请编写一个dict,把Paul同学的成绩也加进去。

    d = {
        'Adam': 95,
        'Lisa': 85,
        'Bart': 59
    }
    ?不会了怎么办

    按照 key: value 的格式写出 'Paul': 75

    参考代码:

    d = {
        'Adam': 95,
        'Lisa': 85,
        'Bart': 59,
        'Paul': 75
    }
    展开全文
  • dict常见方法

    2019-08-26 09:32:20
    1. 定义 字典是一种可变容器模型, 且可存储任意类型对象.具有极快的查找速度. 字典是一种通过名字或者关键字应用的数据结构, 其键可以是数字,字符串,元组,这种结构类型称之为映射.... (1)len( ) 返回字典中键->...

    1. 定义

    字典是一种可变容器模型, 且可存储任意类型对象.具有极快的查找速度.

    字典是一种通过名字或者关键字应用的数据结构, 其键可以是数字,字符串,元组,这种结构类型称之为映射.基本的操作如下:

    (1)len( )  返回字典中键->值对的数量

    (2)d[k]  返回关键字对应的值

    (3) d[k] = v   将值关联到键值k上

    (4) del d[k]    删除键值为k的项

    (5) key in d: 键值key是否在d中, 是返回True, 否则返回False

     

    2. 性质

    (1)字典的键(key)必须不可变(如:字符串,数字,元组), 值(value)可以为任意数据类型

    d1 = {'Alice': '2341', 9102: 'Bibi', (11,22): '3258'}  # 正确

    d2 = {['Alice',123]: '2341', True: '9102', {'abc': '123', 'efg': '456'}}  # 错误! 因为列表 布尔值 字典都是可变的,不能作为键(key)

    (2) 字典是无序的, 每次执行打印,顺序都会发生变化

    d3 = {'Alice': '2341', 9102: 'Bibi', (11,22): '3258'}

    print(d)

    # 打印结果可能是这样

    {'Alice': '2341', 9102: 'Bibi', (11, 22): '3258'}

    # 也有可能是这样

    {(11, 22): '3258' 'Alice': '2341', 9102: 'Bibi'}

    # 甚至可能是这样

    {9102: 'Bibi', 'Alice': '2341', (11, 22): '3258'}

    (3)根据键(key)或值(value)取出对应的值(value)或键(key) 

    1> 返回关键字对应的值 : v = d[key]

    2> 不可通过切片方式获取键值对,因为字典无序

    3> for循环取key和value

     

    3 字典的函数和方法

    (1)函数, 一共3个

    1> str(dict)   输出字典可以打印的字符串表示, 将字典转化为字符串输出

    d6 = {'Year': 2018, 'Month': 3, 'Day': 18}

    content = str(d6)

    print(content)

    打印结果:{'Year': 2018, 'Month': 3, 'Day': 18}

    2> len(dict)  计算字典内元素的个数, 即键的总数

    d7 = {'Year': 2018, 'Month': 3, 'Day': 18}

    count = len(d7)

    print(count)

    打印结果:3  

    3> type(variable)   返回输入的变量类型, 如果变量类型是字典就返回字典

    d8 = {'Year': 2018, 'Month': 3, 'Day': 18}

    ty = type(d8)

    print(ty)

    打印结果:<class 'dict'>

     

    (2)方法

    1> 删除 

    d4 = {'Alice': '2341', 9102: 'Bibi', (11,22): '3258'}

    del d4[9102] # 删除元素 9102:Bibi

    print(d4) # 打印结果:{'Alice': '2341', (11, 22): '3258'}

    d4.clear()    # 清空字典

    print(d4) # 打印结果:{}

    del d4      # 删除字典

    2> items( )方法, 循环获取key和value

    d4 = {'Year': 2018, 'Month': 3, 'Day': 18}

    for k, v in d4.items(): # 用items方法 k接收key ,v接收value

    print(k, v)

    3> keys( )方法,循环获取所有key

    d4 = {'Year': 2018, 'Month': 3, 'Day': 18}

    for item in d4.keys(): # 循环所有的key

    print(item)

    4> values( ) 方法, 循环获取所有value

    d4 = {'Year': 2018, 'Month': 3, 'Day': 18}

    for item in d4.values(): # 循环所有的values

    print(item)

    5> copy( ) 浅拷贝 (着重理解深拷贝和浅拷贝)

    d4 = {'Year': 2018, 'Month': 3, 'Day': 18}

    dict2 = d4.copy()

    print ("新复制的字典为 : ",dict2)

    6> fromkeys( )  创建一个新字典, fromkeys(*args, **kwargs) 以*args中元素做字典的键, **kwargs为字典所有键对应的初始值   (需要重点掌握)

    new_d = ('Year', 'Month', 'Day')

    dict1 = dict.fromkeys(new_d)

    print("新的字典 : %s" % str(dict1))

    dict1 = dict.fromkeys(new_d, 8)

    print("新的字典 : %s" % str(dict1))

    打印结果:

    新的字典 : {'Year': None, 'Month': None, 'Day': None}

    新的字典 : {'Year': 8, 'Month': 8, 'Day': 8}

    7> get( )方法根据key获取值

    get(self, k, d=None)  参数: k为待操作的键(key), d默认为None, 在获取键的时候,如果不存在就返回None,或指定什么就返回什么

    d9 = {'Year': 2018, 'Month': 3, 'Day': 18}

    v = d9.get('Day')

    print('key存在时:', v)

    v1 = d9.get('Hour')

    print('key不存在时:', v1)

    v2 = d9.get('Hour', 1234)

    print("key不存在时并指定返回值:", v2)

    打印结果:

    存在: 18

    key不存在时: None

    key不存在时并指定返回值: 1234

    8>  pop( )方法删除指定的key

    pop(self, k, d=None)   参数: k为待删除的key, d表示如果待删除的key,则返回None,或指定什么返回什么

    d9 = {'Year': 2018, 'Month': 3, 'Day': 18}

    v = d9.pop('Day')

    print('key存在时:', v) # key存在时: 18

    v1 = d9.pop('Hour')

    print('key不存在时:', v1) # key不存在时报错

    v2 = d9.pop('Hour', 1234)

    print("key不存在时并指定返回值:", v2) # key不存在时并指定返回值: 1234

    9>  popitem( ) 方法, 随机删除一个键值对

    d10 = {'Year': 2018, 'Month': 3, 'Day': 18}

    v1 = d10.popitem()

    k, v = d10.popitem()

    print(v1, k, v) # 打印结果:('Day', 18) Month 3

    10> setdefault 方法, 给字典设置(增加)新的键, 存在就不设置(获取当前key对应的值), 不存在就设置并返回当前key对应的值       (需要重点掌握)

    setdefault(self, k, d=None) 参数: k为待设置(添加)的key, d默认为空,可以指定value值

    d11 = {'Year': 2018, 'Month': 3, 'Day': 18}

    v = d11.setdefault('hour', '10') # 如果待加入的key跟字典内重复,则不会添加

    print(d11, v) # 打印结果:{'Year': 2018, 'Month': 3, 'Day': 18, 'hour': '10'} 10#

    11> update( )方法, 更新字典

    update(self, E=None, **F)

    d12 = {'Year': 2018, 'Month': 3, 'Day': 18}

    d12.update({'Year': 2019, 'Day': 20, 'Hour': 10}) # 第一种写法

    # d12.update(Year=2019, Day=20, Hour=10) # 第二种写法

    print(d12) # 打印结果:{'Year': 2019, 'Month': 3, 'Day': 20, 'Hour': 10} # 已存在的key就覆盖,不存在的key就添加进字典

    转载 https://www.cnblogs.com/suendanny/p/8593929.html

     

     

     

     

     

     

     

     

    展开全文
  • dict的一些用法

    千次阅读 2018-10-16 12:16:04
    字典基础参考: 【1】:http://www.w3cschool.cc/python/python-dictionary.html 【2】:http://www.111cn.net/phper/python/56355.htm 【3】:http://skyfen.iteye.com/blog/567571 【4】:...
  • python __dict__函数

    2019-03-31 14:13:42
    python中的类,都会从object里继承一个__dict__属性,这个属性中存放着类的属性和方法对应的键值对。一个类实例化之后,这个类的实例也具有这么一个__dict__属性。但是二者并不相同。 In [26]: class A: ...: some...
  • Python __dict__属性详解

    万次阅读 2018-10-04 22:23:11
    我们都知道Python一切皆对象... 首先看一下类的__dict__属性和类对象的__dict__属性 # -*- coding: utf-8 -*- class A(object): """ Class A. """ a = 0 b = 1 def ...
  • dict.txt.zip

    2020-07-30 23:31:09
    配套博客:https://blog.csdn.net/qq_41739364/article/details/96767359
  • Python中字典(dict)的用法详解

    万次阅读 2018-12-21 14:25:19
    字典是一种可变容器模型,...my_dict = {key1:value1, key2:value2} 键一般是唯一的,如果重复最后的一个键值对会替换前面的,值不需要唯一。 值可以取任何数据类型,但键必须是不可变的,如字符串、数字或元组...
  • Python - 字典(dict)删除元素

    万次阅读 2017-05-19 14:32:07
    字典(dict)删除元素, 可以选择两种方式, dict.pop(key)和del dict[key].代码# -*- coding: utf-8 -*- def remove_key(d, key): r = dict(d) del r[key] return r x = {1: 2, 3: 4, 4: 3, 2: 1, 0: 0} x.pop(1) ...
  • [python]遍历字典dict的几种方法

    万次阅读 2016-03-28 10:44:02
    /usr/bin/python dict={"a":"apple","b":"banana","o":"orange"} print "##########dict######################" for i in dict: print "dict[%s]=" % i,dict[i] print "###########items#########
  • Python之dict(或对象)与json之间的互相转化在Python语言中,json数据与dict字典以及对象之间的转化,是必不可少的操作。在Python中自带json库。通过import json导入。在json模块有2个方法, loads():将json数据转化...
  • Python dict()函数

    2019-10-26 00:04:00
    dict 函数,用于创建一个新的字典(dictionary),返回一个新的字典 语法:dict(key/value) 参数说明:key/value -- 用于创建字典的键/值对,可以表示键/值对的方法有很多。 用法: dict0 = dict() # 1、传一个...
  • python之Dict操作(中)

    千次阅读 2019-10-22 19:24:55
    文章目录python之Dict操作(中)6. Dict更新1) 更新指定key的value7. Dict查找1) 获取value的最大值/最小值2) 获取指定key的value3) 获取键值对列表4) 获取key列表5) 获取value列表6) 从字典中提取符合条件的子集8. ...
  • Tensorflow 学习笔记——占位符和feed_dict(二)

    万次阅读 多人点赞 2019-01-16 11:36:11
    在会话中,占位符可以使用 feed_dict 馈送数据。   feed_dict是一个字典,在字典中需要给出每一个用到的占位符的取值。在训练神经网络时需要每次提供一个批量的训练样本,如果每次迭代选取的数据要通过常量表示,...
  • Python中dict字典使用方法

    万次阅读 2014-03-23 11:09:36
    一、dict字典有很多常用的函数 dict.clear() 删除字典中所有元素 dict.copy() 返回字典(浅复制)的一个副本 dict.fromkeysc(seq,val=None) 创建并返回一个新字典,以seq 中的元素做该字典的键,val 做该字典中所有键...
  • Redis内部数据结构详解(1)——dict

    万次阅读 2019-05-04 18:52:40
    dict是一个用于维护key和value映射关系的数据结构,与很多语言中的Map或dictionary类似。Redis的一个database中所有key到value的映射,就是使用一个dict来维护的。不过,这只是它在Redis中的一个用途而已,它在Redis...
  • 假如 两个字典dict1={'a':1,'b':2,'c':3},dict2={'c':4,'d':5},若两个dict1和dict2有相同的key则对应的value相加,若没有则直接添加过来。结果为dict3={'a':1,'b':2,'c':7,'d':5} def merge_dict(x,y): for k,v ...
  • Redis源码剖析系列文章汇总:传送门...哈希表在C++中对应的是map数据结构,但在Redis中称作dict(字典)。Redis只是用了几个简单的结构体和几种常见的哈希算法就实现了一个简单的类似高级语言中的map结构。下面我们...
  • Python的Dict的内嵌Dict对象赋值给其他变量时当做引用处理,并不是一个副本。所以,后续改变引用变量的值的同时也改变了Dict对象本身的值,代码运行结果如下。 #python ref demo dict = { 'k1':'v1', 'k2':'v2' }...
1 2 3 4 5 ... 20
收藏数 327,856
精华内容 131,142
关键字:

dict