• 文件操作
• 文件操作：OS模块
• 异常处理
• 流程控制语句if else
• 类、方法、继承
• 构造函数、析构函数
• 描述符
• 迭代器、生成器

文件操作

open()函数

#读取文件
f = open("文件地址","w")#以写入状态打开文件
f.close()#关闭文件
f.read(5)#从文件读取n个字符，不个参数n则读取全部文件
f.readline()#按行读取
f.seek(0,0)#重置文件指针位置，参数：第一参数--指针移动的字节数。第二参数--指针开始移动的位置，0---表示从头开始，1----表示从当前位置算起，2----表示从文件末尾算起
f.write("str")#向文件写入字符串
f.writelines(list)#向文件写入一个可迭代得字符串序列
f.tell()#返回文件指针位置
#循环操作文件的每一行
for each_line in f:
	#dosomething
	print(each_line)

文件操作：OS模块

os模块

#引入模块
import os
#返回当前模块
os.getcwd()
#改变工作目录
os.chdir("d://test")
#列举指定目录中的文件名 
os.listdir(path='.')
#创建单层/多层目录
os.mkdir(path)#目录存在抛出异常
os.mkdirs(path)#目录存在抛出异常
#删除文件/目录
os.remove(path)
os.rmdir(path)#目录非空抛出异常
os.removedirs(path)#递归删除目录
#修改名字
os.rename(old,new)

os path模块

#去掉目录路径，返回文件名
os.path.basename(path)
#去掉文件名，返回路径
os.path.dirname(path)
#组合路径
os.path.join(path1,path2····)
#分割文件路径
os.path.split(path)
#分割文件名与扩展名
os.path.splitext(file)
#获取文件大小,单位字节
os.path.getsize(file)
#返回文件最新修改时间
os.path.getmtime(file)
#判断路径目录或问价是否存在
os.path.exists(path)
#判断路径是否存在目录
os.path.isdir(path)
#判断路径是否存在文件
os.path.isfile(path)
#判断路径是否为绝对路径
os.path.isabs(path)
#判断两个路径是否指向同一个文件
os.path.samefile(path1,path2)

数据持久化
pickle模块

import pickle
pickle_file=open(path,"wb")
#数据持久化，保存的数据为2进制
pickle.dump(param,pickle_file)#param想要保存的数据、pickle_file保存路径
#数据读取
pickle_load=open(path,"rb")#rb 2进制读取
fileContent=pickle.load(pickle_load)

异常处理

try:
	#do something
except Exception [as param]:
	#param中包含错误原因
	#do something
except (OSError , TypeError):
	#抓捕多个异常
except:
	#抓取所有错误
finally:
	#必执行代码

手动抛出异常

#使用raise关键字
raise Exception

流程控制语句if else

#if else ： 条件不满足时执行else
if 条件:
	#do something
else:
	#do something
#while else 当while无错执行、无break、无continue时执行else代码块
while 条件:
	#do something
else:
	#do something
#for else 当for无错执行、无break、无continue时执行else代码块
for 条件:
	#do something
else:
	#do something
#try else 当try 无错执行、无break、无continue时执行else代码块
try:
	#do something
except Exception:
	#do something
else:
	#do something

类、方法、继承

同java，封装、继承、多态 继承: 1.单继承 class Child(Parent): 多继承 class Child(Parent1 , Parent2 ····): 无法确定时尽量减少使用多继承 2.调用父类方法---ParentClassName.parentFunction()

#定义类 继承类Person
class MyPersion(Person):
	#定义属性
	name="name"
	gender="women"
	#构造函数
	def __init__(self,name,gender):
		#调用父级函数 
		#写法一
		Person.__init__(self)
		#写法二
		super().__init__()
		
		self.name = name
		self.gender = gender
	#定义类函数 self同java中的this,与java不同的是，定义类函数必须有
	def eat(self,food):
		#do something
		print("吃"+food)

#创建对象 当有init函数时，必须传值
param = MyPersion("name","women")

