python 0基础学习笔记5：装饰器、偏函数、变量作用域、异常处理、文件读写

装饰器：

是一个闭包，把一个函数当做参数返回一个替代版的函数，本质上就是一个返回函数的函数。

例1：一个简单的装饰器：

def func1():
    print("yangjia")

def outer(func):
    print("**")
    func()
func1=outer(func1)

结果为：

**
yangjia

同理：

def outer(func):#outer是这个装饰器，返回的是inner这个函数
    def inner():
        print("**")
        func()
    inner()
f = outer(func1)#f相当于是func1的加强版本，相当于就是inner。

结果为：
**
yangjia

例2：复杂一点的装饰器：

def say(age):
    print("tom is %d years old"%(age))

def outer(func):
    def inner(age):
        if age<0:
            age=0
        func(age)
    return inner
say = outer(say)
say(-10)

结果为：
tom is 0 years old

修改：

def outer(func):
    def inner(age):
        if age < 0:
            age = 0
        func(age)
    return inner
# say = outer(say)
@outer    #相当于say = outer(say)，使用@符号将装饰器应用到函数
def say(age):
    print("tom is %d years old"%(age))

say(-10)

例3：通用装饰器：

def outer(func):
    def inner(*args,**kwargs):
        #添加修改的功能
        print("@@")
        func(*args,**kwargs)
    return inner
# say = outer(say)
@outer
def say(age):
    print("tom is %d years old"%(age))

say(-10)

结果为：
@@
tom is -10 years old

偏函数：

int(“1010”,base = 2)#将1010当成二进制，输出一个转换成十进制的数。

def int2(str,base=2):
    return int(str,base)
print (int2("1010"))

结果同样也为：10

上述是我们自己定义的偏函数，实际上不需要自己定义，有一个模块可以帮助我们生成一个偏函数。

import functools
int3 = functools.partial(int,base=2)
#把一个参数固定住，形成一个新的函数。
print(int3("111"))

结果为：7

变量的作用域：

作用域：变量可以使用的范围。
程序的变量并不是在所有的位置都能使用的，访问的权限决定于变量在哪里赋值得。

局部作用域：
全局作用域：
内建作用域：

异常处理：

需求：当程序遇到问题时不让程序结束，而越过错误继续向下执行。

1、错误处理语句：try…except…else

格式1：每种错误分别处理

try:
    语句t
except 错误码 as e:
    语句1
except 错误码 as e:
    语句2
......
except 错误码 as e:
    语句n
else:
    语句e

注意：else语句可有可无。

作用：用来检测try语句块中的错误，从而让except语句捕获错误信息并处理。

逻辑：当程序遇到try…except…else语句事，1、如果try语句执行出现错误，就会匹配第一个错误码，如果匹配上就执行对应的语句。2、如果当try语句执行出现错误，没有匹配的异常，错误就会被提交到上一层的try语句，或者到程序的最上层。3、如果当try语句执行没有出现错误，执行else下的语句（前提是有else语句）。

try:
    print(3 / 0)
except ZeroDivisionError as e:
    print("分母为0")
print("@@@")

结果为：
分母为0
@@@

try:
    print(3 / 1)
except ZeroDivisionError as e:
    print("分母为0")
else:
    print('代码没问题')

print("@@@")

结果为：
3.0
代码没问题
@@@

格式2：所有错误全部处理

错误类型太多了，我们记不住，所以我们使用except而不使用任何错误类型，即：

try:
    print(3 / 0)
except:
    print("程序异常")

结果为：
程序异常
@@@

格式3：多个错误统一处理

使用except带多种异常：

try:
    print(3 / 0)
except (ZeroDivisionError,NameError):
    print("程序出现ZeroDivisionError或NameError")

else:
    print('代码没问题')

print("@@@")

结构为：
程序出现ZeroDivisionError或NameError
@@@

注意：
1、错误其实是class（类），所有的错误都继承自BaseException，所以在捕获的时候，她捕获了该类型的错误，还把子类一网打尽。
2、跨越多层调用。

def func1(num):
    print(1/num)
def func2(num):
    func1(num)
def main():
    func2(0)
try:
    main()
except ZeroDivisionError as e:

    print("程序出现ZeroDivisionError")

else:
    print('代码没问题')

结果为：
程序出现ZeroDivisionError

2、错误处理语句：try…except…finally

作用：语句t无论是否有错都执行最后的语句f’。在文件读写时，有时会读取错误，这时候我们加上finally关闭文件，就可以保证文件总会被关闭了。

try:
    语句t
except 错误码 as e:
    语句1
except 错误码 as e:
    语句2
......
except 错误码 as e:
    语句n
finaly:
    语句f

3、断言

def func(num,div):
    assert (div!=0),'div不能为0'
    return num/div
print(func(10,0))

结果为：
AssertionError: div不能为0

读文件：

过程：打开文件–读文件内容–关闭文件。

1、打开文件：

open(path,flag[,encoding="utf_8"][,errors="ignore"])

#path:套打开文件的路径=,a,a
#flag:打开方式：
# r,以只读方式打开文件，文件的描述符放在文件的开头。
# rb,以二进制格式打开一个文件，而且用于只读，文件的描述符放在文件的开头
# r+,打开一个文件作用于读写，文件的描述符放在文件的开头。
# w,打开一个文件作用于写入，如果该文件已经存在，会覆盖；不存在则创建一个新文件。
# wb,打开一个文件作用于写入二进制，其他同上。
# w+,打开一个文件作用于读写，其他同上。
# a,打开一个文件用于追加，如果该文件已经存在，文件描述符会放在文件末尾。
# a+，打开一个文件用于追加，文件描述符会放在文件末尾，因为在末尾，所以读不了个啥。
#encoding:编码方式。
#errors:错误处理。

2、读文件：

1、读取文件全部内容
str1 = f.read()#读取内容放在内存里，大文件不适合这么用。
2、读取指定字符数
str2 = f.read(10)
str2 = f.readline(10)
3、读取整行，包括“\n”字符
str3 = f.readline()
4、读取所有行并返回列表
list4 = f.readlines()
5、若给定的数字大于0，返回实际size字节的行数，包括“\n”字符
list5 = f.readlines(size)

修改描述符的位置：f.seek(0)

3、关闭文件：

f.close（）

一个完整的过程：

try:
    f1=open(path,'r',encoding='utf-8')
    print(f1.raed)
finally:
    if f1:#判断有没有f1，如果有，说明打开成功，此时需要关闭，如果没，说明根本                   没有打开，也就不需要关闭文件这一步了。
        f1.close()

或者：

with open(path,'r',encoding='utf-8') as f2:
    print(f2.read())
#此时不需要自己关闭文件，不论读取成不成功，with的作用就是都会帮我们关闭文件

写文件：

过程：打开文件–写文件内容–关闭文件。

1、打开文件：

open(path,flag[,encoding="utf_8"][,errors="ignore"])

2、写文件：

1、将信息写入缓冲器
f.write('abcd')
2、刷新缓冲区，直接把内部缓冲区的数据写入文件，而不是被动等待关闭、自动数信缓冲区写入。f.flush()
注意：如何刷新缓冲区，四种方式：缓冲区满了、关闭文件、遇到\n、f.flush()。

编码与解码：编解码的方式必须一致，否则报错。

list-tuple-dice-set的文件操作：

import pickle#数据持久性模块


mylist = [1,2,3,4,5,'abcd']

path = r'F:\2.txt'
f = open(path,'wb')
pickle.dump(mylist,f)#将信息写入缓冲器
f.close()
#读取
f1=open(path,'rb')
templist = pickle.load(f1)
print(templist)
f1.close()