python3 numpy教程_Python Numpy学习教程（一）Python篇

Python Numpy学习教程

Interpreter：Amusi

Date: 2018-03-24

Reference:

注：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)) # 打印 ""

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)) # 打印 ""

print(y, y+1, y*2, y ** 2) # 打印 "2.5, 3.5, 5.0, 6.25"

注意：与其他语言不同，Python没有一元自增运算符(x++)或者一元自减运算符(x--)。

Python也有复杂数字的内置(built-in)类型; 你可以在

布尔型(Booleans)

Python实现了布尔逻辑的所以常用运算符，但使用英语单词而不是符号(&&,||等):

# 布尔型

t = True

f = False

print(type(t)) # 打印 ""

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"

你可以在

容器(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']"

你可以在

切片(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"

你可以在

循环(Loops)

通过键很容易遍历字典:

d = {'person':2, 'cat':4, 'spider':8}

for animal in d:

legs = d[animal]

print('A%shas%dlegs' % (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%shas%dlegs' % (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"

你可以在

循环(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)) # 打印 ""

print(d[t]) # 将元组作为键在字典中获得对应的值: 打印 "5"

print(d[(1, 2)])# 打印 "1"

函数(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!"

你可以在

类(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!"

你可以在

------我是可爱的分割线-------

若喜欢Amusi写的文章，可以扫描下方二维码关注CVer公众号！