Python学习笔记

Posted bryceyang23

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Python学习笔记相关的知识，希望对你有一定的参考价值。

目录：

　　一.高阶函数

　　二.返回函数

　　三.匿名函数

　　四.偏函数

 

一.高阶函数

高阶函数英文叫Higher - order function.

变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。

一个简单的高阶函数:

　

def add(x, y, f):
    return f(x) + f(y)

当我们调用add(-5,6,abs)时，参数x,y,f,分别接收-5,6，abs。

map/reduce

Python内建了map()和reduce()函数。

map:

map()函数接收两个参数，一个是函数，一个是Iterable,map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回。

举例说明：比如我们有一个函数f(x) = x2,要把这个函数作用在一个list[1,2,3,4,5,6,7,8,9]上，就可以用map实现。

>>>def f(x):
...        return x*x
...
>>>r = map(f, [1,2,3,4,5,6,7,8,9])
>>>list(r)
[1, 4, 16, 25, 36, 49, 64, 81]

 

map传入的参数是f，即函数对象本身。由于结果r是一个Iterator，Iterator是惰性序列，因此通过list()函数让它把整个序列都计算出来并返回一个list。

reduce:

reduce把一个函数作用在一个序列[x1,x2,x3,x4....]上，这个函数必须接受两个参数，reduce把结果继续和序列的下一个元素做累积计算，效果是：

reduce(f, [x1, x2, x3, x4]) = f(f(x1, x2), x3),x4)

比方说对一个序列求和，就可以用reduce实现

>>> from functools import reduce
>>> def add(x, y):
...     return x + y
...
>>> reduce(add, [1, 3, 5, 7, 9])
25

当然求和运算可以直接用Python内建函数sum()，没必要动用reduce。

但是如果要把序列[1, 3, 5, 7, 9]变换成整数13579，reduce就可以派上用场：

>>> from functools import reduce
>>> def fn(x, y):
...     return x * 10 + y
...
>>> reduce(fn, [1, 3, 5, 7, 9])
13579

这个例子本身没多大用处，但是，如果考虑到字符串str也是一个序列，对上面的例子稍加改动，配合map()，我们就可以写出把str转换为int的函数：

>>> from functools import reduce
>>> def fn(x, y):
...     return x * 10 + y
...
>>> def char2num(s):
...     digits = {‘0‘: 0, ‘1‘: 1, ‘2‘: 2, ‘3‘: 3, ‘4‘: 4, ‘5‘: 5, ‘6‘: 6, ‘7‘: 7, ‘8‘: 8, ‘9‘: 9}
...     return digits[s]
...
>>> reduce(fn, map(char2num, ‘13579‘))
13579

整理成一个str2int的函数就是：

from functools import reduce

DIGITS = {‘0‘: 0, ‘1‘: 1, ‘2‘: 2, ‘3‘: 3, ‘4‘: 4, ‘5‘: 5, ‘6‘: 6, ‘7‘: 7, ‘8‘: 8, ‘9‘: 9}

def str2int(s):
    def fn(x, y):
        return x * 10 + y
    def char2num(s):
        return DIGITS[s]
    return reduce(fn, map(char2num, s))

还可以用lambda函数进一步简化成：

from functools import reduce

DIGITS = {‘0‘: 0, ‘1‘: 1, ‘2‘: 2, ‘3‘: 3, ‘4‘: 4, ‘5‘: 5, ‘6‘: 6, ‘7‘: 7, ‘8‘: 8, ‘9‘: 9}

def char2num(s):
    return DIGITS[s]

def str2int(s):
    return reduce(lambda x, y: x * 10 + y, map(char2num, s))

filter

Python内建的filter()函数用于过滤序列。和map()类似，filter()也接受一个函数和一个序列。和map()不同的是，filter()把传入的元素依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。

例如：在一个list中，删掉偶数，只保留奇数：

def is_odd(n):
    return n%2 == 1

list(filter(is_odd, [1,2,4,5,6,9,10,15]))

注意到filter()函数返回的是一个Iterator,也就是一个惰性序列，所以要强迫filter()完成计算结果，需要用list()函数获得所有结果并返回list。

用filter求素数：

计算素数的一个方法是埃式筛选法，它的算法如下：

首先，列出从2开始的所有自然数，构造一个序列：

2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...

取序列的第一个数2，它一定是素数，然后用2把序列的2的倍数筛掉：

3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...

取新序列的第一个数3，它一定是素数，然后用3把序列的3的倍数筛掉：

5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...

取新序列的第一个数5，然后用5把序列的5的倍数筛掉：

7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...

不断筛下去，就可以得到所有的素数。

用Python来实现这个算法，可以先构造一个从3开始的奇数序列：

