003、基础语法2

```mindmap
# 基础语法
- 推导式
  - 是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体
  - 适用于生成列表、字典、集合和生成器
  - 列表推导式
    - 格式
      - [表达式 for 变量 in 列表]     
      - [out_exp_res for out_exp in input_list]
      -  或者
      - [表达式 for 变量 in 列表 if 条件]
      - [out_exp_res for out_exp in input_list if condition]
    - out_exp_res：列表生成元素表达式，可以是有返回值的函数
    - for out_exp in input_list：迭代 input_list 将 out_exp 传入到 out_exp_res 表达式中
    - if condition：条件语句，可以过滤列表中不符合条件的值。
    - 例子1  过滤掉长度小于或等于3的字符串列表，并将剩下的转换成大写字母：
      - names = ['Bob','Tom','alice','Jerry','Wendy','Smith']
      - new_names = [name.upper()for name in names if len(name)>3]
    -  例子2：  计算 30 以内可以被 3 整除的整数：multiples = [i for i in range(30) if i % 3 == 0]
  - 字典推导式
    - 格式
      - { key_expr: value_expr for value in collection }
      - { key_expr: value_expr for value in collection if condition }
    - 例子
      - 使用字符串及其长度创建字典：newdict = {key:len(key) for key in listdemo}
      - 三个数字的平方为值来创建字典：{x: x**2 for x in (2, 4, 6)}
  - 集合推导式
    - 格式
      - { expression for item in Sequence }
      - { expression for item in Sequence if conditional }
    - 例子
      - 计算数字 1,2,3 的平方数： setnew = {i**2 for i in (1,2,3)}
      - 判断不是 abc 的字母并输出： {x for x in 'abracadabra' if x not in 'abc'}
  - 元组推导式（生成器表达式）
    - 格式
      - (expression for item in Sequence )
      - (expression for item in Sequence if conditional )
    - 例子
      - 生成一个包含数字 1~9 的元组：a = (x for x in range(1,10))
      - tuple(a)       # 使用 tuple() 函数，可以直接将生成器对象转换成元组
- 迭代器与生成器
  - 迭代器1
    - 是一个可以记住遍历的位置的对象
    - 从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
    - 有两个基本的方法：iter() 和 next()
    - 字符串，列表或元组对象都可用于创建迭代器
    - 例子
      - list=[1,2,3,4]
       it = iter(list)    # 创建迭代器对象
       print (next(it))   # 输出迭代器的下一个元素
       print (next(it))
    - 例子2 使用常规for语句进行遍历
       list=[1,2,3,4]
       it = iter(list)    # 创建迭代器对象
       for x in it:
           print (x, end=" ")
    - 使用 next() 函数
       import sys         # 引入 sys 模块
       list=[1,2,3,4]
       it = iter(list)    # 创建迭代器对象
       while True:
       try:
       print (next(it))
          except StopIteration:
              sys.exit()
  - 创建一个迭代器
    - 把一个类作为一个迭代器使用需要在类中实现两个方法 __iter__() 与 __next__() 
    - Python 的构造函数为 __init__(), 它会在对象初始化的时候执行
    - __iter__() 方法返回一个特殊的迭代器对象， 这个迭代器对象实现了 __next__() 方法并通过 StopIteration 异常标识迭代的完成
    - __next__() 方法（Python 2 里是 next()）会返回下一个迭代器对象
    - class MyNumbers:
         def __iter__(self):
           self.a = 1
           return self         
         def __next__(self):
             if self.a <= 20:  // 防止死循环；在 20 次迭代后停止执行
               x = self.a
               self.a += 1
               return x
             else:
               raise StopIteration         
         myclass = MyNumbers()
         myiter = iter(myclass)          
         for x in myiter:
           print(x)
    -  StopIteration 异常用于标识迭代的完成，防止出现无限循环的情况
    -  在 __next__() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。
  - 生成器
    - 使用了 yield 的函数被称为生成器（generator）
    - yield 是一个关键字
    - 生成器函数是一种特殊的函数，可以在迭代过程中逐步产生值，而不是一次性返回所有结果
    - 生成器是一个返回迭代器的函数，只能用于迭代操作，生成器就是一个迭代器。
    - 当在生成器函数中使用 yield 语句时，函数的执行将会暂停，并将 yield 后面的表达式作为当前迭代的值返回。
    - 每次调用生成器的 next() 方法或使用 for 循环进行迭代时，函数会从上次暂停的地方继续执行，直到再次遇到 yield 语句
    - 例子
      - def countdown(n):
              while n > 0:
                  yield n
                  n -= 1 
          generator = countdown(5)           # 创建生成器对象
          print(next(generator))  # 输出: 5          # 通过迭代生成器获取值
          print(next(generator))  # 输出: 4
          print(next(generator))  # 输出: 3 
          for value in generator:          # 使用 for 循环迭代生成器
              print(value)  # 输出: 2 1
- 函数
  - 定义一个函数
    - 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()
    - 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数
    - 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明
    - 函数内容以冒号 : 起始，并且缩进
    - return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None
  - 语法
    - def 函数名（参数列表）:
        函数体
  - 实例
    - def hello() :
      print("Hello World!")
      hello()
  - 可变对象在函数体修改了参数值，原始值的参数也被跟着改变
  - 参数
    - 必需参数：必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样
    - 关键字参数
      - 函数调用使用关键字参数来确定传入的参数值
      - 关键字参数允许函数调用时参数的顺序与声明时不一致
      - printme( str = "调用方法时，指定参数名", age = 12,mark="可以不安参数顺序进行")
    - 默认参数
      - 调用函数时，如果没有传递参数，则会使用默认参数
      - def printinfo( name, age = 35 ):
    - 不定长参数（对应C#的参数的部分参数  params sting[] names）
      - 参数带一个*，会以元组的形式导入：def printinfo( arg1, *vartuple ):  >>> printinfo( 70, 60, 50 );
      - 参数带两个**，会以字典的形式导入：def printinfo( arg1, **vardict ):  >>>printinfo(1, a=2,b=3);
      - 如果单独出现星号 *，则星号 * 后的参数必须用关键字传入：def f(a,b,*,c):   >>> f(1,2,c=3) # 正常
  - 匿名函数
    - 使用 lambda 来创建匿名函数
    - lambda 只是一个表达式，而不是一个代码块
    - 语法：lambda [arg1 [,arg2,.....argn]]:expression
    - 例子：x = lambda a : a + 10     >>>  print(x(5))
    - 例子：sum = lambda arg1, arg2: arg1 + arg2   >>> print ("相加后的值为 : ", sum( 10, 20 ))
    - 以将匿名函数封装在一个函数内；则可以使用同样代码创建更多匿名函数
      - def myfunc(n):
            return lambda a : a * n 
          mydoubler = myfunc(2)
          mytripler = myfunc(3) 
          print(mydoubler(11))
          print(mytripler(11))
  - 强制位置参数
    - 函数形参语法 / 用来指明函数形参必须使用指定位置参数，不能使用关键字参数的形式
    - 例子：def f(a, b, /, c, d, *, e, f):   >>>   f(10, 20, 30, d=40, e=50, f=60) #b 不能使用关键字参数的形式  e 必须使用关键字参数的形式
- 装饰器 
- 数据结构
- 模块
- 输入和输出
- File
- OS
- 错误和异常
- 面向对象
- 命名控件||作用域
- 标准库
- 实例
```