Python爬虫——Python基础笔记

1、注释

在我们工作编码的过程中，如果一段代码的逻辑比较复杂，不是特别容易理解，可以适当的添加注释，以辅助自己 或者其他编码人员解读代码。

注意：注释是给程序员看的，为了让程序员方便阅读代码，解释器会忽略注释。使用自己熟悉的语言，适当的对代 码进行注释说明是一种良好的编码习惯。

1.1、单行注释

以 # 开头，后面的都注释内容

#单行注释
#单行注释，一般都是写在代码的上方
print('中国是一个强大的国家') # 也可以写在代码的后面

1.2、多行注释

以 ‘’’ 开始，并以 ‘’’ 结束

'''
多行注释
多行注释
多行注释
'''

2、变量加数据类型

2.1、变量的定义

变量的格式：变量名 = 变量值

说明：

• 变量的值是可以变化的值，可以随时进行修改
• 程序是用来处理数据的，而变量是存储数据的

2.2、变量的数据类型

Numbers 数值型

​ int 整型

​ float 浮点型

​ complex 复数

boolean 布尔类型 True False

String 字符串

List 列表

Tuple 元组

Dictionary 字典

# 变量类型的使用
# int 整型
money = 5000

# float  浮点型
price = 12.99

# boolean  布尔
# 只有True和False两种类型
# 通常在流程控制中使用  性别  男True  女False
is_flag = True
gender = False

# string 字符串
# 使用 单引号'' 或 双引号""
s = '少年不识愁滋味，爱上层楼'
s1 = "爱上层楼，为赋新词强说愁"
# 单双引号的嵌套使用
s2 = "'而今识尽愁滋味，欲说还休'"
s3 = '"欲说还休，却道天凉好个秋"'
# 可以使用print进行输出
print(s)

# list 列表
# 使用[]中括号进行定义，元素之间使用 ，逗号分隔
name_list = ['周杰伦','刘德华']
age_list = [1,2,3]

# tuple 元组
# 使用()小括号进行定义，元素之间使用 ，逗号分隔
name_tuple = ('周杰伦','刘德华')
age_tuple = (18,20,23)

# dict 字典
# 使用{}大括号进行定义，使用 ， 逗号分隔
# 元素是使用 key : value  的方式
person = {'name':'张三','age' = 18}

列表，是Python里面的容器之一，有方括号和方括号括起来的数据构成。里面的数据可以是整数、浮点数、字符串，也可以是另一个列表或者其他数据结构。列表里面的每一项叫做列表的一个元素，每个元素之间使用英文逗号隔开。

元组，是Python里面的容器之一，由小括号和小括号括起来的数据构成。

元组与列表的区别：

列表生成以后，是可以进行更改的，可以添加数据，删除数据，以及修改数据。但是元组一旦定义就不可以修改。如果它里面只有整型、浮点型、字符串、另一个元组，就不能添加数据，也不能删除数据，还不能修改里面的值。但如果元组里面包含了一个列表，元组里面的列表仍然是可以更改的。

2.3、查看变量的数据类型

在Python中，只要定义了一个变量，而且它有数据，那么它的类型就已经确定了，不需要向其他语言一样要主动说明，系统会自动辨别。也就是说，变量没有类型，数据才有类型。

可以使用**type()**函数查看变量的数据类型

a = 1
# <class 'int'>
print(type(a))

e = [1,2,3,4]
# <class 'list'>
print(type(e))

3、标识符和关键字

3.1、标识符的命名规则

1. 标识符由字母、数字和下划线组成。
2. 不能以数字开头
3. Python严格区分大小写
4. 不能使用关键字

3.2、命名规范

1.标识符的命名要做到 ”见名知意“，顾名思义

要起有一定意义的名字，尽量做到看一眼就知道什么意思（提高代码的可读性）

a = '张三'
name = '张三'

2.遵循一定的命名规范

​ 驼峰命名法 小驼峰命名法：第一个单词以小写字母开始，第二个开始首字母大写

​ 还有一种命名法是用下划线“_”来连接所有的单词，比如send_buf

​ Python的命令规则遵循PEP 8标准

first_name = 'Tom'
last_name = 'Jerry'

3.3、关键字

