装饰器&偏函数与作用域与异常处理与文件读写

 

1. 装饰器

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

   • 简单的装饰器

     • def func1():
       
        print("sunck is a good man")
       
       def outer(func):
       
        def inner():
       
        print("*** ** * * ***")
       
        func()
       
        return inner
       
       #f是函数func1的加强版本
       
       f = outer(func1)
       
       f()

   • 复杂一点的装饰器

     • def say(name):
       
        print("%s is a good name" % (name))
       
       def outer(func):
       
        def inner(age):
       
        if age<0:
       
        age = 0
       
        func(age)
       
        return inner
       
       使用@符号将装饰器应用到函数
       
       @outer #相当于say = outer(say)
       
       say(-10)

   • 通用装饰器

     • def outer(func):
       
        def inner(*args, **kwargs):
       
        #添加修改的功能
       
        print("&&&&&&&&&&&")
       
        func(*argc,**kwargs)
       
        return inner
       
       @outer
       
       def say(name,age): #函数的参数理论上是无限制的，但实际上最好不要超过6、7个
       
        print("my name is %s,I am %d years old" % (name,age))
       
       say("xiaoxin",18)

2. 偏函数

   • import functools 
     
     #把一个参数固定住，形成一个新的函数
     
     int3 = functools.partial(int,base = 2)
     
     int3("111") 把111当成2进制转成十进制 值为7

3. 变量的作用域

   • 作用域：变量可以使用的范围

   • 程序的变量并不是再所有位置都能使用的，访问的权限决定于变量的在哪里赋值的

   • 作用域：

     • 局部作用域

       • 局部变量是指在函数内部定义并使用的变量，它只在函数内部有效。
         
       • 每个函数在执行时，系统都会为该函数分配一块“临时内存空间”，所有的局部变量都被保存在这块临时内存空间内。当函数执行完成后，这块内存空间就被释放了，这些局部变量也就失效了，因此离开函数之后就不能再访问局部变量了，否则解释器会抛出 NameError 错误。

     • 函数作用域

     • 全局作用域

       • 和局部变量相对应，全局变量指的是能作用于函数内外的变量，即全局变量既可以在各个函数的外部使用，也可以在各函数内部使用。

       • 在变量前面加个 global 就变成全局变量了

     • 内建作用域

4. 异常处理

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

   • 错误处理的格式

     •  

       try......except.......else
       
       格式：
       
       try:
       
        语句t
       
       except 错误表示码 as e:
       
        语句1
       
       except 错误表示码 as e:
       
        语句2
       
       ........
       
       except 错误表示码 as e:
       
        语句n
       
       else:
       
        语句e
       
       注意: else语句 可有可无

        

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

     • 逻辑： 当程序执行到try- except - else 语句时

       • 当try语句 "语句t" 执行出现错误，会匹配第一个错误码，如果匹配上就执行对应的"语句"

       • 当try语句 "语句t" 执行出现错误，没有匹配的异常，错误将会被提交到上一层的try语句。或者到程序的最上层

       • 当try语句 "语句t" 执行没有出现错误，执行else下的"语句e" (你得有)

     • 使用except 而不使用任何的错误类型

       • try:
         
          print(num)
         
         except:
         
          print("程序出现了异常")

     • 使用except带着多种异常

       • try:
         
          print(5/0)
         
         except (NameError,ZeroDivisionError):
         
          print("出现了NameError或ZeroDIvisionError")

     • 特殊的地方

       • 错误其实是class(类)，所有的错误都继承自BaseException，所以再捕获的时候，它捕获了该类型的错误，还把子类一网打尽

       • 跨越多层调用，main调用了func2,func2调用了func1，func1出现了错误，这是只要main捕获到了就可以处理

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

   • try......except.......finally

     • 格式：

       • try:
         
          语句t
         
         except 错误表示码 as e:
         
          语句1
         
         except 错误表示码 as e:
         
          语句2
         
         ........
         
         except 错误表示码 as e:
         
          语句n
         
         finally:
         
          语句f

     • 作用：语句t无论是否有错误都将执行最后的语句f

   • 断言

     • def func(num,div):
       
        assert(div != 0) , "div 不能为0"
       
        return num / div
       
       print(func(10,0)) 会指出哪里出错了

5. 文件读写

   • 读文件

     • 打开文件

       • f=open(path,flag，encoding，errors)

         • path:要打开文件的路径

         • flag：打开方式

           • r 以只读的方式打开文件，文件的描述符放在文件的开头

           • rb 以二进制格式打开一个文件用于只读，文件的描述符放在文件的开头

           • r+ 打开一个文件用于读写，文件的描述符放在文件的开头

           • w 打开一个文件只用于写入，如果该文件已经存在会覆盖，如果不存在则创建新文件

           • wb 打开一个文件只用于写入二进制，如果该文件已经存在会覆盖，如果不存在则创建新文件

           • w+ 打开一个文件用于读写

           • a 打开一个文件用于追加，如果文件存在，文件描述符将会放到文件末尾

           • a+ 打开一个文件用于追加

         • encoding：编码方式 (可写可不写)

         • errors: 错误处理 (可写可不写

       • 读文件内容

         • 读取文件全部内容

           • str1 = f.read() #读取全部内容

         • 读取指定字符串

           • str2 = f.read(10) #读取10个字符

         • 读取整行，包括 "\n"字符

           • str3 = f.readline()

         • 读取指定字符串

           • str4 = f.readline(10)

         • 读取所有行并返回一个列表

           • list7 = f.readlines()

         • 若给定的数字大于0，返回实际size字节的行数

           • list8 = f.readlines(10)

         • 修改描述符的位置

           • f.seek(0)

       • 关闭文件

         • f.close()

     • 一个读文件完整的过程

       • try:
         
         f1 = open(path,"r",encoding ="utf-8")
         
         print(f1.read())
         
         finally: 
         
          if f1:
         
          f1.close()
         
         1
         
         with open(path,"r",encoding = "utf-8") as f2:
         
          print(f2.read()) 无论你读写成功还是失败，with会自动关闭文件

   • 写文件

     • 第一步打开文件

       • f = open(path,"w")

     • 第二步写文件

       • f.write("sunck is a good man") #1.将信息写入缓冲区

       • f.flush() 2.刷新缓冲区，直接把内部缓冲区的数据立刻写入文件，而不是被动的等待自动刷牙缓冲区写入

     • 第三步关闭文件

       • f.close()

   • 以二进制写文件，必须编码才能写进去，以二进制读文件，必须解码才能读出来

   • list&tuple&dict&set文件操作

     • 需要一个模块

       • import pickle #数据持久性模块

     • 举例

       • myList = [1,2,3,4,5,"sunck is a good man"]
         
         f = open(path,"wb")
         
         pickle.dump(myList,f)
         
         f.close()
         
         #读取
         
         f1 = open(path,"rb")
         
         tempList = pickle.load(f1)
         
         print(tempList)
         
         f1.close()