python

5.1 Python简介

本章将介绍Python的最基本语法，以及一些和深度学习还有计算机视觉最相关的基本使用。

5.1.1 Python简史

Python是一门解释型的高级编程语言，特点是简单明确。Python作者是荷兰人Guido van Rossum，1982年他获得数学和计算机硕士学位后，在荷兰数学与计算科学研究所（Centrum Wiskunde & Informatica, CWI）谋了份差事。在CWI期间，Guido参与到了一门叫做ABC的语言开发工作中。ABC是一门教学语言，所以拥有简单，可读性好，语法更接近自然语言等特点。在那个C语言一统天下的年代，ABC就是一股简单的清流，毕竟是门教学语言，最后没有流行起来，不过这段经历影响了Guido。1989年的圣诞假期，闲得蛋疼的Guido决定设计一门简单易用的新语言，要介于C和Shell之间，同时吸取ABC语法中的优点。Guido用自己喜欢的一部喜剧电视剧来命名这门语言：《Monty Python's Flying Circus》。

1991年，第一版基于C实现的Python编译器诞生，因为简单，拓展性好，Python很快就在Guido的同事中大受欢迎，不久Python的核心开发人员就从Guido一人变成了一个小团队。后来随着互联网时代的到来，开源及社区合作的方式蓬勃发展，Python也借此上了发展的快车道。因为Python非常容易拓展，在不同领域的开发者贡献下，许多受欢迎的功能和特征被开发出来，渐渐形成了各种各样的库，其中一部分被加入到Python的标准库中，这让本来就不需要过多思考底层细节的Python变得更加强大好用。在不过多考虑执行效率的前提下，使用Python进行开发的周期相比传统的C/C++甚至Java等语言都大大缩短，代码量也大幅降低，所以出bug的可能性也小了很多。因此有了语言专家Bruce Eckel的那句名言：Life is short, you need Python. 后来这句话的中文版“人生苦短，我用Python”被Guido印在了T恤上。发展至今，Python渐渐成了最流行的语言之一，在编程语言排行榜TOBIE中常年占据前5的位置。另外随着Python的用户群越来越壮大，慢慢在本身特点上发展出了自己的哲学，叫做Python的禅（The Zen of Python）。遵循Python哲学的做法叫做很Python（Pythonic），具体参见：

PEP 20 -- The Zen of Python

或者在Python中执行：

>> import this

Python拥有很好的扩充性，可以非常轻松地用其他语言编写模块供调用，用Python编写的模块也可以通过各种方式轻松被其他语言调用。所以一种常见的Python使用方式是，底层复杂且对效率要求高的模块用C/C++等语言实现，顶层调用的API用Python封装，这样可以通过简单的语法实现顶层逻辑，故而Python又被称为“胶水语言”。这种特性的好处是，无需花费很多时间在编程实现上，更多的时间可以专注于思考问题的逻辑。尤其是对做算法和深度学习的从业人员，这种方式是非常理想的，所以如今的深度学习框架中，除了MATLAB，或是Deeplearning4j这种摆明了给Java用的，其他框架基本上要么官方接口就是Python，要么支持Python接口。

5.1.2 安装和使用Python

Python有两个大版本，考虑到用户群数量和库的各种框架的兼容性，本文以Python2（2.7）为准，语法尽量考虑和Python3的兼容。

Unix/Linux下的Python基本都是系统自带的，一般默认为Python2，使用时在终端直接键入python就能进入Python解释器界面：

在解释器下就已经可以进行最基本的编程了，比如：

写程序的话还是需要保存成文件再执行，比如我们写下面语句，并且保存为helloworld.py：

print("Hello world!")

然后在终端里执行：

安装更多的python库一般有两种方法，第一是用系统的软件包管理，以Ubuntu 16.04 LTS为例，比如想要安装numpy库（后面会介绍这个库），软件包的名字就是python-numpy，所以在终端中输入：

>> sudo apt install python-numpy

Python自己也带了包管理器，叫做pip，使用如下：

>> pip install numpy

安装和深度学习相关的框架时，一般来说推荐使用系统自带的包管理，出现版本错误的可能性低一些。另外也可以使用一些提前配置好很多第三方库的Python包，这些包通常已经包含了深度学习框架中绝大多数的依赖库，比如最常用的是Anaconda：

Download Anaconda Now!

Windows下的Python安装简单一些，从官方网站下载相应的安装程序就可以了，当然也有更方便的已经包含了很全的第三方库的选择，WinPython：

WinPython

并且是绿色的，直接执行就可以用了。

5.2 Python基本语法

There should be one-- and preferably only one --obvious way to do it.

对于一个特定的问题，应该只用最好的一种方法来解决。

-- Tim Peters

5.2.1 基本数据类型和运算

基本数据类型

Python中最基本的数据类型包括整型，浮点数，布尔值和字符串。类型是不需要声明的，比如：

a = 1       # 整数b = 1.2     # 浮点数c = True    # 布尔类型d = "False" # 字符串e = None    # NoneType

其中#是行内注释的意思。最后一个None是NoneType，注意不是0，在Python中利用type函数可以查看一个变量的类型：

type(a)     # <type 'int'>type(b)     # <type 'float'>type(c)     # <type 'bool'>type(d)     # <type 'str'>type(e)     # <type 'NoneType'>

注释中是执行type()函数后的输出结果，可以看到None是单独的一种类型NoneType。在很多API中，如果执行失败就会返回None。

变量和引用

Python中基本变量的赋值一般建立的是个引用，比如下面的语句：

a = 1b = ac = 1

a赋值为1后，b=a执行时并不会将a的值复制一遍，然后赋给b，而是简单地为a所指的值，也就是1建立了一个引用，相当于a和b都是指向包含1这个值的这块内存的指针。所以c=1执行的也是个引用建立，这三个变量其实是三个引用，指向同一个值。这个逻辑虽然简单，不过也还是常常容易弄混，这没关系，Python内置了id函数，可以返回一个对象的地址，用id函数可以让我们知道每个变量指向的是不是同一个值：

id(a)   # 35556792Lid(b)   # 35556792Lid(c)   # 35556792L

注释中表示的仍是执行后的结果。如果这时候我们接下面两个语句：

b = 2   # b的引用到新的一个变量上id(b)   # 35556768L

可以看到b引用到了另一个变量上。

运算符

Python中的数值的基本运算和C差不多，字符串的运算更方便，下面是常见的例子：

a = 2b = 2.3         c = 3a + b           # 2 + 2.3 = 4.3c – a           # 3 - 2 = 1a / b           # 整数除以浮点数，运算以浮点数为准，2 / 2.3 = 0.8695652173913044a / c           # Python2中，整数除法，向下取整 2 / 3 = 0a ** c          # a的c次方，结果为8a += 1          # Python中没有i++的用法，自增用+=c -= 3          # c变成0了d = 'Hello'     d + ' world!'   # 相当于字符串拼接，结果为'Hello world!'d += ' "world"!'# 相当于把字符串接在当前字符串尾，d变为'Hello "world"!'e = r'\n\t\\'   print(e)        # '\\n\\t\\\\'

需要提一下的几点：1）字符串用双引号和单引号都可以，区别主要是单引号字符串中如果出现单引号字符则需要用转义符，双引号也是一样，所以在单引号字符串中使用双引号，或者双引号字符串中使用单引号就会比较方便。另外三个双引号或者三个单引号围起来的也是字符串，因为换行方便，更多用于文档。2）Python2中两个数值相除会根据数值类型判断是否整数除法，Python3种则都按照浮点数。想要在Python2种也执行Python3中的除法只要执行下面语句：

from __future__ import division     # 使用Python3中的除法1 / 2                                   # 0.5

3）字符串前加r表示字符串内容严格按照输入的样子，好处是不用转义符了，非常方便。

Python中的布尔值和逻辑的运算非常直接，下面是例子：

a = Trueb = Falsea and b     # Falsea or b      # Truenot a       # False

基本上就是英语，操作符优先级之类的和其他语言类似。Python中也有位操作：

~8      # 按位翻转，1000 --> -(1000+1)8 >> 3  # 右移3位，1000 --> 00011 << 3  # 左移3位，0001 --> 10005 & 2   # 按位与，101 & 010 = 0005 | 2   # 按位或，101 | 010 = 1114 ^ 1   # 按位异或，100 ^ 001 = 101

==, !=和is

判断是否相等或者不等的语法和C也一样，另外在Python中也常常见到is操作符，这两者的区别在于==和!=比较引用指向的内存中的内容，而is判断两个变量是否指向一个地址，看下面的代码例子：

a = 1b = 1.0c = 1a == b  # True，值相等a is b  # False，指向的不是一个对象，这个语句等效于 id(a) == id(b)a is c  # True，指向的都是整型值1

