第二篇：复习python

一、啥是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	print
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[:])

输出结果：

1. pyt
2. hon
3. 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. 1
2. (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 子句放在最后，无论是否出现异常都会执行。

小结

写本文主要是为了分享我的学习过程，也是给自己记个笔记，哪里忘记了，回来再看一眼，也可以很快的回想起来

注：本文主要供自己学习练习使用，大部分内容是从第三方平台截图复制而来（究极缝合怪），如有侵权请联系删除