python学习总结---函数使用 and 生成器

# 函数使用

### 生成器

- 使用场景

  在使用列表时，很多时候我们不会一下子使用全部数据，通常都是一个一个使用，但是当数据量比较大的时候，定义一个大的列表将会是内容使用突然增大。为了解决此类问题，python中引入了生成器的概念。

- 使用方式

  - 方式1：将列表生成式的[]改为()

  ```python
  # 列表生成式
  # lt = [i for i in range(10)]
  # 生成器方式1：将列表生成式的[]改为()
  lt = (i for i in range(3))

  1.# 可以转换为列表
  # print(list(lt))

  2.# 可以进行遍历
  # for i in lt:
  #     print(i, end=' ')

  3.# 可以一个一个提取，当遍历完毕后再使用next会报StopIteration错
  print(next(lt))
  print(next(lt))
  print(next(lt))
  ```

  - 方式2：在函数中是使用yield

    ```python
    def test(n):
          for i in range(1, n+1):
              # 执行到此处，函数会返回yield后的值，然后停在这里
              yield i

      t = test(3)
      # print(t)

      # 可以使用next一个一个提取
      # print(next(t))
      # print(next(t))
      # print(next(t))
      # print(next(t))

      # 可以遍历
      # for i in t:
      #     print(i)

      # 可以转换为列表
      print(list(t))
    ```

- 总结：

  - 生成器对象保存的特定数据的生成算法，但并不是保存所有的数据
  - 生成器使用任意一种方式操作，都只能操作一遍
  - 生成器可以做的操作：遍历、转换为列表、next

### 迭代器

- 定义：能够使用for-in进行遍历，并且能够使用next依次获取其中一个元素。

- 说明：

  - 生成器就是一种特殊的迭代器
  - 判断一个对象是不是迭代器

  ```python
  from collections import Iterator

  # lt = [i for i in range(10)]
  lt = (i for i in range(10))

  print(isinstance(lt, Iterator))
  ```

  - 字符串、列表、元组、字典等都不是迭代器，它们都是可迭代对象。

### 可迭代对象

- 定义：可以使用for-in进行遍历的对象，都是可迭代对象。

- 说明：

  - 前面学过的容器类型都是可迭代对象。
  - 迭代器一定是可迭代对象

- 判断：一个对象是否可迭代

  ```python
  from collections import Iterable

  lt = [1, 2, 3]

  print(isinstance(lt, Iterable))
  ```

- iter：将可迭代对象转换为迭代器

  ```python
  from collections import Iterable, Iterator

  lt = [1, 2, 3]
  # 将一个可迭代对象转换为迭代器
  lt = iter(lt)

  print(isinstance(lt, Iterable))
  print(isinstance(lt, Iterator))
  ```

### 高级函数

- map

  - 参数

  ```
  func：一个函数
  iter1：一个可迭代对象
  ```

  - 使用：

  ```python
  from collections import Iterator
  lt = [1, 2, 3, 4, 5]

  def pingfang(x):
      return x * x

  # 返回一个迭代器
  ret = map(pingfang, lt)
  # ret = map(lambda x: 2 * x, lt)

  print(isinstance(ret, Iterator))
  print(list(ret))
  ```

  - 练习：
    - 熟悉字符串的函数：strip、lstrip、rstrip

    - ```python
      #熟悉字符串的函数：strip、lstrip、rstrip
      str = '  LOVE   '
      #去掉字符串中的空格
      #a = str.strip()
      #删除左边的
      #a = str.lstrip( 'B')
      #删除右边的
      a = str.rstrip()
      print('AAA'+a+'BBB')
      ```

      ​

    - 使用map函数：将一个元素全是字符串的列表进行处理，删除元素前后的空白，首字母大写

    - ```python
      a = ['  iloveyou   ']
      b = [a[0].strip()]
      def shanchu(x):
          return x[0].upper() + x[1:].lower()
      print(list(map(shanchu,b)))
      ```

      ​

- filter

  - 参数

  ```
  function：过滤函数
  iterable：可迭代对象
  ```

  - 使用：

  ```python
  lt = [1, 2, 3, 4, 5]

  def oushu(x):
      return x%2 == 0

  # f = filter(oushu, lt)
  f = filter(lambda x: x%2 != 0, lt)
  print(list(f))
  ```

  - 练习：提取列表中长度大于3的字符串，列表中什么元素都有

  - ```python
    第一种：
    lt = ['a','ab','abc','abcd',12345,235]
    def shuzi(x):
        return isinstance(x,str) and len(x) > 3
    f = filter(shuzi,lt)
    print(list(f))
    第二种：
    lt = ['a','ab','abc','abcd',12345,235]
    f = list(filter(lambda s:isinstance(s,str) and len(s) > 3,lt))
    print(list(f))

    ```

    ​