所以一定要分清要比较的对象应该用那种方式，对于一些特殊的情况，比如None，本着Pythonic的原则，最好用is None。

注意关键字

Python中，万物皆对象。不过这并不是这里要探讨的话题，想说的是一定要注意关键字，因为所有东西都是对象，所以一个简简单单的赋值操作就可以把系统内置的函数给变成一个普通变量，来看下边例子：

id(type)                            # 506070640Ltype = 1                            # type成了指向1的变量id(type)                            # 35556792Lid = 2                              # id成了指向2的变量from __future__ import print_functionprint = 3                           # print成了指向3的变量

注意print是个很特殊的存在，在Python3中是按照函数用，在Python2中却是个命令式的语句，最早print的用法其实是下边这样：

print "Hello world!"

这么用主要是受到ABC语法的影响，但这个用法并不Pythonic，后来加入了print函数，为了兼容允许两种用法并存。所以单纯给print赋值是不灵的，在Python2中使用Python3中的一些特性都是用from __future__ import来实现。

模块导入

因为提到了对象名覆盖和import，所以简单讲一下。import是利用Python中各种强大库的基础，比如要计算cos(π)的值，可以有下面4种方式：

# 直接导入Python的内置基础数学库import mathprint(math.cos(math.pi))# 从math中导入cos函数和pi变量from math import cos, piprint(cos(pi))# 如果是个模块，在导入的时候可以起个别名，避免名字冲突或是方便懒得打字的人使用import math as mprint(m.cos(m.pi))# 从math中导入所有东西from math import *print(cos(pi))

一般来说最后一种方式不是很推荐，因为不知道import导入的名字里是否和现有对象名已经有冲突，很可能会不知不觉覆盖了现有的对象。

5.2.2 容器

列表

Python中的容器是异常好用且异常有用的结构。这节主要介绍列表（list），元组（tuple），字典（dict）和集合（set）。这些结构和其他语言中的类似结构并无本质不同，来看例子了解下使用：

a = [1, 2, 3, 4]b = [1]c = [1]d = be = [1, "Hello world!", c, False]print(id(b), id(c))                 # (194100040L, 194100552L)print(id(b), id(d))                 # (194100040L, 194100040L)print(b == c)                       # Truef = list("abcd")print(f)                            # ['a', 'b', 'c', 'd']g = [0]*3 + [1]*4 + [2]*2    # [0, 0, 0, 1, 1, 1, 1, 2, 2]

因为变量其实是个引用，所以对列表而言也没什么不同，所以列表对类型没什么限制。也正因为如此，和变量不同的是，即使用相同的语句赋值，列表的地址也是不同的，在这个例子中体现在id(b)和id(c)不相等，而内容相等。列表也可以用list()初始化，输入参数需要是一个可以遍历的结构，其中每一个元素会作为列表的一项。“*”操作符对于列表而言是复制，最后一个语句用这种办法生成了分段的列表。

列表的基本操作有访问，增加，删除，和拼接：

a.pop()             # 把最后一个值4从列表中移除并作为pop的返回值a.append(5)         # 末尾插入值，[1, 2, 3, 5]a.index(2)          # 找到第一个2所在的位置，也就是1a[2]                # 取下标，也就是位置在2的值，也就是第三个值3a += [4, 3, 2]      # 拼接，[1, 2, 3, 5, 4, 3, 2]a.insert(1, 0)      # 在下标为1处插入元素0，[1, 0, 2, 3, 5, 4, 3, 2]a.remove(2)         # 移除第一个2，[1, 0, 3, 5, 4, 3, 2]a.reverse()         # 倒序，a变为[2, 3, 4, 5, 3, 0, 1]a[3] = 9            # 指定下标处赋值，[2, 3, 4, 9, 3, 0, 1]b = a[2:5]          # 取下标2开始到5之前的子序列，[4, 9, 3]c = a[2:-2]         # 下标也可以倒着数，方便算不过来的人，[4, 9, 3]d = a[2:]           # 取下标2开始到结尾的子序列，[4, 9, 3, 0, 1]e = a[:5]           # 取开始到下标5之前的子序列，[2, 3, 4, 9, 3]f = a[:]            # 取从开头到最后的整个子序列，相当于值拷贝，[2, 3, 4, 9, 3, 0, 1]a[2:-2] = [1, 2, 3] # 赋值也可以按照一段来，[2, 3, 1, 2, 3, 0, 1]g = a[::-1]    # 也是倒序，通过slicing实现并赋值，效率略低于reverse()a.sort()print(a)            # 列表内排序，a变为[0, 1, 1, 2, 2, 3, 3]

因为列表是有顺序的，所以和顺序相关的操作是列表中最常见的，首先我们来打乱一个列表的顺序，然后再对这个列表排序：

import randoma = range(10)                 # 生成一个列表，从0开始+1递增到9print(a)                       # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]random.shuffle(a)             # shuffle函数可以对可遍历且可变结构打乱顺序print(a)                       # [4, 3, 8, 9, 0, 6, 2, 7, 5, 1]b = sorted(a)               print(b)                       # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]c = sorted(a, reverse=True)print(c)                       # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

元组

元组和列表有很多相似的地方，最大的区别在于不可变，还有如果初始化只包含一个元素的tuple和列表不一样，因为语法必须明确，所以必须在元素后加上逗号。另外直接用逗号分隔多个元素赋值默认是个tuple，这在函数多返回值的时候很好用：

a = (1, 2)b = tuple(['3', 4]) # 也可以从列表初始化c = (5,)print(c)            # (5,)d = (6)print(d)            # 6e = 3, 4, 5print(e)            # (3, 4, 5)

集合

集合是一种很有用的数学操作，比如列表去重，或是理清两组数据之间的关系，集合的操作符和位操作符有交集，注意不要弄混：

A = set([1, 2, 3, 4])B = {3, 4, 5, 6}C = set([1, 1, 2, 2, 2, 3, 3, 3, 3])print(C)        # 集合的去重效果，set([1, 2, 3])print(A | B)    # 求并集，set([1, 2, 3, 4, 5, 6])print(A & B)    # 求交集，set([3, 4])print(A - B)    # 求差集，属于A但不属于B的，set([1, 2])print(B - A)    # 求差集，属于B但不属于A的，set([5, 6])print(A ^ B)    # 求对称差集，相当于(A-B)|(B-A)，set([1, 2, 5, 6])

字典

字典是一种非常常见的“键-值”(key-value)映射结构，键无重复，一个键不能对应多个值，不过多个键可以指向一个值。还是通过例子来了解，构建一个名字->年龄的字典，并执行一些常见操作：

a = {'Tom': 8, 'Jerry': 7}print(a['Tom'])             # 8b = dict(Tom=8, Jerry=7)    # 一种字符串作为键更方便的初始化方式print(b['Tom'])             # 8if 'Jerry' in a:            # 判断'Jerry'是否在keys里面    print(a['Jerry'])        # 7print(a.get('Spike'))       # None，通过get获得值，即使键不存在也不会报异常a['Spike'] = 10a['Tyke'] = 3a.update({'Tuffy': 2, 'Mammy Two Shoes': 42})print(a.values())   # dict_values([8, 2, 3, 7, 10, 42])print(a.pop('Mammy Two Shoes'))     # 移除'Mammy Two Shoes'的键值对，并返回42print(a.keys())     # dict_keys(['Tom', 'Tuffy', 'Tyke', 'Jerry', 'Spike']) 

注意到初始化字典和集合很像，的确如此，集合就像是没有值只有键的字典。既然有了人名到年龄的映射，也许你立马想到是否可以给字典排序？在Python3.6之前，这个问题是错误的，字典是一种映射关系，没有顺序。当然了，如果要把(键, 值)的这种对进行排序，是没有问题的，前提是先把字典转化成可排序的结构，items()或者iteritems()可以做到这件事，接上段代码继续：

b = a.items()print(b)  # [('Tuffy', 2), ('Spike', 10), ('Tom', 8), ('Tyke', 3), ('Jerry', 7)]from operator import itemgetterc = sorted(a.items(), key=itemgetter(1))print(c)  # [('Tuffy', 2), ('Tyke', 3), ('Jerry', 7), ('Tom', 8), ('Spike', 10)]d = sorted(a.iteritems(), key=itemgetter(1))print(d)  # [('Tuffy', 2), ('Tyke', 3), ('Jerry', 7), ('Tom', 8), ('Spike', 10)]e = sorted(a)print(e)  # 只对键排序，['Jerry', 'Spike', 'Tom', 'Tuffy', 'Tyke']

