Python高阶用法总结

前言：接触python有一段时间了，从开始的看菜鸟的python教程，看了一些视频，一些书。很多人感觉python很简单，确实相比其他语言，python可能稍微简单一点，但是不能说只学了python基础语法就说自己python水平可以了。最近在阅读YOLOv3的pytorch版本源码，就遇到很多瓶颈，很多是与python相关的。所以这篇进行总结一下，收集一下所有的问题，更深入理解python高阶用法，并且尽量每个都附上例子，做一个认真的coder,bloger。

1. lambda匿名函数
- 1.1 函数式编程
- 1.2 应用在闭包
2. 列表解析式
3. enumerate内建函数
4. 迭代器与生成器
- 4.1 迭代器
- 4.3 生成器
5. 装饰器

1. lambda匿名函数

lambda匿名函数在一些工程项目中经常出现，理解该用法是读懂项目的前提。如：

lf = lambda x: 1 - 10 ** (hyp['lrf'] * (1 - x / epochs))

匿名函数就是没有定义函数的名称，用来实现简单的功能。

语法结构：lambda param_list: expression

param_list 就是参数列表，相当于函数的参数

expression 就是表达式，相当于函数体，用一行进行表示

举个简单的例子：

>>> func=lambda x, y: x+y

>>> func(3,4)

7

应用场景：

1.1 函数式编程

python提供了很多函数式编程特性，如map, reduce, filter, sorted等内置函数，都支持函数作为参数。

map会根据提供的函数对指定序列做映射。

map(function, iterable, ...)

  >>> func2=lambda x: x**x

  >>> L=[1,2,3]

  >>> map(func2, L)

  <map object at 0x00000218C07F0080>

  >>> list(map(func2, L)) # 注意要显示内容需要转为list类型，因为py3中返回的是迭代器对象

  [1, 4, 27]

  >>>

其中function可以使lambda函数对象，也可以是str等类型

  >>> L=[1,2,3,4]

  >>> list(map(str, L))

  ['1', '2', '3', '4']

  >>> list(map(float, L))

  [1.0, 2.0, 3.0, 4.0]

reduce 函数会对参数序列中元素进行累积。
- 语法：reduce(function, iterable[, initializer])
- ```
  >>> reduce(lambda x, y: x+y, [1,2,3,4,5])  # 使用 lambda 匿名函数

  15
```
- 注意python3使用前要加上：from functools import reduce , reduce函数在python3中被移除，放入了functools模块。

filter内置函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。

```
  filter(function, iterable)
```

  >>> filter(lambda x: x % 2 == 0, [1,2,3,4,5,6,7,8,9,10])

  <filter object at 0x00000218C07F0080>

  >>> list(filter(lambda x: x % 2 == 0, [1,2,3,4,5,6,7,8,9,10]))

  [2, 4, 6, 8, 10]

  >>>

这里function智能返回true or false, 将满足true的放入最终列表。

sorted函数对所有可迭代的对象进行排序操作。

sorted(iterable, key=None, reverse=False)

  >>> sorted([[3,4],[2,1],[5,3],[7,4],[9,0]], key=lambda x:x[0])

  [[2, 1], [3, 4], [5, 3], [7, 4], [9, 0]]

1.2 应用在闭包

def get_y(a,b):

     return lambda x:ax+b

y1 = get_y(1,1)

y1(1) # 结果为2

用常规函数实现闭包，如下：

def get_y(a,b):

    def func(x):

        return ax+b

    return func

y1 = get_y(1,1)

y1(1) # 结果为2

例子转载自：https://www.cnblogs.com/hf8051/p/8085424.html

2. 列表解析式

列表解析式是Python内置的非常简单却强大的可以用来创建list的生成式。在深度学习项目中也可以经常看到这种用法。

(1) 语法1：[表达式 for 变量 in 列表]，表示把得到的每一个变量值都放到 for 前面的表达式中计算，然后生成一个列表

(2) 语法2：[表达式 for 变量 in 列表 if 条件]，如果加上 if 判断，则表示把每一个变量值进行判断，如果判断正确再交给表达式进行计算，然后生成一个列表

举例：

>>> items=[1,2,3,4,5,6,7]

>>> [item*2 for item in items]

[2, 4, 6, 8, 10, 12, 14]

>>> [item*2 for item in items if item % 2 == 0]

[4, 8, 12]

使用列表解析式的写法更加简短，除此之外，因为是Python内置的用法，底层使用C语言实现，相较于编写Python代码而言，运行速度更快。

3. enumerate内建函数

对于一个列表，既要遍历索引又要遍历元素。

