目录
变量的作用域
1、变量的作用域
（1）程序代码能访问该变量的区域
（2）根据变量的有效范围可分为
递归函数
1、什么是递归函数
2、递归的组成部分
3、递归的调用过程
4、递归的优缺点
5、斐波拉契数列：
异常处理
1、Python的异常处理机制
2、多个except结构
3、try...except...else...finally结构
（1） finally块无论是否发生异常都会被执行，能常用来释放try块中申请的资源
（2）图示说明：
4、python常见的异常类型
5异常处理模块traceback
6、pycharm开发环境的调试
（1）断点
（2）进入调试视图
（3）进入完调试台后，点击向下的箭头进入下一步调试
编程的两大思想：面向过程和面向对象
类与对象
1、类
2、数据类型
3、对象
类的创建
1、创建类的语法
2、类的组成
3、图示：
对象的创建
1、对象的创建又称为类的实例化
2、语法:
3、例子:
4、图示：
类属性、类方法、静态方法
动态绑定属性和方法
1、Python是动态语言，在创建对象之后，可以动态地绑定属性和方法
2、图解
3、对应图示的例子：
面向对象的三大特征
1、封装:提高程序的安全性
2、继承:提高代码的复用性
3、多态:提高程序的可扩展性和可维护性
4、封装例子：
5、继承
（1）语法格式
（2）如果一个类没有继承任何类，则默认继承object
（3）Python支持多继承
（4）定义子类时，必须在其构造函数中调用父类的构造函数
（5）多继承例子：
6、方法重写
7、object类
8、多态
9、特殊的属性和方法
10、类的浅拷贝与深拷贝
（1）变量的赋值操作
（2）浅拷贝
（3）深拷贝
（4）变量赋值操作例子：
模块
1、模块
2、函数与模块的关系
3、在Python中一个扩展名为.py的文件就是一个模块
4、使用模块的好处
5、自定义模块
（1）创建模块
（2）导入模块
（3）模块导入（自己创建的模块）
（4）以主程序形式运行
6、Python中的包
（1）包是一个分层次的目录结构，它将一组功能相近的模块组织在一个目录下
（2）作用:
（3）包与目录的区别
（4）包的导入
7、python中仓用的内容模块
第三模块的安装及使用
编码格式
文件的读写
常用的文件打开模式
1、文件的类型
with语句
1、with语句(上下文管理器)
操作目录
变量的作用域
1、变量的作用域
（1）程序代码能访问该变量的区域
（2）根据变量的有效范围可分为
（1）程序代码能访问该变量的区域
（2）根据变量的有效范围可分为
①局部变量
在函数内定义并使用的变量，只在函数内部有效，局部变量使用global声明，这个变量就会就成全局变量
②全局变量
函数体外定义的变量,可作用于函数内外
例子:
def fun(a,b):
c=a=b #c,就称为局部变量，因为c实在函数体内定义的变量a，b为函数的形参，通范围也是函数内部，相当于局部变量
print(c)
#print(c) 因为a，c超出了其作用的范围所以会报错
#print(a)
name='杨老师'
def fun2():
print(name)
#调用函数
fun2()
def fun3():
global age #函数内部定义的变量，局部变量，局部变量使用global声明，这个变量实际上就变成了全局变量
age=20
print(age)
fun3()
print(age)
输出结果：
递归函数
1、什么是递归函数
如果在一个函数的函数体内调用了该函数本身，这个函数就称为递归函数
2、递归的组成部分
递归调用与递归终止条件
3、递归的调用过程
每递归调用一次函数,都会在栈内存分配一个栈帧，
每执行完一次函数，都会释放相应的空间
4、递归的优缺点
缺点:占用内存多，效率低下
优点:思路和代码简单
例子：
def fac(n):
if n==1:
return 1
else:
res= n * fac(n-1)
return res
print(fac(6))
输出结果：
5、斐波拉契数列：
第一项：1
第二项：1
第三项：2
第四项：3
第五项：5
。。。。。。
也就是等于前面两项结果之和
例子：
#实现斐波拉契数列
def fib(n):
if n==1:
return 1
elif n==2:
return 1
else:
return fib(n-1)+fib(n-2)
#斐波拉契数列6位上的数字
print(fib(6))
print('---------------------')
#输出这个数列前6位项的数字
for i in range(1,7):
print(fib(i))
输出结果：
异常处理
1、Python的异常处理机制
被动掉坑问题的解决方案
Python提供了异常处理机制，可以在异常出现时即时捕获，然后内部“消化",让程序继续运行
2、多个except结构
捕获异常的顺序按照先子类后父亲类的顺序,为了避免遗漏可能出现的异常，可以在最后增加baseException
例子：
ry:
a=int(input('请输入第一个整数'))
b=int(input('请输入第二个整数'))
result=a/b
print('结果为：',result)
except ZeroDivisionError :
print('对不起，除数不允许为0')
except ValueError:
print('只能输入数字串')
print('程序结束
输出结果：
3、try...except...else...finally结构
（1） finally块无论是否发生异常都会被执行，能常用来释放try块中申请的资源
try:
n1=int(input(’请输入一个整数:∵'))
n2=int(input(’请输入另一个整数:'))
result=n1/n2
except baseException as e :
print('出错了')
print(e)
else:
print('结果为:', result)
finally:
print(’无论是否产生异常，总会被执行的代码')
print('程序结束')
（2）图示说明：
4、python常见的异常类型
| 序号 | 异常类型 | 描述 |
| 1 | zeroDivisionError | 除(或取模)零(所有数据类型) |
| 2 | IndexError | 序列中没有此索引(index) |
| 3 | KeyError | 映射中没有这个键 |
| 4 | NameError | 未声明/初始化对象（没有属性) |
| 5 | SyntaxError | Python语法错误 |
| 6 | ValueError | 传入无效的参数 |
5异常处理模块traceback
使用traceback模块打印异常信息
#print(10/0)
import traceback
try:
print('----------')
print(1/10)
except:
traceback.print_exc()
输出结果：
6、pycharm开发环境的调试
（1）断点
程序运行到此处，暂时挂起，停止执行。此时可以详细观察程序的运行情况，方便做出进一步的判断
（2）进入调试视图
进入调试视图的三种方式
单击工具栏上的按钮
右键单击编辑区:点击: debug'模块名’
快捷键:shift+F9
（3）进入完调试台后，点击向下的箭头进入下一步调试
编程的两大思想：面向过程和面向对象
| 面向过程 | 面向对象 | |
| 区别 | 事物比较简单，可以用线性的思维去解决 | 事物比较复杂，使用简单的线性思维无法解决 |
| 共同点 | 面向过程和面向对象都是解决实际问题的一种思维方式 | |
| 二者相辅相成，并不是对立的 解决复杂问题，通过面向对象方式便于我们从宏观上把握事物之间复杂的关系、方便我们分析整个系统;具体到微观操作，仍然使用面向过程方式来处理 | ||
类与对象
1、类
类是多个类似事物组成的群体的统称。能够帮助我们快速理解和判断事物的性质
2、数据类型
不同的数据类型属于不同的类
使用内置函数查看数据类型
print(type (100))
print(type(99))
print(type(520))
3、对象
100、99、520都是int类之下包含的相似的不同个例，这个个例专业数语称为实例或对象
类的创建
1、创建类的语法
class Studant :
pass
2、类的组成
类属性
实例方法
静态方法
类方法
3、图示：
例子：
class Student: #Student为类的名称（类名）由一个或多个单纯组成，每个单纯的首字母大写，其余小写
pass
#python中一切皆对象吗？内存空有空间开吗
print(id(Student))
print(type(Student))
print(Student)
输出结果：
例子：
lass Student:
nativ_pace='吉林' #直接写在类里的变量，称为类属性
def __init__(self,name,age):
self.name=name #self 称为实体属性，进行了一个赋值的操作，景局部变量的name的值赋给实体属性
self.age=age
#实例方法
def eat(self):
print('学生在吃饭。。。')
#静态方法
@staticmethod
def method():
print('我使用了statticmethod进行修饰，所以我是静态方法')
#在类之外定义的函数，在类之内定义的称方法
def drink():
print('喝水')
对象的创建
1、对象的创建又称为类的实例化
2、语法:
2、语法:
实例名=类名()
3、例子:
#创建Student类的实例对象
stu=Student(' Jack', 20)
print(stu.name). #实例属性
print(stu.age) #实例属性
stu.info() #实例方法
意义:有了实例，就可以调用类中的内容
4、图示：
例子：
class Student:
nativ_pace='吉林' #直接写在类里的变量，称为类属性
def __init__(self,name,age):
self.name=name #self 称为实体属性，进行了一个赋值的操作，景局部变量的name的值赋给实体属性
self.age=age
#实例方法
def eat(self):
print('学生在吃饭。。。')
#静态方法
@staticmethod
def method():
print('我使用了statticmethod进行修饰，所以我是静态方法')
#类方法
@classmethod
def cm(cls):
print('我是类方法，因为我使用了classmethod进行修饰')
#在类之外定义的函数，在类之内定义的称方法
def drink():
print('喝水')
#创建Student类的对象
stu1=Student('张三',20)
print(id(stu1))
print(type(stu1))
print(stu1)
print('----------------------------------')
print(id(Student)) #Student是类名
print(type(Student))
print(Student)
#调用方法
stu1.eat()
print(stu1.name) #对象名.方法名（）
print(stu1.age)
print('---------------')
Student.eat(stu1) #改行代码功能与stu1.eat()相同，也就是有两种调用方法
#类名.方法名（类的对象）--》实际上就是方法定义处的self
输出结果：
类属性、类方法、静态方法
1、类属性:类中方法外的变量称为类属性，被该类的所有对象
所共享
2、类方法:使用@classmethod修饰的方法，使用类名直接访问的方法
3、静态方法:使用@staticmethod修饰的主法，使用类名直接访问的方法
print(Student.native_place)..#访问类属性
student.cm() .#调用类方法
Student.sm().#调用静态方法
例子：
class Student:
nativ_pace='吉林' #直接写在类里的变量，称为类属性
def __init__(self,name,age):
self.name=name #self 称为实体属性，进行了一个赋值的操作，景局部变量的name的值赋给实体属性
self.age=age
#实例方法
def eat(self):
print('学生在吃饭。。。')
#静态方法
@staticmethod
def method():
print('我使用了statticmethod进行修饰，所以我是静态方法')
#类方法
@classmethod
def cm(cls):
print('我是类方法，因为我使用了classmethod进行修饰')
#类属性的使用方法
stu1=(Student('张三',20))
stu2=Student('李四',30)
print(stu1.nativ_pace)
print(stu2.nativ_pace)
Student.nativ_pace='天津'
print(stu1.nativ_pace)
print(stu2.nativ_pace)
print('-----------类方法的使用方式--------------')
Student.cm()
print('-----------静态方法的使用方式--------------')
Student.method()
输出结果：
动态绑定属性和方法
1、Python是动态语言，在创建对象之后，可以动态地绑定属性和方法
def show ():
print(’我是一函数')
stu=Student (' Jack', 20)
stu.gender=’男’ #动态绑定性别
print(stu.name,stu.age, stu.gender)
stu.show=show #动态绑定方法
stu. show()
2、图解
3、对应图示的例子：
lass Student:
def __init__(self,name,age):
self.name=name
self.age=age
def eat(self):
print(self.name+'在吃饭')
stu1=Student('张三',20)
stu2=Student('李四',30)
print(id(stu1))
print(id(stu2))
print('-------------------为stu2动态绑定性别属性-------------')
stu2.gender='女'
print(stu1.name,stu1.age)
print(stu2.name,stu2.age,stu2.gender)
print('----------------动态绑定方法--------------------')
def show():
print('定义在类之外，称函数')
stu1.show=show() #先要绑定方法，才能调用
stu1.show
输出结果：
面向对象的三大特征
1、封装:提高程序的安全性
（1）将数据（属性）和行为(方法）包装到类对象中。在方法内部对属性进行操作，在类对象的外部调用方法。这样，无需关心方法内部的具体实现细节，从而隔离了复杂度。
（2）在Python中没有专门的修饰符用于属性的私有，如果该属性不希望在类对象外部被访问，前边使用两个“二”。
2、继承:提高代码的复用性
3、多态:提高程序的可扩展性和可维护性
4、封装例子：
lass Student:
def __init__(self,name,age):
self.name=name
self.age=age
def show(self):
print(self.name,self.__age)
stu=Student('张三',20)
#在类的外面使用name和age
print(stu.name)
# print(stu.__age) 运行后会报错，因为遇到__代表它不向外在类的外面被看到
5、继承
（1）语法格式
4、封装例子：
lass Student:
def __init__(self,name,age):
self.name=name
self.age=age
def show(self):
print(self.name,self.__age)
stu=Student('张三',20)
#在类的外面使用name和age
print(stu.name)
# print(stu.__age) 运行后会报错，因为遇到__代表它不向外在类的外面被看到
5、继承
（1）语法格式
（1）语法格式
class子类类名(父类1,父类2..):
pass
（2）如果一个类没有继承任何类，则默认继承object
（3）Python支持多继承
（4）定义子类时，必须在其构造函数中调用父类的构造函数
（4）定义子类时，必须在其构造函数中调用父类的构造函数
例子：
lass Student(Person):
def __init__(self,name,age,stu_no):
super().__init__(name,age)
self.stu_no=stu_no
class Teacher(Person):
def __init__(self,name,age,teachofyear):
super().__init__(name,age)
self.teachofyear=teachofyear
stu=Student('张三',20,'10001')
teacher=Teacher('李四',34,10)
stu.info()
teacher.info()
输出结果：
（5）多继承例子：
class A(object):
pass
class B(object):
pass
class C(A,B):
pass
6、方法重写
如果子类对继承自父类的某个属性或方法不满意,可以在子类中对其(方法体)进行重新编写
子类重写后的方法中可以通过super().xxx()调用父类中被重写的方法
例子：
class Person(object): #Person类继承object类
def __init__(self,name,age):
self.name=name
self.age=age
def info(self):
print(self.name,self.age)
class Student(Person):
def __init__(self,name,age,stu_no):
super().__init__(name,age)
self.stu_no=stu_no
def info(self):
super().info()
print(self.stu_no)
class Teacher(Person):
def __init__(self,name,age,teachofyear):
super().__init__(name,age)
self.teachofyear=teachofyear
def info(self): #方法重写
super().info()
print('教龄',self.teachofyear)
stu=Student('张三',20,'10001')
teacher=Teacher('李四',34,10)
stu.info()
teacher.info()
print('------------方法重写---------')
teacher.info()
输出结果：
7、object类
.object类是所有类的父类，因此所有类都有object类的属性和方法。·内置函数dir()可以查看指定对象所有属性
.Object有一个_str_()方法，用于返回一个对于“对象的描述”",对应于内置函数str()经常用于print()方法，帮我们查看对象的信息，所以我们经常会对_str__()进行重写
例子：
class Student:
def __init__(self,name,age):
self.name=name
self.age=age
def __str__(self):
return '我的名字是{0}，今年{1}岁'.format(self.name,self.age)
stu=Student('张三',20)
print(dir(stu))
print(stu) #默认会调用__str__()这样的方法
print(type(stu))
8、多态
简单地说，多态就是"具有多种形态"，它指的是:即便不知道一个变量所引用的对象到底是什么类型，仍然可以通过这个变量调用方法，在运行过程中根据变量所引用对象的类型,动态决定调用哪个对象中的方法。
静态语言和动态语言关于多态的区别：
①静态语言实现（Java就是静态语言）多态的三个必要条件：
继承
方法重写
父类引用指向子类对象
②动态语言（python是动态语言）的多态崇尚“鸭子类型"当看到一只鸟走起来像鸭子、游泳起来像鸭子、收起来也像鸭子，那么这只鸟就可以被称为鸭子。在鸭子类型中，不需要关心对象是什么类型,到底是不是鸭子，只关心对象的行为。
例子：
class Animal(object):
def eat(self):
print('动物会吃')
class Dog(Animal):
def eat(self):
print('狗吃骨头')
class Cat(Animal):
def eat(self):
print('猫吃鱼...')
class Person:
def eat(self):
print('人吃五谷杂粮')
#定义一个函数
def fun(obj):
obj.eat()
#开始调用函数
fun(Cat())
fun(Dog())
fun(Animal())
print('-------------------')
#Person与Animal、Cat、Dog不存在继承关系,但是因为Person中也有eat方法，所以它也会取调用eat方法
fun(Person())
输出结果：
9、特殊的属性和方法
| 名称 | 描述 | |
| 特殊属性 | _dict_ | 获得类对象或实例对象所绑定的所有属性和方法的字典 |
| 特殊方法 | _len_() | _len_()方法，让内置函数len()的参数可以是自定义类型 |
| add_() | 通过重写_add_()方法，可使用自定义对象具有“+”功能 | |
| _new_() | 用于创建对象 | |
| _init_() | 对创建的对象进行初始化 |
特殊属性例子：
class A:
pass
class B:
pass
class C(A,B):
def __init__(self,name,age):
self.name=name
self.age=age
#创建C类对象
x=C('Jack',20) #x是C类型的一个实例对象
print(x.__dict__) #实例对象的属性字典
print(C.__dict__) #如果是一个类对象会看到他的属性和方法
print('-------------------')
print(x.__class__) #输出对象所属的类
print(C.__bases__) #C类的父亲类型的元素
print(C.__base__) #输出形参里最近的父亲类型元素
print(C.__mro__) #类的层次结构
print(A.__subclasses__()) #子类的列表
输出结果：
特殊方法的例子：
a=20
b=100
c=a+b #两个整数类型的对象相加操作
d=a.__add__(b) #结果完全相同
print(c)
print(d)
class Student:
def __init__(self,name):
self.name=name
def __add__(self, other):
return self.name + other.name
def __len__(self):
return len(self.name)
stu1=Student('张三')
stu2=Student('李四')
s=stu1+stu2 #实现了两个对象的加法操作（因为在Student类中编写了__add__()的方法，若是没有编写直接相加会报错）
print(s)
#或者另一种实现方法
s=stu1.__add__(stu2)
print('--------------------------')
lst=[11,22,33,44]
print(len(lst)) #len是内置函数len,用来计算长度
print(lst.__len__())
#print(len(stu1)) #直接使用会报错，要是一定要输出就要编写len（）的方法
输出结果：
特殊方法例子：
class Person(object):
def __init__(self,name,age):
self.name=name
self.age=age
def __new__(cls, *args, **kwargs):
print('__new__被调用执行了，cls的id值为{0}'.format(id(cls)))
obj=super().__new__(cls)
print('创建的对象的id为：{0}'.format(id(obj)))
return obj
def __init__(self,name,age):
print('__init__被调用了，self的id值为：{0}'.format(id(self)))
self.name=name
self.age=age
print('object这个类对象的id为：{0}'.format(id(object)))
print('Person这个类对象的id为：{0}'.format(id(Person)))
#创建Person类的实例对象
P1=Person('张三',20)
print('P1这个Person类的实例对象的id：{0}'.format(id(P1)))
输出结果：
运行的图示步骤说明：
10、类的浅拷贝与深拷贝
（1）变量的赋值操作
（1）变量的赋值操作
只是形成两个变量,实际上还是指向同一个对象
（2）浅拷贝
Python拷贝一般都是浅拷贝，拷贝时，对象包含的子对象内容不拷贝，因此,源对象与拷贝对象会引用同一个子对象
（3）深拷贝
使用copy模块的deepcopy函数，递归拷贝对象中包含的子对象，源对雾和拷贝对象所有的子对象也不相同
（4）变量赋值操作例子：
class CPU:
pass
class Disk:
pass
class Computer:
def __init__(self,cpu,disk):
self.cpu=cpu
self.disk=disk
#（1）变量的赋值
cpu1=CPU()
cpu2=CPU()
print(cpu1)
print(cpu2)
输出结果：
结果分析图：
浅拷贝的例子
lass CPU:
pass
class Disk:
pass
class Computer:
def __init__(self,cpu,disk):
self.cpu=cpu
self.disk=disk
#（1）变量的赋值
cpu1=CPU()
cpu2=CPU()
print(cpu1)
print(cpu2)
#（2）类的浅拷贝
print('----------------------')
disk=Disk() #创建一个计算机类的对象
computer=Computer(cpu1,disk) #创建一个计算机的对象
#浅拷贝
import copy
computer2=copy.copy(computer)
print(computer,computer.cpu,computer.disk)
print(computer2,computer2.cpu,computer2.disk)
分析图示：
深拷贝的例子：
class CPU:
pass
class Disk:
pass
class Computer:
def __init__(self,cpu,disk):
self.cpu=cpu
self.disk=disk
#（1）变量的赋值
cpu1=CPU()
cpu2=CPU()
print(cpu1)
print(cpu2)
#（2）类的浅拷贝
print('----------------------')
disk=Disk() #创建一个计算机类的对象
computer=Computer(cpu1,disk) #创建一个计算机的对象
#浅拷贝
import copy
computer2=copy.copy(computer)
print(computer,computer.cpu,computer.disk)
print(computer2,computer2.cpu,computer2.disk)
#深拷贝
computer3=copy.deepcopy(computer)
print(computer,computer.cpu,computer.disk)
print(computer3,computer3.cpu,computer3.disk)
图示：
模块
1、模块
模块英文为Modules
2、函数与模块的关系
一个模块中可以包含N多个函数
3、在Python中一个扩展名为.py的文件就是一个模块
4、使用模块的好处
方便其它程序和脚本的导入并使用
避免函数名和变量名冲突
提高代码的维扩一心
提高代码的可重用性
5、自定义模块
（1）创建模块
新建一个.py文件,名称尽量不要与Python自带的标准模块名称相同
（2）导入模块
import 模块名称 [as别名]
From 模块名称 import函数/变量/类
（3）模块导入（自己创建的模块）
也可以直接使用from导入，导入后可直接使用
（4）以主程序形式运行
在每个模块的定义中都包括一个记录模块名称的变量_name_，程序可以检查该变量,以确定他们在哪个模块中执行。如果一个模块不是被导入到其它程序中执行，那么它可能在解释器的顶级模块中执行。顶级模块的_name_变量的值为_main_
if_name_ = '__main_' :
pass
6、Python中的包
（1）包是一个分层次的目录结构，它将一组功能相近的模块组织在一个目录下
（2）作用:
（2）作用:
代码规范
避免模块名称冲突
（3）包与目录的区别
包含_init_.py文件的目录称为包
目录里通常不包含_init__.py文件
（4）包的导入
import包名.模块名
7、python中仓用的内容模块
| 模块名 | 描述 |
| sys | 与Python解释器及其环境操作相关的标准库 |
| time | 提供与时间相关的各种函数的标准库 |
| os | 提供了访问操作系统服务功能的标准库 |
| calendar | 提供与日期相关的各种函数的标准库 |
| urllib | 用于读取来自网上（服务器）的数据标准库j |
| json | 用于使用JSON序列化和反序列化对象 |
| re | 用于在字符串中执行正则表达式匹配和替换 |
| math | 提供标准算术运算函数的标准库 |
| decimal | 用于进行精确控制运算精度、有效数位和四舍五入操作的十进制运算 |
| logging | 提供了灵活的记录事件、错误、警告和调试信息等目志信息的功能 |
第三模块的安装及使用
在cmd下输入pip install +需要安装的模块，然后需要等待一会，如果程序不报错的话就代表安装成功
编码格式
常见的字符编码格式
Python的解释器使用的是Unicode (内存)
py文件在磁盘上使用UTF-8存储（外存)
文件的读写
文件的读写原理
文件的读写操作
常用的文件打开模式
1、文件的类型
按文件中数据的组织形式,文件分为以下两大类
（1）文本文件:存储的是普通“字符"文本，默认为unicode字符集，可以使用记本事程序打开
（2）二进制文件:把数据内容用“字节"进行存储，无法用记事本打开，必须使用专用的软件打开，举例: mp3音频文件,jpg图片.doc文档等
| 打开模式 | 描述 |
| r | 以只读模式打开文件，文件的指针将会放在文件的开头 |
| w | 以只写模式打开文件，如果文件不存在则创建，如果文件存在，则覆盖原有内容，文件指针在文件的 |
| a | 以追加模式打开文件，如果文件不存在则创建，文件指针在文件开头，如果文件存在，则在文件末尾追加内容，文件指针在原文件末尾 |
| b | 以二进制方式打开文件，不能单独使用，需要与共它模式一起使用，rb，或者wb |
| + | 以读写方式打开文件，不能单独使用，需要与其它模式一起使用，a+ |
文件对象的常用方法
| 方法名 | 说明 |
| read([size]) | 从文件中读取size个字节或字符的内容返回。若省略[size]，则读取到文件末尾，即一次读取文件所有内容 |
| readline() | 从文本文件中读取一行内容 |
| readlines() | 把文本文件中每一行都作为独立的字符串对象，并将这些对象放入列表返回 |
| write(str) | 将字符串str内容写入文件 |
| writelines(s_list) | 将字符串列表s_list写入文本文件，不添加换行符 |
| seek(offset[, whence]) | 把文件指针移动到新的位置，offset表示相对于whence的位置:offset:为正往结束方向移动，为负往开始方向移动 whence不同的值代表不同含义: 0:从文件头开始计算（默认值) 1:从当前位置开始计算 2:从文件尾开始计算 |
| tell() | 返回文件指针的当前位置 |
| flush() | 把缓冲区的内容写入文件，但不关闭文件 |
| close() | 把缓冲区的内容写入文件，同时关闭文件，释放文件对象相关 |
with语句
1、with语句(上下文管理器)
with语句可以自动管理上下文资源，不论什么原因跳出with块,都能确保文件正确的关闭，以此来达到释放资源的目的
例子：
第三张图实现了enter和exit的方法，所以就称为上下文管理器
操作目录
os模块是Python内置的与操作系统功能和文件系统相关的模块,该模块中的语句的执行结果通常与操作系统有关，在不同的操作系统上运行，得到的结果可能不一样。
os模块与os.path模块用于对目录或文件进行操作
os模块操作目录相关函数
| 函数 | 说明 |
| getcwd () | 返回当前的工作目录 |
| listdir(path) | 返回指定路径下的文件和目录信息 |
| mkdir(path[, mode]) | 创建目录 |
| makedirs(path1/path2.. . [, mode]) | 创建多级目录 |
| removedirs(path1/path2.. . . . .) | 删除多级目录 |
| rmdir(path) | 删除目录 |
| chdir(path) | 将path设置为当前工作目录 |
os.path模块操作目录相关函数
| 函数 | 说明 |
| abspath(path) | 用于获取文件或目录的绝对路径 |
| exists(path) | 用于判断文件或目录是否存在，如果存在返回True, 否则返回False |
| join(path, name) | 将目录与目录或者文件名拼接起来 |
| splitext() | 分离文件名和扩展名 |
| basename(path) | 从一个目录中提取文件名 |
| dirname(path) | 从一个路径中提取文件路径，不包括文件名 |
| isdir(path) | 用于判断是否为路径 |