items()可以把字典中的键值对转化成一个列表，其中每个元素是一个tuple，tuple的第一个元素是键，第二个元素是值。变量c是按照值排序，所以需要一个操作符itemgetter，去位置为1的元素作为排序参考，如果直接对字典排序，则其实相当于只是对键排序。字典被当作一个普通的可遍历结构使用时，都相当于遍历字典的键。如果觉得字典没有顺序不方便，可以考虑使用OrderedDict，使用方式如下：

from collections import OrderedDicta = {1: 2, 3: 4, 5: 6, 7: 8, 9: 10}b = OrderedDict({1: 2, 3: 4, 5: 6, 7: 8, 9: 10})print(a)    # {1: 2, 3: 4, 9: 10, 5: 6, 7: 8}print(b)    # OrderedDict([(1, 2), (3, 4), (9, 10), (5, 6), (7, 8)])

这样初始化时的顺序就保留了，除了有序的特性以外，用法上和字典没有区别。2016年9月，Guido宣布在Python3.6中，字典将默认有序，这样就不用纠结了。另外需要注意的一点是字典是通过哈希表实现的，所以键必须是可哈希的， list不能被哈希，所以也不能作为字典的键，而tuple就可以。

因为上上段代码中用到了iteritems()，所以这里顺带提一下迭代器（iterator），迭代器相当于一个函数，每次调用都返回下一个元素，从遍历的角度来看就和列表没有区别了。iteritems()就是一个迭代器，所以效果一样，区别是迭代器占用更少内存，因为不需要一上来就生成整个列表。一般来说，如果只需要遍历一次，用迭代器是更好的选择，若是要多次频繁从一个可遍历结构中取值，且内存够，则直接生成整个列表会更好。当然，用迭代器生成一个完整列表并不麻烦，所以有个趋势是把迭代器作为默认的可遍历方式，比如前面我们使用过用来生成等差数列列表的range()，在Python2中对应的迭代器形式是xrange()。在Python3中，range()就不再产生一个列表了，而是作为迭代器，xrange()直接没了。

5.2.3 分支和循环

从这节开始，代码就未必适合在Python终端中输入了，选个顺手的编辑器或者IDE。作者良心推荐PyCharm，虽然慢，但好用，社区版免费：

PyCharm

for循环

上面提到的4种容器类型都是可遍历的，所以该讲讲用来遍历的for循环了。for循环的语法也是简单的英语：

a = ['This', 'is', 'a', 'list', '!']b = ['This', 'is', 'a', 'tuple', '!']c = {'This': 'is', 'an': 'unordered', 'dict': '!'}# 依次输出：'This', 'is', 'a', 'list', '!'for x in a:    print(x)# 依次输出：'This', 'is', 'a', 'tuple', '!'for x in b:    print(x)# 键的遍历。不依次输出：'This', 'dict', 'an'for key in c:    print(key)# 依次输出0到9for i in range(10):    print(i)

注意到每个for循环中，print都有缩进，这是Python中一个让人爱恨交织的特点：强行缩进来表明成块的代码。这样做的好处是代码十分清晰工整，还有助于防止写出过长的函数或者过深的嵌套，坏处是有时候不知为什么tab和空格就一起出现了，又或是多重if-else不知怎得就没对齐，还是挺麻烦的。

回到for循环上，这种把每个元素拿出来的遍历方式叫做for_each风格，熟悉Java的话就不会陌生，C++11中也开始支持这种for循环方式。不过如果还是需要下标呢？比如遍历一个list的时候，希望把对应下标也打印出来，这时可以用enumerate：

names = ["Rick", "Daryl", "Glenn"]# 依次输出下标和名字for i, name in enumerate(names):    print(i, name)

需要注意的是，通过取下标遍历当然是可行的，比如用len()函数获得列表长度，然后用range()/xrange()函数获得下标，但是并不推荐这样做：

words = ["This", "is", "not", "recommended"]# not pythonic :(for i in xrange(len(words)):    print(words[i])

在使用for循环时，有时会遇到这样一种场景：我们需要对遍历的每个元素进行某种判断，如果符合这种判断的情况没有发生，则执行一个操作。举个例子某神秘部门要审核一个字符串列表，如果没有发现不和谐的字眼，则将内容放心通过，一种解决办法是下面这样：

wusuowei = ["I", "don't", "give", "a", "shit"]  # 无所谓hexie = True                                    # 默认和谐社会for x in wusuowei:    if x == "f**k":        print("What the f**k!")                 # 发现了不该出现的东西，WTF！        hexie = False                           # 不和谐了        break                                   # 赶紧停下！不能再唱了if hexie:                                       # 未发现不和谐元素！    print("Harmonious society!")                # 和谐社会！

这样需要设置一个标记是否发现不和谐因素的状态变量hexie，循环结束后再根据这个变量判断内容是否可以放心通过。一种更简洁不过有些小众的做法是直接和else一起，如果for循环中的if块内的语句没有被触发，则通过else执行指定操作：

wusuowei = ["I", "don't", "give", "a", "shit"]for x in wusuowei:    if x == "f**k":        print("What the f**k!")        hexie = False        breakelse:                            # for循环中if内语句未被触发    print("Harmonious society!") # 和谐社会！

这样不需要一个标记是否和谐的状态变量，语句简洁了很多。

if和分支结构

上一个例子中已经出现if语句了，所以这部分讲讲if。Python的条件控制主要是三个关键字：if-elif-else，其中elif就是else if的意思。还是看例子：

pets =['dog', 'cat', 'droid', 'fly']for pet in pets:    if pet == 'dog':        # 狗粮        food = 'steak'      # 牛排    elif pet == 'cat':      # 猫粮        food = 'milk'       # 牛奶    elif pet == 'droid':    # 机器人        food = 'oil'        # 机油    elif pet == 'fly':      # 苍蝇        food = 'sh*t'       #     else:        pass    print(food)

需要提一下的是pass，这就是个空语句，什么也不做，占位用。Python并没有switch-case的语法，等效的用法要么是像上面一样用if-elif-else的组合，要么可以考虑字典：

pets = ['dog', 'cat', 'droid', 'fly']food_for_pet = {    'dog': 'steak',     'cat': 'milk',     'droid': 'oil',     'fly': 'sh*t'}for pet in pets:    food = food_for_pet[pet] if pet in food_for_pet else None    print(food)

这里还用到了一个if-else常见的行内应用，就是代替三元操作符，如果键在字典中，则food取字典的对应值，否则为None。

if表达式中的小技巧

通过链式比较让语句简洁：

if -1 < x < 1:  # 相较于 if x > -1 and x < 1:    print('The absolute value of x is < 1')

判断一个值是不是等于多个可能性中的一个：

if x in ['piano', 'violin', 'drum']:    # 相较于 if x == 'piano' or x == 'violin' or x =='drum':    print("It's an instrument!")

Python中的对象都会关联一个真值，所以在if表达式中判断是否为False或者是否为空的时候，是无需写出明确的表达式的：

a = Trueif a:# 判断是否为真，相较于 a is True    print('a is True')if 'sky':# 判断是否空字符串，相较于 len('sky') > 0    print('birds')if '':# 判断是否空字符串，同上    print('Nothing!')if {}:# 判断是否空的容器(字典)，相较于len({}) > 0    print('Nothing!')

隐式表达式为False的是如下状况：

- None

- False

- 数值0

- 空的容器或序列（字符串也是一种序列）

- 用户自定义类中，如果定义了__len__()或者__nonzero__()，并且被调用后返回0或者False

while循环

while的就是循环和if的综合体，是一种单纯的基于条件的循环，本身没有遍历的意思，这是和for_each的本质差别，这种区别比起C/C++中要明确得多，用法如下：

i = 0while i < 100:  # 笑100遍    print("ha")while True:     # 一直笑    print("ha")

5.2.4 函数、生成器和类

还是从几个例子看起：

def say_hello():    print('Hello!')def greetings(x='Good morning!'):    print(x)say_hello()                 # Hello!greetings()                 # Good morning!greetings("What's up!")     # What's up!a = greetings()             # 返回值是Nonedef create_a_list(x, y=2, z=3):# 默认参数项必须放后面    return [x, y, z]b = create_a_list(1)        # [1, 2, 3]c = create_a_list(3, 3)     # [3, 3, 3]d = create_a_list(6, 7, 8)          # [6, 7, 8]def traverse_args(*args):    for arg in args:        print(arg)traverse_args(1, 2, 3)              # 依次打印1, 2, 3traverse_args('A', 'B', 'C', 'D')   # 依次打印A, B, C, Ddef traverse_kargs(**kwargs):    for k, v in kwargs.items():        print(k, v)traverse_kargs(x=3, y=4, z=5)       # 依次打印('x', 3), ('y', 4), ('z', 5)traverse_kargs(fighter1='Fedor', fighter2='Randleman')def foo(x, y, *args, **kwargs):    print(x, y)    print(args)    print(kwargs)# 第一个pring输出(1, 2)# 第二个print输出(3, 4, 5)# 第三个print输出{'a': 3, 'b': 'bar'}foo(1, 2, 3, 4, 5, a=6, b='bar')

