[阶段一] 14. 常用函数与高阶函数

「爱情、让人受尽委屈。」 2022-08-28 13:57 142阅读 0赞

### 常用函数与高阶函数 ###

*  加密工具：

常用的加密工具有 `hashlib` 模块和 `base64` 模块。

`hashlib` 模块加密的内容难以破解，加密过程不可逆。`hashlib` 常用的加密方法：

<table> 
 <thead> 
  <tr> 
   <th>函数名</th> 
   <th>参数</th> 
   <th>介绍</th> 
   <th>示例</th> 
   <th>返回值</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>md5</td> 
   <td>byte</td> 
   <td>MD5算法加密</td> 
   <td>hashlib.md5(b’hello’)</td> 
   <td>hash 对象</td> 
  </tr> 
  <tr> 
   <td>sha1</td> 
   <td>byte</td> 
   <td>Sha1算法加密</td> 
   <td>hashlib.sha1(b’hello’)</td> 
   <td>hash 对象</td> 
  </tr> 
  <tr> 
   <td>sha256</td> 
   <td>byte</td> 
   <td>Sha256算法加密</td> 
   <td>hashlib.sha256(b’hello’)</td> 
   <td>hash 对象</td> 
  </tr> 
  <tr> 
   <td>sha512</td> 
   <td>byte</td> 
   <td>Sha512算法加密</td> 
   <td>hashlib.sha512(b’hello’)</td> 
   <td>hash 对象</td> 
  </tr> 
 </tbody> 
</table>

示例：

# coding:utf-8
    
    import hashlib, time
    
    base_sign = 'python'
    
    
    class Hash(object):
        def __init__(self, sign, timestamp):
            self.sign = sign
            self.timestamp = timestamp
    
        def client(self):
            _token = '%s%s' % (self.sign, self.timestamp)
            token = hashlib.sha1(_token.encode('utf-8')).hexdigest()
            return token, self.timestamp
    
        def server(self):
            _token = '%s%s' % (self.sign, self.timestamp)
            token = hashlib.sha1(_token.encode('utf-8')).hexdigest()
            return token
    
    
    if __name__ == '__main__':
        a = Hash(base_sign, int(time.time()))
        client_token, client_timestamp = a.client()
    
        # b = Hash(base_sign, client_timestamp)
        time.sleep(1)
        b = Hash(base_sign, int(time.time()))
        server_token = b.server()
    
        if client_token == server_token:
            print('验证通过，合法')
        else:
            print('验证不通过，非法')

<table> 
 <thead> 
  <tr> 
   <th>函数名</th> 
   <th>参数</th> 
   <th>介绍</th> 
   <th>示例</th> 
   <th>返回值</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>encodestring</td> 
   <td>byte</td> 
   <td>base64加密</td> 
   <td>base64.encodestring(b’hello’)</td> 
   <td>byte</td> 
  </tr> 
  <tr> 
   <td>decodestring</td> 
   <td>byte</td> 
   <td>base64解密</td> 
   <td>base64.decondestring(b’hello’)</td> 
   <td>byte</td> 
  </tr> 
  <tr> 
   <td>encodebytes</td> 
   <td>byte</td> 
   <td>base64加密</td> 
   <td>base64.encodebytes(b’hello’)</td> 
   <td>byte</td> 
  </tr> 
  <tr> 
   <td>decodebytes</td> 
   <td>byte</td> 
   <td>base64解密</td> 
   <td>base64.decodebytes(b’hello’)</td> 
   <td>byte</td> 
  </tr> 
 </tbody> 
</table>

示例：

# coding:utf-8
    
    import base64
    
    
    class Base(object):
        def __init__(self, data):
            self.data = data
    
        def encode(self):
            if isinstance(self.data, str):
                self.data = self.data.encode('utf-8')
            elif isinstance(self.data, bytes):
                self.data = self.data
            else:
                raise TypeError('data need bytes')
    
            return base64.encodebytes(self.data).decode('utf-8')
    
        def decode(self):
            if not isinstance(self.data, bytes):
                raise TypeError('data need bytes')
    
            return base64.decodebytes(self.data).decode('utf-8')
    
    
    if __name__ == '__main__':
        b = Base('hello 小白')
        result = b.encode()
        print(result)
    
        b = Base(b'aGVsbG8g5bCP55m9')
        new_result = b.decode()
        print(new_result)

*  日志模块：

日志是程序运行时不断产生的记录。通过日志，可以知道程序运行的状态，发现并解决程序运行时产生的 bug。

日志一般有这些等级：`debug`、`info`、`warning`、`error`、`critical`，严重程度依次递增。

简单记录日志，使用 `logging` 模块的 `logging.basicConfig` 方法即可。`logging.basicConfig` 方法参数如下：

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>作用</th> 
   <th>示例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>level</td> 
   <td>日志输出等级</td> 
   <td>level=logging.DEBUG</td> 
  </tr> 
  <tr> 
   <td>format</td> 
   <td>日志输出格式</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>filename</td> 
   <td>存储位置</td> 
   <td>filename=’/var/log/py.log’</td> 
  </tr> 
  <tr> 
   <td>filemode</td> 
   <td>输入模式</td> 
   <td>filemode=‘w’</td> 
  </tr> 
 </tbody> 
</table>

`format` 参数具体格式：

<table> 
 <thead> 
  <tr> 
   <th>格式符</th> 
   <th>函数</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>%(levelname)s</td> 
   <td>日志级别名称</td> 
  </tr> 
  <tr> 
   <td>%(pathname)s</td> 
   <td>执行程序的路径</td> 
  </tr> 
  <tr> 
   <td>%(filename)s</td> 
   <td>执行程序名</td> 
  </tr> 
  <tr> 
   <td>%(lineno)d</td> 
   <td>日志的当前行号</td> 
  </tr> 
  <tr> 
   <td>%(asctime)s</td> 
   <td>打印日志的时间</td> 
  </tr> 
  <tr> 
   <td>%(message)s</td> 
   <td>日志信息</td> 
  </tr> 
 </tbody> 
</table>

常用的 `format` 格式符组合：`'%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s'`

示例：

# coding:utf-8
    
    import os, logging
    
    
    def init_log(path):
        if os.path.exists(path):
            mode = 'a'
        else:
            mode = 'w'
    
        logging.basicConfig(
            level=logging.INFO,
            format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',
            filename=path,
            filemode=mode
        )
    
        return logging
    
    
    if __name__ == '__main__':
        current_path = os.getcwd()
        path = os.path.join(current_path, 'a.log')
    
        log = init_log(path)
        log.info('这是第一条记录的日志信息')
        log.warning('这是第二条记录的警告信息')
        log.error('这是第三条记录的报错信息')

结果：

2021-07-14 21:38:36,841 test.py[line:27] INFO 这是第一条记录的日志信息
    2021-07-14 21:38:36,841 test.py[line:28] WARNING 这是第二条记录的警告信息
    2021-07-14 21:38:36,841 test.py[line:29] ERROR 这是第三条记录的报错信息

*  虚拟环境：

在同一个系统环境中，可能存在多个不同版本的 python，此时就需要创建虚拟环境将它们隔离开。

每个虚拟环境都有自己的 python 二进制文件（与用于创建此环境的二进制文件的版本相匹配），并且可以在其站点目录中拥有自己独立的已安装 python 包。

python 中的虚拟环境工具：

virtualenv
    
    pyenv

命令行下使用 `pip install virtualenv` 安装 `virtualenv`，之后选择创建虚拟环境的目录，然后执行 `virtualenv -p python3.9 penv` 创建虚拟环境。其中 python3.9 表示虚拟环境的 python 版本，而 penv 表示此虚拟环境的名称。最后通过 `./penv/Scripts/active` 启动这个虚拟环境，停止虚拟环境可以使用 `./penv/Scripts/deactive`。

需要注意的是，`virtualenv` 只是针对单一版本下虚拟环境的管理，`pipenv` 可实现对多 python 版本下的虚拟环境的管理。

*  常用的内置函数：

<table> 
 <thead> 
  <tr> 
   <th>函数名</th> 
   <th>参数</th> 
   <th>介绍</th> 
   <th>返回值</th> 
   <th>示例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>abs</td> 
   <td>Number</td> 
   <td>返回数字绝对值</td> 
   <td>正数</td> 
   <td>abs(-10)</td> 
  </tr> 
  <tr> 
   <td>all</td> 
   <td>List</td> 
   <td>判断列表内容是否全是 True</td> 
   <td>Bool</td> 
   <td>all([’’, ‘123’])</td> 
  </tr> 
  <tr> 
   <td>any</td> 
   <td>iterable</td> 
   <td>判断内容是否有 True</td> 
   <td>Bool</td> 
   <td>any([1, 0, ‘’])</td> 
  </tr> 
  <tr> 
   <td>help</td> 
   <td>object</td> 
   <td>打印对象的用法</td> 
   <td>无</td> 
   <td>help(list)</td> 
  </tr> 
  <tr> 
   <td>enumerate</td> 
   <td>iterable</td> 
   <td>迭代时记录索引</td> 
   <td>无</td> 
   <td>for index, item in enumerate(list)</td> 
  </tr> 
  <tr> 
   <td>input</td> 
   <td>str</td> 
   <td>命令行输入消息</td> 
   <td>str</td> 
   <td>input(‘请输入：’)</td> 
  </tr> 
  <tr> 
   <td>isinstance</td> 
   <td>object, type</td> 
   <td>判断对象是否是某种类型</td> 
   <td>Bool</td> 
   <td>isinstance(‘a’, str)</td> 
  </tr> 
  <tr> 
   <td>type</td> 
   <td>object</td> 
   <td>输出对象的类型</td> 
   <td>str</td> 
   <td>type(10)</td> 
  </tr> 
  <tr> 
   <td>vars</td> 
   <td>instance</td> 
   <td>返回实例化对象的属性和值的字典对象</td> 
   <td>dict</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>dir</td> 
   <td>object</td> 
   <td>返回对象中所有可用方法和属性</td> 
   <td>List</td> 
   <td>dir(‘aaa’)</td> 
  </tr> 
  <tr> 
   <td>hasattr</td> 
   <td>object, attr</td> 
   <td>判断对象中是否有某个属性</td> 
   <td>Bool</td> 
   <td>hasattr(‘1’, upper)</td> 
  </tr> 
  <tr> 
   <td>setattr</td> 
   <td>object, attr, value</td> 
   <td>为实例化对象添加属性和值</td> 
   <td>无</td> 
   <td>setattr(person, ‘name’, ‘xiaobai’)</td> 
  </tr> 
  <tr> 
   <td>getattr</td> 
   <td>object, attr</td> 
   <td>通过对象获取属性的值</td> 
   <td>任何类型</td> 
   <td>getattr(person, ‘name’)</td> 
  </tr> 
 </tbody> 
</table>

*  `random` 模块：

python 中的 `random` 模块是随机模块，通常用于产生随机数，达到随机效果。`random` 模块的常用函数如下：

random.random           随机返回 0 ~ 1 之间的浮点数
    
    random.uniform          随机返回 a ~ b 之间的浮点数，a、b 表示参数
    
    random.randint          随机返回 a ~ b 之间的整数，a、b 表示参数
    
    random.choice           随机返回对象中的一个元素
    
    random.sample           随机返回对象中指定数量的元素，结果是列表类型
    
    random.randrange        与 range 类似，随机返回一个区间内的数

示例：

# coding:utf-8
    
    import random
    
    
    def add_zero(interval):
        num = random.randint(1, interval + 1)
    
        if num < 10:
            num = '0' + str(num)
    
        return num
    
    
    def lottery(red_interval, blue_interval):
        red_num, blue_num = 6, 1
        ball = list()
    
        for n in range(red_num):
            ball.append(add_zero(red_interval))
    
        for n in range(blue_num):
            ball.append(add_zero(blue_interval))
    
        return ball
    
    
    if __name__ == '__main__':
        ball_list = lottery(33, 16)
        print(f'''本期双色球中奖号码： { ball_list[0]} { ball_list[1]} { ball_list[2]} { ball_list[3]} { ball_list[4]} { ball_list[5]} { ball_list[6]}''')

*  可迭代对象与迭代器对象：

`iterable` 表示可迭代对象，即能够逐一返回其成员项的对象。可迭代对象可用于 `for` 循环以及其他需要序列的地方（`zip`、`map`、…）。当一个可迭代对象作为参数传给内置函数 `iter` 时，它会返回该对象的迭代器。

可以使用 `isinstance(object, iterable)` 检测一个对象是否已经注册到 `iterable` 或者实现 `__iter__` 函数；但检测一个对象是否是可迭代对象的唯一可信赖的方法是调用 `iter(object)`。

`iterator` 表示迭代器对象，即用来表示一连串数据流的对象。重复调用迭代器的 `__next__` 方法（或将其传给内置函数 `next`）将逐个返回数据流中的每一项，迭代器具有一次性。

判断是否是可迭代对象与迭代器对象：

isinstance(obj, iterable)
    
    isinstance(obj, iterator)

迭代器必须具有 `__iter__` 方法用来返回该迭代器对象自身，因此迭代器对象一定也是可迭代对象，但可迭代对象不一定是迭代器对象。

凡是可以 `for` 循环的，都是可迭代对象；凡是可以 `next`的，都是迭代器对象。可迭代对象是一次性消费的，不同的可迭代对象之间没有关联。python 中的 `for` 循环就是通过 `next`实现的。

`str`、`list`、`truple`、`set`、`dict`，都是可迭代对象，而不是迭代器对象，但可以通过 `iter` 函数获得一个迭代器对象。

*  迭代器的生成与使用：

