python字典 *** 作函数

字典是一种通过名字或者关键字引用的得数据结构，其键可以是数字、字符串、元组，这种结构类型也称之为映射。字典类型是Python中唯一内建的映射类型，基本的 *** 作包括如下：

(1)len()：返回字典中键—值对的数量；

(2)d[k]:返回关键字对于的值；

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

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

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

(6)clear函数：清除字典中的所有项

(7)copy函数：返回一个具有相同键值的新字典；deepcopy()函数使用深复制，复制其包含所有的值，这个方法可以解决由于副本修改而使原始字典也变化的问题

(8)fromkeys函数：使用给定的键建立新的字典，键默认对应的值为None

(9)get函数：访问字典成员

(10)has_key函数：检查字典中是否含有给出的键

(11)items和iteritems函数:items将所有的字典项以列表方式返回，列表中项来自（键，值），iteritems与items作用相似，但是返回的是一个迭代器对象而不是列表

(12)keys和iterkeys：keys将字典中的键以列表形式返回，iterkeys返回键的迭代器

(13)pop函数：删除字典中对应的键

(14)popitem函数：移出字典中的项

(15)setdefault函数：类似于get方法，获取与给定键相关联的值，也可以在字典中不包含给定键的情况下设定相应的键值

(16)update函数：用一个字典更新另外一个字典

(17) values和itervalues函数：values以列表的形式返回字典中的值，itervalues返回值得迭代器，由于在字典中值不是唯一的，所以列表中可以包含重复的元素

一、字典的创建

11 直接创建字典

d={'one':1,'two':2,'three':3}

printd

printd['two']

printd['three']

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\testpy=======

{'three':3,'two':2,'one':1}

>>>

12 通过dict创建字典

# __ coding:utf-8 __

items=[('one',1),('two',2),('three',3),('four',4)]

printu'items中的内容:'

printitems

printu'利用dict创建字典，输出字典内容:'

d=dict(items)

printd

printu'查询字典中的内容:'

printd['one']

printd['three']

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\testpy=======

items中的内容:

[('one',1), ('two',2), ('three',3), ('four',4)]

利用dict创建字典，输出字典内容:

{'four':4,'three':3,'two':2,'one':1}

查询字典中的内容:

>>>

或者通过关键字创建字典

# __ coding:utf-8 __

d=dict(one=1,two=2,three=3)

printu'输出字典内容:'

printd

printu'查询字典中的内容:'

printd['one']

printd['three']

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\testpy=======

输出字典内容:

{'three':3,'two':2,'one':1}

查询字典中的内容:

>>>

二、字典的格式化字符串

# __ coding:utf-8 __

d={'one':1,'two':2,'three':3,'four':4}

printd

print"three is %(three)s"%d

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\testpy=======

{'four':4,'three':3,'two':2,'one':1}

threeis3

>>>

三、字典方法

31 clear函数：清除字典中的所有项

# __ coding:utf-8 __

d={'one':1,'two':2,'three':3,'four':4}

printd

dclear()

printd

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\testpy=======

{'four':4,'three':3,'two':2,'one':1}

{}

>>>

请看下面两个例子

311

# __ coding:utf-8 __

d={}

dd=d

d['one']=1

d['two']=2

printdd

d={}

printd

printdd

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\testpy=======

{'two':2,'one':1}

{}

{'two':2,'one':1}

>>>

312

# __ coding:utf-8 __

d={}

dd=d

d['one']=1

d['two']=2

printdd

dclear()

printd

printdd

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\testpy=======

{'two':2,'one':1}

{}

{}

>>>

312与311唯一不同的是在对字典d的清空处理上，311将d关联到一个新的空字典上，这种方式对字典dd是没有影响的，所以在字典d被置空后，字典dd里面的值仍旧没有变化。但是在312中clear方法清空字典d中的内容，clear是一个原地 *** 作的方法，使得d中的内容全部被置空，这样dd所指向的空间也被置空。

32 copy函数：返回一个具有相同键值的新字典

# __ coding:utf-8 __

