Python Numpy学习教程
Author: Justin Johnson
Interpreter：Amusi
Date: 2018-03-24
Reference:
[1]：http://cs231n.github.io/python-numpy-tutorial/
[2]：https://github.com/kuleshov/cs228-material/blob/master/tutorials/python/cs228-python-tutorial.ipynb
注：Amusi是一名Python初学者，本教程是对CS231n课程中的python-numpy-tutorial进行翻译、注释并做部分修改攥写而来的。若文章存在翻译错误或者语法问题，还请及时指出。
Python Numpy学习教程目录
Python
- 基本数据结构
- 容器
- 列表
- 字典
- 集合
- 元组
- 函数
- 类
Numpy
- 数组
- 数组索引
- 数据类型
- 数组数学（Array math）
- 广播
SciPy
- 图像处理
- MATLAB文件
- 点之间的距离
Matplotlib
- 绘制
- 子图
- 图像
Python Numpy教程将分四篇内容来介绍：
- Python篇、
- Numpy篇
- SciPy篇
- Matplotlib篇
本文只介绍（一）Python篇的内容
Python
Python是一种高级动态类型的多参数编程语言。Python代码经常被认为和伪代码(pseudocode)一样，因为它允许你在非常少的几行代码中表达非常强大的想法，同时可读性很高。举个例子，下面是Python中经典的快速排序算法的实现：
# quicksort
def quicksort(arr):
if len(arr) <=1:
return arr
pivot = arr[len(arr) // 2]
left = [x for x in arr if x < pivot]
middle = [x for x in arr if x == pivot]
right = [x for x in arr if x > pivot]
return quicksort(left) + middle + quicksort(right)
print(quicksort([3,6,8,10,1,2,1]))
# output: [1, 1, 2, 3, 6, 8, 10]Python版本
目前有两种不同的Python支持版本，2.7和3.5（截至2018-02-07，还有3.6）。 令人有些困惑的是，Python3.5引入许多向后不兼容的语言变化，因此用2.7编写的代码可能不能在3.5下工作，反之亦然。针对这个原因和趋势（官方通知Python2.7版本将在2020停止维护），本教程所有代码都将基于Python3.5编写。
你可以通过在命令行运行python –version来检查你的Python版本。
λ python --version
Python 3.5.2 :: Anaconda 4.2.0 (64-bit)基本数据类型
像大多数语言一样，Python有许多基本类型，包括整数，浮点数，布尔型和字符串。这些数据类型的用法与其他编程语言相似。
数值(Numbers)
整数(Integers)和浮点数(floats)按照您从其他语言期望的方式工作：
# 基本数据类型
x = 3
print(type(x)) # 打印 "<class 'int'>"
print(x) # 打印 "3"
print(x + 1) # 加法: 打印 "4"
print(x - 1) # 减法: 打印 "2"
print(x * 2) # 乘法: 打印 "6"
print(x ** 2) # 取幂: 打印 "9"
print(x / 2) # 除法: 打印 "1.5"
print(x // 2) # 取整除: 打印 "1"
x += 1 # 自增
print(x) # 打印 "4"
x *= 2 # 自乘
print(x) # 打印 "8"
y = 2.5
print(type(y)) # 打印 "<class 'float'>"
print(y, y+1, y*2, y ** 2) # 打印 "2.5, 3.5, 5.0, 6.25"
注意：与其他语言不同，Python没有一元自增运算符(x++)或者一元自减运算符(x–)。
Python也有复杂数字的内置(built-in)类型; 你可以在Numeric Types文档中找到所有内置类型的详细介绍。
布尔型(Booleans)
Python实现了布尔逻辑的所以常用运算符，但使用英语单词而不是符号(&&,||等):
# 布尔型
t = True
f = False
print(type(t)) # 打印 "<class 'bool'>"
print(t and f) # 逻辑与: 打印 "False"
print(t or f) # 逻辑或: 打印 "True"
print(not t) # 逻辑非: 打印 "False"
print(not f) # 逻辑非: 打印 "True"
print(t != f) # 逻辑异或: 打印 "True"字符串(String)
Python对字符串有很好的支持:
# 字符串
hello = 'hello' # 字符串可以使用单引号''
world = "world" # 或者使用双引号""
print(hello) # 打印 "hello"
print(world) # 打印 "world"
print(len(hello)) # 字符串长度: 打印 "5"
hw = hello + ' ' + world # 字符串连接(concatenation)
print(hw) # 打印 "hello world"
hw12 = '%s %s %d' % (hello, world, 12) # sprintf 类型-字符串格式化
print(hw12) # 打印 "hello world 12"字符串对象有许多有用的方法，如:
s = "hello"
print(s.title()) # 将字符串标题化，即首字母变成大写，其它字母变成小写: 打印 "Hello"
print(s.capitalize()) # 与title方法作用一直: 打印 "Hello"
print(s.upper()) # 将字符串转换为大写; 打印 "HELLO"
print(s.lower()) # 将字符串转换成小写: 打印 "hello"
print(s.rjust(7)) # 右对齐字符串, 用空格填充; 打印 " hello"
print(s.center(7)) # 将字符串居中, 用空格填充: 打印 " hello "
print(s.replace('l', '(ell)')) # 子字符串替换: 打印 "he(ell)(ell)0"
print(' world '.strip()) # 删除首尾空格: 打印 "world"你可以在String Methods文档中找到关于字符串方法的更多内容。
容器(Containers)
Python包含几个内置的容器(container)类型: 列表(lists)，字典(dictionaries)，集合(sets)和元组((tuples)。
列表(Lists)
列表在Python中等价于数组，但是调整大小，并且可以包含不同类型的元素:
# 列表
xs = [3, 1, 2] # 创建列表
print(xs, xs[2])# 打印 "[3, 1, 2] 2"
print(xs[-1]) # 负数索引值是指向列表中的尾部: 打印 "2"
xs[2] = 'foo' # 列表可以包含不同类型的元素
print(xs) # 打印 "[3 1 'foo']"
xs.append('bar')# 在列表的尾部添加新元素
print(xs) # 打印 "[3 1 'foo' 'bar']"
x = xs.pop() # 删除并返回列表中的尾部元素
print(x, xs) # 打印 "bar [3, 1. 'foo']"你可以在More on Lists文档中找到关于列表的更多内容。
切片(Slicing)
除了每次访问一个列表元素外，Python还提供简介的语法来访问子列表；其被称为切片(slicing):
# 切片(slicing)
nums = list(range(5))
print(nums) # 打印 "[0, 1, 2, 3, 4]"
print(nums[2:4])# 将索引2到4(不包括4)的列表元素作为片(slice): 打印 "[2, 3]"
print(nums[2:]) # 将索引2到尾部的列表元素作为片(slice): 打印 "[2, 3, 4]"
print(nums[:2]) # 将首部到索引2(不包括2)的列表元素作为片(slice): 打印 "[0, 1]"
print(nums[:]) # 将整个列表作为片(slice): 打印 "[0, 1, 2, 3, 4]"
print(nums[:-1])# 切片的索引可以是负数: 打印 "[0, 1, 2, 3]"
nums[2:4] = [8, 9] # 为片分配给新的子列表
print(nums) # 打印 "[0, 1, 8, 9, 4]"循环(Loops)
你可以像这样循环列表中的元素:
# 循环(Loops)
animals = ['cat', 'dog', 'monkey']
for animal in animals:
print(animal)
# 逐行打印 "cat", "dog", "monkey"
如果要访问循环体内每个元素的索引，请使用内置的enumerate枚举函数：
animals = ['cat', 'dog', 'monkey']
for idx, animal in enumerate(animals):
print('#%d: %s' % (idx+1, animal))
# 逐行打印 "#1: cat", "#2: dog", "#3: monkey"列表推导式(List comprehensions)
编程时，我们经常要将一种类型的数据转换成另一种类型的数据(可以是类型，也可以是数值)。举个简单示例，用下面的代码计算平方数:
# 列表推导式(List comprehensions)
nums = [0, 1, 2, 3, 4]
squares = []
for x in nums:
squares.append(x ** 2)
print(squares) # 打印 [0, 1, 4, 9, 16]
你可以使用列表推导式简化上述代码:
# 用列表推导式(List comprehensions)计算平方数
nums = [0, 1, 2, 3, 4]
squares = [x ** 2 for x in nums]
print(squares)列表推倒式也可以包含条件:
nums = [0, 1, 2, 3, 4]
even_squares = [x ** 2 for x in nums if x % 2 == 0]
print(even_squares) # 打印 "[0, 4, 16]"字典(Dictionaries)
字典存储(键key，值value)对，类似于Java中的Map或者Javascript中的对象。你可以像这样使用它:
d = {'cat':'cute', 'dog':'furry'} # 创建含有数据的新字典
print(d['cat']) # 从字典中根据键寻找对应值; 打印 "cute"
print('cat' in d) # 判断字典中是否有给定的键; 打印 "True"
d['fish'] = 'wet' # 在字典中添加新的对
print(d['fish']) # 打印 "wet"
# print(d['monkey'])# KeyError: 'monkey'不是d中的键
print(d.get('monkey'), 'N/A') # 获取一个默认的元素; 打印 "N/A"
print(d.get('fish'), 'N/A') # 获得一个默认的元素; 打印 "wet"
del d['fish'] # 删除字典中的元素
print(d.get('fish'), 'N/A') # "fish"已经被删除所以不是键了; 打印 "N/A"你可以在Mapping Types——dict文档中找到关于字典的更多内容。
循环(Loops)
通过键很容易遍历字典:
d = {'person':2, 'cat':4, 'spider':8}
for animal in d:
legs = d[animal]
print('A %s has %d legs' % (animal, legs))
# 打印 "A person has 2 legs", "A cat has 4 legs", "A spider has 8 legs"如果你想访问keys和对应的值，可以使用items方法:
d = {'person':2, 'cat':4, 'spider':8}
for animal, legs in d.items():
print('A %s has %d legs' % (animal, legs))
# 打印 "A person has 2 legs", "A cat has 4 legs", "A spider has 8 legs"字典推导式(Dictionary comprehensions)
与列表推导式类似，但允许你很容易构建字典。如:
num = [0, 1, 2, 3, 4]
even_num_to_square = {x:x**2 for x in nums if x % 2 == 0}
print(even_num_to_square) # 打印 "{0:0, 2:4, 4:16}"集合(Sets)
集合是特殊元素的无序集合。简单的示例如下:
animals = {'cat', 'dog'} # 创建集合
print('cat' in animals) # 判断元素是否在集合中; 打印 "True"
print('fish' in animals) # 打印 "False"
animals.add('fish') # 添加新元素
print('fish' in animals) # 打印 "True"
print(len(animals)) # 集合中的元素数量; 打印 "3"
animals.add('cat') # 添加已经存在的元素: 无变化
print(len(animals)) # 打印 "3"
animals.remove('cat') # 删除元素
print(len(animals)) # 打印 "2"你可以在Set Types文档中找到关于集合的更多内容。
循环(Loops)
遍历集合与遍历列表有相同的语法；然而因为集合是无序的，所以你不能猜测你访问集合中元素的次序:
animals = {'cat', 'dog', 'fish'}
for idx, animal in enumerate(animals):
print('#%d: %s' % (idx, animal))
# 打印 "#1: fish", "#2: cat", "#3: dog"集合推导式(Set comprehensions)
与列表和字典相似，我们可以很容易使用集合推导式来创建集合:
from math import sqrt
nums = {int(sqrt(x)) for x in range(30)}
print(nums) # 打印 "{0, 1, 2, 3, 4, 5}"元组(Tuples)
元组是一个(不可变的)有序的值列表。元组在很多方面与列表类似；最重要的不同是元组可以用作字典的键和集合的元素，然而列表都不可以。这里有个简单示例:
d = {(x, x + 1): x for x in range(10)} # 创建含有元组键的字典
t = (5, 6) # 创建元组
print(type(t)) # 打印 "<class 'tuple'>"
print(d[t]) # 将元组作为键在字典中获得对应的值: 打印 "5"
print(d[(1, 2)])# 打印 "1"你可以在Tuples and Sequences文档中找到关于元组的更多内容。
函数(Functions)
Python函数是使用def关键字定义的。例如:
def sign(x):
if x > 0:
return 'positive'
elif x < 0:
return 'negative'
else:
return 'zero'
for x in [-1, 0, 1]:
print(sign(x))
# 打印 "negative", "zero", "positive"我们经常采用可选的关键字参数来定义函数(含参函数)，例如:
def hello(name, loud = False):
if loud:
print('HELLO, %s!' % name.upper())
else:
print('Hello, %s' % name)
hello('Bob') # 使用默认参数; 打印 "Hello, Bobs"
hello('Freb', loud = True) # 使用输入参数; 打印 "HELLO, FREB!"你可以在Defining Functions文档中找到关于Python函数的更多内容。
类(Classes)
在Python中定义类的语法很简单:
class Greeter(object):
# Constructor
def __init__(self, name):
self.name = name # 创建一个实例变量
# 实例方法
def greet(self, loud = False):
if loud:
print('HELLO, %s!' % self.name.upper())
else:
print('Hello, %s' % self.name)
g = Greeter('Fred') # 构建Greeter类的实例
g.greet() # 调用实例的方法; 打印 "Hello, Fred"
g.greet(loud = True)# 调用实例的方法; 打印 "HELLO, FRED!"
你可以在Classes文档中找到关于Python类的更多内容。
——我是可爱的分割线——-
若喜欢Amusi写的文章，可以扫描下方二维码关注CVer公众号！