def _odd_iter():
     n = 1
    while True:
        n = n+2
        yield n

注意这是一个生成器，并且是一个无线序列。

然后定义一个筛选函数：

def _not_divisible(n):
    return lambda x: x%n >0

最后，定义一个生成器，不断返回下一个素数：

def primes():
    yield 2
    it = _odd_iter() # 初始序列
    while True:
        n = next(it) # 返回序列的第一个数
        yield n
        it = filter(_not_divisible(n), it) # 构造新序列

这个生成器先返回第一个素数2，然后，利用filter()不断产生筛选后的新的序列。

由于primes()也是一个无限序列，所以调用时需要设置一个退出循环的条件：

for n in primes():
    if n < 1000:
        print(n)
    else:
        break

sorted

排序算法

Python内置的sorted()函数就可以对List进行排序：

>>>sorted([36, 5, -12, 9, -21])
[-21, -12, 5, 9, 36]
>>>sorted([36, 5, -12, 9, -21], key=abs)
[5, 9, -12, -21, 36]

 

二.返回函数

 

 函数作为返回值

实现一个可变参数的求和：

def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum

当我们调用lazy_sum()时，返回的并不是求和结果，而是求和函数：

>>>f = lazy_sum(1, 3, 5, 7, 9)
>>>f
<function lazy_sum.<locals>.sum at 0x101c6ed90>

调用函数f时，才真正计算求和的结果：

>>>f()
25

在这个例子中，我们在函数lazy_sum中又定义了函数sum，并且，内部函数sum可以引用外部函数lazy_sum的参数和局部变量，当lazy_sum返回函数sum时，相关参数和变量都保存在返回的函数中，这种称为“闭包"的程序结构拥有极大的威力。

请再注意一点，当我们调用lazy_sum()时，每次调用都会返回一个新的函数，即使传入相同的参数：

>>> f1 = lazy_sum(1, 3, 5, 7, 9)
>>> f2 = lazy_sum(1, 3, 5, 7, 9)
>>> f1==f2
False

f1()和f2()的调用结果互不影响。

闭包

注意到返回的函数在其定义内部引用了局部变量args,所以，当一个函数返回了一个函数后，其内部的局部变量还是被新函数引用。

另一个需要注意的问题是，返回的函数并没有立刻执行，而是直到调用了f()才执行。

def count():
    fs = []
    for i in range(1,4):
        def f():
            return i*i
        fs.append(f)
    return fs

f1,f2,f3 = count()

在上面的例子中，每次循环，都创建了一个新的函数，然后，把创建的3个函数都返回了。

你可能认为调用f1(),f2(),f3()结果应该是1,4,9，但实际结果是：

>>> f1()
9
>>> f2()
9
>>> f3()
9

全部都是9！原因就在于返回的函数引用了变量i，但它并非立刻执行。等到3个函数都返回时，它们所引用的变量i已经变成了3，因此最终结果为9。

返回闭包时牢记一点：返回函数不要引用任何循环变量，或者后续会发生变化的变量。

如果一定要引用循环变量怎么办？方法是再创建一个函数，用该函数的参数绑定循环变量当前的值，无论该循环变量后续如何更改，已绑定到函数参数的值不变：

def count():
    def f(j):
        def g():
            return j*j
        return g
    fs = []
    for i in range(1, 4):
        fs.append(f(i)) # f(i)立刻被执行，因此i的当前值被传入f()
    return fs

 

三.匿名函数

 

例：

>>>list(map(lambda x: x*x, [1,2,3,4,5,6]))
[1,4,9,16,25,36]

匿名函数lambda x: x*x实际上就是：

def f(x):

　　return x*x

关键字lambda表示匿名函数，冒号前面的x表示函数参数。

匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。

用匿名函数有个好处，因为函数没有名字，不必担心函数名冲突。此外，匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数：

>>> f = lambda x: x * x
>>> f
<function <lambda> at 0x101c6ef28>
>>> f(5)
25

同样，也可以把匿名函数作为返回值返回，比如：

def build(x, y):
    return lambda: x * x + y * y

四.偏函数

Python的functools模块提供了很多有用的功能，其中一个就是偏函数。

>>>import functools
>>>int2 = functools.partial(int, base=2)
>>>int2(‘1000000‘)
64

所以，简单总结functools.partial的作用就是，把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单。

 

以上是关于Python学习笔记的主要内容，如果未能解决你的问题，请参考以下文章

Python 3学习笔记

python 机器学习有用的代码片段

python爬虫学习笔记-M3U8流视频数据爬虫

[原创]java WEB学习笔记61：Struts2学习之路--通用标签 property，uri，param,set,push,if-else,itertor,sort,date,a标签等(代码片段

python基础学习笔记（十三）

Python学习笔记之正则表达式