Python学习笔记4—Python字典元组

一、字典定义

用大括号{}包裹,以逗号分割每个键值对,键与值之间使用冒号连接,构成(key{values)结构。

键和值可以是任意的数据对象,大多数情况还是以数字和字符串的方式构成

字典是无序的,键在字典中必须是唯一,在字典中取值的方式是以键寻找相对应的值

字典是python中的映射数据类型

字典不支持拼接(concatenation)和重复(repetirion)

a={}    #定义空字典,没有任何的键和值
print a
a={‘a‘:1,‘b‘:2,‘c‘:3,‘d‘:4}     #创建字典,键与值对应,以逗号分割,键与值以冒号连接
print a
a={}.fromkeys(list(‘abcdef‘))     #创建字典,使用字典方法,值创建键,值为None,键来自列表的元素
print a
a=dict(([‘x‘, 1], [‘y‘, 2]))    #使用字典函数创建字典
print a
a=dict(zip(["key1",‘key2‘],(1,2)))  #使用zip方法和dict函数创建字典
print a

执行结果为

{}
{‘a‘: 1, ‘c‘: 3, ‘b‘: 2, ‘d‘: 4}
{‘a‘: None, ‘c‘: None, ‘b‘: None, ‘e‘: None, ‘d‘: None, ‘f‘: None}
{‘y‘: 2, ‘x‘: 1}
{‘key2‘: 2, ‘key1‘: 1}

zip([iterable, ...])

zip()是Python的一个内建函数,它接受一系列可迭代的对象作为参数,将对象中对应的元素打包成一个个tuple(元组),然后返回由这些tuples组成的list(列表)。若传入参数的长度不等,则返回list的长度和参数中长度最短的对象相同。利用*号操作符,可以将list unzip(解压)。

>>> a=zip(list(‘abcdefg‘),list(‘1234567‘))
>>> print a
[(‘a‘, ‘1‘), (‘b‘, ‘2‘), (‘c‘, ‘3‘), (‘d‘, ‘4‘), (‘e‘, ‘5‘), (‘f‘, ‘6‘), (‘g‘, ‘7‘)]
>>> zip(*a)
[(‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘, ‘f‘, ‘g‘), (‘1‘, ‘2‘, ‘3‘, ‘4‘, ‘5‘, ‘6‘, ‘7‘)]

二、字典访问

字典无序的,定义字典的顺序与生成字典的顺序是不一至的

通过字典的键,取得字典键所对应的值

>>> a={‘a‘:1,‘b‘:2,‘c‘:{‘d‘:3}}    #字典中包含字典
>>> print a
{‘a‘: 1, ‘c‘: {‘d‘: 3}, ‘b‘: 2}
>>> a[‘a‘]
1
>>> a[‘c‘]
{‘d‘: 3}
>>> a[‘c‘][‘d‘]
3
>>> a[‘a‘]=67    #字典更新
>>> a
{‘a‘: 67, ‘c‘: {‘d‘: 3}, ‘b‘: 2}
>>> del a[‘a‘]    #字典删除
>>> a
{‘c‘: {‘d‘: 3}, ‘b‘: 2}

三、字典方法

1.dict.keys()    获取字典内所有键,以列表返回

dict.values()    获取字典内所有值,以列表返回

>>> a=dict(zip(list(‘abcdef‘),list(‘1234567‘)))
>>> a
{‘a‘: ‘1‘, ‘c‘: ‘3‘, ‘b‘: ‘2‘, ‘e‘: ‘5‘, ‘d‘: ‘4‘, ‘f‘: ‘6‘}
>>> a.keys()
[‘a‘, ‘c‘, ‘b‘, ‘e‘, ‘d‘, ‘f‘]
>>> a.keys()[3]
‘e‘
>>> a.values()
[‘1‘, ‘3‘, ‘2‘, ‘5‘, ‘4‘, ‘6‘]
>>> a.values()[3]
‘5‘

2.dict.pop(k,[d])

弹出指定键k所对应的值,并且将该键及其所对应的值删除,如果键没有找到,将返回指定d

>>> a
{‘a‘: ‘1‘, ‘c‘: ‘3‘, ‘b‘: ‘2‘, ‘e‘: ‘5‘, ‘d‘: ‘4‘, ‘f‘: ‘6‘}
>>> a.pop(‘c‘)
‘3‘
>>> a
{‘a‘: ‘1‘, ‘b‘: ‘2‘, ‘e‘: ‘5‘, ‘d‘: ‘4‘, ‘f‘: ‘6‘}
>>> a.pop(‘c‘,‘not found‘)
‘not found‘
>>> a.pop(‘d‘,‘not found‘)
‘4‘

3.dict.update()

更新字典内键与值,键名即使是字符串,在更新时不需要加引号,更新是以赋值的方式进行。等价于dict[‘key‘]=‘new-value‘

>>> a
{‘a‘: ‘1‘, ‘b‘: ‘2‘, ‘e‘: ‘5‘, ‘f‘: ‘6‘}
>>> a.update(a=55)
>>> a
{‘a‘: 55, ‘b‘: ‘2‘, ‘e‘: ‘5‘, ‘f‘: ‘6‘}
>>> a[‘a‘]=66
>>> a
{‘a‘: 66, ‘b‘: ‘2‘, ‘e‘: ‘5‘, ‘f‘: ‘6‘}

4.dict.get()    获取字典内所有键对应的值,与d[‘keyname‘]相同

>>> a
{‘a‘: 66, ‘b‘: ‘2‘, ‘e‘: ‘5‘, ‘f‘: ‘6‘}
>>> a.get(‘a‘)
66
>>> a[‘a‘]
66

5.dict.items()

将字典的键和值放在一个元组中,每一个键和值作为一个元组,放在列表中存储返回

>>> a
{‘a‘: 66, ‘b‘: ‘2‘, ‘e‘: ‘5‘, ‘f‘: ‘6‘}
>>> a.items()
[(‘a‘, 66), (‘b‘, ‘2‘), (‘e‘, ‘5‘), (‘f‘, ‘6‘)]

6.dict.popitem()    随机的删除字典中的一个键值对,并且以元组的方式返回

>>> a
{‘a‘: ‘1‘, ‘c‘: ‘3‘, ‘b‘: ‘2‘, ‘e‘: ‘5‘, ‘d‘: ‘4‘, ‘g‘: ‘7‘, ‘f‘: ‘6‘, ‘i‘: ‘9‘, ‘h‘: ‘8‘, ‘j‘: ‘0‘}
>>> a.popitem()
(‘a‘, ‘1‘)
>>> a.popitem()
(‘c‘, ‘3‘)
>>> a.popitem()
(‘b‘, ‘2‘)
>>> a.popitem()
(‘e‘, ‘5‘)

7.dict.viewitems()    返回字典dict的元素视图

dict.viewkeys()     返回字典dict的键视图

dict.viewvalues()   返回字典dict的值视图

>>> a
{‘d‘: ‘4‘, ‘g‘: ‘7‘, ‘f‘: ‘6‘, ‘i‘: ‘9‘, ‘h‘: ‘8‘, ‘j‘: ‘0‘}
>>> a.viewitems()
dict_items([(‘d‘, ‘4‘), (‘g‘, ‘7‘), (‘f‘, ‘6‘), (‘i‘, ‘9‘), (‘h‘, ‘8‘), (‘j‘, ‘0‘)])
>>> a.viewkeys()
dict_keys([‘d‘, ‘g‘, ‘f‘, ‘i‘, ‘h‘, ‘j‘])
>>> a.viewvalues()
dict_values([‘4‘, ‘7‘, ‘6‘, ‘9‘, ‘8‘, ‘0‘])

8.dict.iteritems()    返回字典dict的迭代对象

dict.iterkeys()     返回字典dict的键的迭代对象

dict.itervalues()   返回字典dict的值迭代对象

>>> a
{‘d‘: ‘4‘, ‘g‘: ‘7‘, ‘f‘: ‘6‘, ‘i‘: ‘9‘, ‘h‘: ‘8‘, ‘j‘: ‘0‘}
>>> a.iteritems()
<dictionary-itemiterator object at 0x0000000002E2FA98>
>>> a.iterkeys()
<dictionary-keyiterator object at 0x0000000002E41548>
>>> a.itervalues()
<dictionary-valueiterator object at 0x0000000002E2FA98>
>>> a.iteritems().next()
(‘d‘, ‘4‘)
>>> a.iterkeys().next()
‘d‘
>>> a.itervalues().next()
‘4‘

9.dict.setdefault(k,[d])

如果键在字典中,返回字典键所对应的值,如果不在创建该键,值默认为None,如果d给定值,值为d

>>> a
{‘d‘: ‘4‘, ‘g‘: ‘7‘, ‘f‘: ‘6‘, ‘i‘: ‘9‘, ‘h‘: ‘8‘, ‘j‘: ‘0‘}
>>> a.setdefault(‘d‘,99)
‘4‘
>>> a.setdefault(‘a‘)    #创建键a
>>> a
{‘a‘: None, ‘d‘: ‘4‘, ‘g‘: ‘7‘, ‘f‘: ‘6‘, ‘i‘: ‘9‘, ‘h‘: ‘8‘, ‘j‘: ‘0‘}
>>> a.setdefault(‘a‘,99)    #存在键a,不再创建,a的值为None,没有显示
>>> a
{‘a‘: None, ‘d‘: ‘4‘, ‘g‘: ‘7‘, ‘f‘: ‘6‘, ‘i‘: ‘9‘, ‘h‘: ‘8‘, ‘j‘: ‘0‘}
>>> a.setdefault(‘b‘,88)    #创建键b,并赋值为88,将88弹出
88
>>> a
{‘a‘: None, ‘b‘: 88, ‘d‘: ‘4‘, ‘g‘: ‘7‘, ‘f‘: ‘6‘, ‘i‘: ‘9‘, ‘h‘: ‘8‘, ‘j‘: ‘0‘}

10.dict.copy()    产生字典副本,或者说是替身

a=dict(zip(list(‘abcdefg‘),list(‘123456789‘)))
b=a.copy()
print a
print b
print b is a
b[‘a‘]=99
print b
print a

执行结果为

{‘a‘: ‘1‘, ‘c‘: ‘3‘, ‘b‘: ‘2‘, ‘e‘: ‘5‘, ‘d‘: ‘4‘, ‘g‘: ‘7‘, ‘f‘: ‘6‘}
{‘a‘: ‘1‘, ‘c‘: ‘3‘, ‘b‘: ‘2‘, ‘e‘: ‘5‘, ‘d‘: ‘4‘, ‘g‘: ‘7‘, ‘f‘: ‘6‘}
False
{‘a‘: 99, ‘c‘: ‘3‘, ‘b‘: ‘2‘, ‘e‘: ‘5‘, ‘d‘: ‘4‘, ‘g‘: ‘7‘, ‘f‘: ‘6‘}
{‘a‘: ‘1‘, ‘c‘: ‘3‘, ‘b‘: ‘2‘, ‘e‘: ‘5‘, ‘d‘: ‘4‘, ‘g‘: ‘7‘, ‘f‘: ‘6‘}
import copy
a=list(‘abcdefg‘)
b=copy.copy(a)
print a
print b

可以使用这种方法,复制列表等其他对象,执行结果为

[‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘, ‘f‘, ‘g‘]
[‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘, ‘f‘, ‘g‘]

11.dict.clear()    清除字典内的所有键、值

>>> a
{‘a‘: ‘1‘, ‘c‘: ‘3‘, ‘b‘: ‘2‘, ‘e‘: ‘5‘, ‘d‘: ‘4‘, ‘g‘: ‘7‘, ‘f‘: ‘6‘}
>>> a.clear()
>>> a
{}

12.dict.has key()

成员关系检查,判断字典中是否存在指定的键

python3.0 has key将不在支持,被in替代

>>> a
{‘a‘: ‘1‘, ‘c‘: ‘3‘, ‘b‘: ‘2‘, ‘e‘: ‘5‘, ‘d‘: ‘4‘, ‘g‘: ‘7‘, ‘f‘: ‘6‘}
>>> a.has_key(‘a‘)
True
>>> a.has_key(‘h‘)
False
>>> ‘a‘ in a
True
>>> ‘a‘ not in a
False
>>> ‘h‘ in a
False
>>> ‘h‘ not in a
True

四、Python元组

Python元组是python重要的数据对象

元组大多数情况下,用于系统的输入或者系统的返回,元组的特性是不可以修改,但是支持迭代

元组的方法相对来说,比较少,只有count 和 index

元组的定义是以"()"包含以","作为分割元素的对象,元素也可以是任何的数据对象

五、Python数据类型比较

python 数据类型十分灵活,分别有列表,字典,元组

比较点 列表 字典 元组
表示方法 [],[1,2] {},{‘a‘:1,‘b‘:2} (),(1,2)
访问元素的方式 索引 索引
有序性 有序 无序 有序
可变性 可变 可变 不可变
可操作性 操作丰富 操作丰富 操作单调
时间: 2024-11-07 07:36:24

Python学习笔记4—Python字典元组的相关文章

python学习笔记2—python文件类型、变量、数值、字符串、元组、列表、字典

python学习笔记2--python文件类型.变量.数值.字符串.元组.列表.字典 一.Python文件类型 1.源代码 python源代码文件以.py为扩展名,由pyton程序解释,不需要编译 [[email protected] day01]# vim 1.py #!/usr/bin/python        print 'hello world!' [[email protected] day01]# python 1.py hello world! 2.字节代码 Python源码文件

python学习笔记4:字典

python学习笔记4:字典 总结:字典是可变变量: 字典是不排序的,所以不能像列表,元组,字符串一样,切片 1.定义字典dict  --花括号{},字典的只是key-value形式 比如:stu={'name':'zhangying','age':18,'score'=99} 2.key取值,get()方法取值 1)dictname[key] , 取key对应的value值,如果不存在,报错 2)dictname.get(key) , 取key对应的value值,如果不存在,返回none:还可

