匿名函数、内置函数与模块

一、匿名函数

Python使用lambda来创建匿名函数，不再使用def语句这样标准的形式定义一个函数

• lambda只是一个表达式，函数体比def简单很多
• lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去
• lambda函数拥有自己的名称空间，且不能访问自有参数列表之外或全局名称空间里的参数
• 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率
• 适合临时的一次性的使用场景

语法：

lambda [arg1 [,arg2,.....argn]]:expression

实例：

my_sum = lambda x,y,z:x+y+z                    #1、形参不用加括号2、函数体自带return
print(my_sum(1,2,3))

#执行结果：
6

二、内置函数

Python所有的内置函数

参考链接：https://docs.python.org/3/library/functions.html

数学运算（abs、round、pow、divmod、max、min、sum）

print(abs(-6))                      #取绝对值，也就是6
print(round(2.21,1))                #返回浮点数的四舍五入值，保留1位小数
print(pow(2,3))                     #返回 xy（x的y次方） 的值，如果第三个参数存在，则再对结果进行取模，其结果等效于pow(x,y) %z
print(divmod(9,2))                  #返回商和余数，也就是4, 1
print(max(-1,1,2))                  #返回给定参数的最大值，参数可以为序列
print(min(-1,1,2))                  #返回给定参数的最小值，参数可以为序列
print(sum([1,2,3]))                 #求和

类型转换（int、float、str、complex、list、tuple、dict、set、frozenset、ord、chr、bool、bin、hex、oct、slice、bytes）

print(int(5))                       #转为整数
print(float(2))                     #转为浮点数，也就是2.0
print(str(1.2))                     # 转为字符串
print(complex(3,9))                 #返回复数3+9j
print(list((1,2,3)))                #转为列表
print(tuple([1,2,3]))               #转为元组
print(dict(a=1,b=2,c=3))            #构建字典
print(set({‘a‘,‘b‘,‘c‘,‘d‘}))       #构建集合
print(frozenset({‘a‘,‘b‘,‘c‘,‘d‘})) #构建不可变集合
print(ord(‘A‘))                     #"A"字符对应的数值，也就是65
print(chr(65))                      #数值65对应的字符，也就是A。（范围：65-90）
print(bool(0))                      #返回真假值。在Python中，这些对象都相当于False： [], (), {}, 0, None, 0.0, ‘‘
print(bin(10))                      #转换为二进制，也就是0b1010
print(hex(10))                      #转为十六进制，也就是0xa
print(oct(10))                      #转为八进制，也就是0o12
l = [1,2,3,4,5]
print(l[slice(0,4,2)])                      #实现切片对象，主要用在切片操作函数里的参数传递
print(bytes(‘hello‘,encoding=‘utf-8‘))      #转为bytes类型，也就是b‘hello‘

序列操作（all、any、sorted、reversed）

all([True, 1, "hello!"])            #是否所有的元素都相当于True值
any(["", 0, False, [], None])       #是否有任意一个元素相当于True值
l = [-1,-2,2,9]
print(sorted(l))                    #对所有可迭代的对象进行排序操作
l = [1,2,3]
print(list(reversed(l)))            #反向列表中元素

类，对象，属性（class、hasattr、getattr、setattr、delattr、isinstance、issubclass）

a = 2
isinstance (a,int)                  #判断一个对象是否是一个已知的类型，类似 type()

编译，执行（repr、compile、eval、exec）

print(repr(‘Yim‘))                  #返回对象的字符串表达
compile("print(‘Hello‘)",‘test.py‘,‘exec‘)      #将一个字符串编译为字节代码
print(eval(‘1+1‘))                  #执行一个字符串表达式，并返回表达式的值
exec("print(‘Hello‘)")              #执行储存在字符串或文件中的Python语句，相比于 eval，exec可以执行更复杂的 Python 代码

基本数据类型（type）

x=1
print(type(x))                      #返回表达式的值的类型

文件的输入输出（open）

f = open(‘test.txt‘)                #用于打开一个文件，创建一个file对象
f.read()

循环设计（range、enumerate、zip）

print(range(10))                       #创建一个整数列表，一般用在 for 循环中
for i,j in enumerate((‘a‘,‘b‘,‘c‘)):   #遍历序列中的元素以及它们的下标
    print(i,j)

s = ‘hello‘
l = [1,2,3,4,5]
print(list(zip(s,l)))                   #将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表

循环对象（iter、next）

list = [1,2,3,4,5]
g = list.__iter__()                 #iter() 函数用来生成迭代器
print(g.__next__())                 #next() 返回迭代器的下一个项目