x={'one':1,'two':2,'three':3,'test':['a','b','c']}

printu'初始X字典：'

printx

printu'X复制到Y：'

y=xcopy()

printu'Y字典：'

printy

y['three']=33

printu'修改Y中的值，观察输出：'

printy

printx

printu'删除Y中的值，观察输出'

y['test']remove('c')

printy

printx

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\testpy=======

初始X字典：

{'test': ['a','b','c'],'three':3,'two':2,'one':1}

X复制到Y：

Y字典：

{'test': ['a','b','c'],'one':1,'three':3,'two':2}

修改Y中的值，观察输出：

{'test': ['a','b','c'],'one':1,'three':33,'two':2}

{'test': ['a','b','c'],'three':3,'two':2,'one':1}

删除Y中的值，观察输出

{'test': ['a','b'],'one':1,'three':33,'two':2}

{'test': ['a','b'],'three':3,'two':2,'one':1}

>>>

注：在复制的副本中对值进行替换后，对原来的字典不产生影响，但是如果修改了副本，原始的字典也会被修改。deepcopy函数使用深复制，复制其包含所有的值，这个方法可以解决由于副本修改而使原始字典也变化的问题。

# __ coding:utf-8 __

fromcopyimportdeepcopy

x={}

x['test']=['a','b','c','d']

y=xcopy()

z=deepcopy(x)

printu'输出：'

printy

printz

printu'修改后输出：'

x['test']append('e')

printy

printz

运算输出：

=======RESTART: C:\Users\Mr_Deng\Desktop\testpy=======

输出：

{'test': ['a','b','c','d']}

{'test': ['a','b','c','d']}

修改后输出：

{'test': ['a','b','c','d','e']}

{'test': ['a','b','c','d']}

>>>

33 fromkeys函数：使用给定的键建立新的字典，键默认对应的值为None

# __ coding:utf-8 __

d=dictfromkeys(['one','two','three'])

printd

运算输出：

=======RESTART: C:\Users\Mr_Deng\Desktop\testpy=======

{'three':None,'two':None,'one':None}

>>>

或者指定默认的对应值

# __ coding:utf-8 __

d=dictfromkeys(['one','two','three'],'unknow')

printd

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\testpy=======

{'three':'unknow','two':'unknow','one':'unknow'}

>>>

34 get函数：访问字典成员

# __ coding:utf-8 __

d={'one':1,'two':2,'three':3}

printd

printdget('one')

printdget('four')

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\testpy=======

{'three':3,'two':2,'one':1}

1

None

>>>

注：get函数可以访问字典中不存在的键，当该键不存在是返回None

35 has_key函数：检查字典中是否含有给出的键

# __ coding:utf-8 __

d={'one':1,'two':2,'three':3}

printd

printdhas_key('one')

printdhas_key('four')

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\testpy=======

{'three':3,'two':2,'one':1}

True

False

>>>

36 items和iteritems函数:items将所有的字典项以列表方式返回，列表中项来自（键，值），iteritems与items作用相似，但是返回的是一个迭代器对象而不是列表

# __ coding:utf-8 __

d={'one':1,'two':2,'three':3}

printd

list=ditems()

forkey,valueinlist:

  printkey,':',value

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\testpy=======

{'three':3,'two':2,'one':1}

three :3

two :2

one :1

>>>

# __ coding:utf-8 __

d={'one':1,'two':2,'three':3}

printd

it=diteritems()

fork,vinit:

  print"d[%s]="%k,v

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\testpy=======

{'three':3,'two':2,'one':1}

d[three]=3

d[two]=2

d[one]=1

>>>

37 keys和iterkeys：keys将字典中的键以列表形式返回，iterkeys返回键的迭代器

# __ coding:utf-8 __

d={'one':1,'two':2,'three':3}

printd

printu'keys方法：'

list=dkeys()

printlist

printu'\niterkeys方法：'

it=diterkeys()

forxinit:

  printx

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\testpy=======

{'three':3,'two':2,'one':1}

keys方法：

