python

python3教程

一、pip

查看版本： pip -V

环境变量路径：./python/Scripts/

1.1 安装

pip install 包名

1.2 卸载

pip uninstall 包名

1.3 查看包

• pip list
• pip freeze

1.4 修改pip下载源

pip install 包名 -i 国内源地址

国内源

• 阿里云：http://mirrors.aliyun.com/pypi/simple/
• 中国科技大学：https://pypi.mirrors.ustc.edu.cn/simple/
• 豆瓣：http://pypi.douban.com/simple/
• 清华大学：https://pypi.tuna.tsinghua.edu.cn/simple/
• 中国科学技术大学：http://pypi.mirrors.ustc.edu.cn/simple/

永久修改

# 命令行设置永久配置
pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple

# 配置文件设置永久配置c:\user\用户名\pip.ini
# 也可能在C:\Users\YT000\AppData\Roaming\pip\pip.ini
[global]
index-url = https://mirrors.aliyun.com/pypi/simple/
[install]
trusted-host = mirrors.aliyun.com

二、概述

2.1 环境变量

cmd:setx PYTHONCASEOK 1 
#加入PYTHONCASEOK的环境变量, 就会使python导入模块的时候不区分大小写.

2.2 命令行参数

• 查看版本

  python -V

• 启动不引入查找python路径位置

  python -S

• 给定文件执行python脚本

  python filename

三、基础语法

3.1 编码

默认编码utf-8

3.2 标识符

• 第一个字符必须是字母表中字母或下划线 _ 。
• 标识符的其他的部分由字母、数字和下划线组成。
• 标识符对大小写敏感。

在 Python 3 中，可以用中文作为变量名，允许非 ASCII 标识符。

3.3 python保留字

保留字即关键字，我们不能把它们用作任何标识符名称。Python 的标准库提供了一个 keyword 模块，可以输出当前版本的所有关键字：

>>> import keyword
>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

3.4 注释

Python中单行注释以 # 开头

# 单行注释

'''
  多行注释1
'''

"""
  多行注释2
"""

3.5 代码块(行与缩进)

python最具特色的就是使用缩进来表示代码块，不需要使用大括号 {} 。

缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数。

if True:
  print('true')
else:
  print('false')

3.6 多行语句

Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠\来实现多行语句

total = item_one + \
		item_two

3.7 数字(Number)类型

python中数字有四种类型：整数、布尔型、浮点数和复数。

• int (整数), 如 1, 只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
• bool (布尔), 如 True。
• float (浮点数), 如 1.23、3E-2
• complex (复数), 如 1 + 2j、 1.1 + 2.2j

3.8 字符串(String)

• Python 中单引号 ‘ 和双引号 “ 使用完全相同。
• 使用三引号(‘’’ 或 “””)可以指定一个多行字符串。
• 转义符 \
• 反斜杠可以用来转义，使用 r 可以让反斜杠不发生转义。 如 r”this is a line with \n” 则 \n 会显示，并不是换行。
• 按字面意义级联字符串，如 “this “ “is “ “string” 会被自动转换为 this is string。
• 字符串可以用 + 运算符连接在一起，用 ***** 运算符重复。
• Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。
• Python 中的字符串不能改变。
• Python 没有单独的字符类型，一个字符就是长度为 1 的字符串。
• 字符串的截取的语法格式如下：变量[头下标:尾下标:步长]

str='123456789'
 
print(str)                 # 输出字符串
print(str[0:-1])           # 输出第一个到倒数第二个的所有字符
print(str[0])              # 输出字符串第一个字符
print(str[2:5])            # 输出从第三个开始到第六个的字符（不包含）
print(str[2:])             # 输出从第三个开始后的所有字符
print(str[1:5:2])          # 输出从第二个开始到第五个且每隔一个的字符（步长为2）
print(str * 2)             # 输出字符串两次
print(str + '你好')         # 连接字符串

3.9 空行

函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。

空行与代码缩进不同，空行并不是 Python 语法的一部分。书写时不插入空行，Python 解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。