函数对象（map、filter、reduce）

print(list(map(lambda x:x ** 2, [1,2,3,4,5])))    #根据提供的函数对指定序列做映射,第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表

from functools import reduce
print(reduce(lambda x,y:x + y, [1,2,3,4,5]))      #对参数序列中元素进行累积。用传给reduce中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。可以指定初始值（可选参数，默认是None），例如：print(reduce(lambda x,y:x + y, [1,2,3,4,5],1000))，结果是：1015

print(list(filter(lambda x:x % 2 == 0, [1,2,3,4,5,6])))    #，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中

其他（input、globals、locals、callable、dir、hash、help、id、len、vars、__import__）

a = input("input:")             #相等于 eval(raw_input(prompt)) ，用来获取控制台的输入
print(globals())                #查看全局名称空间
print(locals())                 #查看局部名称空间
print(callable(bytes))          #检查是否为可调用对象
import sys
print(dir(sys))                 #找到模块内定义的所有名称，以一个字符串列表的形式返回
print(hash(‘123‘))              #校验字符串
help(max)                       #查看函数或模块用途的详细说明
print(id(x))                    #获取对象的内存地址
print(len(‘12345‘))             #返回对象（字符、列表、元组等）长度或项目个数
print(vars())                   #返回对象object的属性和属性值的字典对象
m_name = input(‘module>>>:‘)
if m_name == ‘sys‘:
    m = __import__(m_name)                 #用于动态加载类和函数 。如果一个模块经常变化就可以使用 __import__() 来动态载入。
    print((m.path))

三、内置函数补充

salaries={
‘A‘:300,
‘B‘:1000,
‘C‘:900,
‘D‘:200
}

#找出薪资最高的那个人
#方法一：
# print(salaries.values())            #取出薪资
# print(salaries.keys())              #取出名字
# print(list(zip(salaries.values(),salaries.keys())))     #将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表
# print(max(list(zip(salaries.values(),salaries.keys()))))   #得到薪资最高的那个由名字和薪资组成的元组
print(max(list(zip(salaries.values(),salaries.keys())))[1])  #取第二个元素，即名字

#方法二：
print(max(salaries,key=lambda name:salaries[name]))

#薪资从低到高排序
print(sorted(salaries,key=lambda name:salaries[name]))

#薪资从高到低排序
print(sorted(salaries,key=lambda name:salaries[name],reverse=True))

四、模块

1 re模块-正则表达式

正则表达式是一个特殊的字符序列，它能帮助我们很方便的检查一个字符串是否与某种模式匹配

它内嵌在Python中，并通过 re 模块实现。正则表达式模式被编译成一系列的字节码，然后由用 C 编写的匹配引擎执行

1.1 re.match函数

re.match尝试从字符串的起始位置匹配一个模式。如果不是起始位置匹配成功的话，match()就返回None

语法：

re.match(pattern, string, flags=0)

函数参数说明：

匹配成功re.match方法返回一个匹配的对象，否则返回None

可以使用group(num)或groups()匹配对象函数来获取匹配表达式

实例：

import re
print(re.match(‘hello‘,‘hello world‘).span())           #在起始位置匹配
print(re.match(‘world‘,‘hello world‘))                  #不在起始位置匹配

#执行结果：
(0, 5)
None 

1.2 re.search函数

re.search扫描整个字符串并返回第一个成功的匹配

语法：

re.search(pattern, string, flags=0)

函数参数说明：

匹配成功re.search方法返回一个匹配的对象，否则返回None

我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式

实例：

import re
print(re.search(‘hello‘,‘hello world‘).span())          #在起始位置匹配
print(re.search(‘world‘,‘hello world‘).span())          #不在起始位置匹配

#执行结果：
(0, 5)
(6, 11) 

1.3 re.sun函数-检索和替换

re模块提供了re.sub用于替换字符串中的匹配项

语法：

re.sub(pattern, repl, string, count=0)

函数参数说明：

实例：

