} } }

    python进修笔记(四)

    添加时间:2013-5-15 点击量:

     数据字典


      字典(dictionary)是除列表之外python之中最灵活的内置数据布局类型。列表是有序的对象连络,字典是无序的对象凑集。两者之间的差别在于:字典傍边的元素是经由过程键来存取的,而不是经由过程偏移存取,这个键可所以数字、字符串甚至元组。映射可以应用任何不成变对象标识元素,最常用的类型是字符串和元组,python独一内建的映射类型是字典。


       创建和应用字典:



    >>> phonebook={Jason:23453James:34231Jzhou:90798}
    
    >>> phonebook[Jason]
    23453


       字典由多个键和其对应的值构成的对构成(键值对称为项),上例中,姓名是键,分机号是值。每个键和它的值之间用冒号隔开,项之间用逗号隔开,全部字典用一对大括号括起来。


    (重视:字典中的键是独一的,其它映射也是如此,而值不独一)


      dict函数


      dict函数可以经由过程其他映射(比如其他字典)或者(键、值)如许的序列对建树字典



    >>> items=[(nameGumby),(age42)]
    
    >>> d=dict (items )
    >>> d
    {
    age: 42name: Gumby}
    >>> d[name]
    Gumby


      dict函数也可以经由过程关键字参数来创建字典



    >>> d=dict(name=Jason,age=42
    >>> d
    {
    age: 42name: Jason}


      还能以映射作为dict函数的参数,以建树其项与映射雷同的字典,若是不带任何参数,则dict函数返回一个新的空的字典,就行list,tuple,str等函数一样。若是另一个映射也是字典,可以应用字典办法copy(之后介绍)。


      根蒂根基的字典操纵


        字典的根蒂根基行动在很多方面和序列类似:


      len(d)  返回d中项(键-值对)的数量


      d[k]返回接洽关系到键k上的值


      d[k]=v 将值v接洽关系到键k上


      del  d[k]删除键为k的项


      k  in  d  搜检中是否有含有键为k的项


      字典也有一些本身的特点,如下:


       键类型:字典的键不必然为整型数据,也可能是其他不成变类型,如浮点型、字符串、元组等


       主动添加:即使那个键起先不存在于字典中,也可以分派给它一个值,即字典会建树一个新项;而列表在不应用append办法的前提下,不克不及将值接洽关系到列表之外的索引上


       成员资格:表达式k  in  d(d为字典)查找的是键而不是值;表达式 v  in l(l为列表)则用来查找值,而不是索引(别的,在字典中搜检键的成员资格比在列表中搜检值的成员更高效,尤其当数据布局的范围很大时。)


         我们来看一个简单的例子,来看看字典相对于列表的益处:




    >>> x=[]   #创建一个空列表
    
    >>> x[42]=floor #呈现错误

    Traceback (most recent call last):
    File
    <pyshell#77>, line 1, in <module>
    x[42]=floor
    IndexError: list assignment index out of range
    >>> x={} #创建一个字典
    >>> x[42]=floor #主动将这项添加到字典中
    >>> x #字典的值
    {
    42: floor}
    >>>



        下面是一个较错杂的字典的示例:




     应用人名作为键的字典,每小我用另一个字典来默示,phone和addr是子字典的键
    
    people ={
    Jason:{
    phone:2341
    addr:Foo drive 23
    },
    James:{
    phone:4564
    addr:Bar street 42
    },
    Jzhou:{
    phone:4564
    addr:Baz avenue 90
    }
    }

    针对德律风号码和地址应用的描述性标签会在打印输出的时辰用到
    labels={
    phone:phone number
    addr:address
    }

    name
    =raw_input(Name:

    查找德律风号码还是地址?应用正确的键
    request=raw_input (Phone number(p) or address(a)?
    应用正确的键:
    if request==p:key=phone
    if request==a:key=addr

    若是名字是字典中的有效键才打印信息
    if name in people:
    print %ss %s is %s. (name,labels[key],people[name][key])

    raw_input(
    press any key to exit!



     运行成果如下:


      


       字典的格局化字符串


      上一篇介绍过字符串是如何格局化的,如今我们来看看字典是如何格局化的。在每个转换申明符的后面,加上键再跟其他申明元素。看例子:



    >>> phonebook={James:3422Jason:3441Jzhou:2321}
    
    >>> phonebook
    {
    James: 3422Jason: 3441Jzhou: 2321}
    >>> Jzhous phone number is %(Jzhou)s. phonebook
    Jzhous phone number is 2321.


      除了增长字符串键之外,转换申明符还是像以前一样,当以这种体式格式应用字典的时辰,只要所有给出的键都能在字典中找到,就可以获得随便率性数量的转换申明符,所以这类字符串格局化在模板体系中很是有效,看下面这个例子:




    >>> template=<html>
    
    <head><title>%(title)s</title></head>
    <body>
    <h1>%(title)s<h1>
    <p>%(text)s</p>
    </body>

    >>> data={title:my home pagetext:Welcome to my home age!}

    >>> print template % data
    <html>
    <head><title>my home page</title></head>
    <body>
    <h1>my home page<h1>
    <p>Welcome to my home age!</p>
    </body>



       字典办法


       clear——清除字典中的所有项。类似于list.sort,无返回值




    >>> d={}
    
    >>> d[name]=Jason
    >>> d[age]=42
    >>> d
    {
    age: 42, name: Jason}
    >>> return_value=d.clear()
    >>> d
    {}
    >>> print return_value
    None



         经由过程下面的例子看一下clear的简单感化:




    未应用clear办法
    
    >>> x={}
    >>> y=x
    >>> x[key]=value
    >>> y
    {
    key: value}
    >>> x={}
    >>> y x应用x={}置空后y的值还存在
    {key: value}
    应用clear办法
    >>> x={}
    >>> y=x
    >>> x[key]=value
    >>> y
    {
    key: value}
    >>> x.clear() x应用clear办法后,y的值也被清空了
    >>> y
    {}



      copy——返回一个具有雷同键值对的新字典(实现的是浅复制,因为值本身雷同,而不是副本)




    >>> x={username:adminmachines:[foobarbaz]}
    
    >>> y=x.copy()
    >>> y[username]=mlh
    >>> y[machines].remove (bar
    >>> y
    {
    username: mlhmachines: [foobaz]}
    >>> x
    {
    username: adminmachines: [foobaz]}



      上例看出,当在副本中调换值的时辰,原字典不受影响,想上述y中username赋了新值,而x没变;然则若是批改了某个值而不是调换,则原字典也会改变,像上述y的machines中移除了bar,则x中也移除了这个值。


      避免这个题目的办法是应用深复制(deep copy),复制它包含所有的值。应用copy模块的deepcopy函数来完成




    >>>  copy import deepcopy
    
    >>> d={}
    >>> d[names]=[JamesJason]
    >>> c=d.copy()
    >>> dc=deepcopy(d)
    >>> d[names].append(Jzhou
    >>> c
    {
    names: [JamesJasonJzhou]}
    >>> dc
    {
    names: [JamesJason]}



       keys——应用给定的键建树新的字典,每个键默认对应的值为None



    >>> {}.keys([nameage])  #机关了有一个空字典来建树别的一个字典
    
    {
    age: None, name: None}


      也可以直接在所有字典的类型dict上调用办法



    >>> dict.keys([nameage])
    
    {
    age: None, name: None}


      若不想应用None作默认值,也可以供给本身的默认值



    >>> dict.keys([nameage],Unknown
    {
    age: Unknownname: Unknown}


        get——获得字典中的某个项




    一般当是视图获得字典中不存在的项时将失足
    
    >>> d={}
    >>> print d[name]

    Traceback (most recent call last):
    File
    <pyshell#42>, line 1, in <module>
    print d[name]
    KeyError: name

    应用get办法时不会失足
    >>> print d.get(name
    None
    也可以自定义默认值来调换None
    >>> d.get(nameN/A
    N/A
    若是键值存在,get用起来就像通俗的字典查询一样
    >>> d[name]=Eric
    >>> d.get(name
    Eric



       看下面这个经过的例子:





    View Code




      运行成果如下,即正常输入和异常输入时的处理惩罚成果:


       


       has_key——搜检字典中是否含有给出的键。表达式dict.has_key(k)相当于 表达式key  in  dict。重视在python3.0中不包含这个函数了。



    >>> d={}
    
    >>> d.has_key(name
    False
    >>> d[name]=Jzhou
    >>> d.has_key(name
    True


       items和iteritems——items办法将所有字典项以列表体式格式返回,这些列表项中的每一项都来自于(键、值),然则在项返回时并没有特别次序。



    >>> d={title:python,url:http://www.python.org}
    >>> d.items ()
    [(url, http://www.python.org), (title, python)]




    iteritems感化大致一样,然则会返回一个迭代器对象而不是列表



    >>> it=d.iteritems ()
    
    >>> it
    <dictionary-itemiterator object at 0 x01D9EAB0>
    >>> list(it) #将iterator转换为列表
    [(
    urlhttp://www.python.org), (titlepython)]


             keys和iterkeys——keys办法将字典中的键以列表的情势返回,而iterkeys是返回针对键的迭代器



    >>> d.keys()
    
    [
    urltitle]
    >>> d.iterkeys()
    <dictionary-keyiterator object at 0 x02BD1DE0>
    >>> list(d.iterkeys ())
    [
    urltitle]


          values和itervalues——values办法以列表的情势返回字典中的值,itervalues返回值的迭代器。与返回键的列表不合的是,返回值的列表中可以包含反复的元素




    >>> d={}
    
    >>> d[1]=1
    >>> d[2]=2
    >>> d[3]=3
    >>> d[4]=1
    >>> d.values()
    [
    1, 2, 3, 1]
    >>> d.itervalues ()
    <dictionary-valueiterator object at 0 x02BD1ED0>
    >>> list(d.itervalues ())
    [
    1, 2, 3, 1]



         pop——获得对应于给定键的值,然后将这个键值对从字典中移除



    >>> d={x:1,y:2}
    
    >>> d.pop(x
    1
    >>> d
    {
    y: 2}


        popitem——类似list.pop,后者会弹出列表的最后一个元素,但不合的是,popitem弹出的是随机的项,因为字典是无序的。若想一个接一个的移除并处理惩罚项,这个办法很是有效,因为不消先获取键的列表




    >>> d={title:pythonurl:http://www.python.orgspam:0}
    
    >>> d
    {
    url: http://www.python.orgspam: 0, title: python}
    >>> d.popitem()
    urlhttp://www.python.org
    >>> d
    {
    spam: 0, title: python}



    尽管popitem和列表的pop办法很类似,但字典中并没有与append等价的办法,因为字典是无序的,无“追加至最后”可言。


        setdefault——获得与给定键相接洽关系的值,类似get()办法,别的,它还能在字典中不含有给定键的景象下设定响应的键值




    >>> d={}
    
    >>> d.setdefault(nameN/A
    N/A
    >>> d
    {
    name: N/A}
    >>> d[name]=Jzhou
    >>> d.setdefault(nameN/A
    Jzhou
    >>> d
    {
    name: Jzhou}



    可以看出,当键不存在的时辰,setdefault返回默认值并且响应的更新字典。若是键存在,那么就返回与其对应的值,但不改变字典。默认值可选,若是不写,默认为None



    >>> d={}
    
    >>> print d.setdefault(name
    None
    >>> d
    {
    name: None}


        ——哄骗一个字典更新别的一个字典




    >>> d={
    
    title:Python web site
    url:http://www.python.org
    changed:April 4 20:18 2013
    }
    >>> x={title:Python Language Website}
    >>> d.(x) #供给的字典中的项会被添加到旧的字典中,如有雷同的键则会进行覆盖
    >>> d
    {
    url: http://www.python.orgchanged: April 4 20:18 2013title: Python Language Website}



        以上是字典常用的首要办法,调用体式格式和调用列表及字符串的体式格式雷同。


                                                                            (转)

    读书,不要想着实用,更不要有功利心。读书只为了自身的修养。邂逅一本好书如同邂逅一位知己,邂逅一个完美之人。有时心生敬意,有时怦然心动。仿佛你心底埋藏多年的话,作者替你说了出来,你们在时光深处倾心相遇的一瞬间,情投意合,心旷神怡。
    分享到: