python基础教程之字典操作详解

python基础教程之字典操作详解（精选12篇）

python基础教程之字典操作详解 第1篇

-04-04python启动办公软件进程(word、excel、ppt、以及wps的et、wps、w

-01-01python获得图片base64编码示例

-12-12python2.7删除文件夹和删除文件代码实例

2014-05-05Python中os和shutil模块实用方法集锦

-05-05python访问纯真IP数据库的代码

2009-04-04python 获取et和excel的版本号

-04-04python远程登录代码

2009-05-05python 正则式使用心得

2013-11-11python插入排序算法的实现代码

2013-11-11python批量导出导入MySQL用户的方法

python基础教程之字典操作详解 第2篇

setdefault()方法类似于get()方法，但会设置字典[键]=默认情况下，如果键不是已经在字典中，

方法

以下是setdefault()方法的语法：

dict.setdefault(key, default=None)

参数

key -- 这是要被搜索的键

default -- 这是没有找到键的情况下返回的值，

返回值

此方法返回字典可用的键值，如果给定键不可用，则它会返回所提供的默认值。

例子

下面的例子显示了setdefault()方法的使用。

#!/usr/bin/pythondict = {Name: Zara, Age: 7}print “Value : %s” % dict.setdefault(Age, None)print “Value : %s” % dict.setdefault(Sex, None)

当我们运行上面的程序，它会产生以下结果：

python基础教程之字典操作详解 第3篇

clear()方法将删除字典中的所有项目(清空字典)

语法

以下是clear()方法的语法：

dict.clear()

参数

NA

返回值

此方法不返回任何值，

在Python中操作字典之clear()方法的使用

，

例子

下面的例子显示了clear()方法的使用

#!/usr/bin/pythondict = {Name: Zara, Age: 7};print “Start Len : %d” % len(dict)dict.clear()print “End Len : %d” % len(dict)

当我们运行上面的程序，它会产生以下结果：

python基础教程之字典操作详解 第4篇

2014-06-06pycharm 使用心得(八)如何调用另一文件中的函数

2014-04-04Python的ORM框架SQLAlchemy入门教程

2014-02-02使用python装饰器验证配置文件示例

2014-06-06教你如何在Django 1.6中正确使用 Signal

2009-03-03python 判断自定义对象类型

2006-09-09Python开发编码规范

2013-03-03python中wx将图标显示在右下角的脚本代码

2014-04-04python中的__init__ 、__new__、__call__小结

python基础教程之字典操作详解 第5篇

flush()方法刷新内部缓冲区，像标准输入输出的fflush，这类似文件的对象，无操作。

Python关闭时自动刷新文件。但是可能要关闭任何文件之前刷新数据。

语法

以下是flush()方法的语法：

fileObject.flush();

参数

NA

返回值

此方法不返回任何值，

例子

下面的例子显示了flush()方法的使用。

#!/usr/bin/python# Open a filefo = open(“foo.txt”, “wb”)print “Name of the file: ”, fo.name# Here it does nothing, but you can call it with read operation.fo.flush()# Close opend filefo.close()

当我们运行上面的程序，它会产生以下结果：

python基础教程之字典操作详解 第6篇

这篇文章主要介绍了Python中字典映射类型的学习教程,是Python入门学习中的基础知识,需要的朋友可以参考下

字典是python语言中唯一的映射类型，用花括号{}表示，一个字典条目就是一个键值对，方法keys返回字典的键列表，values()返回字典的值列表，items()返回字典的键值对列表，字典中的值没有任何限制，它们可以是任意python对象，但字典中的键是有类型限制的，每个键只能对应一个值，且键必须是可哈系的，所有不可变类型都是可哈希的。不可变集合frozenset的元素可作为字典的键，但可变集合set就不行了。

以下是字典类型的常用方法。

clear()：删除字典中所有元素。

copy()：返回字典(浅复制)的一个副本。

fromkeys(seq,val=None)：创建并返回一个新字典，以seq中的元素做该字典的键，val做该字典中所有键对应的初始值。

get(key,default=None)：返回字典中的键key对应的值value，如果字典中不存在此键，则返回default的值。

has_key(key)：如果键key在字典中存在，返回True，否则返回False。python2.2后这个方法几乎已废弃不用了，通常用in来替代。

items()：返回一个包含字典中键值对元组的列表。

keys()：返回一个包含字典中键的列表。

iter()：方法iteritems()、iterkeys()、itervalues()与它们对应的非迭代方法一样，不同的是它们返回一个迭代子，而不是一个列表。

pop(key[,default])：和方法get()类似，如果字典中key键存在，删除并返回dict[key]，如果key键不存在，且没有给出default的值，引发KeyError异常。

setdefault(key,default=None)：和方法get()相似，如果字典中不存在key键，由dict[key]=default为它赋值。

update(dict2)：将字典dict2的键值对添加到当前字典中。

values()：返回一个包含字典中所有值的列表。

键可以是多种类型，但键是唯一的不重复的，值可以不唯一

>>>d = {a:1, b:2} >>>d {b: 2, a: 1} >>>L = [(Jonh,18), (Nancy,19)] >>>d = dict(L) #通过包含键值的列表创建 >>>d {Jonh: 18, Nancy: 19} >>>T = tuple(L) >>>T ((Jonh, 18), (Nancy, 19)) >>>d = dict(T) #通过包含键值的元组创建 >>>d {Jonh: 18, Nancy: 19} >>>d = dict(x = 1, y = 3) #通过关键字参数创建 >>>d {x: 1, y: 3} >>>d[3] = z >>>d {3: z, x: 1, y: 3}

还有一个创建字典的方法就是 fromkeys(S [ , v]) python里的解释是 New dict with key from S and value equal to v ，即将S里的元素作为键，v作为所有键的值，v 的默认值为 None。可以通过已存在的字典 d 调用 d.fromkeys(S [, v] ) 也可以通过类型调用 dict.fromkeys( S [, v] )

>>>d {3: z, y: 3} >>>L1 = [1,2,3] >>>d.fromkeys(L1) {1: None, 2: None, 3: None} >>>{}.fromkeys(L1,nothing) {1: nothing, 2: nothing, 3: nothing} >>>dict.fromkeys(L1,over) {1: over, 2: over, 3: over}

字典是无序的，所以不能通过索引来获取值，要通过键来找到关联值。对于不存在的键，会出现错误KeyError

>>>d {3: z, x: 1, y: 3} >>>d[3] z >>>d[x] 1 >>>d[0] Traceback (most recent call last): File “

”, line 1, in d[0] KeyError: 0

字典操作和方法：

len( d )返回字典d里面的键值对数目

x in d查询字典d中是否有键 x

>>>d = {x:1,y:3} >>>len(d) 2 >>>x in d True >>>z not in d True

d [ x ] = y若键 x 存在，则修改 x 对应的值为 y， 若键 x 不存在，则在字典 d 中增加键值对 x : y

>>>d {x: 1, y: 3} >>>d[x] = 1.5 >>>d {x: 1.5, y: 3} >>>d[z] = 5 >>>d {z: 5, x: 1.5, y: 3}

del d[x]删除字典 d 中键为 x 的键值对，若 x 不存在会出现 KeyError

>>>d = {z: 5, x: 1.5, y: 3} >>>del d[x] >>>d {z: 5, y: 3} >>>del d[x] Traceback (most recent call last): File “

”, line 1, in del d[x] KeyError: x

d.clear() 清空字典d

d.copy() 对字典 d 进行浅复制，返回一个和d有相同键值对的新字典

>>>d {z: 5, y: 3} >>>d.copy() {z: 5, y: 3}

d.get( x [ , y]) 返回字典 d 中键 x 对应的值，键 x 不存在的时候返回 y， y 的默认值为None

>>>d = {z: 5, x: 1.5, y: 3} >>>d.get(x) 1.5 >>>del d[x] >>>d.get(x) >>>d.get(x,nothing) nothing

d.items() 将字典 d 中所有键值对以dict_items的形式返回(Python 2中d.iteritems() 返回一个针对键值对的迭代器对象，Python 3中没有 iteritems 方法了)

>>>d = {z: 5, x: 1.5, y: 3} >>>d.items() dict_items([(z, 5), (x, 1.5), (y, 3)]) >>>list(d.items()) [(z, 5), (x, 1.5), (y, 3)]

d.keys() 将字典 d 中所有的键以dict_keys形式返回(Python 2 中d.iterkeys() 返回一个针对键的迭代器对象，Python 3 没有此语法)

>>>d.keys() dict_keys([z, x, y]) >>>for x in d.keys(): print(x) z x y

d.pop( x ) 返回给定键 x 对应的值，并将该键值对从字典中删除

>>>d = {z: 5, x: 1.5, y: 3} >>>d.pop(x) 1.5 >>>d.pop(x) Traceback (most recent call last): File “

”, line 1, in d.pop(x) KeyError: x

d.popitem( ) 返回并删除字典 d 中随机的键值对

>>>d = {z: 5, x: 1.5, y: 3} >>>d.popitem() (z, 5) >>>d.popitem() (x, 1.5)

d.setdefault( x, [ , y ] )返回字典 d 中键 x 对应的值，若键 x 不存在，则返回 y， 并将 x : y 作为键值对添加到字典中，y 的默认值为 None

>>>d = {z: 5, x: 1.5, y: 3} >>>d.setdefault(x) 1.5 >>>del d[x] >>>d.setdefault(x,Look!) Look! >>>d {z: 5, x: Look!, y: 3}

d.update( x ) 将字典 x 所有键值对添加到字典 d 中(不重复，重复的键值对用字典 x 中的键值对替代字典 d 中)

>>>d1 = {x:1, y:3} >>>d2 = {x:2, z:1.4} >>>d1.update(d2) >>>d1 {z: 1.4, x: 2, y: 3}

d.values( ) 将字典里所有的值以dict_values 的形式返回(Python 2 中d.itervalues() 返回针对字典d里所有值的迭代器对象，Python 3无此语法)

python基础教程之字典操作详解 第7篇

-02-02Python中使用中文的方法

-06-06python网络编程学习笔记(一)

2014-02-02python基础教程之python消息摘要算法使用示例

2014-06-06pycharm 使用心得(六)进行简单的数据库管理

-05-05ssh批量登录并执行命令的python实现代码

2014-04-04python中的__init__ 、__new__、__call__小结

-04-04python编程-将Python程序转化为可执行程序[整理]

2014-06-06Python struct模块解析

python基础教程之字典操作详解 第8篇

get()方法返回给定键的值，如果键不可用，则返回默认值None。

语法

以下是get()方法的语法：

dict.get(key, default=None)

参数

key -- 这是要搜索在字典中的键。

default -- 这是要返回键不存在的的情况下默认值，

返回值

该方法返回一个给定键的值。如果键不可用，则返回默认值为None。

例子

下面的例子显示了get()方法的使用。

#!/usr/bin/pythondict = {Name: Zara, Age: 27}print “Value : %s” % dict.get(Age)print “Value : %s” % dict.get(Sex, “Never”)

当我们运行上面的程序，它会产生以下结果：

python基础教程之字典操作详解 第9篇

JSON是一种轻量级的数据交换格式，各种语言都有良好的支持，字典是Python的一种数据结构。可以看成关联数组。

有些时候我们需要设计到字典转换成JSON序列化到文件，或者从文件中读取JSON。简单备忘一下。

Dict转JSON写入文件

代码如下:

#!/usr/bin/env python

# coding=utf-8

import json

d = {first: One, second:2}

json.dump(d, open(/tmp/result.txt, w))

写入结果

代码如下:

cat /tmp/result.txt

{“second”: 2, “first”: “One”}

读取JSON

代码如下:

#!/usr/bin/env python

# coding=utf-8

import json

d = json.load(open(/tmp/result.txt,r))

print d, type(d)

运行结果

代码如下:

{usecond: 2, ufirst: uOne}

python基础教程之字典操作详解 第10篇

time()方法返回时间，在UTC时代以秒表示浮点数，

注意：尽管在时间总是返回作为一个浮点数，并不是所有的系统提供时间超过1秒精度。虽然这个函数正常返回非递减的值，就可以在系统时钟已经回来了两次调用期间返回比以前调用一个较低的值。

语法

以下是time()方法的语法：

参数

NA

返回值

此方法返回的时间，因为时代以秒表示浮点数(在UTC)，

例子

下面的例子显示time()方法的使用。

#!/usr/bin/pythonimport timeprint “time.time(): %f ” % time.time()print time.localtime( time.time() )print time.asctime( time.localtime(time.time()) )

当我们运行上面的程序，它会产生以下结果：

python基础教程之字典操作详解 第11篇

这篇文章主要介绍了Python中字典的基础知识归纳小结,都是Python入门学习中的基本知识,值得反复巩固:)需要的朋友可以参考下

定义一个字典

>>> d = {“server”:“mpilgrim”, “database”:“master”} 1>>> d{server: mpilgrim, database: master}>>> d[“server”] 2mpilgrim>>> d[“database”] 3master>>> d[“mpilgrim”] 4

Traceback (innermost last):

File “”, line 1, in ?

KeyError: mpilgrim

首先，我们创建了一个拥有两个元素的新字典，并将其赋值给变量 d，每一个元素都是一个键-值对，整个元素集合用大括号括起来。

server 是一个键字，它所关联的值为 mpilgrim，用 d[“server”] 来引用。

database 是一个键字，它所关联的值为 master，用 d[“database”] 来引用。

你可以通过键字来得到值，但是不能通过值得到键字。所以 d[“server”] 为 mpilgrim，但是使用 d[“mpilgrim”] 会引发一个异常，因为 mpilgrim 不是一个键字。

修改一个字典

>>> d{server: mpilgrim, database: master}>>> d[“database”] = “pubs” 1>>> d{server: mpilgrim, database: pubs}>>> d[“uid”] = “sa” 2>>> d{server: mpilgrim, uid: sa, database: pubs}

不能在一个字典中有重复的键字。给一个存在的键字赋值会抹掉原来的值。

可以在任何时候加入新的键-值对。这种语法同修改存在的值一样。(是的，它可能某天会给你带来麻烦，你可能认为增加了新值，但实际上只是反复地修改了同样的值，因为你的键字没有按照你的想象改变。)

注意新的元素(键字为 uid，值为 sa)出现在字典中间。实际上，它只不过是一种巧合，在第一个例子中的元素看上去是有序的。现在它们看上去无序了则更是一种巧合。

Note

字典没有元素顺序的概念。说元素顺序乱了是不正确的，它们只是简单的无序。这是一个重要的特性，它会在你想要以一种特定的，可重复的顺序(象以键字的字母表顺序)存取字典元素的时候骚扰你。有一些实现的方法，它们只是没有加到字典中去。

在字典中混用数据类型

>>> d{server: mpilgrim, uid: sa, database: pubs}>>> d[“retrycount”] = 3 1>>> d{server: mpilgrim, uid: sa, database: master, retrycount: 3}>>> d[42] = “douglas” 2>>> d{server: mpilgrim, uid: sa, database: master, 42: douglas, retrycount: 3}

字典不是只用于字符串。字典的值可以是任意数据类型，包括字符串，整数，对象，或者甚至其它的字典。在一个单个字典里，字典的值并不需要全都是同一数据类型，可以根据需要混用和配匹。

字典的关键字要严格一些，但是它们可以是字符串，整数和几种其它的类型(后面还会谈到这一点)。也可以在一个字典中混用和配匹关键字。

从字典中删除元素

>>> d{server: mpilgrim, uid: sa, database: master, 42: douglas, retrycount: 3}>>> del d[42] 1>>> d{server: mpilgrim, uid: sa, database: master, retrycount: 3}>>> d.clear 2>>> d{}

del 允许你根据键字将单个元素从字典中删除。

clear 会删除一个字典中所有元素。注意空的大括号所表示的集合说明一个字典没有元素，

字符串是大小写敏感

>>> d = {}>>> d[“key”] = “value”>>> d[“key”] = “other value” 1>>> d{key: other value}>>> d[“Key”] = “third value” 2>>> d{Key: third value, key: other value}

将一个值赋给一个存在的字典关键字只是简单的用新值替换旧值。

这样做不会将一个值赋给一个存在的字典关键字，因为在Python中字符串是大小写敏感的，所以 key 与 Key 是不同的。这样就在字典中生成了一个新的键/值对。对你来说可能差不多，但对于Python来说，完全是不同的。

如何访问字典中的值:

>>> dict2 = {name:earth,port:80} >>> for key in dict2.keys(): ... print key=%s,value=%s %(key,dict2[key])...key=name,value=earthkey=port,value=80>>> for key in dict2: ... print key=%s,value=%s %(key,dict2[key])...key=name,value=earthkey=port,value=80

获取字典某个元素值:

>>> dict2[name]earth>>> print host %s is running on port %d %(dict2[name],dict2[port])host earth is running on port 80

检查字典中是否有某个键的方法 has_key()或in,not in

>>> name in dict2True>>> server in dict2False>>> name in dict2 True>>> dict2[name]earth>>> dict2.has_key(server)False>>> dict2.has_key(name) True

一个字典中混用数字和字符串的例子:

>>> dict3 = {}>>> dict3[1] = abc>>> dict3[1] = 3.14159>>> dict3[3.2] = xyz>>> dict3{1: 3.14159, 1: abc, 3.2: xyz}

整体赋值:

>>> dict3 = {1: 3.14159, 1: abc, 3.2: xyz,33:hehe}>>> dict3{1: 3.14159, 1: abc, 3.2: xyz, 33: hehe}

更新字典:

>>> dict2[name] = venus>>> dict2[port] = 6969>>> dict2[arch] = sunos5>>> print host %(name)s is running on port %(port)d %dict2host venus is running on port 6969

删除字典元素和字典

>>> dict2{arch: sunos5, name: venus, port: 6969}>>> del dict2[name]>>> dict2{arch: sunos5, port: 6969}>>> dict2.clear()>>> dict2{}>>> del dict2>>> dict2Traceback (most recent call last): File “”, line 1, in NameError: name dict2 is not defined>>> dict3{1: 3.14159, 1: abc, 3.2: xyz, 33: hehe}>>> dict3.pop(33) hehe>>> dict3{1: 3.14159, 1: abc, 3.2: xyz}

注:避免使用内建对象名字作为变量的标识符

Python文件和目录操作详解 第12篇

一、文件的打开和创建

1、打开

代码如下:

open(file,mode):

>>>fo = open(test.txt, r)

>>>fo.read()

hello

>>>fo.close()

file(file,mode):

>>>f = file(test.txt, r)

>>>f.read()

hello

>>>f.close()

mode可取值：

2、创建

用w/w+/a/a+模式打开即可，

二、文件的读取

1、String = FileObject.read([size])

代码如下:

>>>fr = open(test.txt)

>>>fr.read()

hello world

or:

代码如下:

>>>for i in open(test.txt):

...print i

...

hello

world

2、String = FileObject.readline([size])

代码如下:

>>>f = open(test.txt)

>>>f.readline()

hello

>>>f.readline()

world

>>>f.readline()

或者可以用next

3、List = FileObject.readlines([size])

代码如下:

>>>f = open(test.txt)

>>>f.readlines()

[hello , world ]

三、文件的写入

1、write(string)

代码如下:

>>>f = open(test.txt, a)

>>>f.write(hello world)

#hello world

2、writelines(list)

代码如下:

>>>l = [a,b,c]

>>>f=open(test.txt,a)

>>>f.writelines(l)

#hello worldabc

注：writelines相当于调用了多次write，不会自动添加换行( )符

四、内容查找替换

1、FileObject.seek(offset, mode)

offset：偏移量

mode：