['three','two','one']

iterkeys方法：

three

two

one

>>>

38 pop函数：删除字典中对应的键

# __ coding:utf-8 __

d={'one':1,'two':2,'three':3}

printd

dpop('one')

printd

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\testpy=======

{'three':3,'two':2,'one':1}

{'three':3,'two':2}

>>>

39 popitem函数：移出字典中的项

# __ coding:utf-8 __

d={'one':1,'two':2,'three':3}

printd

dpopitem()

printd

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\testpy=======

{'three':3,'two':2,'one':1}

{'two':2,'one':1}

>>>

310 setdefault函数：类似于get方法，获取与给定键相关联的值，也可以在字典中不包含给定键的情况下设定相应的键值

# __ coding:utf-8 __

d={'one':1,'two':2,'three':3}

printd

printdsetdefault('one',1)

printdsetdefault('four',4)

printd

运算结果：

{'three':3,'two':2,'one':1}

{'four':4,'three':3,'two':2,'one':1}

>>>

311 update函数：用一个字典更新另外一个字典

# __ coding:utf-8 __

d={

  'one':123,

  'two':2,

  'three':3

  }

printd

x={'one':1}

dupdate(x)

printd

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\testpy=======

{'three':3,'two':2,'one':123}

{'three':3,'two':2,'one':1}

>>>

312 values和itervalues函数：values以列表的形式返回字典中的值，itervalues返回值得迭代器，由于在字典中值不是唯一的，所以列表中可以包含重复的元素

# __ coding:utf-8 __

d={

  'one':123,

  'two':2,

  'three':3,

  'test':2

  }

printdvalues()

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\testpy=======

[2,3,2,123]

>>>

在Python中使用字典，格式如下：

dict={ key1:value1 , key2;value2 }

在实际访问字典值时的使用格式如下：

dict[key]

多键值

字典的多键值形式如下：

dict={(ke11,key12)：value ，(key21,key22):value }

在实际访问字典里的值时的具体形式如下所示(以第一个键为例)：

dict[key11,key12]

或者是：

dict[(key11,key12)]

以下是实际例子：

由于字典长，我将前10个改为前5个，你只需要将，我回答中的4改为9就行。

例如字典

a={'the': 958035, 'of': 536684, 'and': 375233, 'one': 371796, 'in': 335503, 'a': 292250, 'to': 285093, 'zero': 235406, 'nine': 224705}

一：只想看看元素。如果字典很长，只想看前5个，可以先变成list，再取索引来看。利用了字典的items方法。

print(list(vocabitems())[:5]) # 先items取元素，再转list，再切片取前5，最后print输出

输出为[('the', 958035), ('of', 536684), ('and', 375233), ('one', 371796), ('in', 335503)]

二。要获取前5个元素。遍历字典：

for i,(k,v) in enumerate(aitems()):

print({k:v},end="")

if i==4:

print()

break

输出：{'the': 958035}{'of': 536684}{'and': 375233}{'one': 371796}{'in': 335503}

三。保持原来字典样式，取前5个元素。

a={'the': 958035, 'of': 536684, 'and': 375233, 'one': 371796, 'in': 335503, 'a': 292250,

'to': 285093, 'zero': 235406, 'nine': 224705}

new_a = {}

for i,(k,v) in enumerate(aitems()):

new_a[k]=v

if i==4:

print(new_a)

break

输出：{'the': 958035, 'of': 536684, 'and': 375233, 'one': 371796, 'in': 335503}

1、设定缓存放在那里：CACHE_BACKEND

也可以使用memcached:CACHE_BACKEND = 'memcached://127001:11211/'

多个memcached:CACHE_BACKEND = 'memcached://1721926240:11211;1721926242:11211/'

/// pip install python-memcached

2、python *** 作memcached:

import memcache

mc = memcacheClient(['1391295191:12000'], debug=True)

mcset("name", "python")

ret = mcget('name')

print (ret)

python

3、设置权重

import memcache

mc = memcacheClient([('1111:12000', 1), ('1112:12000', 2),('1113:12000',3)])