记住：空行也是程序代码的一部分。

3.10 多个语句构成代码组

缩进相同的一组语句构成一个代码块，我们称之代码组。

像if、while、def和class这样的复合语句，首行以关键字开始，以冒号( : )结束，该行之后的一行或多行代码构成代码组。

我们将首行及后面的代码组称为一个子句(clause)。

if expression : 
   suite
elif expression : 
   suite 
else : 
   suite

3.11 输入输出

3.11.1 print

print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 end=””

print(txt,end='')

格式化输出:

格式：%s %d

print('%s %d' % (var1,var2))

name = 'zhangsan'
age = 20
print('my name is:%s ,age is:%d' %(name,age))

3.11.2 input

var = input('txt:')

3.12 import 与 from…import

在 python 用 import 或者 from…import 来导入相应的模块。

将整个模块(somemodule)导入，格式为： import somemodule

从某个模块中导入某个函数,格式为： from somemodule import somefunction

从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc

将某个模块中的全部函数导入，格式为： from somemodule import *

3.13 基本数据类型

Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

在 Python 中，变量就是变量，它没有类型，我们所说的”类型”是变量所指的内存中对象的类型。

等号（=）用来给变量赋值。

3.13.1 多个变量赋值

Python允许同时为多个变量赋值。

a = b = c = 1
a, b, c = 1, 2, "runoob"

3.13.2 标准数据类型

Python3 中常见的数据类型有：

• Number（数字）
• String（字符串）
• bool（布尔类型）
• List（列表）
• Tuple（元组）
• Set（集合）
• Dictionary（字典）

Python3 的六个标准数据类型中：

• 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
• 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

此外还有一些高级的数据类型，如: 字节数组类型(bytes)。

3.13.3 Number（数字）

Python3 支持 int、float、bool、complex（复数）。

在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。

像大多数语言一样，数值类型的赋值和计算都是很直观的。

内置的 type() 函数可以用来查询变量所指的对象类型。

isinstance 和 type 的区别在于：

• type()不会认为子类是一种父类类型。
• isinstance()会认为子类是一种父类类型。

>>> class A:
...     pass
... 
>>> class B(A):
...     pass
... 
>>> isinstance(A(), A)
True
>>> type(A()) == A 
True
>>> isinstance(B(), A)
True
>>> type(B()) == A
False

注意：Python3 中，bool 是 int 的子类，True 和 False 可以和数字相加，True==1、False==0 会返回 True，但可以通过 is 来判断类型。

del删除变量

del var1[,var2[,var3[….,varN]]]

del var
del var_a, var_b

数值运算

• 1、Python可以同时为多个变量赋值，如a, b = 1, 2。

• 2、一个变量可以通过赋值指向不同类型的对象。

