Python入门学习(七)

在熟悉了自定义函数和函数中使用到的参数(必选参数, 默认参数, 可变参数, 关键字参数, 命名关键字参数), 以及由函数返回值引伸出的递归和装饰器后, 让我们继续前行.

Python 高阶函数

map

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

def func(x):
    return x * x
m = map(func, [2, 3])
print(m)
for x in m:
    print(x)

map函数, 就有点类似一个加工厂, func 就像是加工规则, [2, 3] 就像是加工原料, 每个原料加工后, 就成了map的返回值[4, 9]

reduce

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

from functools import reduce
def func(x, y):
    return x + y
s = reduce(func, [1, 2, 3, 4, 5]) # 15

# s = func(func(func(func(1, 2), 3), 4), 5) # 15

reduce函数, 就像是个面包机, [1, 2, 3, 4, 5] 就像是事先要准备的原料 [面粉,鸡蛋, 牛奶, 糖] 而func, 就像是向面包机里加的动作 最后的面包机中的热腾腾的面包, 就是返回结果了.^_^

filter

filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。

def remove_ood(x):
    if x % 2 == 0:
        return True
    else:
        return False

arr = list(range(1, 10))

envn = filter(remove_ood, arr)
print(even) # <filter object at 0x10a444630>
for x in envn:
    print(x)
# 2 4 6 8

filter函数 就是把传入集合中的元素, 按照指定规则分离. 有点像是做奶油前要从鸡蛋中去出蛋黄, 留下蛋清. (^_^)

sorted

sorted()函数就可以对list进行排序

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

sorted()函数也是一个高阶函数，它还可以接收一个key函数来实现自定义的排序，例如:

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

其实还可以这样玩

>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower)
['about', 'bob', 'Credit', 'Zoo']

这样 排序就忽略了数组中的字符的大小写

---

>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True)
['Zoo', 'Credit', 'bob', 'about']

数组的反转

匿名函数

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

print(reduce(lambda x, y: x + y, [1, 2, 3, 4, 5])) # 15

lambda 与 : 之间是匿名函数的入参

偏函数

所谓偏函数，其实就是将一个已知参数和函数进行绑定，生成一个新的函数

假设要转换大量的二进制字符串，每次都传入int(x, base=2)非常麻烦，于是，我们想到，可以定义一个int2()的函数，默认把base=2传进去

def int2(x, base=2):
    return int(x, base)

这样，我们转换二进制就非常方便了：

>>> int2('1000000')
64
>>> int2('1010101')
85

functools.partial 就是帮助我们创建一个偏函数的，不需要我们自己定义int2()，可以直接使用下面的代码创建一个新的函数int2：

>>> import functools
>>> int2 = functools.partial(int, base=2)
>>> int2('1000000')
64
>>> int2('1010101')
85

Python 高级特性

切片

切片是Python提供处理Iterable类型数据的一个工具.

>>> L = list(range(100))

# 前10个元素
>>> L[:10] # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 后10个元素
>>> L[-10:] # [90, 91, 92, 93, 94, 95, 96, 97, 98, 99]

# 前11-20个元素
>>> L[10:20] # [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

# 前10个数，每两个取一个
>>> L[:10:2] # [0, 2, 4, 6, 8]

# 倒数第3个~倒数第5个
>>> L[-5:-2][::-1] # [97, 96, 95]

>>> 'ABCDEFG'[:3] # 'ABC'
>>> 'ABCDEFG'[::2] # 'ACEG'
>>> 'ABC'[::-1] # 'CBA'

Iterable[起始位置=0:截至位置=len(Iterable):步长=1]

迭代

我们可以通过for循环来遍历这个list或tuple，这种遍历我们称为迭代（Iteration）

d = {'a': 1, 'b': 2, 'c': 3}

for k in d:
    print(k) 
# a b c

for v in d.values():
    print(v)
# 1 2 3

for k, v in d.items():
    print(k, '-', v)
# a - 1 b - 2 c - 3

如何判断一个对象是可迭代对象呢？

>>> from collections import Iterable
>>> isinstance('abc', Iterable) # str是否可迭代
True
>>> isinstance([1,2,3], Iterable) # list是否可迭代
True
>>> isinstance(123, Iterable) # 整数是否可迭代
False

迭代tuple

for x, y in [(1, 1), (2, 4), (3, 9)]:
    print('{0}-{1}'.format(x, y))
# 1-1 2-4 3-9

列表生成式

从一定意义上来说, 列表生成式可以做到的, 用map()函数也可以做到.但列表生成器更容易, 更直观.

我现在需要一个数组2次方后的一个数组.

L = [1, 2, 3, 4, 5]
L1 = map(lambda x: x * x, L)
L2 = [x * x for x in L]
print(L1) # object.map
print(L2) #[1, 4, 9, 16, 25]

其实, 还可以这样^_^

t = [1, 2, 3]
l = [t[i] * t[i + 1] for i in range(len(t) -1)]
print(l) # [2, 6]

生成器

在Python中，这种一边循环一边计算的机制，称为generator(生成器)

g = (x * x for x in range(10))
print(g) # <generator object <genexpr> at 0x1101431a8>

和列表生成式不同的是, 生成器返回的是一个Iterable, 而列表生成式返回的是一个数组

generator: 存储的是计算规则, 并没有真实的数据. 遍历时, 每次返回的数据, 都是按照所存储的计算规则计算出的

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

o = odd()
print(next(o)) # 1
print(next(o)) # 3

odd不是普通函数，而是generator，在执行过程中，遇到yield就中断，下次又继续执行。

最后附上一位大神用generator实现的杨辉三角

def triangles():
    t = [1]
    while True:
        yield t
        t= [t[i] + t[i-1] for i in range(1,len(t))]
        t.insert(0,1) # 第一位始终为 1
        t.append(1) # 最后一位始终为 1

迭代器

凡是可作用于for循环的对象都是Iterable类型；
凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；
集合数据类型如list、dict、str等是Iterable, 但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。

Python 模块

这是我项目中各文件的路径.
我在hello.py中希望引用我web模块下的utils中的函数

from web.utils import reverse
print(reverse("123"))

import web.utils
web.utils.welcome("Tom")