数据类型

1. 数据类型
   • 数值类型
     • int float complex bool
   • 容器
     • 不可变的容器
       • str tuple forzenset bytes(字符串)
     • 可变的容器
       • list dict set bytearray(字节数组)
2. 值
   • None False True
3. 运算符
   • 算数运算符
     • + - * / // % **
   • 比较运算符
     • < <= > >= == !=
     • in, not in
   • 布尔运算
     • not, and, or, +(正好), -(负号)
     • & | ^
     • [] (索引，切片，键索引)
4. 表达式

       1
       1+2
       max(1, 2, 3) # 函数调用表达式
       x if x > y else y, 条件表达式
   

   • 三种推导式
     • 列表， 字典， 集合推导式（三种）
5. 语句
   • 表达式语句:
     • 所有的表达式语句都可以单独写在一行，形成一个语句
     • 例：

           print("hello world")
           1 + 2
       

   • 赋值语句：

         a = 100
         a = b = c = 100
         x, y = 100
         a[0] = 100
         dict['name'] = 'pengyuan'
     

   • del语句
   • if 语句
   • while 语句
   • for 语句
   • break 语句
   • continue 语句
   • pass 语句
6. 函数
   • 内建函数
     • len(x), max(x), min(x), sum(x), any(x), all(x)
   • 构造函数(用来创建同类型的数据对象)
     • bool(x), int(x), float(x), complex(x)
     • list(x), tuple(x), str(x), dict(x), set(x), forzenset(x)
     • abs(x)
     • round(x)
     • pow(x, y, z=None)
     • bin(x), oct(x), hex(x)
     • chr(x), ord(x)
     • range(start, stop, step)
     • input(x), print(x)
     • help(__builtins__)

函数function

• 函数是可以重复执行的语句块，可以重复使用
• 作用
  • 用于封装语句块，可以重复调用
  • 定义用户级别的函数
• 语法

      def 函数名(形参列表):
          语句块
  

• 说明
  1. 函数的名字就是语句块的名称
  2. 函数名的命名规则和写变量名相同（函数名必须是标识符）
  3. 函数名是一个变量（不要轻易对其赋值）
  4. 函数有自己的名字空间，在函数外部不可以访问函数内部的变量，在函数可以访问函数外部的变量，但不能修改此变量
  5. 函数如果不需要传入参数，形参列表可以为空
  6. 语句部分不能为空，如果为空需要填充pass
• 函数调用
  • 函数名(实际调用传递参数)
  • 注：实际调用传递参数，简称传参
  • 说明：
    1. 函数调用时一个表达式
    2. 如果函数内部没有return语句，函数调用完毕后返回None对象
    3. 如果函数需要返回其他的对象需要用到return 语句
• return 语句
  • 语法： return [表达式]
  • 注：[] 代表可省略
  • 作用： 用于函数中，结束当前函数的执行，返回到调用该函数的地方，同时尽管返回一个对象的引用关系
  • return 语句说明
    1. return 语句后跟的表达式可以省略，省略后相当于return None
    2. 如果函数内没有return语句，则函数执行完最后一条语句后返回None（相当于在最后加了一条return None 语句）

D009

函数的参数传递

• 传递方式：

  - 位置传参
      - 序列传参
  - 关键词传参
      - 字典关键字传参 
  

• 位置传参
  • 实际参数（实参）的对应关系已形式参数的对应关系是按照位置来一次对应的
  • 说明
    • 实参和形参通过位置进行传递和匹配
    • 实际参数的个数必须与形式参数的个数相同
• 序列传参
  • 序列传参是指在函数调用过程中，用*将序列拆解后按位置进行传递的参数方式
  • 说明
    • 序列传参时，序列拆解的位置将与形参一一对应
    • 序列的位置代表参数相应的位置

      def myfun1(a, b, c):
          print('a的值是', a)
          print('b的值是', b)
          print('c的值是', c)
          
      s1 = [11, 22, 33]
      myfun1(*s1) # 相当于myfun1(11, 22, 33)
      
      t1 = (44, 55, 66)
      myfun1(*t1)
      myfun1(*'ABC')
  