import re
num = ‘0123456789#阿拉伯数字‘
print(re.sub(r‘#.*$‘,‘‘,num))                       #去掉注释

#执行结果
0123456789

print(re.sub(‘(\w+)(\W+)(\w+)(\W+)(\w+)(\W+)(\w+)‘,r‘\7\2\3\4\5\6\1‘,‘one two three four‘))

#执行结果
four two three one 

1.4 re.findall函数

re.findall遍历匹配，可以获取字符串中所有匹配的字符串，返回一个列表

语法：

re.findall(pattern, string, flags=0)

函数参数说明：

实例：

import re
print(re.findall(‘\d‘,‘a2g1c35‘))

#执行结果
[‘2‘, ‘1‘, ‘3‘, ‘5‘]

1.5 re.split函数

按照能够匹配的子串将string分割后返回列表

语法：

re.split(pattern, string[, maxsplit])

函数参数说明：

实例：

print(re.split(‘\d+‘,‘one1two2three3four4five5‘))
print(re.split(‘\d+‘,‘one1two2three3four4five5‘,1))

#执行结果
[‘one‘, ‘two‘, ‘three‘, ‘four‘, ‘five‘, ‘‘]
[‘one‘, ‘two2three3four4five5‘] 

1.6 re.subn函数

替换并返回替换次数

语法：

subn(pattern, repl, string, count=0, flags=0)

函数参数说明：

实例：

print(re.subn(‘1‘,‘A‘,‘123456123456‘))
print(re.subn(‘1‘,‘A‘,‘123456123456‘,count=1))

#执行结果：
(‘A23456A23456‘, 2)
(‘A23456123456‘, 1) 

1.7 re.compile函数

编译正则表达式模式，返回一个对象的模式。（可以把那些常用的正则表达式编译成正则表达式对象，这样可以提高一点效率）

语法：

re.compile(pattern,flags=0)

函数参数说明：

实例：

obj = re.compile(‘\d{2}‘)
print(obj.findall(‘abc123eee‘))

#执行结果
[‘12‘]

1.8 re.finditer函数

搜索string，返回一个顺序访问每一个匹配结果（Match对象）的迭代器。找到 RE 匹配的所有子串，并把它们作为一个迭代器返回。

语法：

re.finditer(pattern, string, flags=0)

函数参数说明：

实例：

iter = re.finditer(r‘\d+‘,‘12 drumm44ers drumming, 11 ... 10 ...‘)
for i in iter:
    print(i.group())

#执行结果：
12
44
11
10 

1.9 正则表达式修饰符-可选标志

正则表达式可以包含一些可选标志修饰符来控制匹配的模式。修饰符被指定为一个可选的标志。多个标志可以通过按位 OR(|) 它们来指定。如 re.I | re.M 被设置成 I 和 M 标志：

1.10 正则表达式模式

字母和数字表示它们自身，一个正则表达式模式中的字母和数字匹配同样的字符串

多数字母和数字前加一个反斜杠时，会拥有不同的含义

标点符号只有被转义时才匹配自身，否则它们表示特殊的含义

反斜杠本身需要使用反斜杠转义，最好使用原始字符串来表示它们。模式元素(如 r‘/t‘，等价于‘//t‘)匹配相应的特殊字符

1.11 正则表达式实例

字符匹配

字符类

特殊字符类

2 time模块

Python提供了一个time和calendar模块可以用于格式化日期和时间

时间间隔是以秒为单位的浮点小数

每个时间戳都以自从1970年1月1日午夜经过了多长时间来表示

实例：

#time.time()获取当前时间戳
import time                     #引入time模块
print(time.time())

#执行结果
1502155966.0468564
#时间戳单位最适于做日期运算。但是无法表示1970年之前的日期，也不支持太遥远的日期，UNIX和Windows只支持到2038年

2.1 获取当前时间

结构化的时间

import time
print(time.localtime())
print(time.localtime().tm_mon)              #查看月份

#执行结果：
time.struct_time(tm_year=2017, tm_mon=8, tm_mday=8, tm_hour=10, tm_min=15, tm_sec=19, tm_wday=1, tm_yday=220, tm_isdst=0)
8

格林威治天文时间（UTC）：

import time
print(time.gmtime())

#执行结果：
time.struct_time(tm_year=2017, tm_mon=8, tm_mday=8, tm_hour=2, tm_min=24, tm_sec=27, tm_wday=1, tm_yday=220, tm_isdst=0)

2.2 格式化日期

可以使用time模块的strftime方法来格式化日期

语法：

time.strftime(format[, t])

时间日期格式化符号：

　　%y        两位数的年份表示（00-99）

　　%Y              四位数的年份表示（000-9999）

%m              月份（01-12）

%d        天（0-31）

%H              24小时制（0-23）

%I        12小时制（01-12）

%M             分钟（00-59）

%S        秒（00-59）

%a        本地简化星期名称（Mon…Sun）

%A              本地完整星期名称（Monday…Sunday）

%b        本地简化的月份名称（Jan…Dec）

%B              本地完整的月份名称（January…December）

%c        本地相应的日期表示和时间表示（Tue Aug  8 10:00:02 2017）

%j         年内的一天（001-366）

%p        本地AM或PM的等价符

%U              一年中的星期数（00-53），星期天为星期的开始

%w              星期（0-6），星期天为星期的开始

%W      一年的星期数（00-53），星期一为星期的开始

%x        本地相应的日期表示（日/月/年，如：08/08/17）

%X              本地相应的时间表示（时:分:秒，如：10:09:00）

%z        当前时区的名称（+0800）

%%              %号本身

实例：

import time
print(time.strftime(‘%Y-%m-%d %X‘))                     # 格式化成2017-08-08 09:39:31形式
print(time.strftime(‘%Y-%m-%d %H:%M:%S‘))               # 格式化成2017-08-08 09:39:31形式

#执行结果
2017-08-08 09:39:31
2017-08-08 09:39:31

2.3 时间格式的转换

1.实例：时间戳转结构化的时间localtime([secs]

import time
print(time.localtime())                 #未指定secs参数，则以当前时间为准
print(time.localtime(1473525444.037215))

#执行结果
time.struct_time(tm_year=2017, tm_mon=8, tm_mday=8, tm_hour=10, tm_min=39, tm_sec=2, tm_wday=1, tm_yday=220, tm_isdst=0)
time.struct_time(tm_year=2016, tm_mon=9, tm_mday=11, tm_hour=0, tm_min=37, tm_sec=24, tm_wday=6, tm_yday=255, tm_isdst=0)

2.实例：结构化的时间转时间戳mktime(t)

import time
print(time.mktime(time.localtime()))
print(time.mktime((2017, 8, 8, 10, 39, 2, 1, 220, 0)))

#执行结果：
1502162703.0
1502159942.0

3.实例：结构化的时间转格式化的时间字符串strftime(format[, t])

import time
print(time.strftime(‘%Y-%m-%d %H:%M:%S‘,time.localtime()))              #如果t未指定，也将传入time.localtime()
print(time.strftime(‘%Y-%m-%d %H:%M:%S‘,(2017, 8, 8, 10, 39, 2, 1, 220, 0)))

#执行结果：
2017-08-08 11:32:35
2017-08-08 10:39:02

4.实例：格式化的时间字符串转结构化的时间time.strptime(string[, format])

import time
print(time.strptime(‘2017-08-08 11:32:35‘,‘%Y-%m-%d %H:%M:%S‘))

#执行结果：
time.struct_time(tm_year=2017, tm_mon=8, tm_mday=8, tm_hour=11, tm_min=32, tm_sec=35, tm_wday=1, tm_yday=220, tm_isdst=-1) 

5.实例：结构化的时间转‘Sun Jun 20 23:21:05 1993‘形式asctime([t])

import time
print(time.asctime())                   #如果t未指定，将传入time.localtime()
print(time.asctime((2017, 8, 8, 10, 39, 2, 1, 220, 0)))

#执行结果：
Tue Aug  8 11:49:14 2017
Tue Aug  8 10:39:02 2017

6.实例：时间戳转‘Sun Jun 20 23:21:05 1993‘形式ctime([secs])

import time
print(time.ctime())             #None的时候，将会默认time.time()为参数,相当于time.asctime(time.localtime(secs))
print(time.ctime(1502161211.630944))

#执行结果：
Tue Aug  8 11:54:00 2017
Tue Aug  8 11:00:11 2017

2.4 time模块函数

Time 模块包含了以下内置函数：

Time模块包含了以下2个非常重要的属性：

3 random模块

可以生成随机浮点数、整数、字符串，甚至帮助你随机选择列表序列中的一个元素，打乱一组数据等

3.1 random模块函数

3.2 生成随机验证码

#生成随机验证码
import random

def make_code(n):
    res = ‘‘
    for i in range(n):
        s1 = str(random.randint(0,9))            #整型数字无法与字符串拼接，这里用str转换成字符串
        s2 = chr(random.randint(65,90))          #利用chr内置函数，产生随机的大写字母
        res += random.choice([s1,s2])
    return res

print(make_code(10)) 

4 os模块

os模块是与操作系统交互的一个接口，提供了非常丰富的方法用来处理文件和目录

常用的方法

os.getcwd()                         获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname")                 改变当前脚本工作目录；相当于shell下cd
os.curdir                           返回当前目录: (‘.‘)
os.pardir                           获取当前目录的父目录字符串名：(‘..‘)
os.makedirs(‘dirname1/dirname2‘)    可生成多层递归目录
os.removedirs(‘dirname1‘)           若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir(‘dirname‘)                 生成单级目录；相当于shell中mkdir dirname
os.rmdir(‘dirname‘)                 删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir(‘dirname‘)               列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove()                         删除一个文件
os.rename("oldname","newname")      重命名文件/目录
os.stat(‘path/filename‘)            获取文件/目录信息
os.sep                              输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
os.linesep                          输出当前平台使用的行终止符，win下为"\r\n",Linux下为"\n"
os.pathsep                          输出用于分割文件路径的字符串 win下为;,Linux下为:
os.name                             输出字符串指示当前使用平台。win->‘nt‘; Linux->‘posix‘
os.system("bash command")           运行shell命令，直接显示
os.environ                          获取系统环境变量
os.path.abspath(path)               返回path规范化的绝对路径
os.path.split(path)                 将path分割成目录和文件名二元组返回
os.path.dirname(path)               返回path的目录。其实就是os.path.split(path)的第一个元素
os.path.basename(path)              返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
os.path.exists(path)                如果path存在，返回True；如果path不存在，返回False
os.path.isabs(path)                 如果path是绝对路径，返回True
os.path.isfile(path)                如果path是一个存在的文件，返回True。否则返回False
os.path.isdir(path)                 如果path是一个存在的目录，则返回True。否则返回False
os.path.join(path1[, path2[, ...]]) 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.getatime(path)              返回path所指向的文件或者目录的最后存取时间
os.path.getmtime(path)              返回path所指向的文件或者目录的最后修改时间
os.path.getsize(path)               返回path的大小

1、在Linux和Mac平台上，该函数会原样返回path，在windows平台上会将路径中所有字符转换为小写，并将所有反斜杠转换为斜杠。
>>> os.path.normcase(‘c:/windows\\system32\\‘)
‘c:\\windows\\system32\\‘  

2、规范化路径，如..和/
>>> os.path.normpath(‘c://windows\\System32\\../Temp/‘)
‘c:\\windows\\Temp‘  

>>> a=‘/Users/jieli/test1/\\\a1/\\\\aa.py/../..‘
>>> print(os.path.normpath(a))
/Users/jieli/test1 

#os路径处理
#方式一：推荐使用
import os
#具体应用
import os,sys
possible_topdir = os.path.normpath(os.path.join(
    os.path.abspath(__file__),
    os.pardir, #上一级
    os.pardir,
    os.pardir
))
sys.path.insert(0,possible_topdir)

#方式二：不推荐使用
os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) 

5 sys模块

sys 模块提供了许多函数和变量来处理 Python 运行时环境的不同部分

5.1 sys模块常见函数列表

sys.argv                实现从程序外部向程序传递参数,第一个元素是程序本身路径
sys.exit([arg])         退出程序，正常退出是exit(0)
sys.version             获取Python解释程序的版本信息
sys.maxint              最大的Int值
sys.path                返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform            返回操作系统平台名称

5.2 sys模块常见函数的使用

#sys_test.py如下：
import sys
print(sys.argv[0])
print(sys.argv[1])

#执行命令：
F:\Python\Code>python sys_test.py argv1

#执行结果：
sys_test.py
argv1 

#sys.path功能：获取指定模块搜索路径的字符串集合，可以将写好的模块放在得到的某个路径下，就可以在程序中import时正确找到
>>> import sys
>>> sys.path
[‘‘, ‘C:\\Python36\\python36.zip‘, ‘C:\\Python36\\DLLs‘, ‘C:\\Python36\\lib‘, ‘C:\\Python36‘, ‘C:\\Python36\\lib\\site-packages‘]

>>> sys.path.append("F:\Python\test")               #添加自定义模块路径 

#=========知识储备==========
#指定宽度
print(‘<%-10.3f>‘ %3.22) #总宽度为10,保留3位小数点
#打印结果
#<3.220     >

#打印%号,用%%
width=10
print(‘<%%-%ds>‘ %width)
#打印结果
# <%-10s>

#嵌套的%
width=10
print((‘<%%-%ds>‘ %width) %(‘hello‘))
#打印结果
# <hello     >

#=========实现打印进度条函数==========
import sys
import time
def progress(percent,width=50):
    if percent >= 100:
        print(‘\r[%s] %d%%‘ %(‘#‘*width,100)) #print的end默认为回车
        return

    show_str=(‘[%%-%ds]‘ %width) %(int(width * percent / 100) * "#") #字符串拼接的嵌套使用
    print("\r%s %d%%" %(show_str, percent),end=‘‘,file=sys.stdout,flush=True)

#=========应用==========
data_size=3030333
recv_size=0
while recv_size < data_size:
    time.sleep(0.001) #模拟数据的传输延迟
    recv_size+=1024 #每次收1024

    recv_per=int(100*(recv_size/data_size)) #接收的比例
    progress(recv_per,width=30) #进度条的宽度30

6 json与pickle模块

序列化 (Serialization)将对象的状态信息转换为可以存储或传输的形式的过程。在序列化期间，对象将其当前状态写入到临时或持久性存储区。以后，可以通过从存储区中读取或反序列化对象的状态，重新创建该对象

序列化的作用：持久保存状态、跨平台数据交互

6.1 json模块

如果我们要在不同的编程语言之间传递对象，就必须把对象序列化为标准格式，比如XML，但更好的方法是序列化为JSON，因为JSON表示出来就是一个字符串，可以被所有语言读取，也可以方便地存储到磁盘或者通过网络传输。JSON不仅是标准格式，并且比XML更快，而且可以直接在Web页面中读取，非常方便

JSON表示的对象就是标准的JavaScript语言的对象，JSON和Python内置的数据类型对应如下：

json函数：

dumps是将dict转化成str格式，loads是将str转化成dict格式

dump和load也是类似的功能，只是与文件操作结合起来了

实例1：

#1、序列化，将 Python 对象编码成 JSON 字符串
import json
data = {‘a‘:1,‘b‘:2,‘c‘:3}
with open(‘a.json‘,‘w‘) as f:
    f.write(json.dumps(data))

#2、反序列化，将已编码的 JSON 字符串解码为 Python 对象
import json
with open(‘a.json‘,‘r‘) as f:
    data = json.loads(f.read())
    print(data[‘a‘])

#执行结果：
1

实例2：另一种实现方法

import json
data = {‘a‘:1,‘b‘:2,‘c‘:3}
json.dump(data,open(‘b.json‘,‘w‘))

import json
print(json.load(open(‘b.json‘,‘r‘))[‘a‘])

#执行结果：
1 

6.2 pickle模块

pickle提供了一个简单的持久化功能。可以将对象以文件的形式存放在磁盘上

pickle模块只能在Python中使用，python中几乎所有的数据类型（列表，字典，集合，类等）都可以用pickle来序列化

pickle序列化后的数据可读性差，人一般无法识别

实例1：

#1、序列化
import pickle
data = {‘a‘:1,‘b‘:2,‘c‘:3}
with open(‘a.pkl‘,‘wb‘) as f:
    f.write(pickle.dumps(data))

#2、反序列化
import pickle
with open(‘a.pkl‘,‘rb‘) as f:
    data = pickle.loads(f.read())
    print(data[‘a‘])

#执行结果：
1

实例2：另一种实现方法

import pickle
data = {‘a‘:1,‘b‘:2,‘c‘:3}
pickle.dump(data,open(‘b.pkl‘,‘wb‘))

import pickle
print(pickle.load(open(‘b.pkl‘,‘rb‘))[‘a‘])

#执行结果：
1 

7 shelve模块

shelve是一种简单的数据存储方案，它只有一个open()函数，这个函数接收一个参数就是文件名

调用shelve.open()会返回一个shelf对象用来存储内容，将它当做一个普通的字典来存储数据（字典的键一定要是字符串），在存储完毕之后要调用close()函数，关闭文件。

保存对象至shelve文件中：

import shelve

f = shelve.open(‘shelveDict‘)              #打开一个文件
f[‘baidu‘] = ‘www.baidu.com‘               #向文件中添加内容，添加方式与给字典添加键值对相同
f[‘taobao‘] = ‘www.taobao.com‘
f.close()                                  #关闭文件

从文件中读取对象：

import shelve

f = shelve.open(‘shelveDict‘)              #打开文件
print(f[‘baidu‘])                          #跟字典一样读取内容
print(f[‘taobao‘])
f.close()                                  #关闭文件

#执行结果
www.baidu.com
www.taobao.com

更新文件中的数据：

import shelve

f = shelve.open(‘shelveDict‘)               #打开文件
f[‘baidu‘] = ‘map.baidu.com‘                #直接对对象进行修改
print(f[‘baidu‘])
f.close()                                   #关闭文件

#执行结果：
map.baidu.com
www.taobao.com