第二篇：复习python
文章目录
- 一、啥是python
- 二、python的优点
- 三、python 的下载与环境搭建
- 四、python基础弟中弟
-
- 1. 标识符
- 2. Python 注释
- 3. 编码
- 4.输入/输出
- 5. 缩进
- 6. 多行语句
- 7. Python 引号
- 8. 数据类型
- 9. 运算符
- 五、python基础
-
- 1. 条件语句
- 2. 循环语句
-
- 2.1 for循环
- 2.2 whie循环
- 2.3 break
- 2.4 continue
- 2.5 pass
- 3. 数字的基本运用
-
- 3.1 math
- 3.2 随机数函数
- 4. 字符串基本操作
-
- 4.1 访问
- 4.2 字符串的运算符
- 4.3 字符串格式化
- 5. 序列
-
- 5.1 索引
- 5.2 切片
- 5.3 内置函数
- 6. 列表与元组
-
- 6.1 列表基本使用
- 6.2 元组基本使用
- 7. 字典与集合
-
- 7.1 字典基础使用
- 7.2 集合基础使用
- 六、python中的函数
-
- 1. 什么是函数
- 2. 自定义函数
- 3. 函数的调用
- 七、 面向对象
-
- 1. 面向对象的相关概念
- 2. 类的基本操作
-
- 2.1 如何定义类
- 2.2 对象
- 2.3 继承
- 3封装继承和多态的例子
-
- 3.1 普通类
- 3.2 封装
- 3.3 继承
- 3.4 多态
- 八、文件操作
-
- 1. 文件操作
-
- 1.1 创建/打开文件
- 1.2 写入文件
- 1.3 读取文件
- 1.4 定位
- 2. 文件夹操作
- 异常
-
- 1. 什么是异常
- 2. python内置异常
- 3. 异常处理
- 小结
一、啥是python
Python 是一种解释型语言
Python 是交互式语言
Python 是面向对象语言
Python 是初学者语言
二、python的优点
-
1.易于学习：Python有相对较少的关键字，结构简单，和一个明确定义的语法，学习起来更加简单。
-
2.易于阅读：Python代码定义的更清晰。
-
3.易于维护：Python的成功在于它的源代码是相当容易维护的。
-
4.一个广泛的标准库：Python的最大的优势之一是丰富的库，跨平台的，在UNIX，Windows和Macintosh兼容很好。
-
5.互动模式：互动模式的支持，您可以从终端输入执行代码并获得结果的语言，互动的测试和调试代码片断。
-
6.可移植：基于其开放源代码的特性，Python已经被移植（也就是使其工作）到许多平台。
-
7.可扩展：如果需要一段运行很快的关键代码，或者是想要编写一些不愿开放的算法，可以使用C或C++完成那部分程序，然后从Python程序中调用。
-
8.数据库：Python提供所有主要的商业数据库的接口。
-
9.GUI编程：Python支持GUI可以创建和移植到许多系统调用。
-
10.可嵌入: 可以将Python嵌入到C/C++程序，让程序的用户获得"脚本化"的能力。
三、python 的下载与环境搭建
python的官方地址: `https://www.python.org/
安装后详情可见：https://www.runoob.com/python/python-install.html
接下来，正式进入python的复习
四、python基础弟中弟
1. 标识符
标识符是编程时使用的名字，用于给变量、函数、语句块等命名，Python 中标识符由字母、数字、下划线组成，不能以数字开头，区分大小写。
以下划线开头的标识符有特殊含义，单下划线开头的标识符，如：_xxx ，表示不能直接访问的类属性，需通过类提供的接口进行访问，不能用 from xxx import * 导入；双下划线开头的标识符，如：__xx，表示私有成员；双下划线开头和结尾的标识符，如：__xx__，表示 Python 中内置标识，如：__init__() 表示类的构造函数。
————————————————
| and | exec | not | assert | finally | or |
|---|---|---|---|---|---|
| break | for | pass | class | from | |
| continue | global | raise | def | if | return |
| del | import | try | elif | in | while |
| else | is | with | except | lambda | yield |
上面表中是 Python 中的关键字（保留字），我们在自定义标识符时不能使用关键字。
2. Python 注释
以‘#’开头的语句是注释，不一定要出现在行首，在某些语句后面也可以加注释，注释是给人看的，可以是任意内容，解释器会忽略掉注释，但注意不要使用无意义的注释。
Python 中单行注释采用 # 开头，Python 没有块注释，所以现在推荐的多行注释也是采用的 #
需要多行注释，可以在vscode中直接用快捷键 全部选中+Ctrl+?/
3. 编码
Python2 中默认编码为 ASCII，假如内容为汉字，不指定编码便不能正确的输出及读取，比如我们想要指定编码为 UTF-8，Python 中通过在开头加入 # -*- coding: UTF-8 -*- 进行指定。
Python3 中默认编码为 UTF-8，因此在使用 Python3 时，我们通常不需指定编码
4.输入/输出
Python 输出使用 print()，内容加在括号中即可。如下所示：
print('Hello Python')
Python 提供了一个 input()，可以让用户输入字符串，并存放到一个变量里。如下所示
name = input("请输入您的名字")
print('hi',name)
如果需要输入的值是数值类型，需要进行运算的话，需要进行一次强转
num = eval(input("请输入一个数字"))
print(num+1)
否则会报错
5. 缩进
大部分的编程语言都是使用“{}”来表示一个语句块或者代码段，而 Python 用缩进层次来组织代码块，而约定一个缩进是用‘4个空格’来表示，请务必遵守约定俗成的习惯，坚持使用4个空格的缩进。
缩进的空白数量是可变的，但是所有代码块语句必须包含相同的缩进空白数量，这个必须严格执行。
if True:
print("嘿嘿")
else:
print("不嘿嘿")
6. 多行语句
Python 语句中一般以新行作为为语句的结束符
但是我们可以使用斜杠（ \）将一行的语句分为多行显示
num_six = num_one + \
num_two + \
num_three
7. Python 引号
Python 接收单引号(‘ )，双引号(“)，三引号(""") 来表示字符串，引号的开始与结束必须的相同类型的。
hello = 'hello'
name = "张箫剑"
hello_name = """hello,
我是张箫剑"""
#其中三引号可以由多行组成，编写多行文本的快捷语法
8. 数据类型
- Number（数字）
- int
- float
- String（字符串）
- bool（布尔类型）
- true
- flase
- List（列表）
- Tuple（元组）
- Set（集合）
- Dictionary（字典）
9. 运算符
- +、 -、 *、 /（ 加减乘除）
- % （求余）
- ** （ 幂）
- // （整除）
- ==（相等）
- !=（不等）
- > 、>=、 <、 <=（大于，大于等于，小于，小于等于）
- =（赋值）
- +=（a+=1就是 a=a+1）
- & and（并且\和）
- | or（或者）
五、python基础
1. 条件语句
在进行逻辑判断时，我们需要用到条件语句，Python 提供了 if、elif、else 来进行逻辑判断。格式如下所示：
if a=1:
print("a是1")
elif a=2:
print("a是2")
else:
print("a既不是1，也不是2")
2. 循环语句
当需要多次重复执行时，我们要用到循环语句，Python 提供了 for 循环和 while 循环。
2.1 for循环
for 循环可以遍历任何序列，比如：字符串。如下所示：
str = 'python'
for i in str:
print(i)
输出结果:
1. p
2. y
3. t
4. h
5. o
6. n
也可以循环数字
for i in range(5):
print(i)
输出结果:
1. 0
2. 1
3. 2
4. 3
5. 4
从0 开始，循环五次结束
也可以指定从 几 开始，步长为 几
for i in range(2,6,2):
print(i)
输出结果：
1. 2
2. 4
for循环也可以嵌套使用，外层循环一次，内层循环一周
以下代码用99乘法表为例：
num = 0
for i in range(1,10):
for j in range(1,i+1):
num = i * j
print(f"{i} * {j} = {num} ",end="")
print('')
结果如下：
2.2 whie循环
while 循环，满足条件时进行循环，不满足条件时退出循环。如下所示：
num = 1
five = 5
while num < five:
num+=1
print(num)
输出结果：
5
当while后面的条件不成立之后，退出循环
2.3 break
break 用在 for 循环和 while 循环语句中，用来终止整个循环。
str = 'python'
for s in str:
if s == 'o':
break
print(s)
结果为：
1. p
2. y
3. t
4. h
2.4 continue
continue 用于在循环中，结束本次循环，进入下一次循环
str = 'python'
for s in str:
if s == 'o':
print("continue")
continue
print(s)
结果为：
1. p
2. y
3. t
4. h
5. continue
6. n
2.5 pass
pass 是空语句，它不做任何事情，一般用做占位语句，作用是保持程序结构的完整性。如下所示：
if True:
pass
3. 数字的基本运用
3.1 math
首先要先引入数学模块math。如下所示：
import math
引入之后就可以使用了，以 math 模块中求平方根函数 sqrt(x) 为例。使用方式如下所示：
import math
print(math.sqrt(1024))
结果为：
32.0
math 模块中除了求平方根函数，还有很多可以使用的函数。如下表所示：
| 函数 | 描述 |
|---|---|
| abs(x) | 返回 x 的绝对值 |
| ceil(x) | 返回 x 的上入整数，如：math.ceil(1.1) 返回 2 |
| floor(x) | 返回 x 的下舍整数，如：math.floor(1.1) 返回 1 |
| exp(x) | 返回 e 的 x 次幂 |
| log(x) | 返回以 e 为底 x 的对数 |
| log10(x) | 返回以 10 为底 x 的对数 |
| pow(x, y) | 返回 x 的 y 次幂 |
| sqrt(x) | 返回 x 的平方根 |
| factorial(x) | 返回 x 的阶乘 |
3.2 随机数函数
在安全领域有时会用到随机数，random 模块对随机数的生成提供了支持。
首先还是要引入 random 模块。如下所示：
import random
强烈推荐randint函数
num=random.randint(1,100)
可以随机生成1-100的整数
4. 字符串基本操作
4.1 访问
访问单个字符：
str = 'python'
print(str[0])
访问的结果是 str下标为0 的字符 p
访问范围内字符：
str = 'python'
# 访问 yt
print(str[1:3])
# 访问 前三个字符
print(str[:3])
# 访问 后三个字符
print(str[3:])
4.2 字符串的运算符
| 运算符 | 描述 |
|---|---|
| + | 连接符 |
| * | 重复输出 |
| [] | 通过下标索引获取字符串中字符 |
| [ : ] | 获取字符串中连续的一部分 |
| in | 字符串中是否包含指定字符 |
| not in | 字符串中是否不包含指定字符 |
4.3 字符串格式化
当我们需要输出的内容中含有变量时，比如：Hello xxx，xxx 为变量，此时便需要一种格式化字符串的方式，Python 使用 % 格式化字符串。
| 占位符 | 描述 |
|---|---|
| %s | 格式化字符串 |
| %d | 格式化整数 |
| %f | 格式化浮点数 |
以字符串为例
print(‘hello %s’ % ‘python’)
输出结果：
hello python
也可以使用format() 方法进行格式化:
这种是用传入的参数，按顺序替换掉掉大括号内的0，1
print(‘{0} {1}’.format(‘Hello’, ‘Python’))
5. 序列
5.1 索引
序列是一块可存放多个值的连续内存空间，所有值按一定顺序排列，每个值所在位置都有一个编号，称其为索引，我们可以通过索引访问其对应值。
序列索引支持非负数和负数，索引为非负数，从 0 开始，如下所示：
索引为负数由右向左计数，从 -1 开始，如图所示：
5.2 切片
切片操作可以访问一定范围内的元素
序列名[开始的索引 ：结束的索引 ：步长]
类似于循环中的 开始 结束 步长
str = 'ython'
print(str[:3])
print(str[3:])
print(str[:])
输出结果：
- pyt
- hon
- python
+ 相加
Python 支持类型相同的序列使用 + 作相加操作，该操作不会去除重复的元素
str1 = "123"
str2 = "456"
print(num1+num2) #”123456“
注意，此中的123，456 都是字符串类型，最后两个字符串会拼接成一个新的字符串
+ 相乘
使用数字 n 乘以一个序列会生成新的序列，内容为原来序列被重复 n 次的结果，如下所示：
str = 'python'
print(str*2)
输出结果：
pythonpython
5.3 内置函数
| 函数 | 描述 |
|---|---|
| len() | 计算序列的长度 |
| max() | 找出序列中的最大元素 |
| min() | 找出序列中的最小元素 |
| list() | 将序列转换为列表 |
| str() | 将序列转换为字符串 |
| sum() | 计算元素的和 |
| sorted() | 对元素进行排序 |
| enumerate() | 将序列组合为一个索引序列，多用在 for 循环中 |
6. 列表与元组
6.1 列表基本使用
- 创建
列表中的所有元素都放在一个 [ ]中，中间用,分割，如下所示：
l= [1,2,3,4,5]
- 访问
通过索引访问列表中的值，还可以使用 : 截取范围内的元素，如下所示：
l= [1,2,3,4,5]
print(l[0]) #1
print(l[1:]) #[2,3,4,5]
- 更新
除了对列表中现有元素进行修改外，还可以使用 append() 向列表中添加新元素，如下所示：
l= list(range(10)) #[0,1,2,3,4,5,6,7,8,9]
l(0) = 10 #修改第一个元素（下标为0）
print(l) #[10,1,2,3,4,5,6,7,8]
- 尾部添加append
l= [1,2,3,5]
l.append(8)
print(l) # [1,2,3,5,8]
- 删除
使用 del 删除列表中元素，如下所示：
l= [1,2,3]
del l[0]
print(l) #[2,3]
- count()计数
统计列表中某个元素出现的次数，使用如下所示：
l= ["a","b","c","d","a"]
print(l.count("a"))
结果为：
2
- index（）检索
l= [1,3,3,4,5,8,9]
l2= l.index(3,0,3) #3是想搜索的内容 0是搜索的起始下标 2是搜索的结束下标
print(l2) # 含头不含尾，不包含结束的
返回的结果为第一个搜寻到的下标：
-
remove（）移除
结果为：[1,3,6,55,9]
-
sort（）排序
结果为：[1,1,2,3,3,4,5,5]
-
copy 复制
l= [1,2,3,4,5]
l_copy = l.copy()
print(l_copy)
结果为：
[1,2,3,4,5]
6.2 元组基本使用
- 创建
元组中所有元素都放在一个小括号 () 中，相邻元素之间用逗号 , 分隔，如下所示：
t= (1,0.1,'python')
- 访问
与访问列表中元素类似，如下所示
t= (1,0.1,'python')
print(t[0])
print(t[1:])
输出结果为：
- 1
- (0.1,‘python’)
- 修改
元组中元素不能被修改，但是可以用重新赋值的方式操作，操作如下：
t= (10,0.1,'python')
t= (1,0.1,'python')
print(t)
输出结果：
(1,0.1,‘python’)
- 删除
元组中的元素不能被删除，只能删除整个元组，操作如下：
t= [1,0.1,'python']
del t
print(t)
输出结果：
NameError: name ‘t’ is not defined
- len() 求长
计算元组中的元素个数，使用如下：
t= (1,2,3,4,5)
print(len(t))
结果为：
5
- max()和min()
t= (5,3,1,2,4)
print(max(t))
print(min(t))
结果如下：
5
1
- tuple()
将列表转换为元组，使用如下：
t= [1,2,3,4,5]
l= tuple(t)
print(l)
输出结果：
(1, 2, 3, 4, 5)
7. 字典与集合
7.1 字典基础使用
- 创建
字典的内容存在于花括号内{},键值对类型（key-value）之间用冒号:隔开，键值对之间用,逗号分隔，创建字典如下：
d = {'name':'箫剑','age':19}
# 使用 dict 函数
# 方式一
l = [('name', '箫剑'), ('age', 19)]
d = dict(l)
# 方式二
d = dict(name='箫剑', age=19)
# 空字典
d = dict()
d = {}
- 访问
字典中的值通过key进行访问，如下所示：
d = dict(name='箫剑',age=19)
print(d['name'])
# 结果为 箫剑
# 使用 get 方法
print(d.get("name"))
# 结果为 箫剑
- 修改
d = dict(name='箫剑',age=19)
d['age'] = '20'
print(d['age'])
# 结果为 20
- 清空集合
d = dict(name='箫剑',age=19)
d.clear()
print(d)
# 结果为 {}
- 获取字典的长度
d = dict(name='箫剑',age=19)
len(d)
# 结果为 2
7.2 集合基础使用
集合与字典相同存储key但也只存储key,因为key不可以重复，所以也是无序的
- 创建
集合使用花括号 {} 或者 set() 函数创建，如果创建空集合只能使用 set() 函数
s = {'a', 'b', 'c'}
# 使用 set 函数
s = set(['a', 'b', 'c'])
# 空集合
s = set()
集合中重复的元素会被自动过滤掉，如下所示：
s = {"a","a","b","b","c","c"}
print(s)
# 结果为 {"a","b","c"}
添加元素可以使用 add 或 update 方法，如下所示：
s = {'a', 'b', 'c'}
s.add('d')
print(s)
# 结果为 {'a', 'd', 'c', 'b'}
s.update('e')
print(s)
# 结果为 {'a', 'b', 'e', 'd', 'c'}
# 添加已经存在的元素 a
s.add('a')
print(s)
# 结果为 {'a', 'b', 'e', 'd', 'c'}
因为集合是无序的，所以结果顺序也不是固定的
- remove（）删除
s = {'a', 'b', 'c'}
s.remove('c')
print(s)
# 结果为 {'a', 'b'}
- clear （）清空集合
s = {'a', 'b', 'c'}
s.clear()
print(s)
# 结果为 set()
- len（）获得长度
s = {'a', 'b', 'c'}
print(len(s))
# 结果为 3
六、python中的函数
1. 什么是函数
函数是一段具有特定功能的代码块，可以被重复调用。函数可以接受任意数量的输入参数，并返回一个或多个值。
python中有很多的内置函数，当内置函数不足以满足需求时，还可以自定义函数
2. 自定义函数
python中使用 def 关键字来声明函数，格式如下：
def 函数名(参数):
函数体
return 返回值
定义一个无任何功能的空函数，函数体只写 pass 即可。格式如下所示
def 函数名():
pass
当不确定参数的个数时，可以使用不定长参数，在参数名前加 * 进行声明，格式如下所示：
def 函数名(*参数名):
函数体
也可以使用lambda定义匿名函数，格式如下：
lambda 参数 : 表达式
四种函数举一个例子
# 空函数
def my_pass():
pass
# 无返回值
def my_name(name):
print('hello', name)
# 有返回值
def my_sum(x, y):
s = x + y
print(s)
return s
# 不定长参数
def my_variable(*params):
for i in params:
print(i)
# 匿名函数
my_sum2 = lambda x, y: x + y
3. 函数的调用
调用函数需要知道函数名和参数
下面以调用上面四条为例子：
my_pass()
my_name('箫剑')
result = my_sum(1, 2)
my_variable(1, 2, 3, 4, 5, 6)
print(my_sum2(3, 4))
七、 面向对象
1. 面向对象的相关概念
-
类：描述具有相同属性和方法的集合，简单来说就是一个模板，通它来创建对象。
-
对象：类的实体。
-
方法：在类中定义的函数。
-
类变量：定义在类中且在函数之外的变量，在所有实例化对象中公用。
-
局部变量：方法中定义的变量，只作用于当前实例。
面向对象三大特性
- 封装：隐藏对象的属性和实现细节，仅对外提供公共访问方式，提高复用性和安全性。
- 继承：一个类继承一个基类便可拥有基类的属性和方法，可提高代码的复用性。
- 多态：父类定义的引用变量可以指向子类的实例对象，提高了程序的拓展性。
2. 类的基本操作
2.1 如何定义类
Python 中类的定义使用 class 关键字，语法如下所示：
class 类名字:
属性
def 方法名 (self): #必带self可以打点调用class里面的属性
函数体
-
当类属性和实例属性在class以外时，class中不可以使用类属性和实例属性
-
而当类属性时在class里,所有人都可以调用
-
构造方法
class 类名:
name:""
weight:
def _ _方法名_ _(self,name,weight):
self.name = name
self.weight = weight
下面以自行车为例：
class Bicycle():
name = ""
km = 0
def __run__(self,name,km):
self.name = name
self.km = km
print(self.name+f"已经奔腾{self.km}米")
构造方法 __init__() 会在类实例化时自动调用。无论构造方法还是其他方法都需要将 self 作为第一个参数，它代表类的实例。
类创建好后，可以直接通过类名访问属性，格式为：类名.属性名，比如访问 Bicycle类的 name属性，如下所示：
print(bicycle.name)
上面 Bicycle类中定义的属性和方法都是公开的，还可以定义私有属性和方法，声明方式为：在属性名或方法名前加两条下划线，示例如下所示：
class Bicycle:
__bid = '1'
def __run(self):
pass
外部不能访问私有属性和调用私有方法， Bicycle.__cid 是会报错的。
只能在类内部才能调用私有属性和私有方法
2.2 对象
创建对象也称类的实例化，比如可以通过 Bicycle 类创建对象，如下所示：
# 创建对象
bicycle = Bicycle()
创建好对象后，就可以使用它访问属性和调用方法了，如下所示：
# 访问属性
print(bicycle.name)
print(bicycle.km)
# 调用方法
bicycle.__run__('青青',200)
2.3 继承
Python 中支持类的继承，而且支持多继承，语法格式为：
class 主类(子类1, 子类2 ...):
...
例如：
# 父亲类
class Father():
name=''
work_name=''
def __init__(self,name):
self.name = name
def work(self,work_name)
print(self.name,"正在做"+work_name+"工作")
# 大儿子类
class BigSon(Father):
def __init__(self,name):
self.name = name
def play(self,game):
print(self.name,"正在玩"+game+"游戏")
# 小儿子类
class SmallSon(Father):
def __init__(self,name):
self.name = name
def eat(self,food):
print(self.name,"正在吃"+food+"食物")
# 单继承
class Single(BigSon)
pass
# 多继承
class Double(BigSon，SmallSon)
pass
# 调用
bs = Single("小明")
bs.game("农药")
ss = Double("小小明")
ss.game("农药plus")
ss.eat("蛋糕")
如果继承的父类方法不能满足需求，这时子类可以重写父类方法，如下所示：
class Single(BigSon):
def play(self, food ):
print(self.name,"正在玩"+game+"游戏,过了一会",self.name+"玩腻了")
s= Single('小黑')
s.game('开心斗地主')
3封装继承和多态的例子
3.1 普通类
class Pet:
name = ""
health = 100
def woof (self):
print("你在狗叫什么")
dog = Pet()
dog.name = "小明"
pig = Pet()
pig.name = "小青"
print(dog.name, end=",")
print(pig.name)
dog.woof()
运行结果：
小明,小青
你在狗叫什么
3.2 封装
class Person:
def __init__(self,name,health):
self.__name = name
self.__health = health
def set_name(self,name):
if len(name) > 0:
self.__name = name
def get_name(self):
return self.__name
def set_health(self,health):
if health < 0:
self.__health = 0
else:
self.__health = health
def get_health(self):
return self.__health
def eat(self):
print("你会吃饭吗?")
xiaoming = Person("小明",60)
xiaoqing = Person("小青",0)
print(xiaoming.get_name()+","+xiaoqing.get_name())
xiaoming.eat()
运行结果：
小明,小青
你会吃饭吗?
3.3 继承
class Animal():
def __init__(self,name,age):
self.name = name
self.age = age
def eat(self):
print("Animal"+self.name+"再吃东西")
def sleep(self):
print("Animal:"+self.name+"在睡觉")
class Dog(Animal):
def __init__(self,name,age,color):
super().__init__(name,age)
self.color = color
def bark(self):
print("Dog:"+self.name+"你在狗叫什么")
my_dog = Dog("小青",19,"white")
my_dog.bark()
my_dog.eat()
my_dog.sleep()
运行结果：
Dog:小青你在狗叫什么
Animal小青再吃东西
Animal:小青在睡觉
3.4 多态
class Phone(): # 定义手机类,属性有尺寸,颜色,价格
def __init__(self,size,color,price):
self.size = size
self.color = color
self.price = price
def features(self):
pass
class XiaoMi(Phone): # 小米继承于手机类
def __init__(self,size,color,price,Android):
super().__init__(size,color,price)
self.Android = Android
def features(self):
print("我用小米手机,Android系统,我爹是Phone,亲爹是雷军")
class Apple(Phone):
def __init__(self,size,color,price,Ios):
super().__init__(size,color,price)
self.Ios = Ios
def features(self):
print("我用苹果手机,Ios系统,我爹是Phone,亲爹是乔布斯")
class people():
def __init__(self,name):
self.name = name
def use_Phone(self,brand):
brand.features()
p = people("小青")
print("我叫"+p.name,end=",")
p.use_Phone(XiaoMi("6.67英寸","红色",1999,"Android"))
运行结果：
我叫甄青青,我用小米手机,Android系统,我爹是Phone,亲爹是雷军
八、文件操作
1. 文件操作
1.1 创建/打开文件
文件操作流程：
-
1 建立/打开文件
- 文件对象 = open(文件名，打开方式)
- r: 只读打开文本文件，文件必须存在
- w: 只写打开一个文件，文件不存在则创建
- a: 追加欸容到文件
与+组合: 可读可写
与b组合: 以二进制方法操作
-
2 文件读写
-
3 关闭文件
文件对象 = open(文件名,打开方式,编码方式)
文件操作
文件对象.close()
文件对象 = open(文件位置，打开方式，编码方式)
也可以使用
with open(文件位置，打开方式，编码方式) as 文件对象
with open ("test.txt","r",encoding="utf-8") as file:
1.2 写入文件
| 函数 | 描述 |
|---|---|
| write(str) | 将字符串写入文件，返回写入字符长度 |
| writelines(s) | 向文件写入一个字符串列表 |
# 写文件
w = open("test.txt","w+")
w.write("111222333444555666777888999\n")
w.writes(['hello\n','python'])
w.close()
1.3 读取文件
| 函数 | 描述 |
|---|---|
| read(size) | 读取指定的字节数，参数可选，无参或参数为负时读取所有 |
| readline() | 读取一行 |
| readlines() | 读取所有行并返回列表 |
使用如上的函数读取一下之前写的内容
with open('test.txt','r',encoding='utf-8') as r
print(r.readline())
print(r.read(6))
print(r.readlines())
1.4 定位
Python 提供了两个与文件对象位置相关的函数，如下所示：
| 函数 | 描述 |
|---|---|
| tell() | 返回文件对象在文件中的当前位置 |
| file.seek(offset[, whence]) | 将文件对象移动到指定的位置；offset 表示移动的偏移量；whence 为可选参数，值为 0 表示从文件开头起算（默认值）、值为 1 表示使用当前文件位置、值为 2 表示使用文件末尾作为参考点 |
with open('test.txt', 'rb+') as f:
f.write(b'123456789')
# 文件对象位置
print(f.tell())
# 移动到文件的第六个字节
f.seek(5)
# 读取一个字节，文件对象向后移动一位
print(f.read(1))
print(f.tell())
# 移动到倒数第二个字节
f.seek(-2, 2)
print(f.tell())
print(f.read(1))
2. 文件夹操作
这点真的忘了，看一下之前的代码吧，如有错误请指定更改
# 1 mkdir 创建单级目录 需要调os模块
import os
import shutil
os.mkdir("e://heiHei")
print("文件夹创建成功")
# 2 makedirs 创建多级目录
os.makedirs("e://a/b/c/d")
print("makedirs成功")
# 3 listdir 查看指定路径下的内容,以列表返回
print(os.listdir())
print("listdir成功")
# 4 getcwd 显示当前工作目录
print(os.getcwd())
print("getcwd成功")
# 5 chdir 按照path指定路径改变当前工作目录
# open当前工作目录下的文件时,可以省略路径前面,反之则不能
os.chdir("e://VsCode")
print("chdir成功")
# 6 rmdir 删除目录,必须是空目录,否则抛出异常
os.rmdir("e://a/b/c/d")
print("d目录")
os.rmdir("e://a/b/c")
print("c目录")
os.rmdir("e://a/b")
print("b目录")
os.rmdir("e://a")
print("a目录")
os.rmdir
# 删除目录方法
def del_files(path):
for i in os.listdir(path):
if ".py" in i:
continue
if os.path.isdir(os.path.join(path,i)):
del_files(os.path.join(path,i))
os.remove(os.path.join(path,i))
del_files("e://a")
# 7 remove 删除文件
os.remove("e://a/b/c/d/d.txt")
print("remove成功")
# 8 rename 重命名
os.rename("e://a","e://aa")
print("rename成功")
# 9 copyfile 复制文件 导入shutil模块
shutil.copyfile("e://aa//b.txt","e://aa//b2.txt")
print("copyfile成功")
# 在E创建一个text目录 在目录下面创建message.txt文件,文件内写入 "你好,李焕英"!
os.mkdir("E://text")
message = open("E://text//message.txt","w")
print("文件打开成功")
message.write("你好,李焕英!")
print("写入成功")
message.close()
shutil.copyfile("E://text//message.txt","E://text//message.copy.txt")
print("复制成功")
message_copy=open("E://text//message.copy.txt","a+")
message_copy.write(",我是张箫剑")
print("追加成功")
message_copy.close()
#删除全部文件和文件夹
top = "E://text"
shutil.rmtree(path=top)
print("done")
看完还不会的话
参考：https://docs.python.org/zh-cn/3/library/os.html?highlight=os#module-os
异常
1. 什么是异常
- 异常即是一个时间，该事件会在程序执行过程中发生，从而影响程序的正常执行
- 一般情况下，python无法正常处理程序时就会发生一个异常
- 异常时python对象，表示一个错误
- 当python脚本发生异常时，我们需要捕获处理它，否则程序会终止执行
2. python内置异常
| 异常名称 | 描述 |
|---|---|
| BaseException | 所有异常的基类 |
| SystemExit | 解释器请求退出 |
| KeyboardInterrupt | 用户中断执行(通常是输入^C) |
| Exception | 常规错误的基类 |
| StopIteration | 迭代器没有更多的值 |
| GeneratorExit | 生成器(generator)发生异常来通知退出 |
| StandardError | 所有的内建标准异常的基类 |
| ArithmeticError | 所有数值计算错误的基类 |
| FloatingPointError | 浮点计算错误 |
| OverflowError | 数值运算超出最大限制 |
| ZeroDivisionError | 除(或取模)零 (所有数据类型) |
| AssertionError | 断言语句失败 |
| AttributeError | 对象没有这个属性 |
| EOFError | 没有内建输入,到达EOF 标记 |
| EnvironmentError | 操作系统错误的基类 |
| IOError | 输入/输出操作失败 |
| OSError | 操作系统错误 |
| WindowsError | 系统调用失败 |
| ImportError | 导入模块/对象失败 |
| LookupError | 无效数据查询的基类 |
| IndexError | 序列中没有此索引(index) |
| KeyError | 映射中没有这个键 |
| MemoryError | 内存溢出错误(对于Python 解释器不是致命的) |
| NameError | 未声明/初始化对象 (没有属性) |
| UnboundLocalError | 访问未初始化的本地变量 |
| ReferenceError | 弱引用(Weak reference)试图访问已经垃圾回收了的对象 |
| RuntimeError | 一般的运行时错误 |
| NotImplementedError | 尚未实现的方法 |
| SyntaxError Python | 语法错误 |
| IndentationError | 缩进错误 |
| TabError | Tab 和空格混用 |
| SystemError | 一般的解释器系统错误 |
| TypeError | 对类型无效的操作 |
| ValueError | 传入无效的参数 |
| UnicodeError | Unicode 相关的错误 |
| UnicodeDecodeError | Unicode 解码时的错误 |
| UnicodeEncodeError | Unicode 编码时错误 |
| UnicodeTranslateError | Unicode 转换时错误 |
| Warning | 警告的基类 |
| DeprecationWarning | 关于被弃用的特征的警告 |
| FutureWarning | 关于构造将来语义会有改变的警告 |
| OverflowWarning | 旧的关于自动提升为长整型(long)的警告 |
| PendingDeprecationWarning | 关于特性将会被废弃的警告 |
| RuntimeWarning | 可疑的运行时行为(runtime behavior)的警告 |
| SyntaxWarning | 可疑的语法的警告 |
| UserWarning | 用户代码生成的警告 |
3. 异常处理
Python 程序捕捉异常使用 try/except 语句，例子如下：
#1、被除数为 0，未捕获异常
def getNum(n):
return 1 / n
print(getNum(0))
#输出结果：ZeroDivisionError: division by zero
#2、捕获异常
def getNum(n):
try:
return 1 / n
except IOError:
print('Error: IOError argument.')
except ZeroDivisionError:
print('Error: ZeroDivisionError argument.')
print(getNum(0))
'''
输出结果：
Error: ZeroDivisionError argument.
None
'''
try/except执行流程
try : #进行捕捉
# 代码块
except Exception:
#处理异常的代码
else : #没有错误才输出
# 代码块
finally:
# 一定会执行的（一般释放资源）
-
首先，执行 try 子句 （try冒号下面的内容）；
-
如果没有异常发生， except 子句 在 try 语句执行完毕后就被忽略了；
-
如果在 try 子句执行过程中发生了异常，那么该子句其余的部分就会被忽略；
-
如果异常匹配于 except 关键字后面指定的异常类型，就执行对应的except子句，然后继续执行 try 语句之后的代码；
-
如果发生了一个异常，在 except 子句中没有与之匹配的分支，它就会传递到上一级 try 语句中；
-
如果最终仍找不到对应的处理语句，它就成为一个 未处理异常，终止程序运行，显示提示信息。
其中，else 子句只能出现在所有 except 子句之后，只有在没有出现异常时执行；finally 子句放在最后，无论是否出现异常都会执行。
小结
写本文主要是为了分享我的学习过程，也是给自己记个笔记，哪里忘记了，回来再看一眼，也可以很快的回想起来
注：本文主要供自己学习练习使用，大部分内容是从第三方平台截图复制而来（究极缝合怪），如有侵权请联系删除