• 3、数值的除法包含两个运算符：**/** 返回一个浮点数，**//** 返回一个整数。

• 4、在混合计算时，Python会把整型转换成为浮点数。

• 5、数值使用**时会成为一个乘方

• [ + - * / // % **]

>>> 5 + 4  # 加法
9
>>> 4.3 - 2 # 减法
2.3
>>> 3 * 7  # 乘法
21
>>> 2 / 4  # 除法，得到一个浮点数
0.5
>>> 2 // 4 # 除法，得到一个整数
0
>>> 17 % 3 # 取余
2
>>> 2 ** 5 # 乘方
32

3.13.4 bool（布尔类型）

布尔类型即 True 或 False。

在 Python 中，True 和 False 都是关键字，表示布尔值。

布尔类型可以用来控制程序的流程，比如判断某个条件是否成立，或者在某个条件满足时执行某段代码。

布尔类型特点：

• 布尔类型只有两个值：True 和 False。
• 布尔类型可以和其他数据类型进行比较，比如数字、字符串等。在比较时，Python 会将 True 视为 1，False 视为 0。
• 布尔类型可以和逻辑运算符一起使用，包括 and、or 和 not。这些运算符可以用来组合多个布尔表达式，生成一个新的布尔值。
• 布尔类型也可以被转换成其他数据类型，比如整数、浮点数和字符串。在转换时，True 会被转换成 1，False 会被转换成 0。

3.13.5 List（列表）

List（列表） 是 Python 中使用最频繁的数据类型。

• 列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。
• 列表是写在方括号 [] 之间、用逗号分隔开的元素列表。
• 和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

列表截取的语法格式如下：

变量[头下标:尾下标]
# 索引值以 0 为开始值，-1 为从末尾的开始位置。

加号 + 是列表连接运算符，星号 ***** 是重复操作。如下实例：

list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
tinylist = [123, 'runoob']

print (list)            # 输出完整列表
print (list[0])         # 输出列表第一个元素
print (list[1:3])       # 从第二个开始输出到第三个元素
print (list[2:])        # 输出从第三个元素开始的所有元素
print (tinylist * 2)    # 输出两次列表
print (list + tinylist) # 连接列表

输出结果：

['abcd', 786, 2.23, 'runoob', 70.2]
abcd
[786, 2.23]
[2.23, 'runoob', 70.2]
[123, 'runoob', 123, 'runoob']
['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob']

列表中的元素可以改变：

a[0] = 9
a[2:5] = [13, 14, 15]
a[2:5] = []

方法

len(arr) : 遍历统计数组个数

3.13.6 Tuple（元组）

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。

tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2  )
tinytuple = (123, 'runoob')

string、list 和 tuple 都属于 seq uence（序列）。

注意：

• 1、与字符串一样，元组的元素不能修改。
• 2、元组也可以被索引和切片，方法一样。
• 3、注意构造包含 0 或 1 个元素的元组的特殊语法规则。
• 4、元组也可以使用+操作符进行拼接。

3.13.7 Set（集合）

集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。

• 基本功能是进行成员关系测试和删除重复元素。
• 可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 **{ }**，因为 { } 是用来创建一个空字典。

创建格式：

parame = {value01,value02,...}
或者
set(value)

3.13.8 Dictionary（字典）

字典（dictionary）是Python中另一个非常有用的内置数据类型。

• 列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
• 字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。
• 键(key)必须使用不可变类型。
• 在同一个字典中，键(key)必须是唯一的。

dict = {}
dict['one'] = "1 - 菜鸟教程"
dict[2]     = "2 - 菜鸟工具"

tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}


print (dict['one'])       # 输出键为 'one' 的值
print (dict[2])           # 输出键为 2 的值
print (tinydict)          # 输出完整的字典
print (tinydict.keys())   # 输出所有键
print (tinydict.values()) # 输出所有值

输出结果：

1 - 菜鸟教程
2 - 菜鸟工具
{'name': 'runoob', 'code': 1, 'site': 'www.runoob.com'}
dict_keys(['name', 'code', 'site'])
dict_values(['runoob', 1, 'www.runoob.com'])

注意：

• 1、字典是一种映射类型，它的元素是键值对。
• 2、字典的关键字必须为不可变类型，且不能重复。
• 3、创建空字典使用 **{ }**。

3.13.9 bytes 类型

在 Python3 中，bytes 类型表示的是不可变的二进制序列（byte sequence）。

• 与字符串类型不同的是，bytes 类型中的元素是整数值（0 到 255 之间的整数），而不是 Unicode 字符。
• bytes 类型通常用于处理二进制数据，比如图像文件、音频文件、视频文件等等。在网络编程中，也经常使用 bytes 类型来传输二进制数据。
• 创建 bytes 对象的方式有多种，最常见的方式是使用 b 前缀：
• 此外，也可以使用 bytes() 函数将其他类型的对象转换为 bytes 类型。bytes() 函数的第一个参数是要转换的对象，第二个参数是编码方式，如果省略第二个参数，则默认使用 UTF-8 编码

x = bytes("hello", encoding="utf-8")

3.14 数据类型转换

Python 数据类型转换可以分为两种：

• 隐式类型转换 - 自动完成
• 显式类型转换 - 需要使用类型函数来转换

3.14.1 隐式类型转换

• int可以隐式转换为float类型
• 整型数据无法与字符串类型数据进行相加

3.14.2 显式类型转换

在显式类型转换中，用户将对象的数据类型转换为所需的数据类型。 我们使用 int()、float()、str() 等预定义函数来执行显式类型转换。

int():向下取整，int(2.8) == 2

float()

str()

3.14.3 内置数据转换

**eval(str)**：执行一个字符串表达式，格式：eval(expression[, globals[, locals]])

eval("n + 4")

**char(x)**：将一个整数转换为字符

**ord(x)**：将一个字符转换为整数

**hex(x)**：讲一个整数转换为一个十六进制字符串

**oct(x)**：讲一个整数转换为一个八进制字符串

3.15 运算符

3.15.1 逻辑运算符

与 或 非

and or not

3.15.2 成员运算符

• in : 如果在指定的序列中找到值返回 True，否则返回 False。
• not in : 如果在指定的序列中没有找到值返回 True，否则返回 False。

a = 10
b = 20
list = [1, 2, 3, 4, 5 ]
 
if ( a in list ):
   print ("1 - 变量 a 在给定的列表中 list 中")
else:
   print ("1 - 变量 a 不在给定的列表中 list 中")
 
if ( b not in list ):
   print ("2 - 变量 b 不在给定的列表中 list 中")
else:
   print ("2 - 变量 b 在给定的列表中 list 中")
 
# 修改变量 a 的值
a = 2
if ( a in list ):
   print ("3 - 变量 a 在给定的列表中 list 中")
else:
   print ("3 - 变量 a 不在给定的列表中 list 中")

3.15.3 身份运算符

is : is 是判断两个标识符是不是引用自一个对象

is not : is not 是判断两个标识符是不是引用自不同对象

x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
#  id() 函数用于获取对象内存地址

a = 20
b = 20
 
if ( a is b ):
   print ("1 - a 和 b 有相同的标识")
else:
   print ("1 - a 和 b 没有相同的标识")
 
if ( id(a) == id(b) ):
   print ("2 - a 和 b 有相同的标识")
else:
   print ("2 - a 和 b 没有相同的标识")

3.16 流程控制语句

3.16.1 if…else

# 语法一：推荐语法
if condition:
    ...
else:
    ...
    
# 语法二
if (condition):
    ...
else:
    ...

3.16.2 if…elif…else

if condition1:
    ...
elif condition2:
    ...
else:
    ...

3.16.3 for…in…

dicc = [1,2,3,4,5,6,7]
for i in dicc:
    print(i)

3.16.4 range()

range(var) : 循环区间

range(5) : 0~4 [0,5)左闭右开原则

for i in range(5):
    print('range:'+str(i))
# range:0 range:1 range:2 range:3 range:4

range(var1,var2) : 起始值，结束值

range(1,6) : [1,6)左闭右开原则

for i in range(1,6):
    print('range:'+str(i),end=' ')
# range:1 range:2 range:3 range:4 range:5 

range(var1,var2,var3) : 起始值，结束值，步长

for i in range(1,10,3):
    print('range:'+str(i),end=' ')
# range:1 range:4 range:7 

四、数据类型高级

4.1 字符串(Str)

方法

• len：获取长度

s = 'china'
# len(s)
print(len(s))
# 5

• find：

# s.find('a')
print(s.find('a'))
# 4

• startswith,endswith

print(s.startswith('ch'))
print(s.endswith('n'))
# True
# False

• count

print(s.count('i'))
# 1

• replace

print(s.replace('i','aaa'))
# chaaana

• split

print(s.split('i'))
# ['ch', 'na']

• upper,lower

print(s.upper())
print(s.lower())
# CHINA
# china

• strip：去空格（首尾空格）

ss = ' chin a  '
print(ss.strip())
# chin a

• join：字符串拼接

# s = 'china'
print(s.join('123'))
# 1china2china3
# 此方法将s字符串加入到join的参数分割中

4.2 数字(Number)

创建

var1 = 20

删除

del var1

4.2.1 数字函数

• abs(x) // abs(-10) == 10
• ceil(x) // math.ceil(4.1) == 5
• exp(x) // e的x次幂，math.exp(1)返回2.718281828459045
• floor(x) // math.floor(4.9) == 4
• max(x1,x2,x3,…)
• min(x1,x2,x3,…)
• pow(x,y) // x的y次幂
• round(x[,n]) // 返回浮点数x的四舍五入值，如给定n，代表舍入到小数点后几位
• sqrt(x)

4.2.2 随机数函数

• choice(seq)：从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。

import random

print ("从 range(100) 返回一个随机数 : ",random.choice(range(100)))
print ("从列表中 [1, 2, 3, 5, 9]) 返回一个随机元素 : ", random.choice([1, 2, 3, 5, 9]))
print ("从字符串中 'Runoob' 返回一个随机字符 : ", random.choice('Runoob'))

• random() ： 随机生成一个实数，它在[0,1)之间
• seed()：改变随机数生成器的种子，调用其他随机模块函数之前调用此函数

import random

random.seed ( [x] )

import random

random.seed()
print ("使用默认种子生成随机数：", random.random())
print ("使用默认种子生成随机数：", random.random())

random.seed(10)
print ("使用整数 10 种子生成随机数：", random.random())
random.seed(10)
print ("使用整数 10 种子生成随机数：", random.random())

random.seed("hello",2)
print ("使用字符串种子生成随机数：", random.random())

4.3 列表(List)

4.3.1 增

• append(object) 追加

food_list = ['铁锅炖大鹅','小鸡炖蘑菇']
food_list.append('红烧五花肉')
print(food_list)
# ['铁锅炖大鹅', '小鸡炖蘑菇', '红烧五花肉']

• insert(index,object) 插入

char_list = ['a','c','d','e']
char_list.insert(1,'b')
print(char_list)
# ['a', 'b', 'c', 'd', 'e']

• extend() 继承

num_list = [1,2,3]
num_list1 = [4,5,6]
# 将一个数组加入到另一个数组之后
num_list.extend(num_list1)
print(num_list)
# [1, 2, 3, 4, 5, 6]

4.3.2 改

# 通过下标修改列表元素的值
city_list = ['北京','上海','天津','深圳','广州']
city_list[2] = '成都'
print(city_list)
# ['北京', '上海', '成都', '深圳', '广州']

4.3.3 查

• in

food_list = ['铁锅炖大鹅', '小鸡炖蘑菇','红烧五花肉']
food = '红烧五花肉'
if food in food_list:
    print('食物存在')
else:
    print('食物不存在')

• not in

if food not in food_list:
    print('食物不存在')
else:
    print('食物存在')

4.3.4 删

del_list = ['var1','var2','var3','var4','var5']

• del：根据下标删除

del del_list[2]

• pop：删除最后一个元素

del_list.pop()

• remove：根据元素值删除

del_list.remove('var1')

4.4 元组(Tuple)

元组元素不能修改

• 当元组中只有一个数据时，数据类型为该元素值类型，需要在尾部增加’,’才可成为tuple

a_tuple = ('a',)
print(type(a_tuple))
# <class 'tuple'>

4.5 切片

字符串、列表、元组都支持切片操作

切片语法：[起始:结束:步长] || [起始:结束]

s = 'hello  world'

print(s[0]) 								# h
print(s[1:])								# ello world
print(s[:5])								# hello
print(s[1:5])								# ello
print(s[0::2])								# hlowrd
print(s[::-1])								# dlrow olleh
print(s[:5:-1])					 			# dlrow
print(s[-1:5:-1])							# dlrow

4.6 字典(Dict)

定义

person = {'name': 'zhangsan', 'age': 18}

4.6.1 增

# 直接使用下标新建，字典中不存在则为增加
person['name'] = 'lisi'

4.6.2 删

• del

  • 删除字典中某一元素

  del person['name']

  • 删除整个字典

  del person # 删除后字典整个定义被删除，无法被使用

• clear

  • 清空字典，但保留字典对象

  person.clear()  # {}

4.6.3 改

# 直接使用下标修改
person['name'] = 'lisi'

4.6.4 查

# 方法一 person['name']
print(person['name'])
# 方法二（推荐使用） person.get('age')
print(person.get('age'))
# 注：方法一获取不存在的key时会报错，方法二会返回None值

4.6.5 遍历

四种遍历方式

• 遍历字典key

for key in person.keys():
    print(key,end=' ')
# name age 

• 遍历字典value

for value in person.values():
    print(value,end=' ')
# zhangsan 18

• 遍历字典key-value

for key, value in person.items():
    print(key + ':' + str(value), end=' ')
# name:zhangsan age:18 

• 遍历字典的项/元素

for item in person.items():
    print(item,end=' ')
# ('name', 'zhangsan') ('age', 18)      

五、函数

5.1 定义函数

注意事项：缩进为四个空格

def function():
    ...

5.2 函数参数

def function(a,b):
    ...

5.3 函数返回值

def function():
    ...
    return result

六、文件

6.1 打开与关闭

打开文件/创建文件

open(文件路径 , 访问模式)

fp = open('test.txt','w')

关闭文件

fp.close()

文件路径

• 绝对路径：盘符开始
• 相对路径：./或不写

6.2 模式

• w：可写

fp =open('test.txt','w')
# 写
fp.write('hello world')
fp.close()

• r：可读

fp = open('test.txt','r')
# 方法一
# read()所有数据都会被以字节方式读取，单字节的读取，效率低
content = fp.read()
print(content)

# 方法二
# readline()一行一行读，只能读取一行
content = fp.readline()
print(content)

# 方法三（推荐使用）
# readlines()以行为单位读取数据，返回一个list
content = fp.readlines() # ['hello world\n', 'hello world\n' [,...]]
# 遍历输出每行数据
for msg in content:
    print(msg,end='')
fp.close()

• a：追加
• r+：打开文件用于读写，文件指针在开头
• w+：打开文件用于读写，文件已存在则覆盖，不存在则创建新文件
• a+：打开文件用于读写，文件存在时文件指针在文件结尾，文件不存在时创建文件
• 以下b的模式皆为二进制文件模式
• rb wb ab
• rb+ wb+ ab+

6.3 序列化与反序列化

默认情况下file.write只能写入str字符串数据

python中的json模块实现了序列化和反序列化

6.3.1 序列化

• 方式一：json.dumps(对象)

fp = open('serializable.txt', 'w')
    
# list
nameList = ['zhangsan', 'lisi', 'wangwu']

# 1.导入json模块
import json

# 2.调用json.dumps将list转为str类型
names = json.dumps(nameList)

# 3.写入
fp.write(names)
    
fp.close()

• 方式二：json.dump

fp = open('serializable.txt', 'w')

# list
nameList = ['zhangsan', 'lisi', 'wangwu','zhaoliu']

# 1.导入json模块
import json

# 2.调用json.dump(object,file)写入文件
json.dump(nameList,fp)

fp.close()

6.3.2 反序列化

• 方式一：json.loads

fp = open('serializable.txt', 'r')

# 1.读取内容
content = fp.read()
    
# 2.导入json模块
import json
    
# 3.调用json.loads(str)
result = json.loads(content)
    
print(result)
print(type(result))
    
fp.close()

• 方式二：json.load

fp = open('serializable.txt', 'r')

# 1.导入json模块
import json

# 2.调用json.load(file)
result = json.load(fp)

print(result)
print(type(result))

fp.close()

七、异常

格式：try…except…

try:
    fp = open('a.txt', 'r')
    msg = fp.read()
    fp.close()
except FileNotFoundError:
    print('异常报错')