• 关键字传参
  • 关键字传参是值传参时，按着形参的名称给形参赋值，实参和形参按形参名进行匹配

      def myfun1(a, b, c):
          print('a的值是', a)
          print('b的值是', b)
          print('c的值是', c)
          
      myfun1(b=22, c=33, a=11)
  

• 字典关键字传参
  • 是指实参为字典，将字典用'**'拆解后再进行关键字传参的传参方式
  • 说明：
    • 字典的键名和形参名必须一致
    • 字典的键名必须为字符串（标识符）
    • 字典的键名要在形参中存在

      def myfun1(a, b, c):
          print('a的值是', a)
          print('b的值是', b)
          print('c的值是', c)
      d = {'a': 100, 'b': 200, 'c': 300}
      myfun1(**d) # 等同于 myfun1(a=100, b=200, c=300)
      
      d2 = {'a': 100, 'b': 200, 'c': 300, 'd': '400'}
      myfun1(**d) # 报错， 意外的参数
      
  

• 函数的综合传参
  • 函数的传参方式在能确定形参能唯一匹配相应实参的情况下可以任意组合
  • 说明
    • 位置传参（序列传参）要在关键字传参（字典关键字传参）的左侧
  • 示例：

        def mufun1(a, b, c):
             print('a的值是', a)
             print('b的值是', b)
             print('c的值是', c)
        
        # 调用时
        myfun1(100, *[200, 300])
        myfun1(*(100, 200), 300)
        mufun1(*[100], 200, *(300,))
        myfun1(100, c=300, b=200) # 正确
        myfun1(c=300, b=200, 100) # 错误
        myfun1(100, **{'c': 300, 'b': 200})
    

函数形参的定义

• 函数的缺省参数

  • 语法

        def 函数名(形参= 默认实参1, 形参2 = 默认实参2, ...):
            语句块
    

  • 说明：
    • 缺省参数必须自右至左依次存在，如果一个参数有缺省参数，则其右侧的所有参数都必须有缺省参数
    • 如：

          def fe(a, b=10, c): # 错误
              pass
      

• 函数形参的定义方式

  1. 位置形参

         def 函数名(形参名1, 形参名2, ...):
             语句块
     

  2. 星号元组形参

         def 函数名(*元组形参名):
             语句块
     

     • 作用：收集多余的位置传参
  3. 命名关键字形参

         def 函数名(*, 命名关键字形参):
             语句块
         # 或
         def 函数名(*args, 命名关键字形参)：
             语句块
     

     • 作用：
       • 强制所胡的参数都必须用关键字传参或字典关键字传参
  4. 双星号字典形参

         def 函数名(**字典参数名):
             语句块
     

     作用：收集多余的关键字传参 说明：字典形参名通常**kwargs

• 函数参数的说明：

  • 位置形参，缺省参数，星号元组形参，双星号字典形参可以混合使用
  • 函数形参自左至右的顺序为:
    • 位置形参
    • 星号元组形参
    • 命名关键字形参
    • 双星号字典形参

      def fx(a, b, *args, c, **kwargs):
          pass
      
      fx(100, 200, 300, 400, c="c", d="D", e="E")
  

• 函数的不定长参数：

  • 星号元组形参， 双星号字典形参
  • 说明：
    • 可以接收任意的位置传参和关键字传参
  • 示例：

        def fn(*args, **kwargs):
            pass
    

• 全局变量和局部变量

  • 局部变量
    1. 定义在函数内部的变量称为局部变量（函数的形参也是局部变量）
    2. 局部变量只能在函数内部使用
    3. 局部变量在函数调用时才能够被创建，在函数调用之后会自动销毁
  • 局部变量
    1. 定义在函数外部，模块内部的变量称为全局变量
    2. 全局变量所有的函数都可以直接访问（但函数内不能将其直接赋值）

0713,0716 打不开

• 7-17pm 开始

D011回顾

• 高阶函数
  • map filter sorted
• 递归 recursion

      import sys
      sys.getrecursionlimit()
      
      sys.setrecursionlimt(2000)
  

• 闭包 closure

D012

• 装饰器 decorators(专业提高篇)

  • 装饰器是一个函数，主要作用是用来包装另一个函数或类
  • 装饰的目的是在不改变原函数名（或类名）的情况下，改变被包装对象的行为