概念：一些具有特殊功能的标识符。

关键字，已经被Python官方使用了，所以不允许开发者定义和关键字相同名字的标识符

False		None 	True 	and 	as 		assert	 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

4、类型转换

函数	说明
int(var)	将数据转换为整形数据
float(var)	将数据转换为浮点型数据
str(var)	将数据转换为字符串
bool(var)	将数据转换为布尔类型

1.转换为整型数据

# 字符串转换为整型
pirnt(int('123'))
# 浮点型转换为整型
print(int(3.56)) # 3 
# 布尔类型转换为整型    True --> 1    False --> 0
print(int(True))

# 失败的情况
print(int('12an'))
print(int('12.34'))
# 12ab 和 12.34  如果字符串 包含了非法字符，不能转换为整型   报错

2.转换为浮点型数据

# 字符串转换为浮点型数据
print(float('12.34'))
# 整型转换为浮点型
print(float(32))
# 布尔型转换为浮点型
print(float(True))  # 1.0
print(float(False)) # 0.0

3.转换为字符串

# 整型转换为字符串
print(type(str(666)))
# 浮点型转换为字符串
str('12.35')
# 布尔型转换为字符串
str(True)

4.转换为布尔类型

# 整型转换为布尔类型
# 对于非0的整数(包括正数和负数)，转换为布尔型，都返回 True   0 --> False
print(bool(12))
# 浮点型转换为布尔类型
# 所有正的浮点数和负的浮点数，都返回True   0.0 --> False
print(bool(1.2))
# 字符串转换为布尔型
# 只要字符串有内容，强制类型转换为布尔型，就返回True    空串'' /"" -->  False
print(bool('abc'))
# 列表转换为布尔型
# 只要列表中有数据，强制类型转换为布尔型时，返回True   [] --->  False
print(bool(['tom']))
# 元组转换为布尔类型
# 只要元组中有数据 那么强制类型转换为bool类型的时候  返回True  () ---> False
print(bool( (1,2) ))
# 字典转换为布尔型
# 只要字典中有数据，那么在强制类型转换的时候 就返回 True  {} ---> False
print(bool({'name':'张三'}))

# 返回False的情况
print(bool(0))
print(bool(0.0))
print(bool(''))
print(bool(""))
print(bool([]))
print(bool( () ))
print(bool({}))

5、运算符

5.1、算术运算符

下面以 a = 10 , b = 20 为例进行计算

运算符	描述	实例
+	加	两个对象相加a+b 输出结果30
-	减	得到负数或是一个数减去另一个数a-b 输出结果-10
*	乘	两个数相乘或是返回一个被重复若干次的字符串a*b输出结果200
/	除	b/a 输出结果2
//	取整数	返回商的整数部分 9//2 输出结果 4， 9.0 // 2.0 输出结果 4.0
%	取余	返回除法的余数 b%a 输出结果0
**	指数	a**b为10的20次方
()	小括号	提高运算优先级，比如：(1+2) * 3

注意：混合运算时，优先级顺序为：** 高于 * / % // 高于 + - ，为了避免歧义，建议使用 ( )来处理运算符优先级。并且，不同类型的数字在进行混合运算时，整数会转换为浮点数进行运算。