其实和很多语言差不多，括号里面定义参数，参数可以有默认值，且默认值不能在无默认值参数之前。Python中的返回值用return定义，如果没有定义返回值，默认返回值是None。参数的定义可以非常灵活，可以有定义好的固定参数，也可以有可变长的参数(args: arguments)和关键字参数(kargs: keyword arguments)。如果要把这些参数都混用，则固定参数在最前，关键字参数在最后。

Python中万物皆对象，所以一些情况下函数也可以当成一个变量似的使用。比如前面小节中提到的用字典代替switch-case的用法，有的时候我们要执行的不是通过条件判断得到对应的变量，而是执行某个动作，比如有个小机器人在坐标(0, 0)处，我们用不同的动作控制小机器人移动：

moves = ['up', 'left', 'down', 'right']coord = [0, 0]for move in moves:    if move == 'up':        # 向上，纵坐标+1        coord[1] += 1    elif move == 'down':    # 向下，纵坐标-1        coord[1] -= 1    elif move == 'left':    # 向左，横坐标-1        coord[0] -= 1    elif move == 'right':   # 向右，横坐标+1        coord[0] += 1    else:        pass    print(coord)            # 打印当前位置坐标

不同条件下对应的是对坐标这个列表中的值的操作，单纯的从字典取值就办不到了，所以就把函数作为字典的值，然后用这个得到的值执行相应动作：

moves = ['up', 'left', 'down', 'right']def move_up(x):         # 定义向上的操作    x[1] += 1def move_down(x):       # 定义向下的操作    x[1] -= 1def move_left(x):       # 定义向左的操作    x[0] -= 1def move_right(x):      # 定义向右的操作    x[0] += 1# 动作和执行的函数关联起来，函数作为键对应的值actions = {    'up': move_up,    'down': move_down,    'left': move_left,    'right': move_right}coord = [0, 0]for move in moves:    actions[move](coord)    print(coord)

把函数作为值取到后，直接加一括号就能使了，这样做之后起码在循环部分看上去很简洁。有点C里边函数指针的意思，只不过更简单。其实这种用法在之前讲排序的时候我们已经见过了，就是operator中的itemgetter。itemgetter(1)得到的是一个可调用对象(callable object)，和返回下标为1的元素的函数用起来是一样的：

def get_val_at_pos_1(x):    return x[1]heros = [    ('Superman', 99),    ('Batman', 100),    ('Joker', 85)]sorted_pairs0 = sorted(heros, key=get_val_at_pos_1)sorted_pairs1 = sorted(heros, key=lambda x: x[1])print(sorted_pairs0)print(sorted_pairs1)

在这个例子中我们用到了一种特殊的函数：lambda表达式。Lambda表达式在Python中是一种匿名函数，lambda关键字后面跟输入参数，然后冒号后面是返回值（的表达式），比如上边例子中就是一个取下标1元素的函数。当然，还是那句话，万物皆对象，给lambda表达式取名字也是一点问题没有的：

some_ops = lambda x, y: x + y + x*y + x**ysome_ops(2, 3)  # 2 + 3 + 2*3 + 2^3 = 19

生成器（Generator）

生成器是迭代器的一种，形式上看和函数很像，只是把return换成了yield，在每次调用的时候，都会执行到yield并返回值，同时将当前状态保存，等待下次执行到yield再继续：

# 从10倒数到0def countdown(x):    while x >= 0:        yield x        x -= 1for i in countdown(10):    print(i)# 打印小于100的斐波那契数def fibonacci(n):    a = 0    b = 1    while b < n:        yield b        a, b = b, a + bfor x in fibonacci(100):    print(x)

生成器和所有可迭代结构一样，可以通过next()函数返回下一个值，如果迭代结束了则抛出StopIteration异常：

a = fibonacci(3)print(next(a))  # 1print(next(a))  # 1print(next(a))  # 2print(next(a))  # 抛出StopIteration异常

Python3.3以上可以允许yield和return同时使用，return的是异常的说明信息：

# Python3.3以上可以return返回异常的说明def another_fibonacci(n):    a = 0    b = 1    while b < n:        yield b        a, b = b, a + b    return "No more ..."a = another_fibonacci(3)print(next(a))  # 1print(next(a))  # 1print(next(a))  # 2print(next(a))  # 抛出StopIteration异常并打印No more消息

类（Class）

Python中的类的概念和其他语言相比没什么不同，比较特殊的是protected和private在Python中是没有明确限制的，一个惯例是用单下划线开头的表示protected，用双下划线开头的表示private：

class A:    """Class A"""    def __init__(self, x, y, name):        self.x = x        self.y = y        self._name = name    def introduce(self):        print(self._name)    def greeting(self):        print("What's up!")    def __l2norm(self):        return self.x**2 + self.y**2    def cal_l2norm(self):        return self.__l2norm()a = A(11, 11, 'Leonardo')print(A.__doc__)        # "Class A"a.introduce()           # "Leonardo"a.greeting()            # "What's up!"print(a._name)          # 可以正常访问print(a.cal_l2norm())   # 输出11*11+11*11=242print(a._A__l2norm())   # 仍然可以访问，只是名字不一样print(a.__l2norm())     # 报错: 'A' object has no attribute '__l2norm'

类的初始化使用的是__init__(self,)，所有成员变量都是self的，所以以self.开头。可以看到，单下划线开头的变量是可以直接访问的，而双下划线开头的变量则触发了Python中一种叫做name mangling的机制，其实就是名字变了下，仍然可以通过前边加上“_类名”的方式访问。也就是说Python中变量的访问权限都是靠自觉的。类定义中紧跟着类名字下一行的字符串叫做docstring，可以写一些用于描述类的介绍，如果有定义则通过“类名.__doc__”访问。这种前后都加双下划线访问的是特殊的变量/方法，除了__doc__和__init__还有很多，这里就不展开讲了。

Python中的继承也非常简单，最基本的继承方式就是定义类的时候把父类往括号里一放就行了：

class B(A):    """Class B inheritenced from A"""    def greeting(self):        print("How's going!")b = B(12, 12, 'Flaubert')b.introduce()   # Flaubertb.greeting()    # How's going!print(b._name())        # Flaubertprint(b._A__l2norm())   # “私有”方法，必须通过_A__l2norm访问

5.2.5 map, reduce和filter

map可以用于对可遍历结构的每个元素执行同样的操作，批量操作：

map(lambda x: x**2, [1, 2, 3, 4])                 # [1, 4, 9, 16]map(lambda x, y: x + y, [1, 2, 3], [5, 6, 7])   # [6, 8, 10]

reduce则是对可遍历结构的元素按顺序进行两个输入参数的操作，并且每次的结果保存作为下次操作的第一个输入参数，还没有遍历的元素作为第二个输入参数。这样的结果就是把一串可遍历的值，减少（reduce）成一个对象：

reduce(lambda x, y: x + y, [1, 2, 3, 4])    # ((1+2)+3)+4=10

filter顾名思义，根据条件对可遍历结构进行筛选：

filter(lambda x: x % 2, [1, 2, 3, 4, 5])    # 筛选奇数，[1, 3, 5]

需要注意的是，对于filter和map，在Python2中返回结果是列表，Python3中是生成器。

5.2.6 列表生成（list comprehension）

列表生成是Python2.0中加入的一种语法，可以非常方便地用来生成列表和迭代器，比如上节中map的两个例子和filter的一个例子可以用列表生成重写为：

[x**2 for x in [1, 2, 3, 4]]                      # [1, 4, 9 16][sum(x) for x in zip([1, 2, 3], [5, 6, 7])] # [6, 8, 10][x for x in [1, 2, 3, 4, 5] if x % 2]       # [1, 3, 5]

zip()函数可以把多个列表关联起来，这个例子中，通过zip()可以按顺序同时输出两个列表对应位置的元素对。有一点需要注意的是，zip()不会自动帮助判断两个列表是否长度一样，所以最终的结果会以短的列表为准，想要以长的列表为准的话可以考虑itertools模块中的izip_longest()。如果要生成迭代器只需要把方括号换成括号，生成字典也非常容易：

iter_odd = (x for x in [1, 2, 3, 4, 5] if x % 2)print(type(iter_odd))                       # <type 'generator'>square_dict = {x: x**2 for x in range(5)}   # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

至于列表生成和map/filter应该优先用哪种，这个问题很难回答，不过Python创始人Guido似乎不喜欢map/filter/reduce，他曾在表示过一些从函数式编程里拿来的特性是个错误。

5.2.7 字符串

Python中字符串相关的处理都非常方便，来看例子：

a = 'Life is short, you need Python'a.lower()              # 'life is short, you need Python'a.upper()               # 'LIFE IS SHORT, YOU NEED PYTHON'a.count('i')            # 2a.find('e')             # 从左向右查找'e'，3a.rfind('need')         # 从右向左查找'need'，19a.replace('you', 'I')   # 'Life is short, I need Python'tokens = a.split()    # ['Life', 'is', 'short,', 'you', 'need', 'Python']b = ' '.join(tokens)# 用指定分隔符按顺序把字符串列表组合成新字符串c = a + '\n'            # 加了换行符，注意+用法是字符串作为序列的用法c.rstrip()              # 右侧去除换行符[x for x in a]          # 遍历每个字符并生成由所有字符按顺序构成的列表'Python' in a   # True

Python2.6中引入了format进行字符串格式化，相比在字符串中用%的类似C的方式，更加强大方便：

a = 'I’m like a {} chasing {}.'# 按顺序格式化字符串，'I’m like a dog chasing cars.'a.format('dog', 'cars')# 在大括号中指定参数所在位置b = 'I prefer {1} {0} to {2} {0}'b.format('food', 'Chinese', 'American')# >代表右对齐，>前是要填充的字符，依次输出：# 000001# 000019# 000256for i in [1, 19, 256]:    print('The index is {:0>6d}'.format(i))# <代表左对齐，依次输出：# *---------# ****------# *******---for x in ['*', '****', '*******']:    progress_bar = '{:-<10}'.format(x)    print(progress_bar)for x in [0.0001, 1e17, 3e-18]:    print('{:.6f}'.format(x))   # 按照小数点后6位的浮点数格式    print('{:.1e}'.format(x))   # 按照小数点后1位的科学记数法格式    print ('{:g}'.format(x))    # 系统自动选择最合适的格式template = '{name} is {age} years old.'c = template.format(name='Tom', age=8)) # Tom is 8 years old.d = template.format(age=7, name='Jerry')# Jerry is 7 years old.

format在生成字符串和文档的时候非常有用，更多更详细的用法可以参考Python官网：

7.1. string - Common string operations - Python 2.7.13 documentation

5.2.8 文件操作和pickle

在Python中，推荐用上下文管理器（with-as）来打开文件，IO资源的管理更加安全，而且不用老惦记着给文件执行close()函数。还是举例子来说明，考虑有个文件name_age.txt，里面存储着名字和年龄的关系，格式如下：

Tom,8Jerry,7Tyke,3...

读取文件内容并全部显示：

with open('name_age.txt', 'r') as f: # 打开文件，读取模式    lines = f.readlines()              # 一次读取所有行    for line in lines:                  # 按行格式化并显示信息        name, age = line.rstrip().split(',')        print('{} is {} years old.'.format(name, age))

open()的第一个参数是文件名，第二个参数是模式。文件的模式一般有四种，读取(r)，写入(w)，追加(a)和读写(r+)。如果希望按照二进制数据读取，则将文件模式和b一起使用（wb, r+b…）。

再考虑一个场景，要读取文件内容，并把年龄和名字的顺序交换存成新文件age_name.txt，这时可以同时打开两个文件：

with open('name_age.txt', 'r') as fread, open('age_name.txt', 'w') as fwrite:    line = fread.readline()    while line:        name, age = line.rstrip().split(',')        fwrite.write('{},{}\n'.format(age, name))        line = fread.readline()

有的时候我们进行文件操作是希望把对象进行序列化，那么可以考虑用pickle模块：

import picklelines = [    "I'm like a dog chasing cars.",    "I wouldn't know what to do if I caught one...",    "I'd just do things."]with open('lines.pkl', 'wb') as f: # 序列化并保存成文件    pickle.dump(lines, f)with open('lines.pkl', 'rb') as f: # 从文件读取并反序列化    lines_back = pickle.load(f)print(lines_back)                   # 和lines一样

注意到，序列化的时候就得使用b模式了。Python2中有个效率更高的pickle叫cPickle，用法和pickle一样，在Python3中就只有一个pickle。

5.2.9 异常

相比起其他一些语言，在Python中我们可以更大胆地使用异常，因为异常在Python中是非常常见的存在，比如下面这种简单的遍历：

a = ['Why', 'so', 'serious', '?']for x in a:    print(x)

当用for进行遍历时，会对要遍历的对象调用iter()。这需要给对象创建一个迭代器用来依次返回对象中的内容。为了能成功调用iter()，该对象要么得支持迭代协议(定义__iter__())，要么得支持序列协议(定义__getitem__())。当遍历结束时，__iter__()或者__getitem__()都需要抛出一个异常。__iter__()会抛出StopIteration，而__getitem__()会抛出IndexError，于是遍历就会停止。

在深度学习中，尤其是数据准备阶段，常常遇到IO操作。这时候遇到异常的可能性很高，采用异常处理可以保证数据处理的过程不被中断，并对有异常的情况进行记录或其他动作：

for filepath in filelist:   # filelist中是文件路径的列表    try:        with open(filepath, 'r') as f:            # 执行数据处理的相关工作            ...                print('{} is processed!'.format(filepath))    except IOError:        print('{} with IOError!'.format(filepath))        # 异常的相应处理        ...

5.2.10 多进程（multiprocessing）

深度学习中对数据高效处理常常会需要并行，这时多进程就派上了用场。考虑这样一个场景，在数据准备阶段，有很多文件需要运行一定的预处理，正好有台多核服务器，我们希望把这些文件分成32份，并行处理：

from multiprocessing import Process#, freeze_supportdef process_data(filelist):    for filepath in filelist:        print('Processing {} ...'.format(filepath))        # 处理数据        ...if __name__ == '__main__':    # 如果是在Windows下，还需要加上freeze_support()    #freeze_support()        # full_list包含了要处理的全部文件列表    ...    n_total = len(full_list) # 一个远大于32的数    n_processes = 32    # 每段子列表的平均长度    length = float(n_total) / float(n_processes)        # 计算下标，尽可能均匀地划分输入文件列表    indices = [int(round(i*length)) for i in range(n_processes+1)]        # 生成每个进程要处理的子文件列表    sublists = [full_list[indices[i]:indices[i+1]] for i in range(n_processes)]        # 生成进程    processes = [Process(target=process_data, args=(x,)) for x in sublists]    # 并行处理    for p in processes:        p.start()    for p in processes:        p.join()

其中if __name__ == '__main__'用来标明在import时不包含，但是作为文件执行时运行的语句块。为什么不用多线程呢？简单说就是Python中线程的并发无法有效利用多核，如果有兴趣的读者可以从下面这个链接看起：

GlobalInterpreterLock - Python Wiki

5.2.11 os模块

深度学习中的数据多是文件，所以数据处理阶段和文件相关的操作就非常重要。除了文件IO，Python中一些操作系统的相关功能也能够非常方便地帮助数据处理。想象一下我们有一个文件夹叫做data，下边有3个子文件夹叫做cat，dog和bat，里面分别是猫，狗和蝙蝠的照片。为了训练一个三分类模型，我们先要生成一个文件，里面每一行是文件的路径和对应的标签。定义cat是0，dog是1，bat是2，则可以通过如下脚本：

import os# 定义文件夹名称和标签的对应关系label_map = {    'cat': 0,    'dog': 1,    'bat': 2}with open('data.txt', 'w') as f:    # 遍历所有文件，root为当前文件夹，dirs是所有子文件夹名，files是所有文件名    for root, dirs, files in os.walk('data'):        for filename in files:            filepath = os.sep.join([root, filename])   # 获得文件完整路径            dirname = root.split(os.sep)[-1]            # 获取当前文件夹名称            label = label_map[dirname]                  # 得到标签            line = '{},{}\n'.format(filepath, label)            f.write(line)

其中，os.sep是当前操作系统的路径分隔符，在Unix/Linux中是'/'，Windows中是'\\'。有的时候我们已经有了所有的文件在一个文件夹data下，希望获取所有文件的名称，则可以用os.listdir():

filenames = os.listdir('data')

os也提供了诸如拷贝，移动和修改文件名等操作。同时因为大部分深度学习框架最常见的都是在Unix/Linux下使用，并且Unix/Linux的shell已经非常强大（比Windows好用太多），所以只需要用字符串格式化等方式生成shell命令的字符串，然后通过os.system()就能方便实现很多功能，有时比os，还有Python中另一个操作系统相关模块shutil还要方便：