• 函数装饰器

  • 函数装饰器指装饰器传入的是一个函数，返回的也是一个函数
  • 语法：

        def 装饰器函数名(参数)：
            语句块
            return 函数对象
            
        @装饰器函数名<换行>
        def 函数名(形参列表):
            语句块
    

  • 示例:

        # 此示例示意函数装饰器的定义用调用
        def mudeco(fn):
            def fx():
                print('====== myfunc调用之前 ======')
                fn()
                print('------ myfunc调用之后 ------')
            return fx
        
        
        @mydeco
        def myfunc():
            print("mufunc被调用")
        
        # myfunc = mudeco(myfunc) # 原理就是改变原变量绑定的函数
        
        
        myfunc()
        myfunc()
        myfunc()
    

• 函数的文档字符串

  • 函数内第一次未被赋值字符串是此函数的文档字符串
  • 语法：

        def 函数名(参数列表):
            '函数文档字符串'
            函数语句块
    

  • 示例：

       def myfun(name, x):
            ''' 这是函数的文档字符串
            name 表示人名
            x 表示钱数
            '''
            pass
            
        >>> help(myfun)
    

  • 说明：
    1. 文档字符串通常用来说明本函数的功能和使用方法
    2. 在交互模式下输入： help(函数名) 可以查看函数的'文档字符串'
    3. 函数的文档字符串绑定在函数的__doc__属性上

• 函数的 __doc__属性

  • 用于绑定函数的文档字符串

• 函数定义语句（def语句）的完整语法：

      [@装饰器1]
      [@装饰器2]
      [...]
      def 函数名([位置形参], [*元组形参], [命名关键字形参], [**字典形参]):
          ''' 文档字符串 '''
          语句块
  

  • 注： []代表其内部内容可省略

模块 Module

• 模块是一个包含有一系列数据/函数/类组成的程序组
• 模块是一个文件，模块文件名通常以.py结尾
• 作用：
  • 让一些相关的数据，函数，类有逻辑的组织在一起，使逻辑结构更加清晰
  • 模块中的数据，函数，类等可提供给其他模块或程序使用
• 模块的分类：
  • 内建模块（builtins)在解析器的内可以直接使用
  • 标准库模块，安装python时已安装且可以直接使用
  • 第三方模块（通常开源）需要自己安装
  • 用户自己编写的模块（可作为其他人的第三方模块）