mcset('k1','value1')

ret = mcget('k1')

print (ret)

4、已经存在的键重复添加会出错：

import memcache

mc = memcacheClient(['0000:12000'])

mcadd('k1', 'v1')

mcadd('k1', 'v2') # 报错，对已经存在的key重复添加，失败！！！

例如：

ret1 = mcadd('name','tom')

print(refalse)

ret2 = mcadd('name','jack')

print(retrue)

结果：

False #当已经存在key 那么返回false

True #如果不存在key 那么返回treue

5、替换 *** 作：replace,如果键不存在，出错

import memcache

mc = memcacheClient(['0000:12000'])

mcset('name','tom')

re = mcget('name')

print(re)

rereplace = mcreplace('name','jack')

re = mcget('name')

print(rereplace,re)

结果：

tom #第一次赋值

True jack #如果存在key那么修改成功为yaoyao 返回True

rereplace = mcreplace('name1','hahaha')

re = mcget('name1')

print(rereplace,re)

结果：

False None #如果不存在key，修改失败，返回空值

6、set:键值存在，就修改，不存在，则创建

import memcache

mc = memcacheClient(['0000:12000'])

mcset('name','tom')

re = mcget('name')

print('set用法',re) #设置一个键值对

dic = {'name':'to,','age':'19','job':'IT'}

mcset_multi(dic) #设置多个键值对

mcname = mcget('name')

mcage = mcget('age')

mcjob = mcget('job')

print('set_multi用法:',mcname,mcage,mcjob)

7、delete:

import memcache

mc = memcacheClient(['0000:12000'])

mcset('name','tom')

re = mcget('name')

print('存在',re)

mcdelete('name')

re = mcget('name')

print('删除',re) #删除一个键值对

8、get

import memcache

mc = memcacheClient(['0000:12000'])

mcset('name','tom')

re = mcget('name')

print('get',re) #获取一个键值对

dic = {'name':'to,','age':'19','job':'IT'}

mcset_multi(dic)

regetmu=mcget_multi(['name','age','job'])

print('get_multi',re) #获取多个键值对的值

9、append,prepend

import memcache

mc = memcacheClient(['0000:12000'])

mcset('num','第一|')

re = mcget('num')

print(re)

mcappend('num','追加第二个') #在第一后面追加

re = mcget('num')

print(re)

mcprepend('num','我是零个') #在第一前面追加

re = mcget('num')

print(re)

结果：

第一|

第一|追加第二个

我是零个第一|追加第二个

10、decr,incr自增自减

import memcache

mc = memcacheClient(['0000:12000'])

mcset('num','1')

re = mcget('num')

print('我是没加过的值',re)

mcincr('num','9')

re = mcget('num')

print('我是加上新增后的值',re)

mcdecr('num','5')

re = mcget('num')

print('我是减去的值',re)

我是没加过的值 1

我是加上新增后的值 10

是减去的值 5

11、锁机制：gets cas

import memcache

mc = memcacheClient(['0000:12000'],cache_cas=True)

mcset('count','10')

reget = mcget('count')

print('件数',reget)

regets = mcgets('count')

print(regets)

下面的设置将会执行失败，剖出异常，从而避免非正常数据的产生

recas = mccas('count','11')

print(recas)

regets = mcgets('count')

print('修改',regets)

添加键值对

首先定义一个空字典

>>> dic={}

直接对字典中不存在的key进行赋值来添加

>>> dic['name']='zhangsan'

>>> dic

{'name': 'zhangsan'}

如果key或value都是变量也可以用这种方法

>>> key='age'

>>> value=30

>>> dic[key]=value

>>> dic

{'age': 30 'name': 'zhangsan'}

这里可以看到字典中的数据并不是按先后顺序排列的，如果有兴趣，可以搜一搜数据结构中的——哈希表

从python37开始，字典按照插入顺序，实现了有序。修改一个已存在的key的值，不影响顺序，如果删了一个key后再添加该key，该key会被添加至末尾。标准json库的dump(s)/load(s)也是有序的

