python进修笔记（四）-

python进修笔记（四）

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

　数据字典

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

　　　创建和应用字典：

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

>>> phonebook[Jason]

23453

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

（重视：字典中的键是独一的，其它映射也是如此，而值不独一）

　　dict函数

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

>>> items=[（name，Gumby），（age，42）]

>>> d=dict （items ）

>>> d

{age: 42， name: Gumby}

>>> d[name]

Gumby

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

>>> d=dict（name=Jason，age=42）

>>> d

{age: 42， name: 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:3422，Jason:3441，Jzhou:2321}

>>> phonebook

{James: 3422， Jason: 3441， Jzhou: 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 page，text: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:admin，machines:[foo，bar，baz]}

>>> y=x.copy（）

>>> y[username]=mlh

>>> y[machines].remove （bar）

>>> y

{username: mlh， machines: [foo， baz]}

>>> x

{username: admin， machines: [foo， baz]}

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

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

>>>  copy import deepcopy

>>> d={}

>>> d[names]=[James，Jason]

>>> c=d.copy（）

>>> dc=deepcopy（d）

>>> d[names].append（Jzhou）

>>> c

{names: [James， Jason， Jzhou]}

>>> dc

{names: [James， Jason]}

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

>>> {}.keys（[name，age]）  ＃机关了有一个空字典来建树别的一个字典

{age: None， name: None}

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

>>> dict.keys（[name，age]）

{age: None， name: None}

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

>>> dict.keys（[name，age]，Unknown）

{age: Unknown， name: 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（name，N/A）

N/A

＃若是键值存在，get用起来就像通俗的字典查询一样

>>> d[name]=Eric

>>> d.get（name）

Eric

　　看下面这个经过的例子：

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

　　 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转换为列表

[（url， http://www.python.org）， （title， python）]

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

>>> d.keys（）

[url， title]

>>> d.iterkeys（）

<dictionary-keyiterator object at 0 x02BD1DE0>

>>> list（d.iterkeys （））

[url， title]

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:python，url:http://www.python.org，spam:0}

>>> d

{url: http://www.python.org， spam: 0， title: python}

>>> d.popitem（）

（url， http://www.python.org）

>>> d

{spam: 0， title: python}

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

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

>>> d={}

>>> d.setdefault（name，N/A）

N/A

>>> d

{name: N/A}

>>> d[name]=Jzhou

>>> d.setdefault（name，N/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.org， changed: April 4 20:18 2013， title: Python Language Website}

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

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　（转）

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

分享到：

相关文章

按版本划分

按功能划分

企业管理软件

python进修笔记（四）