0表示将文件指针指向从文件头部到“偏移量”字节处，

1表示将文件指针指向从文件当前位置向后移动“偏移量”字节，

2表示将文件指针指向从文件尾部向前移动“偏移量”字节。

代码如下:

>>>f=open(test.txt)

>>>f.read()

hello worldabc

>>>f.read()

>>>f.seek(0,0)

>>>f.read()

hello worldabc

>>>f.close()

2、flush：提交更新，即在文件关闭之前把内存中的内容强制写入文件(一般是文件关闭后写入)

3、文件查找：遍历行进行查找

代码如下:

#!/usr/bin/python

import re

search=hello world

file=test.txt

count = 0

f = open(file)

for l in f.readlines():

li = re.findall(search,l)

if len(li) >0:

count += len(li)

print “Search ” + str(count) + “ ”“ + search + ”“”

f.close()

4、文件内容替换：遍历行进行替换

替换到新文件demo：

代码如下:

#!/usr/bin/python

s=hello

f=test.txt

rs=ten

rf=test2.txt

fh = open(of)

newl=[]

for l in ofh.readlines():

nl = l.replace(os,rs)

newl.append(nl)

rfh = open(rf,w+)

rfh.writelines(newl)

ofh.close()

rfh.close()

替换到原文件demo:

代码如下:

[server@localserver file]$ cat test.txt

abc

hello

world

hello world

helloworld

hello hello world

[server@localserver file]$ cat fr.py

#!/usr/bin/python

s=hello

file=test.txt

rs=ten

f = open(file, r+)

s=f.read()

f.seek(0,0)

f.close()

f = open(file, w+)

f.write(s.replace(os,rs))

f.close()

[server@localserver file] python fr.py

[server@localserver file]$ cat test.txt

abc

ten

world

ten world

tenworld

ten ten world

这里采用了重建文件的办法，

或用 fileinput 模块直接在原文件上修改：

代码如下:

#!/usr/bin/python

import fileinput

s=hello

file=test.txt

rs=ten

for line in fileinput.input(file, inplace=True):

print line.replace(os,rs).replace( ,)

注意，这里删除了 是因为print时会写入换行。

五、文件及目录操作

一般是借助OS模块实现

1、mkdir(path[,mode=0777])：创建目录，相当于mkdir

代码如下:

>>>import os

>>>os.mkdir(tt)

2、makedirs(name[, mode=511])：创建多级目录，相当于mkdir -p

3、rmdir(path)：删除目录，相当于rm

4、removedirs(path)：删除多级目录，相当于rm -rf

5、listdir(path)：列出目录中文件和文件夹，相当于ls

6、getcwd()：获取当前路径，相当于pwd

7、chdir(path)：切换目录，相当于cd

8、rename(src, dst)：重命名

9、shutil.copyfile(str,dst)：复制文件(要引入shutil模块)

10、path.splitext(filename)：获取文件路径和扩展名

代码如下:

>>>import os

>>>fileName, fileExtension = os.path.splitext(/path/to/somefile.ext)

>>>fileName

/path/to/somefile

>>>fileExtension

.ext

11、walk(top, topdown=True, nerror=None)：遍历目录

代码如下:

>>>import os

>>>g = os.walk(a)

>>>g.next()

(a, [b], [])

>>>g.next()

(a/b, [f, c], [])

>>>g.next()

(a/b/f, [], [3.txt])

>>>g.next()

(a/b/c, [d, e], [])

>>>g.next()

(a/b/c/d, [], [1.txt])

>>>g.next()

(a/b/c/e, [], [2.txt])

walk返回的是一个生成器，生成器中的内容是：当前目录，目录列表，文件列表

python自己递归实现文件遍历：

代码如下:

#!/usr/bin/python

import os

def dirList(path):

filelist = os.listdir(path)

fpath = os.getcwd()

allfile = []

for filename in filelist:

filepath = os.path.abspath(os.path.join(path, filename))

if os.path.isdir(filepath):

allfile.extend(dirList(filepath))

else:

allfile.append(filepath)

return allfile

files = dirList(a)