import os, shutilfilepath0 = 'data/bat/IMG_000001.jpg'filepath1 = 'data/bat/IMG_000000.jpg'# 修改文件名os.system('mv {} {}'.format(filepath0, filepath1))#os.rename(filepath0, filepath1)# 创建文件夹dirname = 'data_samples'os.system('mkdir -p {}'.format(dirname))#if not os.path.exists(dirname):#    os.mkdir(dirname)# 拷贝文件os.system('cp {} {}'.format(filepath1, dirname))#shutil.copy(filepath1, dirname)
5.3 Python的科学计算包 - Numpy
numpy(Numerical Python extensions)是一个第三方的Python包，用于科学计算。这个库的前身是1995年就开始开发的一个用于数组运算的库。经过了长时间的发展，基本上成了绝大部分Python科学计算的基础包，当然也包括所有提供Python接口的深度学习框架。
numpy在Linux下的安装已经在5.1.2中作为例子讲过，Windows下也可以通过pip，或者到下面网址下载：
Obtaining NumPy & SciPy libraries
5.3.1 基本类型（array）
array，也就是数组，是numpy中最基础的数据结构，最关键的属性是维度和元素类型，在numpy中，可以非常方便地创建各种不同类型的多维数组，并且执行一些基本基本操作，来看例子：
import numpy as npa = [1, 2, 3, 4]     #b = np.array(a)         # array([1, 2, 3, 4])type(b)                   # <type 'numpy.ndarray'>b.shape                   # (4,)b.argmax()               # 3b.max()                   # 4b.mean()                  # 2.5c = [[1, 2], [3, 4]]  # 二维列表d = np.array(c)         # 二维numpy数组d.shape                   # (2, 2)d.size                   # 4d.max(axis=0)            # 找维度0，也就是最后一个维度上的最大值，array([3, 4])d.max(axis=1)            # 找维度1，也就是倒数第二个维度上的最大值，array([2, 4])d.mean(axis=0)          # 找维度0，也就是第一个维度上的均值，array([ 2.,  3.])d.flatten()              # 展开一个numpy数组为1维数组，array([1, 2, 3, 4])np.ravel(c)               # 展开一个可以解析的结构为1维数组，array([1, 2, 3, 4])# 3x3的浮点型2维数组，并且初始化所有元素值为1e = np.ones((3, 3), dtype=np.float)# 创建一个一维数组，元素值是把3重复4次，array([3, 3, 3, 3])f = np.repeat(3, 4)# 2x2x3的无符号8位整型3维数组，并且初始化所有元素值为0g = np.zeros((2, 2, 3), dtype=np.uint8)g.shape                    # (2, 2, 3)h = g.astype(np.float)  # 用另一种类型表示l = np.arange(10)      # 类似range，array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])m = np.linspace(0, 6, 5)# 等差数列，0到6之间5个取值，array([ 0., 1.5, 3., 4.5, 6.])p = np.array(    [[1, 2, 3, 4],     [5, 6, 7, 8]])np.save('p.npy', p)     # 保存到文件q = np.load('p.npy')    # 从文件读取
注意到在导入numpy的时候，我们将np作为numpy的别名。这是一种习惯性的用法，后面的章节中我们也默认这么使用。作为一种多维数组结构，array的数组相关操作是非常丰富的：
import numpy as np'''array([[[ 0,  1,  2,  3],        [ 4,  5,  6,  7],        [ 8,  9, 10, 11]],       [[12, 13, 14, 15],        [16, 17, 18, 19],        [20, 21, 22, 23]]])'''a = np.arange(24).reshape((2, 3, 4))b = a[1][1][1]  # 17'''array([[ 8,  9, 10, 11],       [20, 21, 22, 23]])'''c = a[:, 2, :]''' 用:表示当前维度上所有下标array([[ 1,  5,  9],       [13, 17, 21]])'''d = a[:, :, 1]''' 用...表示没有明确指出的维度array([[ 1,  5,  9],       [13, 17, 21]])'''e = a[..., 1]'''array([[[ 5,  6],        [ 9, 10]],       [[17, 18],        [21, 22]]])'''f = a[:, 1:, 1:-1]'''平均分成3份[array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8])]'''g = np.split(np.arange(9), 3)'''按照下标位置进行划分[array([0, 1]), array([2, 3, 4, 5]), array([6, 7, 8])]'''h = np.split(np.arange(9), [2, -3])l0 = np.arange(6).reshape((2, 3))l1 = np.arange(6, 12).reshape((2, 3))'''vstack是指沿着纵轴拼接两个array，verticalhstack是指沿着横轴拼接两个array，horizontal更广义的拼接用concatenate实现，horizontal后的两句依次等效于vstack和hstackstack不是拼接而是在输入array的基础上增加一个新的维度'''m = np.vstack((l0, l1))p = np.hstack((l0, l1))q = np.concatenate((l0, l1))r = np.concatenate((l0, l1), axis=-1)s = np.stack((l0, l1))'''按指定轴进行转置array([[[ 0,  3],        [ 6,  9]],       [[ 1,  4],        [ 7, 10]],       [[ 2,  5],        [ 8, 11]]])'''t = s.transpose((2, 0, 1))'''默认转置将维度倒序，对于2维就是横纵轴互换array([[ 0,  4,  8],       [ 1,  5,  9],       [ 2,  6, 10],       [ 3,  7, 11]])'''u = a[0].transpose()# 或者u=a[0].T也是获得转置'''逆时针旋转90度，第二个参数是旋转次数array([[ 3,  2,  1,  0],       [ 7,  6,  5,  4],       [11, 10,  9,  8]])'''v = np.rot90(u, 3)'''沿纵轴左右翻转array([[ 8,  4,  0],       [ 9,  5,  1],       [10,  6,  2],       [11,  7,  3]])'''w = np.fliplr(u)'''沿水平轴上下翻转array([[ 3,  7, 11],       [ 2,  6, 10],       [ 1,  5,  9],       [ 0,  4,  8]])'''x = np.flipud(u)'''按照一维顺序滚动位移array([[11,  0,  4],       [ 8,  1,  5],       [ 9,  2,  6],       [10,  3,  7]])'''y = np.roll(u, 1)'''按照指定轴滚动位移array([[ 8,  0,  4],       [ 9,  1,  5],       [10,  2,  6],       [11,  3,  7]])'''z = np.roll(u, 1, axis=1)
对于一维的array所有Python列表支持的下标相关的方法array也都支持，所以在此没有特别列出。
既然叫numerical python，基础数学运算也是强大的：
import numpy as np# 绝对值，1a = np.abs(-1)# sin函数，1.0b = np.sin(np.pi/2)# tanh逆函数，0.50000107157840523c = np.arctanh(0.462118)# e为底的指数函数，20.085536923187668d = np.exp(3)# 2的3次方，8f = np.power(2, 3)# 点积，1*3+2*4=11g = np.dot([1, 2], [3, 4])# 开方，5h = np.sqrt(25)# 求和，10l = np.sum([1, 2, 3, 4])# 平均值，5.5m = np.mean([4, 5, 6, 7])# 标准差，0.96824583655185426p = np.std([1, 2, 3, 2, 1, 3, 2, 0])
对于array，默认执行对位运算。涉及到多个array的对位运算需要array的维度一致，如果一个array的维度和另一个array的子维度一致，则在没有对齐的维度上分别执行对位运算，这种机制叫做广播（broadcasting），言语解释比较难，还是看例子理解：
import numpy as npa = np.array([    [1, 2, 3],    [4, 5, 6]])b = np.array([    [1, 2, 3],    [1, 2, 3]])'''维度一样的array，对位计算array([[2, 4, 6],       [5, 7, 9]])'''a + b'''array([[0, 0, 0],       [3, 3, 3]])'''a - b'''array([[ 1,  4,  9],       [ 4, 10, 18]])'''a * b'''array([[1, 1, 1],       [4, 2, 2]])'''a / b'''array([[ 1,  4,  9],       [16, 25, 36]])'''a ** 2'''array([[  1,   4,  27],       [  4,  25, 216]])'''a ** bc = np.array([    [1, 2, 3],    [4, 5, 6],    [7, 8, 9],    [10, 11, 12]])d = np.array([2, 2, 2])'''广播机制让计算的表达式保持简洁d和c的每一行分别进行运算array([[ 3,  4,  5],       [ 6,  7,  8],       [ 9, 10, 11],       [12, 13, 14]])'''c + d'''array([[ 2,  4,  6],       [ 8, 10, 12],       [14, 16, 18],       [20, 22, 24]])'''c * d'''1和c的每个元素分别进行运算array([[ 0,  1,  2],       [ 3,  4,  5],       [ 6,  7,  8],       [ 9, 10, 11]])'''c - 1
5.3.2 线性代数模块（linalg）
在深度学习相关的数据处理和运算中，线性代数模块（linalg）是最常用的之一。结合numpy提供的基本函数，可以对向量，矩阵，或是说多维张量进行一些基本的运算：
import numpy as npa = np.array([3, 4])np.linalg.norm(a)b = np.array([    [1, 2, 3],    [4, 5, 6],    [7, 8, 9]])c = np.array([1, 0, 1])# 矩阵和向量之间的乘法np.dot(b, c)            # array([ 4, 10, 16])np.dot(c, b.T)          # array([ 4, 10, 16])np.trace(b)             # 求矩阵的迹，15np.linalg.det(b)        # 求矩阵的行列式值，0np.linalg.matrix_rank(b)# 求矩阵的秩，2，不满秩，因为行与行之间等差d = np.array([    [2, 1],    [1, 2]])'''对正定矩阵求本征值和本征向量本征值为u，array([ 3.,  1.])本征向量构成的二维array为v，array([[ 0.70710678, -0.70710678],       [ 0.70710678,  0.70710678]])是沿着45°方向eig()是一般情况的本征值分解，对于更常见的对称实数矩阵，eigh()更快且更稳定，不过输出的值的顺序和eig()是相反的'''u, v = np.linalg.eig(d)# Cholesky分解并重建l = np.linalg.cholesky(d)'''array([[ 2.,  1.],       [ 1.,  2.]])'''np.dot(l, l.T)e = np.array([    [1, 2],    [3, 4]])# 对不镇定矩阵，进行SVD分解并重建U, s, V = np.linalg.svd(e)S = np.array([    [s[0], 0],    [0, s[1]]])'''array([[ 1.,  2.],       [ 3.,  4.]])'''np.dot(U, np.dot(S, V))
5.3.3 随机模块（random）
随机模块包含了随机数产生和统计分布相关的基本函数，Python本身也有随机模块random，不过功能更丰富，还是来看例子：
import numpy as npimport numpy.random as random# 设置随机数种子random.seed(42)# 产生一个1x3，[0,1)之间的浮点型随机数# array([[ 0.37454012,  0.95071431,  0.73199394]])# 后面的例子就不在注释中给出具体结果了random.rand(1, 3)# 产生一个[0,1)之间的浮点型随机数random.random()# 下边4个没有区别，都是按照指定大小产生[0,1)之间的浮点型随机数array，不Pythonic…random.random((3, 3))random.sample((3, 3))random.random_sample((3, 3))random.ranf((3, 3))# 产生10个[1,6)之间的浮点型随机数5*random.random(10) + 1random.uniform(1, 6, 10)# 产生10个[1,6]之间的整型随机数random.randint(1, 6, 10)# 产生2x5的标准正态分布样本random.normal(size=(5, 2))# 产生5个，n=5，p=0.5的二项分布样本random.binomial(n=5, p=0.5, size=5)a = np.arange(10)# 从a中有回放的随机采样7个random.choice(a, 7)# 从a中无回放的随机采样7个random.choice(a, 7, replace=False)# 对a进行乱序并返回一个新的arrayb = random.permutation(a)# 对a进行in-place乱序random.shuffle(a)# 生成一个长度为9的随机bytes序列并作为str返回# '\x96\x9d\xd1?\xe6\x18\xbb\x9a\xec'random.bytes(9)
随机模块可以很方便地让我们做一些快速模拟去验证一些结论。比如来考虑一个非常违反直觉的概率题例子：一个选手去参加一个TV秀，有三扇门，其中一扇门后有奖品，这扇门只有主持人知道。选手先随机选一扇门，但并不打开，主持人看到后，会打开其余两扇门中没有奖品的一扇门。然后，主持人问选手，是否要改变一开始的选择？
这个问题的答案是应该改变一开始的选择。在第一次选择的时候，选错的概率是2/3，选对的概率是1/3。第一次选择之后，主持人相当于帮忙剔除了一个错误答案，所以如果一开始选的是错的，这时候换掉就选对了；而如果一开始就选对，则这时候换掉就错了。根据以上，一开始选错的概率就是换掉之后选对的概率（2/3），这个概率大于一开始就选对的概率（1/3），所以应该换。虽然道理上是这样，但是还是有些绕，要是通过推理就是搞不明白怎么办，没关系，用随机模拟就可以轻松得到答案：
import numpy.random as randomrandom.seed(42)# 做10000次实验n_tests = 10000# 生成每次实验的奖品所在的门的编号# 0表示第一扇门，1表示第二扇门，2表示第三扇门winning_doors = random.randint(0, 3, n_tests)# 记录如果换门的中奖次数change_mind_wins = 0# 记录如果坚持的中奖次数insist_wins = 0# winning_door就是获胜门的编号for winning_door in winning_doors:    # 随机挑了一扇门    first_try = random.randint(0, 3)        # 其他门的编号    remaining_choices = [i for i in range(3) if i != first_try]      # 没有奖品的门的编号，这个信息只有主持人知道    wrong_choices = [i for i in range(3) if i != winning_door]    # 一开始选择的门主持人没法打开，所以从主持人可以打开的门中剔除    if first_try in wrong_choices:        wrong_choices.remove(first_try)        # 这时wrong_choices变量就是主持人可以打开的门的编号    # 注意此时如果一开始选择正确，则可以打开的门是两扇，主持人随便开一扇门    # 如果一开始选到了空门，则主持人只能打开剩下一扇空门    screened_out = random.choice(wrong_choices)    remaining_choices.remove(screened_out)        # 所以虽然代码写了好些行，如果策略固定的话，    # 改变主意的获胜概率就是一开始选错的概率，是2/3    # 而坚持选择的获胜概率就是一开始就选对的概率，是1/3        # 现在除了一开始选择的编号，和主持人帮助剔除的错误编号，只剩下一扇门    # 如果要改变注意则这扇门就是最终的选择    changed_mind_try = remaining_choices[0]    # 结果揭晓，记录下来    change_mind_wins += 1 if changed_mind_try == winning_door else 0    insist_wins += 1 if first_try == winning_door else 0# 输出10000次测试的最终结果，和推导的结果差不多：# You win 6616 out of 10000 tests if you changed your mind# You win 3384 out of 10000 tests if you insist on the initial choiceprint(    'You win {1} out of {0} tests if you changed your mind\n'    'You win {2} out of {0} tests if you insist on the initial choice'.format(        n_tests, change_mind_wins, insist_wins        ))
5.4 Python的可视化包 – Matplotlib
Matplotlib是Python中最常用的可视化工具之一，可以非常方便地创建海量类型地2D图表和一些基本的3D图表。Matplotlib最早是为了可视化癫痫病人的脑皮层电图相关的信号而研发，因为在函数的设计上参考了MATLAB，所以叫做Matplotlib。Matplotlib首次发表于2007年，在开源和社区的推动下，现在在基于Python的各个科学计算领域都得到了广泛应用。Matplotlib的原作者John D. Hunter博士是一名神经生物学家，2012年不幸因癌症去世，感谢他创建了这样一个伟大的库。
安装Matplotlib的方式和numpy很像，可以直接通过Unix/Linux的软件管理工具，比如Ubuntu 16.04 LTS下，输入：
>> sudo apt install python-matplotlib
或者通过pip安装：
>> pip install matplotlib
Windows下也可以通过pip，或是到官网下载：
python plotting - Matplotlib 1.5.3 documentation
Matplotlib非常强大，不过在深度学习中常用的其实只有很基础的一些功能，这节主要介绍2D图表，3D图表和图像显示。
5.4.1 2D图表
Matplotlib中最基础的模块是pyplot。先从最简单的点图和线图开始，比如我们有一组数据，还有一个拟合模型，通过下面的代码图来可视化：
import numpy as npimport matplotlib as mplimport matplotlib.pyplot as plt# 通过rcParams设置全局横纵轴字体大小mpl.rcParams['xtick.labelsize'] = 24mpl.rcParams['ytick.labelsize'] = 24np.random.seed(42)# x轴的采样点x = np.linspace(0, 5, 100)# 通过下面曲线加上噪声生成数据，所以拟合模型就用y了……y = 2*np.sin(x) + 0.3*x**2y_data = y + np.random.normal(scale=0.3, size=100)# figure()指定图表名称plt.figure('data')# '.'标明画散点图，每个散点的形状是个圆plt.plot(x, y_data, '.')# 画模型的图，plot函数默认画连线图plt.figure('model')plt.plot(x, y)# 两个图画一起plt.figure('data & model')# 通过'k'指定线的颜色，lw指定线的宽度# 第三个参数除了颜色也可以指定线形，比如'r--'表示红色虚线# 更多属性可以参考官网：http://matplotlib.org/api/pyplot_api.htmlplt.plot(x, y, 'k', lw=3)# scatter可以更容易地生成散点图plt.scatter(x, y_data)# 将当前figure的图保存到文件result.pngplt.savefig('result.png')# 一定要加上这句才能让画好的图显示在屏幕上plt.show()
matplotlib和pyplot的惯用别名分别是mpl和plt，上面代码生成的图像如下：
基本的画图方法就是这么简单，如果想了解更多pyplot的属性和方法来画出风格多样的图像，可以参考官网：
pyplot - Matplotlib 1.5.3 documentation
Customizing matplotlib
点和线图表只是最基本的用法，有的时候我们获取了分组数据要做对比，柱状或饼状类型的图或许更合适：
import numpy as npimport matplotlib as mplimport matplotlib.pyplot as pltmpl.rcParams['axes.titlesize'] = 20mpl.rcParams['xtick.labelsize'] = 16mpl.rcParams['ytick.labelsize'] = 16mpl.rcParams['axes.labelsize'] = 16mpl.rcParams['xtick.major.size'] = 0mpl.rcParams['ytick.major.size'] = 0# 包含了狗，猫和猎豹的最高奔跑速度，还有对应的可视化颜色speed_map = {    'dog': (48, '#7199cf'),    'cat': (45, '#4fc4aa'),    'cheetah': (120, '#e1a7a2')}# 整体图的标题fig = plt.figure('Bar chart & Pie chart')# 在整张图上加入一个子图，121的意思是在一个1行2列的子图中的第一张ax = fig.add_subplot(121)ax.set_title('Running speed - bar chart')# 生成x轴每个元素的位置xticks = np.arange(3)# 定义柱状图每个柱的宽度bar_width = 0.5# 动物名称animals = speed_map.keys()# 奔跑速度speeds = [x[0] for x in speed_map.values()]# 对应颜色colors = [x[1] for x in speed_map.values()]# 画柱状图，横轴是动物标签的位置，纵轴是速度，定义柱的宽度，同时设置柱的边缘为透明bars = ax.bar(xticks, speeds, width=bar_width, edgecolor='none')# 设置y轴的标题ax.set_ylabel('Speed(km/h)')# x轴每个标签的具体位置，设置为每个柱的中央ax.set_xticks(xticks+bar_width/2)# 设置每个标签的名字ax.set_xticklabels(animals)# 设置x轴的范围ax.set_xlim([bar_width/2-0.5, 3-bar_width/2])# 设置y轴的范围ax.set_ylim([0, 125])# 给每个bar分配指定的颜色for bar, color in zip(bars, colors):    bar.set_color(color)# 在122位置加入新的图ax = fig.add_subplot(122)ax.set_title('Running speed - pie chart')# 生成同时包含名称和速度的标签labels = ['{}\n{} km/h'.format(animal, speed) for animal, speed in zip(animals, speeds)]# 画饼状图，并指定标签和对应颜色ax.pie(speeds, labels=labels, colors=colors)plt.show()
在这段代码中又出现了一个新的东西叫做，一个用ax命名的对象。在Matplotlib中，画图时有两个常用概念，一个是平时画图蹦出的一个窗口，这叫一个figure。Figure相当于一个大的画布，在每个figure中，又可以存在多个子图，这种子图叫做axes。顾名思义，有了横纵轴就是一幅简单的图表。在上面代码中，先把figure定义成了一个一行两列的大画布，然后通过fig.add_subplot()加入两个新的子图。subplot的定义格式很有趣，数字的前两位分别定义行数和列数，最后一位定义新加入子图的所处顺序，当然想写明确些也没问题，用逗号分开即可。。上面这段代码产生的图像如下：
5.3.1 3D图表
Matplotlib中也能支持一些基础的3D图表，比如曲面图，散点图和柱状图。这些3D图表需要使用mpl_toolkits模块，先来看一个简单的曲面图的例子：
import matplotlib.pyplot as pltimport numpy as np# 3D图标必须的模块，project='3d'的定义from mpl_toolkits.mplot3d import Axes3D     np.random.seed(42)n_grids = 51        # x-y平面的格点数 c = n_grids / 2     # 中心位置nf = 2              # 低频成分的个数# 生成格点x = np.linspace(0, 1, n_grids)y = np.linspace(0, 1, n_grids)# x和y是长度为n_grids的array# meshgrid会把x和y组合成n_grids*n_grids的array，X和Y对应位置就是所有格点的坐标X, Y = np.meshgrid(x, y)# 生成一个0值的傅里叶谱spectrum = np.zeros((n_grids, n_grids), dtype=np.complex)# 生成一段噪音，长度是(2*nf+1)**2/2noise = [np.complex(x, y) for x, y in np.random.uniform(-1,1,((2*nf+1)**2/2, 2))]# 傅里叶频谱的每一项和其共轭关于中心对称noisy_block = np.concatenate((noise, [0j], np.conjugate(noise[::-1])))# 将生成的频谱作为低频成分spectrum[c-nf:c+nf+1, c-nf:c+nf+1] = noisy_block.reshape((2*nf+1, 2*nf+1))# 进行反傅里叶变换Z = np.real(np.fft.ifft2(np.fft.ifftshift(spectrum)))# 创建图表fig = plt.figure('3D surface & wire')# 第一个子图，surface图ax = fig.add_subplot(1, 2, 1, projection='3d')# alpha定义透明度，cmap是color map# rstride和cstride是两个方向上的采样，越小越精细，lw是线宽ax.plot_surface(X, Y, Z, alpha=0.7, cmap='jet', rstride=1, cstride=1, lw=0)# 第二个子图，网线图ax = fig.add_subplot(1, 2, 2, projection='3d')ax.plot_wireframe(X, Y, Z, rstride=3, cstride=3, lw=0.5)plt.show()
这个例子中先生成一个所有值均为0的复数array作为初始频谱，然后把频谱中央部分用随机生成，但同时共轭关于中心对称的子矩阵进行填充。这相当于只有低频成分的一个随机频谱。最后进行反傅里叶变换就得到一个随机波动的曲面，图像如下：
3D的散点图也是常常用来查看空间样本分布的一种手段，并且画起来比表面图和网线图更加简单，来看例子：
import matplotlib.pyplot as pltimport numpy as npfrom mpl_toolkits.mplot3d import Axes3Dnp.random.seed(42)# 采样个数500n_samples = 500dim = 3# 先生成一组3维正态分布数据，数据方向完全随机samples = np.random.multivariate_normal(    np.zeros(dim),    np.eye(dim),    n_samples)# 通过把每个样本到原点距离和均匀分布吻合得到球体内均匀分布的样本for i in range(samples.shape[0]):    r = np.power(np.random.random(), 1.0/3.0)    samples[i] *= r / np.linalg.norm(samples[i])upper_samples = []lower_samples = []for x, y, z in samples:    # 3x+2y-z=1作为判别平面    if z > 3*x + 2*y - 1:        upper_samples.append((x, y, z))    else:        lower_samples.append((x, y, z))fig = plt.figure('3D scatter plot')ax = fig.add_subplot(111, projection='3d')uppers = np.array(upper_samples)lowers = np.array(lower_samples)# 用不同颜色不同形状的图标表示平面上下的样本# 判别平面上半部分为红色圆点，下半部分为绿色三角ax.scatter(uppers[:, 0], uppers[:, 1], uppers[:, 2], c='r', marker='o')ax.scatter(lowers[:, 0], lowers[:, 1], lowers[:, 2], c='g', marker='^')plt.show()
这个例子中，为了方便，直接先采样了一堆3维的正态分布样本，保证方向上的均匀性。然后归一化，让每个样本到原点的距离为1，相当于得到了一个均匀分布在球面上的样本。再接着把每个样本都乘上一个均匀分布随机数的开3次方，这样就得到了在球体内均匀分布的样本，最后根据判别平面3x+2y-z-1=0对平面两侧样本用不同的形状和颜色画出，图像如下：
5.3.1 图像显示
Matplotlib也支持图像的存取和显示，并且和OpenCV一类的接口比起来，对于一般的二维矩阵的可视化要方便很多，来看例子：
import matplotlib.pyplot as plt# 读取一张小白狗的照片并显示plt.figure('A Little White Dog')little_dog_img = plt.imread('little_white_dog.jpg')plt.imshow(little_dog_img)# Z是上小节生成的随机图案，img0就是Z，img1是Z做了个简单的变换img0 = Zimg1 = 3*Z + 4# cmap指定为'gray'用来显示灰度图fig = plt.figure('Auto Normalized Visualization')ax0 = fig.add_subplot(121)ax0.imshow(img0, cmap='gray')ax1 = fig.add_subplot(122)ax1.imshow(img1, cmap='gray')plt.show()
这段代码中第一个例子是读取一个本地图片并显示，第二个例子中直接把上小节中反傅里叶变换生成的矩阵作为图像拿过来，原图和经过乘以3再加4变换的图直接绘制了两个形状一样，但是值的范围不一样的图案。显示的时候imshow会自动进行归一化，把最亮的值显示为纯白，最暗的值显示为纯黑。这是一种非常方便的设定，尤其是查看深度学习中某个卷积层的响应图时。得到图像如下：