a = 3
b = 2
print(a + b)	# 5
print(a - b)	# 1
print(a * b)	# 6
print(a / b)	# 1.5
print(a // b)	# 1
print(a % b)	# 1
print(a ** b)	# 8
print((5+2) * 3) # 21

# 扩展  字符串 进行拼接运算
a = '123'
b = '456'
print(a + b)	# 123456
# 在Python中，必须 两端都是 字符串才能进行加法运算。

5.2、赋值运算符

运算符	描述	实例
=	赋值运算符	把=右边的结果 赋给 左边的变量，如num = 1+2*3，结果num的值为7

# 单个变量赋值
num = 10
# 同时为多个变量赋值 (使用等号连接)
a = b = 4
# 多个变量赋值 (使用逗号分隔)
num1,f1,str1 = 100,3.14,'hello'

5.3、复合赋值运算符

运算符	描述	实例
+=	加法赋值运算符	b += a ==> b = b + a
-=	减法赋值运算符	b -= a ==> b = b - a
*=	乘法赋值运算符	b *= a ==> b = b * a
/=	除法赋值运算符	b /= a ==> b = b / a
//=	取整除赋值运算符	b //= a ==> b = b // a
%=	取余赋值运算符	b %= a ==> b = b % a
**=	幂赋值运算符	b **= a ==> b = b * * a

a += 1    #  a = a + 1
print(a)  #  2

5.4、比较运算符

比较运算符 的运算结果是 boolean类型的值 True 或 False

下面以 a = 10 , b = 5 进行运算

运算符	描述	实例
==	等于：比较两个对象是否相等	a == b 返回 False
!=	不等于：比较两个对象是否不相等	a != b 返回 True
>	大于	a > b 返回 True
>=	大于等于	a >= b 返回 True
<	小于	a < b 返回 False
<=	小于等于	a <= b 返回 False

5.5、逻辑运算符

运算符	逻辑表达式	描述
and 与	x and y	and 两端必须全部为True，才返回True，有一端为False，则返回False
or 或	x or y	or 只要有一端为True，就返回True。两端都为False，则返回False
not 非	not x	取反。如果是True,则返回False。如果是False，则返回True

逻辑与and 和 逻辑或 or 的短路问题。

短路与and，只要前面为False，就不在执行后面的表达式，直接返回False。

短路或or ，只要前面为True，就不在执行后面的表达式，直接返回True。

练习题：以下的输出结果是什么？

a = 66

a > 10 and print('1执行了')
a < 10 and print('2执行了')

a > 10 or print('3执行了')
a < 10 or print('4执行了')

思考：逻辑与 和 逻辑或 为什么采用短路运算？

6、输入和输出

6.1、输出

普通输出

print('少年强，则国强')

格式化输出

在Python中，看到使用%，就是格式化输出

%d 代表整数 %s 代表字符串

age = 18
print('女生的年龄永远%d岁' % age)
name = '林志玲'
print('%s的年龄永远%d' % (name,age))

6.2、输入

在Python中，获取键盘输入数据的方法采用的是 input()函数（详细在后面），我们先看一下如何使用？

# input('提示内容')
password = input('请输入你的黑卡密码：')
print('你输入的密码为：%s' % % password)

注意：

1. 在input()函数的小括号里面可以放提示内容，用来给用户一个有好的提示
2. 有返回值，返回值就是用户输入的内容。所有的返回值，都是字符串类型

7、流程控制语句

7.1、if 判断语句

if 语句是用来做判断的，其格式如下：

# if 要判断的条件:
#	  条件成立时，执行的操作
age = 18
if age >= 18:
	print('你可以开车了')

注意：条件不成立时，将不执行里面的代码。

7.2、if else

if else 的使用格式：

# if 条件:
#	满足条件的操作
# else:
#	不满足条件时的操作
age = 18
if age >= 18:
	print('你可以开车了')
else:
    print('回家洗洗睡吧')

7.3、elif

elif 的使用格式：

# elif  使用格式
# if 条件1:
#     代码1
# elif  条件2:
#     代码2
# elif  条件3:
#     代码3
# ....
# else:  （可选）
#     代码n

练习：

# 在控制台上输入您的成绩分数
# 如果你考了90以上  成绩为优秀
# 如果你考了80以上  成绩为良好
# 如果你考了70以上  成绩为中等
# 如果你考了60以上  成绩为合格
# 否则            成绩为不合格
score = int(input('请输入您的成绩'))
if score >= 90:
	print('您的成绩为：优秀')
elif score >= 80:
    print('您的成绩为：良好')
elif score >= 70:
    print('您的成绩为：中等')
elif score >= 60:
    print('您的成绩为：合格')
else:
    print('您的成绩为：不合格')

7.4、for

在Python中，for循环可以遍历任何序列的项目。如列表、字符串等

for循环的格式：

# for 临时变量 in 要遍历的数据（列表或字符串等可迭代的对象）
#	 满足条件时执行的代码
#range(5)  range(1,5)  range(1,10,3)

# 遍历一个字符串
for s in 'hello':
    print(s)
# 遍历一个列表
name_list = ['张三','李四','王五']
for name in name_list:
    print(name)
for i in range(5):
    print(i)
    print(name[i])

range函数

range可以生成数字，供for循环遍历。range可以传递三个参数：range(起始，结束，步长)

range(结束 n ) ： [0 , n) 左闭右开区间

# range(5)
for i in range(5):
    print(i)  # 0 1 2 3 4 
    
# range(1,6)
for i in range(1,6):
    print(i) # 1 2 3 4 5
    
# range(1,10,3)
for i in range(1,10,3):  # 左闭右开区间
    print(i) # 1 4 7 

8、数据类型高级

8.1、字符串高级

字符串的常用函数：

• 获取长度：len len函数可以获取字符串的长度。
• 查找内容：find 查找指定内容在字符串中是否存在，如果存在就返回该内容在字符串中第一次出现的开始位置索引值，如果不存在，就返回-1。
• 判断 startswith,endswith 判断字符串是不是以谁谁开头 / 结尾。
• 计算出现次数 count 返回str在start和end之间 ，在mystr中出现的次数
• 替换内容 replace 替换字符串中指定的内容，如果指定次数count，则替换不会超过count次
• 切割字符串 split 通过参数内容切割字符串
• 修改大小写 upper lower 是字符串中的大小写字母互换
• 空格处理 strip 去空格
• 字符串拼接 join 在mystr的每个字符之后拼接上str，最后一个不加 不好用

# len
s = 'china'
print(len(s))
# find
s1 = 'china'
print(s1.find('a'))
# count
s3 = 'aaabbccc'
print(s3.count('b'))
# replace
s4 = 'aabbbcccdd'
print(s4.replace('b','z'))
# split
s5 = '1#2#3#4#5'
print(s5.split('#'))
# upper
s6 = 'china'
print(s6.upper())
# lower
s7 = 'CHINA'
print(s7.lower)
# strip
s8 = '     a    '
print(s8.strip())
# join
s9 = 'a'
print(s9.join('hello')) # haealalao

8.2、列表高级

列表的增删改查

添加元素

• append 在列表的末尾添加元素
• insert 在列表的指定位置插入元素
• extend 合并两个列表

append 在末尾添加新元素

book_list = ['Python从入门到放弃','张三的爱情故事']
print(book_list)
book_list.append('断舍离')
print(book_list)

insert(index,object) 在指定index前插入元素object

a = ['a','b','d']
print(a)
a.insert(2,'c')
print(a)

extend 将另一个列表的元素逐一添加到列表中

a = ['a','b','c']
b = [1,2,3]
a.extend(b)
print(a)

修改元素

通过指定元素的下标进行修改即可，注意列表的下标是从0开始的

city_list = ['北京','上海','深圳','济南']
city_list[3] = '南京'
print(city_list)

查找元素

在列表中查找指定元素是否存在，常使用的方法是：

• in 存在 ：如果指定元素存在则返回True，不存在返回False。
• not in 不存在 ：如果指定元素不存在返回True，存在返回False

# 使用 in 在列表中查找指定的元素
name_list = ['张三','李四','王五']
find_name = input('请输入你要查找的姓名：')

if find_name in name_list:
    print('找到了指定元素')
else:
    print('未找到')

注：in 和not in 的使用方法相同。

删除元素

删除就是从列表中删除指定元素，常用方法：

• del 根据下表进行删除
• pop 删除最后一个元素
• remove 根据元素的值，进行删除

book_list = ['断舍离','人性的弱点','羊皮卷','墨菲定律','狼道']

#del 根据下表进行删除
del book_list[2]
print(book_list)

# pop 删除列表的最后一个元素
book_list.pop()
print(book_list)

# remove 根据元素的值，进行删除
book_list.remove('断舍离')
print(book_list)

8.3、元组的高级

元组中的元素是不能修改的，下表从0开始，和列表类似。

元组的访问

元组，通过下标进行访问

age_tuple = (18,20,24,26)
print(age_tuple[0])
print(age_tuple[2])

修改元组测试

元组中的内容是不可以修改的

# 通过下标修改元组
age_tuple[2] = 22  # 报错

注：Python中不允许修改元组的数据，包括不能删除元组的元素。

定义只有一个元素的元组

定义一个只有一个元素的元组，需要在唯一的元素后面加上逗号 ,

# 定义只有一个元素的元组
a_tuple = (5)
print(type(a_tuple))  # <class 'int'>
# 在元祖中只放一个整形数据时， 它是整型数据
# 必须在唯一一个元素后，加上逗号
b_tuple = (5,)
print(type(b_tuple))  # <class 'tuple'>

c_tuple = ('a')
print(type(c_tuple)) # <class 'str'>

8.4、切片

切片，是指对操作的对象截取其中一部分的操作。字符串，列表，元组都支持切片操作。

切片的语法：[起始 : 结束 : 步长]，也可以简化使用 [起始 : 结束]

注：左闭右开区间

# 切片，通过下标 获取某一段数据
s = 'Hello World'

# 切片中直接写一个下标
print(s[0])  # H
print(s[1])  # e

# [0:4]  左闭右开区间 [0,4)
print(s[0:4]) # Hell

# [1:] 从起始值开始，到末尾结束
print(s[1:]) # ello World

# [:4] 从0开始，到结束值的前一个结束。左闭右开
print(s[:4]) # Hell

# [0:6:2]  [0,6)  步长为2
print(s[0:6:2]) # HLo

8.5、字典高级

查看元素

字典获取数据的常用方法：

• key 键
• get 方法

# 使用 key 和 get在字典中获取数据
person_dict = {'name' : '张三','age' = 18}

# 通过 key查看数据
print(person_dict['name'])
print(person_dict['age'])
# 通过key获取不存在的数据，会报错
print(person_dict['sex'])  # 报异常

# 通过get 获取数据
print(person_dict.get('name'))
print(person_dict.get('age'))
# 通过get 获取字典中不存在的key  会返回 None
print(person_dict.get('sex'))  # None
# 还可以给不存在的key，设置 返回一个默认值 
print(person_dict.get('sex','男'))

修改数据

字典中的，每一个元素都是可以删除的，只要找到对应的key，即可。

# 修改字典中的值
person_dict['name'] = '法外狂徒'
person_dict['age'] = 100
print(person_dict)

添加元素

如果 变量名[‘键’] = 数据 ，这个 键 在字典中，不存在，那么就会添加这个元素。

person_dict = {'name' : '张三'}
person_dict['age'] = 18

print(person_dict)
# 如果 键 存在就是修改数据
person_dict['name'] = '法外狂徒'

删除元素

字典常用的删除方法：

• del 删除字典中指定的某一个元素
  • ​ 删除整个字典
• clear 清空字典

# del 删除指定元素
del person_dict['age']
print(person_dict)

# del 删除整个字典
del person_dict
print(person_dict)  # 异常  not defined

# clear 清空字典  但保留字典对象
clear person_dict
print(person_dict)  # {}

字典的遍历

常用遍历字典的方法：

• 遍历字典的key (键)
• 遍历字典的value (值)
• 遍历字典的 项 (元素)
• 遍历字典的 key-value (键值对)

person = {'name':'张三','age':18,'gender':'男'}

# 遍历字典的 key
# 字典.keys() 方法  获取字典中所有的key值
for key in person.keys():  # key 是临时变量 名字随意  推荐key
    print(key)

# 遍历字典的 value
# 字典.values() 获取字典中所有的value值
for value in person.values():
    print(value)
    
# 遍历字典的 项/元素
# 字典.items() 获取字典的所有项
for item in person.items():
    print(item)
    
# 遍历字典的 key和value
for key,value in person.items():
    print('key = %s, value = %s' % (key,value))

9、函数

9.1、定义函数

函数的结构：

# 函数结构
# def 函数名(参数1，参数2，参数3，...)
#     函数体第一行
#     函数体第二行
#     ....
#     函数体第n行
#     return返回值
#
# 很多重复的业务逻辑  重复出现的时候 可以使用函数

# 定义函数
def f1():
    print('欢迎马大哥光临红浪漫')
    print('男宾2位')
    print('欢迎下次光临')
# 调用函数
f1()

9.2、调用函数

定义函数后，要想执行它，就必须要调用，才能执行。

调用函数，只需要通过 函数名() 即可完成调用

# 定义完函数后，不会自动执行，必须要调用才能执行
f1()

9.3、函数参数

定义和调用带有参数的函数。

只需要在函数名后面的小括号中，加上参数即可

# 定义带参数的函数
def sum(m,n):
    sum = m + n
    print(sum)
# 调用函数
# 位置参数
sum(10,20)
# 关键字参数
sum(n = 5,m = 10)

注：形参，函数定义时小括号里的参数，用来接收参数的，称为 形参

​ 实参，函数调用时小括号里的参数，用来传递给函数的，称为 实参

9.4、函数的返回值

在函数使用 return，来进行返回值

# 定义带返回值的函数
def sum(m,n):
    sum = m + n
    return sum

# 调用
result = sum(10,5)

9.5、局部变量和全局变量

局部变量：

• 在函数内定义的变量
• 其作用域范围就是这个函数的内部，即只能在这个函数内使用，在函数的外部不能使用

全局变量：

• 在函数外部定义的变量
• 可以在函数外部使用 ，也可以在函数内部使用

# 局部变量
def f1():
    a = 1
    print(a)
# 函数外部
f1()
print(a)  # 报异常  not defined

# 全局变量
b = 2
print(b)
def f2():
    print(b)
# 函数外部
f2()
print(b)

注：在满足添加的情况下，要使用作用域最小的那个变量范围

9.6、如何定义一个类

类一般有以下元素构成：

· 类名

· 父类

· 初始化方法（在有些编程语言中叫做构造方法）

· 属性

· 方法

class People(object)
	def __init__(self,name,age):
    	self.name = name
        self.age = age
        self.jump()
        
	def walk(self):
        print('我的名字叫做: {},我正在走路' .format(self.name))
    
    def eat(self):
        print('我的名字叫做: {},我正在吃饭' .format(self.name))
        
    def jump(self):
        print('我的名字叫做: {},我调了一下' .format(self.name))
        
zhangsan = People('张三',18)
lisi = People('李四',20)

print('*********获取对象属性*********')
print(zhangsan.name)
print(lisi.age)
print('*********执行对象的方法*********')
zhangsan.walk()
lisi.eat()

# 执行结果是什么？

注：在代码的第一行定义了一个类名为People的类，这个类的父类为Object。

第二行是构造函数。一旦类被初始化，就会 自动执行。

self：在类的内部，如果要运行它自己的方法，那么调用时需要使用“self.方法名(参数)”的形式。如果要让一个变量在这个类的所有方法里面都能直接使用，就需要把变量初始化为“self.变量名”。

10、文件

10.1、文件的打开与关闭

在Python中，使用open函数，打开一个已存在的文件，或者创建一个新文件。

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

# 创建一个新的test.txt文件
# open(文件路径,访问模式)
# 路径： ①相对路径  从当前位置开始
#		②绝对路径	从盘符开始
# 模式：r 可读
#	   w 可写

# 创建文件
open('test.txt','w')
# 打开文件
fp = open('test.txt','w')
fp.write('hello word')
# 关闭文件
fp.close()

文件的关闭：使用close方法。

注：文件打开之后，必须要进行关闭。

访问模式：

访问模式	说明
r	以只读方式打开文件。文件的指针将会放在文件的开头。如果文件不存在，则报错。这是默认模式。
w	打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
w+	打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模 式。如果该文件不存在，创建新文件用于读写。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新 文件。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是 说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文 件。
ab+	以二进制格式打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。如果该文 件不存在，创建新文件用于读写。

10.2、文件的读写

写数据(write)

使用write()向文件内写入数据。

# write() 方法  w模式
fp = open('test.txt','w')
fp.write('Hello World \n' * 5) 
fp.write('Hello World \n' * 5) #会覆盖
fp.close()
# a 模式
fp = open('test.txt','a')
fp.write('Hello World \n' * 5)
fp.write('Hello World \n' * 5) # 追加
fp.close()

读数据(read)

主要的读数据的方法有：

• read()
• readLine()
• readLines()

# 使用read(num)可以从文件中读取数据，num表示要从文件中读取的数据的长度（单位是字节），如果没有传入
# num，那就表示读取文件中所有数据
fp = open('test.txt','r')
# 默认情况下，read是一字节一字节的读  效率比较低
content = fp.read()
# content = fp.read(5)
print(content)

# readline 是一行一行的读取  但是只能读一行
content = fp.readline()
print(content)

# readlines 可以按照行来读取  但是会将所有数据都读取到  并且会以一个列表的形式返回
# 而列表的数据 是一行一行的数据
content = fp.readlines()
print(content)

10.3、序列化和反序列化

通过文件操作，我们可以将字符串写入到一个本地文件。但是，如果是一个对象（如列表、元组、字典等），就无法直接写入到一个文件里，需要对这个对象进行序列化，然后才能写入到文件里。

设计一套协议，按照某种规则，把内存中的数据转化为字节序列，保存到文件，就是序列化。反之，从文件的字符序列恢复到内存中，就是反序列化。

对象 —> 字符序列 === 序列化

字符序列 —> 对象 ====反序列化

Python通过 JSON这个模块来实现数据的序列化和反序列化

JSON模块

JSON(JavaScriptObjectNotation, JS对象简谱)是一种轻量级的数据交换标准。JSON的本质是字符串

使用 JSON实现序列化

JSON提供了dump和dumps方法，将一个对象进行序列化

dumps方法的作用是将对象转换为字符串，它本身不具备将数据写入到文件的功能

fp = open('test.txt','w')
# # 默认情况下  对象无法写入到文件中  如果想写入到文件中  那么必须使用序列化操作
name_list = ['Tom','Jerry']
# TypeError: write() argument must be str, not list
fp.write(name_list) # 报错

序列化的两种方式：

• dumps 是把对象转换成为字符串，它本身不具备将数据写入到文件的功能。
• dump 可以在将对象转换成为字符串的同时，指定一个文件对象，把转换后的字符串写入到这个文件里。

dumps

# dumps
# 1.创建一个文件
fp = open('test.txt','w')
# 2.定义一个列表
name_list = ['张三','李四']
# 3.导入JSON模块
import json
# 4.序列化，将对象转化为json字符串
names = json.dumps(name_list)
# 5.写入到文件中
fp.write(names)
# 6.关闭文件
fp.close()

dump

# dump
fp = open('test.txt','w')
name_list = ['张三','李四']
import json
# dump可以将对象转换为字符串的同时将字符串写入对象中
json.dump(name_list,fp)
fp.close();

反序列化

反序列化，就是将一个JSON字符串转换为Python对象

使用JSON实现反序列化，常用方法：

• loads loads方法需要一个字符串参数，用来将一个字符串加载成为Python对象。
• load load方法可以传入一个文件对象，用来将一个文件对象里的数据加载成为Python对象。

loads

# loads()
# 1.读取一个文件内容。  以只读的方式打开一个文件
fp = open('test.txt','r')
# 2.读取文件内容
content = fp.read()
# 3.加载JSON模块
import json
# 4.使用loads方法 将JSON字符串转为Python对象
name_list = json.loads(content)
print(name_list)
print(type(name_list))
# 5.关闭文件
fp.close()

load

# load()
import json
fp = open('test.txt','r')
# 使用load()方法，传入一个文件对象
name_list = json.load(fp)
print(name_list)
print(type(name_list))
fp.close()

11、异常

程序在运行过程中，由于我们的编码不规范，或者其他原因一些客观原因，导致我们的程序无法继续运行，此时， 程序就会出现异常。如果我们不对异常进行处理，程序可能会由于异常直接中断掉。为了保证程序的健壮性，我们 在程序设计里提出了异常处理这个概念。

11.1、读取文件异常

在读取一个文件时，如果这个文件不存在，则会报出FileNotFoundError 错误。

# 先删除test.txt文件
fp = open('test.txt','r')
fp.read()
fp.close()
# 报异常  FileNotFoundError

11.2、try…except语句

try…except语句可以对代码运行过程中可能出现的异常进行处理。

# 语句结构
# try:
#    可能出现异常的代码块
# except 异常的类型:
# 	 出现异常以后的处理语句
try:
    fp = open('test.txt','r')
    fp.read()
except FileNotFoundError:
    print('系统正在升级，请稍后再试.....')