python 学习笔记 7 -- Python关键字总结

0.写在前面的话 学习一门语言最重要的功课是练习与复习,在<笨方法学Python>中第三十七节虽然没有教你任何内容,但是它提醒我们:"学了这么多,你还能记得多少?该复习了!" 下面我们就对这一节的第一部分"关键字"来做个复习: Python中的关键字包括如下: and       del        from      not      while    as        elif       global    or       with     

python学习笔记之列表、元组、字典(1)

1.最基本的数据结构:序列 a.任何序列都是从 0 序列号(也成为索引)开始的: 如下:第一个元素是‘H’ >>> a = 'Hello'>>> a[0]'H' b.序列的操作: 分片:a[1:5]  #表示从第2个元素到第6个元素,但不包括第6个元素 a[-3:-1] #表示从倒数第3个元素到倒数第一个元素,但不包括倒数第一个元素 a[-3:]   #表示从倒数第三个元素到最后一个元素,可以取到最后一个元素 a[:]  #表示a的全部元素 a[1:9:2]  #表示从

python 学习笔记 二 序列, 列表, 元组, 字符串

序列 序类是一个集合概念, Pthon包括六种内建序列: 列表, 元组, 字符串, Unicode字符串, buffer对象和xrange对象. 其中, 我们最长用的要数前三个. 通用序列操作 1. 索引(indexing) 序列的所有元素都是有编号的(从0开始...), 这些元素可以通过编号访问, 如: >>> greeting = 'Hello' >>> greeting[0] 'H' 使用负数索引(从-1开始...)是从右边开始的: >>> gr