• 模块的导入语句
  • import 语句
  • 语法：

        import 模块名1 [as 模块新名1], 模块名2 [as 模块新名2], ...
    

  • 示例：

        import math # 导入math模块
        import sys, os
    

  • 作用：
    • 将某模块整体导入到当前模块中
  • 用法：
    • 模块名.属性名 或 模块名。函数属性名(实参传参)
    • 如: ``` math.factorial(5)
    • dir(obj) 函数返回所有属性的字符串列表
    • help(obj) 函数可以查看模块的相关文档字符串
• from import
  • 语法：

    from 模块名 import 模块属性名1 [as 属性新名1], 模块属性名2 [as 属性新名2]
    

  • 作用：
    • 将某模块的一个或多个属性导入到当前模块的作用域
  • 示例：

        from math import factorial as fac
        from math import sin
        from math import pi
        print(fac(5)) # 120
    

• from import * 语句
  • 语法：

        from 模块名 import *
    

  • 作用：将某模块的所有属性导入到当前模块
  • 示例：

        from math import *
        print(sin(pi/2))
        print(factorial(5))
    

• dir 函数
  • dir([对象]) # 返回一个字符串的列表
  • 说明：
    • 如果没有给参数调用，则返回当前作用域内的所有变量的列表
    • 如果给定一个对象作为参数，则返回这个对象的所有变量的列表
      1. 对于一个模块，返回这个模块的全部属性
      2. 对于一个类，返回这个类的所有变量，并递归基类对象的所有变量
      3. 对于其他的对象，返回所有变量类变量和基类变量
• 内建模块
  • math 模块
    • 模块名 math
  • 时间模块 time

        import time
        # 或 
        from time import XXX
        # 或
        from time import *
    

  • 系统模块 sys

    • 运行时系统相关信息

      属性	描述
      sys.path	模块搜索路径path[0] 是当前脚本程序的路径名
      sys.modules	已加载模块的字典
      sys.version	版本信息字符串
      sys.version_info	版本信息元组
      sys.platform	操作系统平台名称信息
      sys.argv	命令行参数argv[0] 代表当前脚本程序路径名

      函数	描述
      sys.exit([arg])	退出程序，正常退出时sys.exit(0)
      sys.getrecursionlimit()	得到递归嵌套层次限制（栈的深度）
      sys.setresursionlimit()	得到和修改递归嵌套层次的限制（栈的深度）

D013

• 自定义模块并导入
  • 备注:
    • 自定义模块的文件要求以.py文件结尾，文件名必须是标识符的规则
• 导入语句 import 语句等 搜索块的路径顺序
  • import mymod
  • from mymod import myfac
  • from mymod import *
  • 搜索顺序
    1. 搜索程序运行时的路径（当前路径）
    2. sys.path 提供的路径
       • sys.path 是一个列表，里面放的都是模块的搜索路径
    3. 搜索内建模块
• 模块的加载过程
  1. 在模块导入时，模块的所有语句都会执行
  2. 如果一个模块已经导入，则再次导入时不会重新执行模块内的语句
• 模块的重新加载

      import mymod
      import imp
      imp.reload(mymod) # 重新加载mymod模块
  

• 模块被导入和执行的过程
  1. 先搜索相关路径，找到模块名.py
  2. 判断是否有此模块对应的.pyc文件。如果.py比.py文件新，则直接加载.pyc文件
  3. 否则，用模块.py文件生成.pyc,并加载执行
• pyc python 编译

      mymod.py ----编译---- > mymod.pyc ----解释执行----> python3
  

• 模块的文档字符串
  • 模块内的第一个没有赋值给任何变量的字符中称为模块的文档字符串
  1. 模块的 __doc__属性
     • 此属性用于绑定模块的文档字符串
  2. 模块的__file__属性
     • 此属性用于记录模块对应的文件路径名
  3. 模块的__name__属性
     • 用来记录模块自身的名字
     • 作用：
       • 记录模块名
       • 用来判断是否为主模块
     • 说明：
       • 当此模块为主模块（也就是第一个运行的模块时）运行时，__name__绑定__main__
       • 当此模块不是主模块时，而是被其他模块导入时，此时__name__绑定模块名
  4. 模块的__all__列表
     • 模块中的__all__列表是一个用来存放可导出属性的字符串列表
     • 作用：
       • 当用 from XXX import *语句导入时只导入__all__列表内的属性
     • __all__属性只对from import * 语句有效
• 模块的隐藏属性
  • 模块中以'_' 开头的属性, 在from XXX import *导放时，将不被导入，通常称这些属性为隐藏属性
• 随机模块 random

  • 模块名 random

  • 作用： 用于模拟或生成随机输出的模块

  • import random as R

    函数名	描述
    R.random()	返回一个[0, 1) 之间的随机数
    R.uniform(a, b)	返回[a, b)区间内的随机实数
    R.randrange([start,] stop[,step])	返回range(start, stop, step)中的随机数
    R.choice(seq)	从序列中返回随意元素
    R.shuffle(seq[, random])	随机指定序列的顺序（乱序序列）
    R.sample(seq, n)	从序列中选择n个随机且不重复的元素

包（模块包）package

• 包的定义
  • 包是将模块以文件夹的组织形式进行分组管理的管理方法
  • 作用
    • 将一系列模块进行分类管理，有利于防止命名冲突
    • 可以在需要是加载一个或部分模块则不是全部模块
  • 包示例

        mypack/
            __init__.py
            menu.py
            games/
                __init__.py
                contra.py
                supermario.py
                tanks.py
            office/
                word.py
                excel.py
                powerpoint.py
    

  • __init__.py文件
    • __init__.py 是常规包内必须存在的文件
    • __init__.py会在宝鸡在时自动调用
    • 作用：
      1. 编写此包内容
      2. 在内部填写文档字符串
      3. 在__init__.py文件内可以加载此包所依赖的一些其他模块
• 包的导入
  • 同模块的导入规则

      # import 语句
      import 包名 [as 模块名]
      import 包名.模块名 [as 模块新名]
      import 包名.子包名.模块名 [as 模块新名]
      
      
      # from import 语句
      from 包名 import 模块名 [as 模块新名]
      from 包名.子包名 import 模块名 [as 模块新名]
      from 包名.子包名.模块名 import 属性名 [as 属性新名]
      
      # from import * 语句
      from 包名 import *
      from 包名.模块名 import *
      ...
  

  • 导入包时的索引路径顺序：
    1. 搜索程序的当前路径
    2. sys.path 提供的路径
  • 说明： __all__列表值对 from XXX import *语句起作用
  • 包的相对导入
    • 包的相对导入是指包内模块的相互导入
    • 语法：

          from 相对路径包或模块 import 属性或模块名
          from 相对路径包或模块 import *
      

      • 相对路径

            . 代表当前目录
            .. 代表上一级目录
            ... 代表上二级目录
            .... 以此类推
            注： 相对导入时不能超出包的外部
        

D014

• 异常（基础）except

  • 什么是错误
    • 错误是由于逻辑或语法等导致一个程序已无法正常执行的问题
  • 什么是异常
    • 异常是程序出错时标识的一种状态
    • 当一场发生时，程序不会在向下执行，而转为调用此函数的地方待处理此错误并恢复为正常的状态
  • 异常的作用：
    • 用作信号，通知上层调用者有错误产生需要处理

• try 语句：

  • 两种语法：
    • try-except语句
    • tri-finally语句
  • try-except语句语法：

      try:
          课程触发异常的语句
      except 错误类型1 [as 变量1]:
          异常处理语句1
      except 错误类型2 [as 变量2]:
          异常处理语句2
      except (错误类型3, 错误类型4, ...) [as 变量3]
          异常处理语句3
      ...
      except:
          异常处理语句（其他）
      else:
          未发生异常语句
      finlly:
          最终语句
  

  • 作用：
    • 尝试捕获异常，将程序转为正常状态并正常执行

• try-except语句说明

  1. as 子句是用于绑定错误对象的变量，可以省略
  2. except 子句可以有一个或多个，但至少要有一个
  3. else子句最多只能有一个，也可以省略不写
  4. finally 子句最多只能有一个，也可以省略不写
  5. else子句的语句将在此try语句没有发生异常时被执行

• python 全部的错误类型

  错误类型	说明
  ZeroDivisionError	除(或取模)零(所有数据类型)
  valueError	传入无效的参数
  AssertionError	断言语句失败
  StopIteration	迭代器没有更多的值
  IndexError	序列中没有此索引(index)
  IndentationError	缩进错误
  OSError	输入/输出操作失败
  Import	导入模块/对象失败
  NameError	未声明/初始化对象（没有属性）
  AttributeError	对象没有这个属性

• try-finally 语句

  • 语法

        try:
            可能触发异常语句
        finally:
            最终语句
    

  • 说明：
    1. finally 子句不可忽略
    2. 一定不存在except子句
  • 作用： 通常用try-finally 语句来做触发异常时必须要处理的事情，无论异常是否发生，finally子句都会被执行
  • 注意：
    • try-finally 语句不会改变程序的（正常/异常状态）

• rasie 语句

  • 作用：
    • 触发一个错误，让程序进入异常状态
    • 发送错误通知给调用者
  • 语法：

        raise 异常类型
        或
        raise 异常对象
    

• assert 语句(断言语句)

  • 语法
    • assert 真值表达式，错误数据（通常是字符串）
  • 作用：
    • 当真值表达式为False时，用错误数据创建一个AssertionError类型的错误，并进入异常状态
  • 等同于：

        if 真值表达式 === False
            raise AssertionError(错误数据)
    

• 小结：

  • 异常处理语句（四条）
    • try-except 语句:
      • 用于接收异常通知，捕获异常
    • try-finally语句：
      • 执行必须要执行的语句
    • raise语句
      • 发送异常通知，并进入异常状态
    • assert 语句
      • 根据选择性的发送AssertionError类型的异常通知

• 为什么使用异常处理机制

  • 在程序调用层数较深时，向主调函数传递错误信息需要层层return
  • 返回比较麻烦，用异常处理机制可以比较简单的传达错误信息