还可以用字典的setdefault方法

>>> dicsetdefault('sex','male')

'male'

>>> key='id'

>>> value='001'

>>> dicsetdefault(key,value)

'001'

>>> dic

{'id': '001', 'age': 30 'name': 'zhangsan', 'sex': 'male'}

“键值对”是组织数据的一种重要方式，广泛应用在Web系统中。键值对的基本思想是将“值”信息关联一个“键”信息，进而通过键信息查找对应值信息，这个过程叫映射。Python语言中通过字典类型实现映射。

Python语言中的字典使用大括号{}建立，每个元素是一个键值对，使用方式如下:

                     {<键1>:<值1>, <键2>:<值2>, , <键n>:<值n>}

其中，键和值通过冒号连接，不同键值对通过逗号隔开。字典类型也具有和集合类似的性质，即键值对之间没有顺序且不能重复。 

列表类型采用元素顺序的位置进行索引。由于字典元素“键值对”中键是值的索引，因此，可以直接利用键值对关系索引元素。

字典中键值对的索引模式如下，采用中括号格式:

                                         <值> = <字典变量>[<键>]

print(d[‘201801’])    

输出的也就是: 小明

使用大括号可以创建字典。通过索引和赋值配合，可以向字典中增加元素。

字典是存储可变数量键值对的数据结构，键和值可以是任意数据类型，通过键索引值，并可以通过键修改值。

字典类型有一些通用的 *** 作函数

dict()函数用于生成一个空字典，作用和{}一致

字典类型存在一些 *** 作方法，使用语法形式是:

                                 <字典变量><方法名称>(<方法参数>)

dkeys()返回字典中的所有键信息，返回结果是Python的一种内部数据类型dict_keys，专用于表示字典的键。如果希望更好的使用返回结果，可以将其转换为列表类型。

dvalues()返回字典中的所有值信息，返回结果是Python的一种内部数据类型dict_values。如果希望更好的使用返回结果，也可以将其转换为列表类型。

ditems()返回字典中的所有键值对信息，返回结果是Python的一种内部数据类型dict_items。当然也可以转成列表类型   即: list(ditems())

dget(key, default)根据键信息查找并返回值信息，如果key存在则返回相应值，否则返回默认值，第二个元素default可以省略，如果省略则默认值为空。  例如:  就拿上边的数组d  来说 dget(‘201801’,“不存在”)   相当于一个if语句  如果key  201801 存在  就返回201801 values  不存在就返回   默认值  不存在

dpop(key, default)根据键信息查找并取出值信息，如果key存在则返回相应值，否则返回默认值，第二个元素default可以省略，如果省略则默认值为空。相比dget()方法，dpop()在取出相应值后，将从字典中删除对应的键值对。  和dget方法类似 

dpopitem()随机从字典中取出一个键值对，以元组(key,value)形式返回。取出后从字典中删除这个键值对。

dclear()删除字典中所有键值对。

此外，如果希望删除字典中某一个元素，可以使用Python保留字del。   即: del  d[key]

字典类型也支持保留字in，用来判断一个键是否在字典中。如果在则返回True，否则返回False。

与其他组合类型一样，字典可以遍历循环对其元素进行遍历，基本语法结构如下:

                                      for <变量名> in <字典名>

                                            <语句块>

for循环返回的变量名是字典的索引值。如果需要获得键对应的值，可以在语句块中通过get()方法获得。

以上就是本章的所有内容,感谢大家

Python 学习的基础（持续更新中）

这么讲你肯定明白了

例如,要记录一个班级里面学生的成绩,可以采用

姓名:成绩,

为了不引起混乱,规定(记住,是规定)任意2个学生姓名不能相同,但是成绩可以相同,很好理解吧

字典相当于成绩记录表,键就是姓名,值就是成绩键必须具有唯一性,值则任意了

以上就是关于python字典 *** 作函数全部的内容，包括:python字典 *** 作函数、python字典如何同时输出多个键值、python怎样获取字典中前十个等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！