- reduce

  - 参数

  ```
  function：处理函数
  sequence：序列(容器对象)
  ```

  - 说明：

  ```
  1.首先从序列中取出两个元素，作为处理函数的参数
  2.处理完的结构与下一个元素进行使用处理函数处理
  3.处理结束，将处理完的结果返回
  ```

  - 使用：

  ```python
    from functools import reduce

    lt = [1, 2, 3, 4, 5]

    def add(a, b):
        return a + b

    # ret = reduce(add, lt)
    # 转换为12345
    ret = reduce(lambda x, y: x * 10 + y, lt)
    print(ret)
  ```

  - 练习：求一个列表中所有元素的乘积

  - ```python
    from functools import  reduce
    lt = [1,2,3,4,5]
    ret = reduce(lambda  x , y : x*y,lt)
    print(ret)
    ```

    ​

- sorted

  - 说明：
    - 排序函数，支持逆序和任意元素排序
    - 返回新的排序后的列表，不会改变原列表
    - 使用方式与列表的排序方法一样
    - 与我们自己实现的稍有不同

### random

- 示例：

  ```python
  import random

  #生成指定范围内的随机整数
  print(random.randint(1,10))
  #生成某一范围内的随机小数
  print(random.random())
  #生成指定位置内的随机小数
  print(random.uniform())
  #从容器对象（列表或字符）串中随机抽取一个元素
  it=[1,2,3,4,5,6,7,8,9,0]
  print(random.choice(it))
  #从容器对象中随机提取两个元素；指定个数
  print(random.sample([1,2,3,4,5],2))
  #sample 提取个数为一的情况 等价于上面提取个数为一的函数
  print(random.choices('absajbdsad'))
  #随机提取一个列表
  it=[1,2,3,4,5,6,]
  random.shuffle(it)
  print(it)
  ```

### 练习

- 使用random函数实现randint函数的功能，函数名：def my_randint(start, end)

- ```python
  import  random
  def rand_int(m,n):
     return round(random.random() *(n-m)+m)
  print(rand_int(1,10))
  ```

  ​

- 生成指定长度指定类型的随机字符串，参数：长度、类型

- ```python
  第一种：
  import random
  def random_str(n):
       str1 = ""
       base_str = 'ABCDEFGHIGKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'
       length = len(base_str)-1
       for i in range (n):
           str1 += base_str[random.randint(0,length)]
       return  str1
  f = random_str(24)
  print(f)
  第二种：
  import  random
  def rand_str(lenght=4,kind=0):
      if kind == 0 :   #纯数字
          base_str = '1234567890'
      elif kind == 1 :  #纯字母
          base_str = 'askdrjnfk'
      else:              #数字字母混合
          base_str = '41ss4e5rtg56h'
      return  ''.join(random.choice(base_str)  for i in range(lenght))
  print(rand_str(3,2))
  ```

  ​

- 字符串转换，如：`IloveYOUmoreTHANiCANsay` => `I love you more than i can say`

- ```python
  第一种：
  def sep_words(s):
      ret = s[0].upper()
      for i in range(1,len(s)):
           if s[i].islower() == s[i-1].isupper():
               ret += ' '
           ret += s[i].lower()
      return  ret
  print(sep_words('IloveYOUmoreTHANiCANsay'))
  第二种：
  def sep_words(s):
     ret = s[0]
     for i in range(1,len(s)):
       if s[i].islower() == s[i-1].isupper():
          ret += ' '
       ret += s[i]
     return  ret.capitalize()
  print(sep_words('IloveYOUmoreTHANiCANsay'))
  ```

  ​

- 将列表中的元素完成特定的向右移动，参数：列表、移动长度
  - 如：`[1, 2, 3, 4, 5]`，移动2，结果：`4, 5, 1, 2, 3`

  - ```python
    第一种：
    def right_shuft(lt,step):
         step = step%len(lt)
         for i in range(step):
          #弹出最后一个元素
             last = lt.pop()
             #将最后一个元素插入到开头
             lt.insert(0,last)
    lt = [1,2,3,4,5]
    right_shuft(lt,2)
    print(lt)
    第二种：
    def right_shift(lt,step):
        step %= len(lt)
        left = lt[:-step]
        right = lt[-step:]
        lt.clear()
        lt.extend(right)
        lt.extend(left)
    lt = [1,2,3,4,5]
    right_shift(lt,2)
    print(lt)
    ```

    ​

- 使用递归，完成传入n，返回`1! + 2! + 3! + ... + n!`

- ```python
  #f(n) => f(n-1) + n!
  #f(n) => f(n-1) + n * (n-1)!
  #f(n) => f(n-1) + n * (f(n-1)-f(n-2))
  def jiechenghe(n):
       if n == 1:
         return  1
       elif n == 2:
         return  3
       return  jiechenghe(n-1)+ n * (jiechenghe(n-1)-jiechenghe(n-2))
  print(jiechenghe(1))
  print(jiechenghe(2))
  print(jiechenghe(3))
  ```

  ​