python学习笔记(一):python简介和入门

最近重新开始学习python,之前也自学过一段时间python,对python还算有点了解,本次重新认识python,也算当写一个小小的教程.一.什么是python?python是一种面向对象.解释型的计算机语言,它的特点是语法简洁.优雅.简单易学.在1989诞生,Guido(龟叔)开发.这里的python并不是蟒蛇的意思,而是龟叔非常喜欢一部叫做<Monty Python飞行马戏团>的电视剧,所以以python命名(老外就是这么任性).二.解释型语言和编译型语言编译型语言就是先把写好的程序翻

python学习笔记(python发展介绍)

一.python介绍 python的创始人为吉多·范罗苏姆(Guido van Rossum) 目前python主要应用领域: ·云计算 ·WEB开发 ·科学运算.人工智能 ·系统运维 ·金融:量化交易,金融分析等,作为动态语言的python,语言结构清晰简单,库丰富,成熟稳定,科学计算和统计分析都很牛 ·图形GUI python是一门什么样的语言? 编程语言主要从以下几个角度进行分类,编译型和解释型.静态语言和动态语言.强类型定义语言和弱类型定义语言. 编译型和解释型 编译型,如:c,c++,

python学习笔记3:基础(元组、字符串、列表、字典)

参考文档:http://www.cnblogs.com/liu-yao/p/5145876.html 一,对象与类 对象: python中一切皆为对象,所谓对象:我自己就是一个对象,我玩的电脑就是对象,玩的手机就是对象. 我们通过描述属性(特征)和行为来描述一个对象的. 在python中,一个对象的特征也称为属性(attribute).它所具有的行为也称为方法(method) 结论:对象=属性+方法 在python中,把具有相同属性和方法的对象归为一个类(class) 比如人类,动物,植物等等,

python学习笔记(四)列表、元组、字符串及字典

1.列表及元组操作 1.1 列表 Python内置的一种数据类型是列表:list.list是一种有序的集合,可以随时添加和删除其中的元素. 定义列表: 1 >>> namelist = ['cc','uu','tt','yy','nn'] 变量namelist就是一个list.用len()函数可以获得list元素的个数: 1 >>> print(len(namelist)) 1.1.1 list取值 用索引来访问list中每一个位置的元素,记得索引是从0开始的: 1 &