`iter` 函数可以生成一个迭代器对象。

用法：

iter(iterable)

参数 `iterable` 表示可迭代对象。

`next` 函数可以返回迭代器对象中的数据。

用法：

next(iterator)

参数 `iterator` 表示迭代器对象。

示例：

>>> s = iter({ 1, 2, 3})
    
    >>> s
    <set_iterator object at 0x0000011C75F2BC80>
    
    >>> next(s)
    1
    
    >>> next(s)
    2
    
    >>> next(s)
    3
    
    >>> next(s)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    StopIteration

*  生成器：

在 python 中，使用了 `yield` 关键字的函数被称为生成器 `generator`。

跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，可以理解生成器就是一个迭代器。调用一个生成器函数，返回的是一个迭代器对象。

在调用生成器运行的过程中，每次遇到 `yield` 时函数会暂停并保存当前所有的运行信息，返回 `yield` 的值，并在下一次执行 `next` 方法时从当前位置继续运行。

生成器分类：

1.  生成器函数：常规函数定义，但是使用的是 yield 语句而不是 return 语句返回结果，yield 语句一次返回一个结果，可以使用多次，在每个结果中间，挂起函数的状态，以便下次从它离开的地方继续执行。
2.  生成器表达式：类似列表推导式，生成器返回按需产生结果的一个对象，而不是一次构建一个完整的结果列表。

生成器的优点是：可以在需要的时候才产生结果，而不用立即产生结果。

示例：

>>> def test():
    ...     for i in range(3):
    ...         yield i
    ...
    
    >>> t = test()
    
    >>> t
    <generator object test at 0x0000011C75E96C80>
    
    >>> next(t)
    0
    
    >>> next(t)
    1
    
    >>> next(t)
    2
    
    >>> next(t)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    StopIteration

*  python 的高阶函数：

python中，可以接收另一个函数作为参数的函数称为高阶函数。常用的高阶函数有 `map`、`reduce` 和 `filter`。

`map` 会根据提供的函数对指定迭代器对象的每个元素做映射，映射规则由指定的函数决定，返回一个 `map` 对象。

map(func, *iterables)

第一个参数 `func` 以迭代器对象中的每一个元素调用 `func` 函数，返回包含每次 `func` 函数返回值的 `map` 对象。

通常，`map` 函数会与匿名函数 `lambda` 一起使用。示例：

# coding:utf-8
    
    list1 = list(x for x in range(1, 6))
    
    r = map(lambda x: x * x, list1)
    print(list(r))

结果：

[1, 4, 9, 16, 25]

`map` 允许传入多个迭代器对象，迭代器的数量与 `lambda` 传入的变量数量一致。当最短的迭代器耗尽时停止。示例：

# coding:utf-8
    
    list1 = list(x for x in range(1, 6))
    list2 = list(x for x in range(1, 10))
    
    r = map(lambda x, y: x * x + y, list1, list2)
    print(list(r))

结果：

[2, 6, 12, 20, 30]

`reduce` 函数会对参数序列中元素进行累积，累积规则由指定的函数决定。

`reduce` 函数将一个序列中的所有数据进行下列操作：用传给 `reduce` 中的函数 `func`（必须有两个参数）先对集合中的第 1、2 个元素进行操作，得到的值再与第 3 个元素用 `func` 函数运算，依次类推，最后得到一个值。

reduce(func, sequence[, initial])

累积规则由指定的函数决定。当指定了初始值后，初始值作为第一个元素，与序列中第一个元素开始按函数规则运算。

通常，`reduce` 函数会与匿名函数 `lambda` 一起使用。示例：

# coding:utf-8
    
    from functools import reduce
    
    list1 = list(x for x in range(1, 6))
    
    reduce_sum = reduce(lambda x, y: x + y, list1)
    reduce_red = reduce(lambda x, y: x - y, list1, 10)
    
    print(reduce_sum)
    print(reduce_red)

结果：

15
    -5

`filter` 函数用于对循环根据过滤条件进行过滤，过滤掉不符合条件的元素，返回一个由符合条件元素组成的 `filter` 对象。

filter(func, iterable)

`filter` 函数接收两个参数，第一个参数为函数，第二个参数为迭代器对象，迭代器对象的每个元素作为参数传递给函数进行判断，然后返回 `True` 或 `False`，最后将返回 `True` 的元素放到 `filter` 对象中。

通常，`filter` 函数会与匿名函数 `lambda` 一起使用。示例：

# coding:utf-8
    
    from random import randint
    
    list1 = [randint(-10, 10) for _ in range(10)]
    
    r = filter(lambda x: x > 0, list1)
    print(list(r))

--------------------