>>> days=['mon','tus','wed','ths','fri','sat','sun']

>>> for i,day in enumerate(days):

...     print(i,day)

...

0 mon

1 tus

2 wed

3 ths

4 fri

5 sat

6 sun

>>> for i,day in enumerate(days, start=1):

...     print(i,day)

...

1 mon

2 tus

3 wed

4 ths

5 fri

6 sat

7 sun

>>>

4. 迭代器与生成器

有时候项目会使用到这种语法，如果不了解这两种用法，可能很难读懂代码，可能会直接懵B o((⊙﹏⊙))o。下面分别看看这两个的用法：

4.1 迭代器

迭代器指的是可以使用next()方法来回调的对象，可以对可迭代对象使用iter()方法，将其转换为迭代器。

>>> L=[1,2,3,4,5]

>>> lst = iter(L)

>>> type(lst)

<class 'list_iterator'>

>>> L1=(1,2,3,4,5)

>>> lst1 = iter(L1)

>>> type(lst1)

<class 'tuple_iterator'>

>>> next(lst)

1

>>> next(lst1)

1

>>>

迭代器优势：所有的元素不是一次性加载的，在调用next方法才会返回，不需要考虑内存问题。next()只能往后进行访问。

迭代器应用场景：

list规模过大，出于对内存的考虑使用迭代器。
有规律，但是不能使用列表推导式描述

迭代器的创建：

__iter__() 方法返回一个特殊的迭代器对象，这个迭代器对象实现了 next() 方法并通过 StopIteration 异常标识迭代的完成。
__next__() 方法（Python 2 里是 next()）会返回下一个迭代器对象。

class MyNumbers:

  def __iter__(self):

    self.a = 1

    return self

  def __next__(self):

    x = self.a

    self.a += 1

    return x

myclass = MyNumbers()

myiter = iter(myclass)

print(next(myiter))

print(next(myiter))

例子来自菜鸟教程：https://www.runoob.com/python3/python3-iterator-generator.html

4.3 生成器

生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。

使用了yield的函数被称为生成器。

在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。（之前也遇见过yolo的代码中使用了这种用法，需要仔细理解并掌握）

#!/usr/bin/python3

import sys

def fibonacci(n): # 生成器函数 - 斐波那契

    a, b, counter = 0, 1, 0

    while True:

        if (counter > n):

            return

        yield a

        a, b = b, a + b

        counter += 1

f = fibonacci(10) # f 是一个迭代器，由生成器返回生成

while True:

    try:

        print (next(f), end=" ")

    except StopIteration:

        sys.exit()

例子来自菜鸟教程：https://www.runoob.com/python3/python3-iterator-generator.html

生成器的优点是延迟计算，一次返回一个结果，这样非常适用于大数据量的计算。但是，使用生成器必须要注意的一点是：生成器只能遍历一次。

5. 装饰器

装饰器本质是一个python函数，如果学过flask就知道，里边装饰器是必须的，经常用到。

装饰器的作用：抽离大量和函数功能本身无关的代码进行重用

一个简单的装饰器，用于计数，由于对不同的函数运行时间进行计数的需要，所以要对时间计数这部分进行处理。

def get_time(func):

	def wrapper():

        startTime = time.time()

        func()

        endTime = time.time()

        print("spend %f" % (endTime-startTime))

    return wrapper

myFunction = get_time(myFunction)

精简一下，使用@语法来进行精简：

import time

def get_time(func):

    startTime = time.time()

    func()

    endTime = time.time()

    processTime = (endTime - startTime) * 1000

    print ("The function timing is %f ms" %processTime)

@get_time

def myfunc():

	print("start")

	time.sleep(0.8)

	print("end")

if __name__ == "__main__":

    myfunc

output：

start

end

The function timing is 800.058126 ms

理解为：get_time(myfun()) ,将myfunc()函数包裹

装饰器可以叠加使用，若多个装饰器同时装饰一个函数，那么装饰器的调用顺序和@语法糖的声明顺序相反，也就是：

@decorator1

@decorator2

def func():

    pass

等效于：

func = decorator1(decorator2(func()))

内置装饰器

Python中，常见的类装饰器包括：@staticmathod、@classmethod和@property

@staticmethod：类的静态方法，跟成员方法的区别是没有self参数，并且可以在类不进行实例化的情况下调用。
@classmethod：跟成员方法的区别是接收的第一个参数不是self，而是cls（当前类的具体类型）
@property：表示可以直接通过类实例直接访问的信息。

了解更多请看：https://www.jianshu.com/p/ee82b941772a