python学习笔记(四)——数据字典

简介:                    数据字典   字典(dictionary)是除列表之外python之中最灵活的内置数据结构类型。列表是有序的对象结合,字典是无序的对象集合。两者之间的区别在于:字典当中的元素是通过键来存取的,而不是通过偏移存取,这个键可以是数字、字符串甚至元组。

                   数据字典

  字典(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 "%s's %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'}
>>> "Jzhou's phone number is %(Jzhou)s." % phonebook
"Jzhou's 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函数来完成

>>> from 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']}

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

>>> {}.fromkeys(['name','age'])  #构造了有一个空字典来建立另外一个字典
{'age': None, 'name': None}

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

>>> dict.fromkeys(['name','age'])
{'age': None, 'name': None}

  若不想使用None作默认值,也可以提供自己的默认值

>>> dict.fromkeys(['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'

   看下面这个经过改造的例子:

people ={
     'Jason':{
        'phone':'2341',
        'addr':'Foo drive 23'
         },
     'James':{
        'phone':'4564',
        'addr':'Bar street 42'
         }
    }
labels={
    'phone':'phone number',
    'addr':'address'
    }
name = raw_input('Name:')
#查找电话号码还是地址?
request=raw_input('phone number(p) or address(a)?')
#使用正确的键
key=request
if request =='p':key='phone'
if request =='a':key='addr'

person=people.get(name,{})
label=labels.get(key,key)
#使用get()提供的默认值
result=person.get('key','not available')

#如果请求不是p或者a,则使用get()提供的默认值
if request != 'p' and request != 'a':
  print "%s's %s is %s." % (name,label,result)
#如果请求正确,则按正常处理
elif request == 'p' or request == 'a':
  print "%s's %s is %s." % (name,labels[key],people[name][key])

raw_input("press any key to exit!")

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

   

   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 0x01D9EAB0>
>>> list(it)  #将iterator转换为列表
[('url', 'http://www.python.org'), ('title', 'python')]

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

>>> d.keys()
['url', 'title']
>>> d.iterkeys()
<dictionary-keyiterator object at 0x02BD1DE0>
>>> 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 0x02BD1ED0>
>>> 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}

    update——利用一个字典更新另外一个字典

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

    以上是字典常用的主要方法,调用方式和调用列表及字符串的方式相同。

  

 

作者: zhoujie
本文版权归作者和博客园共有,欢迎转载,但未经作者同意必须保留此段声明,且在文章页面明显位置给出原文连接,不然我担心博客园找你算账
如果您觉得本文对你有帮助,请竖起您的大拇指右下角点推荐,也可以关注我
目录
相关文章
|
7天前
|
存储 JSON 索引
一文让你彻底搞懂 Python 字典是怎么实现的
一文让你彻底搞懂 Python 字典是怎么实现的
29 13
|
8天前
|
数据挖掘 索引 Python
Python数据挖掘编程基础3
字典在数学上是一个映射,类似列表但使用自定义键而非数字索引,键在整个字典中必须唯一。可以通过直接赋值、`dict`函数或`dict.fromkeys`创建字典,并通过键访问元素。集合是一种不重复且无序的数据结构,可通过花括号或`set`函数创建,支持并集、交集、差集和对称差集等运算。
15 9
|
6天前
|
数据采集 数据挖掘 数据处理
Python中实现简单爬虫并处理数据
【9月更文挑战第31天】本文将引导读者理解如何通过Python创建一个简单的网络爬虫,并展示如何处理爬取的数据。我们将讨论爬虫的基本原理、使用requests和BeautifulSoup库进行网页抓取的方法,以及如何使用pandas对数据进行清洗和分析。文章旨在为初学者提供一个易于理解的实践指南,帮助他们快速掌握网络数据抓取的基本技能。
17 3
|
8天前
|
存储 索引 Python
python中的数据容器
python中的数据容器
|
7天前
|
数据采集 存储 监控
如何使用 Python 爬取京东商品数据
如何使用 Python 爬取京东商品数据
28 0
|
8天前
|
存储 数据安全/隐私保护 Python
Python常用数据结构—字典
Python常用数据结构—字典
|
8天前
|
数据挖掘 Python
Python数据挖掘编程基础8
在Python中,默认环境下并不会加载所有功能,需要手动导入库以增强功能。Python内置了诸多强大库,例如`math`库可用于复杂数学运算。导入库不仅限于`import 库名`,还可以通过别名简化调用,如`import math as m`;也可指定导入库中的特定函数,如`from math import exp as e`;甚至直接导入库中所有函数`from math import *`。但需注意,后者可能引发命名冲突。读者可通过`help(&#39;modules&#39;)`查看已安装模块。
14 0
|
8天前
|
人工智能 数据挖掘 Serverless
Python数据挖掘编程基础
函数式编程中的`reduce`函数用于对可迭代对象中的元素进行累积计算,不同于逐一遍历的`map`函数。例如,在Python3中,计算n的阶乘可以使用`reduce`(需从`funtools`库导入)实现,也可用循环命令完成。另一方面,`filter`函数则像一个过滤器,用于筛选列表中符合条件的元素,同样地功能也可以通过列表解析来实现。使用这些函数不仅使代码更加简洁,而且由于其内部循环机制,执行效率通常高于普通的`for`或`while`循环。
14 0
|
8天前
|
分布式计算 数据挖掘 Serverless
Python数据挖掘编程基础6
函数式编程(Functional Programming)是一种编程范型,它将计算机运算视为数学函数计算,避免程序状态及易变对象的影响。在Python中,函数式编程主要通过`lambda`、`map`、`reduce`、`filter`等函数实现。例如,对于列表`a=[5,6,7]`,可通过列表解析`b=[i+3 for i in a]`或`map`函数`b=map(lambda x:x+3, a)`实现元素加3的操作,两者输出均为`[8,9,10]`。尽管列表解析代码简洁,但其本质仍是for循环,在Python中效率较低;而`map`函数不仅功能相同,且执行效率更高。
7 0
|
8天前
|
数据挖掘 Python
Python数据挖掘编程基础5
函数是Python中用于提高代码效率和减少冗余的基本数据结构,通过封装程序逻辑实现结构化编程。用户可通过自定义或函数式编程方式设计函数。在Python中,使用`def`关键字定义函数,如`def pea(x): return x+1`,且其返回值形式多样,可为列表或多个值。此外,Python还支持使用`lambda`定义简洁的行内函数,例如`c=lambda x:x+1`。
16 0
下一篇
无影云桌面