Python学习笔记——高级特性（一）

为了跟上信息时代的潮流，决定学习一下人工智能时代的标配语言Python。Python语言的语法简洁，类似解释性语言的编译执行方式，非常适合于编程基础比较差的程序猿。由于其简洁的使用方式，利用python语言能否进行比较大的项目开发呢。
实际上，python能够流行起来，还是有其明显优势的，我认为python语言的流行，离不开一下几个方面：
1、python语言语法简单，与c语言语法很相似，学过c语言的人上手非常方便。
2、解释性的语言形态，非常便于初学者掌握，一条语句就能实现一个“Hello World”程序，对于初学者来说，想想都有成就感。
3、大量的开源模块，推动了语言的发展，丰富的GUI库、人工智能算法库、数据分析库，而且python对第三方库的引入非常方便，使得python开发者很适合于站在巨人的肩膀上。
4、大量的高级特性，也支持大型项目开发所需要的高级程序功能。如面向对象、切片、迭代、高级函数等。
今天就介绍python语言的高级特性，在开发小的程序时，可能不会接触到，但是在大型项目中使用python语言的这些特性能够做到事半功倍。

切片

（1）Python提供了切片（Slice）操作符，能够大大简化取列表特定范围的值的过程。语法为L[k:n],第一个索引是0的话，还可以简写成L[:n]
类似的，既然Python支持L[-1]取倒数第一个元素，那么它同样支持倒数切片。

L[-2:]
[‘Bob’, ‘Jack’]

L[-2:-1]
[‘Bob’]

（2）tuple也是一种list，唯一区别是tuple不可变。因此，tuple也可以用切片操作，只是操作的结果仍是tuple：

(0, 1, 2, 3, 4, 5)[:3]
(0, 1, 2)

（3）字符串’xxx’也可以看成是一种list，每个元素就是一个字符。因此，字符串也可以用切片操作，只是操作结果仍是字符串

‘ABCDEFG’[:3]
‘ABC’

‘ABCDEFG’[::2]
‘ACEG’

迭代

（1）当我们使用for循环时，只要作用于一个可迭代对象，for循环就可以正常运行，而我们不太关心该对象究竟是list还是其他数据类型。那么，如何判断一个对象是可迭代对象呢？方法是通过collections模块的Iterable类型判断。

from collections import Iterable
isinstance(‘abc’, Iterable) # str是否可迭代
True

isinstance([1,2,3], Iterable) # list是否可迭代
True

isinstance(123, Iterable) # 整数是否可迭代
False

（2）如果要对list实现类似Java那样的下标循环怎么办？Python内置的enumerate函数可以把一个list变成索引-元素对，这样就可以在for循环中同时迭代索引和元素本身：

for i, value in enumerate([‘A’, ‘B’, ‘C’]):
… print(i, value)
…
0 A
1 B
2 C
for循环里，同时引用了两个变量，在Python里是很常见的

列表生成器

（1）列表生成式即List Comprehensions，是Python内置的非常简单却强大的可以用来创建list的生成式。