#类变量作用域
class Persion:
	#私有变量 伪私有，可通过_ClassName.__param 访问
	__gender = "man"
	#get函数
	def getGender(self):
		return self.__gender

#issubclass 检查是否子类
issubclass(child , parent) #返回true

#isinstance 检查对象是否属于类
isinstance(obj , className) #返回布尔值

#hasattr 检查对象是否是指定对象
hasattr(obj , paramName)

#getattr 从对象中获取指定对象
getattr(obj , paramName)
getattr(obj , paramName , default) #判断obj中是否含有paramName属性，没有返回default

#delattr 从对象中删除指定对象
delattr(obj , paramName)

#property 整合对象的get、set、del方法
class MyClass:
	def __init__(self):
		self.param="a"
	def getParam(self):
		return self.param
	def setParam(self,param):
		self.param=param
	def delParam(self):
		del self.param
	param = property(getParam, setParam , delParam)
#对象通过param对属性param来进行get、set、del操作
obj=MyClass()
obj.param #会自动调用getParam函数
obj.param=10 #会自动调用setParam函数
del obj.param #自动调用delParam函数
#优点：当修改类中的get、set、del函数时不会影响调用的函数

构造函数、析构函数

class MyClass:
	#对象创建前调用
	def __new__(clas)：
		pass
	#构造函数
	def __init__(self,param):
		self.param=param
	#析构函数
	def __del__(self):
		#当对象被删除时调用，不声明使用python默认。用于回收内存
		pass
	#相当于java的toString方法重写
	def __str__(self):
		return self.param
	#当用户访问不存在的属性时执行该方法
	def __getattr__(self,name):
		pass
	#当用户访问属性时执行
	def __getattribute__(self,name):
		pass
	#当用户属性被设置时调用
	def __setattr__(self,name):
		pass
	#当用户删除属性时调用
	def __delattr__(self,name):
		
		
#析构函数当当前对象的全部引用被删除时才会调用
obj = MyClass()
obj2=obj
obj3=obj2
del obj3
del obj
#当删除obj2的时候，才会执行析构函数__del__
del obj2

描述符

描述符类必须重写__get__、__set__、__delete__中的一个或者多个。 描述符类的作用实质上与property方法相同。所不同的是，描述符类中的方法是自己设定的。感觉描述符类像是java拼装类中的基础类。通过重写的get、set、delete方法实现相应的功能。

#描述符类
class MyProperty:
	def __init__(self, fget=None,fset=None,fdel=None):
		self.fget=fget
		self.fset=fset
		self.fdel=fdel
		
	#instance相当于实例
	def __get__(self , instance,owner):
		return self.fget(instance)
		
	def __set__(self,instance ,value):
		self.fset(instance,value)
		
	def __del__(self,instance,instance):
		self.fdel(instance)

#使用描述服类
class MyClass:
	def __init__(self):
		self.param="param"
	def getX(self):
		return self.param
	def setX(self ,vlaue):
		self.param=value
	def delX(self):
		del self.param
	
	#使用描述符类，此时描述符类使用默认的函数与property()函数用法相同
	paramMethod = MyProperty(getX,setX,delX)

#描述符的简便用用
class MyClass:
	def __init__(self,num = 0):
		self.num  = num
	
	#加上该注解后相当于get函数
	@property
	def num(self):
		return self.num
	
	#相当于set函数
	@num.setter
	def num(self,num):
		if(num < 0 ):
			self.num=0
		else:
			self.num=0
			
	#相当于delete函数
	@num.deleter
	def num(self):
		del self.num

迭代器、生成器（协程）

迭代器
iter()、next()

string="python"
t=iter(string)
next(t) #依次输出每个字符
#当没有数据可迭代时，抛出异常

生成器
协程就是生成器，但是协程不是官方用语，只是便于讨论。
yield关键字。如下demo，第一次调用函数返回1，第二次调用时，返回2。遇见yield程序挂起，再次调用继续执行。
yield关键字修饰的函数，可以变相看成一个迭代器，可以通过next()函数调用。

def myMth():
	print("demo")
	yield 1
	yield 2