list(range(1, 11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

[x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

(2)for循环后面还可以加上if判断，这样我们就可以筛选出仅偶数的平方：

[x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]
还可以使用两层循环，可以生成全排列：

[m + n for m in ‘ABC’ for n in ‘XYZ’]
[‘AX’, ‘AY’, ‘AZ’, ‘BX’, ‘BY’, ‘BZ’, ‘CX’, ‘CY’, ‘CZ’]

(3)运用列表生成式，可以写出非常简洁的代码。例如，列出当前目录下的所有文件和目录名，可以通过一行代码实现：

import os # 导入os模块，模块的概念后面讲到
[d for d in os.listdir(’.’)] # os.listdir可以列出文件和目录
[’.emacs.d’, ‘.ssh’, ‘.Trash’, ‘Adlm’, ‘Applications’, ‘Desktop’, ‘Documents’, ‘Downloads’, ‘Library’, ‘Movies’, ‘Music’, ‘Pictures’, ‘Public’, ‘VirtualBox VMs’, ‘Workspace’, ‘XCode’]

(4)for循环其实可以同时使用两个甚至多个变量，比如dict的items()可以同时迭代key和value：

d = {‘x’: ‘A’, ‘y’: ‘B’, ‘z’: ‘C’ }
for k, v in d.items():
… print(k, ‘=’, v)
…
y = B
x = A
z = C

生成器

（1）在Python中，可以采用一边循环一边计算的机制，创建列表，这种列表称为生成器：generator。要创建一个generator，有很多种方法。第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator：

L = [x * x for x in range(10)]
L
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

g = (x * x for x in range(10))
g
<generator object at 0x1022ef630>

（2）可以通过next函数打印generator的元素。generator保存的是算法，每次调用next(g)，就计算出g的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的错误。

next(g)
0

next(g)
1

next(g)
4

next(g)
9
当然获取generator的元素的正确方法是通过for循环迭代，因为generator也是一个迭代对象。

for n in g:
… print(n)

（3）yield。如果一个函数中定义了yield关键字，那么这个函数就不再是一个普通函数，而是一个generator，这就是定义generator的另一种方法。
def fib(max):
n, a, b = 0, 0, 1
while n < max:
yield b
a, b = b, a + b
n = n + 1
return ‘done’
f=fib(6)
这里，最难理解的就是generator和函数的执行流程不一样。函数是顺序执行，遇到return语句或者最后一行函数语句就返回。而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。

迭代器

（1） 可以直接作用于for循环的数据类型有以下几种：一类是集合数据类型，如list、tuple、dict、set、str等；一类是generator，包括生成器和带yield的generator function。这些可以直接作用于for循环的对象统称为可迭代对象：Iterable。可以使用isinstance()判断一个对象是否是Iterable对象

from collections import Iterable
isinstance([], Iterable)
True

isinstance({}, Iterable)
True

isinstance(‘abc’, Iterable)
True

isinstance((x for x in range(10)), Iterable)
True

isinstance(100, Iterable)
False

（2）可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。可以使用isinstance()判断一个对象是否是Iterator对象

from collections import Iterator
isinstance((x for x in range(10)), Iterator)
True

isinstance([], Iterator)
False

isinstance({}, Iterator)
False

isinstance(‘abc’, Iterator)
False

（3）Python的Iterator对象表示的是一个数据流，Iterator对象可以被next()函数调用并不断返回下一个数据，直到没有数据时抛出StopIteration错误。可以把这个数据流看做是一个有序序列，但我们却不能提前知道序列的长度，只能不断通过next()函数实现按需计算下一个数据，所以Iterator的计算是惰性的，只有在需要返回下一个数据时它才会计算。

函数式编程

函数式编程就是一种抽象程度很高的编程范式，纯粹的函数式编程语言编写的函数没有变量，因此，任意一个函数，只要输入是确定的，输出就是确定的，这种纯函数我们称之为没有副作用。而允许使用变量的程序设计语言，由于函数内部的变量状态不确定，同样的输入，可能得到不同的输出，因此，这种函数是有副作用的。
1、 高阶函数
Python中函数可以指向变量，如f=abs

f = abs
f(-10)
10

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

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

add(-5, 6, abs)

（1） map、reduce
Python内建了map()和reduce()函数。map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回。

def f(x):
… return x * x
…

r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
list®
[1, 4, 9, 16, 25, 36, 49, 64, 81]

所以，map()作为高阶函数，事实上它把运算规则抽象了，因此，我们不但可以计算简单的f(x)=x2，还可以计算任意复杂的函数。
reduce把一个函数作用在一个序列[x1, x2, x3, …]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算，其效果就是：
reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

from functools import reduce
def add(x, y):
… return x + y
…

reduce(add, [1, 3, 5, 7, 9])
25

from functools import reduce
def fn(x, y):
… return x * 10 + y
…

reduce(fn, [1, 3, 5, 7, 9])
13579

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

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

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

可见用filter()这个高阶函数，关键在于正确实现一个“筛选”函数。
filter()函数返回的是一个Iterator，也就是一个惰性序列，所以要强迫filter()完成计算结果，需要用list()函数获得所有结果并返回list。

（3）sort。Python内置的sorted()函数就可以对list进行排序。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’]

要进行反向排序，不必改动key函数，可以传入第三个参数reverse=True：

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

（4）返回函数
一个函数可以返回一个计算结果，也可以返回一个函数。返回一个函数时，牢记该函数并未执行，返回函数中不要引用任何可能会变化的变量。

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

f1, f2, f3 = count()
f1()
9

f2()
9

f3()
9

（5） 匿名函数。
关键字lambda表示匿名函数，冒号前面的x表示函数参数。匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。用匿名函数有个好处，因为函数没有名字，不必担心函数名冲突。此外，匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数。

list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
[1, 4, 9, 16, 25, 36, 49, 64, 81]

f = lambda x: x * x
f
<function at 0x101c6ef28>

f(5)
25

（6） 装饰器
假设我们要增强now()函数的功能，比如，在函数调用前后自动打印日志，但又不希望修改now()函数的定义，这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。

def log(func):
def wrapper(*args, **kw):
print(‘call %s():’ % func.name)
return func(*args, **kw)
return wrapper
@log
def now():
print(‘2015-3-25’)

如果decorator本身需要传入参数，那就需要编写一个返回decorator的高阶函数，写出来会更复杂。比如，要自定义log的文本：

def log(text):
def decorator(func):
def wrapper(*args, **kw):
print(’%s %s():’ % (text, func.name))
return func(*args, **kw)
return wrapper
@log(‘execute’)
def now():
print(‘2015-3-25’)

（7）偏函数
当函数的参数个数太多，需要简化时，使用functools.partial可以创建一个新的函数，这个新函数可以固定住原函数的部分参数，从而在调用时更简单。functools.partial的作用就是，把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单。

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

int2(‘1010101’)
85