pythonnumpy教程_Python Numpy学习教程（一）Python篇

通知：这篇文章主要简单介绍Python的基本数据结构、容器、列表、字典、集合、元组、函数和类等知识点

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中经典的快速排序算法的实现：1# quicksort

2def quicksort(arr):

3 if len(arr) <=1:

4 return arr

5 pivot = arr[len(arr) // 2]

6 left = [x for x in arr if x < pivot]

7 middle = [x for x in arr if x == pivot]

8 right = [x for x in arr if x > pivot]

9 return quicksort(left) + middle + quicksort(right)

10

11print(quicksort([3,6,8,10,1,2,1]))

12# 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版本。1python --version

基本数据类型

像大多数语言一样，Python有许多基本类型，包括整数，浮点数，布尔型和字符串。这些数据类型的用法与其他编程语言相似。

数值(Numbers)

整数(Integers)和浮点数(floats)按照您从其他语言期望的方式工作：1# 基本数据类型

2x = 3

3print(type(x)) # 打印 ""

4print(x) # 打印 "3"

5print(x + 1) # 加法: 打印 "4"

6print(x - 1) # 减法: 打印 "2"

7print(x * 2) # 乘法: 打印 "6"

8print(x ** 2) # 取幂: 打印 "9"

9print(x / 2) # 除法: 打印 "1.5"

10print(x // 2) # 取整除: 打印 "1"

11x += 1 # 自增

12print(x) # 打印 "4"

13x *= 2 # 自乘

14print(x) # 打印 "8"

15y = 2.5

16print(type(y)) # 打印 ""

17print(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实现了布尔逻辑的所以常用运算符，但使用英语单词而不是符号(&&,||等):1# 布尔型

2t = True

3f = False

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

5print(t and f) # 逻辑与: 打印 "False"

6print(t or f) # 逻辑或: 打印 "True"

7print(not t) # 逻辑非: 打印 "False"

8print(not f) # 逻辑非: 打印 "True"

9print(t != f) # 逻辑异或: 打印 "True"

字符串(String)

Python对字符串有很好的支持:1# 字符串

2hello = 'hello' # 字符串可以使用单引号''

3world = "world" # 或者使用双引号""

4print(hello) # 打印 "hello"

5print(world) # 打印 "world"

6print(len(hello)) # 字符串长度: 打印 "5"

7hw = hello + ' ' + world # 字符串连接(concatenation)

8print(hw) # 打印 "hello world"

9hw12 = '%s %s %d' % (hello, world, 12) # sprintf 类型-字符串格式化

10print(hw12) # 打印 "hello world 12"

字符串对象有许多有用的方法，如:1s = "hello"

2print(s.title()) # 将字符串标题化，即首字母变成大写，其它字母变成小写: 打印 "Hello"

3print(s.capitalize()) # 与title方法作用一直: 打印 "Hello"

4print(s.upper()) # 将字符串转换为大写; 打印 "HELLO"

5print(s.lower()) # 将字符串转换成小写: 打印 "hello"

6print(s.rjust(7)) # 右对齐字符串, 用空格填充; 打印 " hello"

7print(s.center(7)) # 将字符串居中, 用空格填充: 打印 " hello "

8print(s.replace('l', '(ell)')) # 子字符串替换: 打印 "he(ell)(ell)0"

9print(' world '.strip()) # 删除首尾空格: 打印 "world"

你可以在String Methods文档中找到关于字符串方法的更多内容。

容器(Containers)

Python包含几个内置的容器(container)类型:列表(lists)

字典(dictionaries)

集合(sets)

元组((tuples)

列表(Lists)

列表在Python中等价于数组，但是调整大小，并且可以包含不同类型的元素:1# 列表

2xs = [3, 1, 2] # 创建列表

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

4print(xs[-1]) # 负数索引值是指向列表中的尾部: 打印 "2"

5xs[2] = 'foo' # 列表可以包含不同类型的元素

6print(xs) # 打印 "[3 1 'foo']"

7xs.append('bar')# 在列表的尾部添加新元素

8print(xs) # 打印 "[3 1 'foo' 'bar']"

9x = xs.pop() # 删除并返回列表中的尾部元素

10print(x, xs) # 打印 "bar [3, 1. 'foo']"

你可以在More on Lists文档中找到关于列表的更多内容。

切片(Slicing)

除了每次访问一个列表元素外，Python还提供简介的语法来访问子列表；其被称为切片(slicing):1# 切片(slicing)

2nums = list(range(5))

3print(nums) # 打印 "[0, 1, 2, 3, 4]"

4print(nums[2:4])# 将索引2到4(不包括4)的列表元素作为片(slice): 打印 "[2, 3]"

5print(nums[2:]) # 将索引2到尾部的列表元素作为片(slice): 打印 "[2, 3, 4]"

6print(nums[:2]) # 将首部到索引2(不包括2)的列表元素作为片(slice): 打印 "[0, 1]"

7print(nums[:]) # 将整个列表作为片(slice): 打印 "[0, 1, 2, 3, 4]"

8print(nums[:-1])# 切片的索引可以是负数: 打印 "[0, 1, 2, 3]"

9nums[2:4] = [8, 9] # 为片分配给新的子列表

10print(nums) # 打印 "[0, 1, 8, 9, 4]"

循环(Loops)

你可以像这样循环列表中的元素:1# 循环(Loops)

2animals = ['cat', 'dog', 'monkey']

3for animal in animals:

4 print(animal)

5# 逐行打印 "cat", "dog", "monkey"

6如果要访问循环体内每个元素的索引，请使用内置的enumerate枚举函数：

7animals = ['cat', 'dog', 'monkey']

8for idx, animal in enumerate(animals):

9 print('#%d: %s' % (idx+1, animal))

10# 逐行打印 "#1: cat", "#2: dog", "#3: monkey"

列表推导式(List comprehensions)

编程时，我们经常要将一种类型的数据转换成另一种类型的数据(可以是类型，也可以是数值)。举个简单示例，用下面的代码计算平方数:1# 列表推导式(List comprehensions)

2nums = [0, 1, 2, 3, 4]

3squares = []

4for x in nums:

5 squares.append(x ** 2)

6print(squares) # 打印 [0, 1, 4, 9, 16]

7你可以使用列表推导式简化上述代码:

8# 用列表推导式(List comprehensions)计算平方数

9nums = [0, 1, 2, 3, 4]

10squares = [x ** 2 for x in nums]

11print(squares)

列表推倒式也可以包含条件:1nums = [0, 1, 2, 3, 4]

2even_squares = [x ** 2 for x in nums if x % 2 == 0]

3print(even_squares) # 打印 "[0, 4, 16]"

字典(Dictionaries)

字典存储(键key，值value)对，类似于Java中的Map或者Javascript中的对象。你可以像这样使用它:1d = {'cat':'cute', 'dog':'furry'} # 创建含有数据的新字典

2print(d['cat']) # 从字典中根据键寻找对应值; 打印 "cute"

3print('cat' in d) # 判断字典中是否有给定的键; 打印 "True"

4d['fish'] = 'wet' # 在字典中添加新的对

5print(d['fish']) # 打印 "wet"

6# print(d['monkey'])# KeyError: 'monkey'不是d中的键

7print(d.get('monkey'), 'N/A') # 获取一个默认的元素; 打印 "N/A"

8print(d.get('fish'), 'N/A') # 获得一个默认的元素; 打印 "wet"

9del d['fish'] # 删除字典中的元素

10print(d.get('fish'), 'N/A') # "fish"已经被删除所以不是键了; 打印 "N/A"

你可以在Mapping Types——dict文档中找到关于字典的更多内容。

循环(Loops)

通过键很容易遍历字典:1d = {'person':2, 'cat':4, 'spider':8}

2for animal in d:

3 legs = d[animal]

4 print('A %s has %d legs' % (animal, legs))

5# 打印 "A person has 2 legs", "A cat has 4 legs", "A spider has 8 legs"

如果你想访问keys和对应的值，可以使用items方法:1d = {'person':2, 'cat':4, 'spider':8}

2for animal, legs in d.items():

3 print('A %s has %d legs' % (animal, legs))

4# 打印 "A person has 2 legs", "A cat has 4 legs", "A spider has 8 legs"

字典推导式(Dictionary comprehensions)

与列表推导式类似，但允许你很容易构建字典。如:1num = [0, 1, 2, 3, 4]

2even_num_to_square = {x:x**2 for x in nums if x % 2 == 0}

3print(even_num_to_square) # 打印 "{0:0, 2:4, 4:16}"

集合(Sets)

集合是特殊元素的无序集合。简单的示例如下:1animals = {'cat', 'dog'} # 创建集合

2print('cat' in animals) # 判断元素是否在集合中; 打印 "True"

3print('fish' in animals) # 打印 "False"

4animals.add('fish') # 添加新元素

5print('fish' in animals) # 打印 "True"

6print(len(animals)) # 集合中的元素数量; 打印 "3"

7animals.add('cat') # 添加已经存在的元素: 无变化

8print(len(animals)) # 打印 "3"

9animals.remove('cat') # 删除元素

10print(len(animals)) # 打印 "2"

你可以在Set Types文档中找到关于集合的更多内容。

循环(Loops)

遍历集合与遍历列表有相同的语法；然而因为集合是无序的，所以你不能猜测你访问集合中元素的次序:1animals = {'cat', 'dog', 'fish'}

2for idx, animal in enumerate(animals):

3 print('#%d: %s' % (idx, animal))

4# 打印 "#1: fish", "#2: cat", "#3: dog"

集合推导式(Set comprehensions)

与列表和字典相似，我们可以很容易使用集合推导式来创建集合:1from math import sqrt

2nums = {int(sqrt(x)) for x in range(30)}

3print(nums) # 打印 "{0, 1, 2, 3, 4, 5}"

元组(Tuples)

元组是一个(不可变的)有序的值列表。元组在很多方面与列表类似；最重要的不同是元组可以用作字典的键和集合的元素，然而列表都不可以。这里有个简单示例:1d = {(x, x + 1): x for x in range(10)} # 创建含有元组键的字典

2t = (5, 6) # 创建元组

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

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

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

你可以在Tuples and Sequences文档中找到关于元组的更多内容。

函数(Functions)

Python函数是使用def关键字定义的。例如:1def sign(x):

2 if x > 0:

3 return 'positive'

4 elif x < 0:

5 return 'negative'

6 else:

7 return 'zero'

8for x in [-1, 0, 1]:

9 print(sign(x))

10# 打印 "negative", "zero", "positive"

我们经常采用可选的关键字参数来定义函数(含参函数)，例如:1def hello(name, loud = False):

2 if loud:

3 print('HELLO, %s!' % name.upper())

4 else:

5 print('Hello, %s' % name)

6hello('Bob') # 使用默认参数; 打印 "Hello, Bobs"

7hello('Freb', loud = True) # 使用输入参数; 打印 "HELLO, FREB!"

你可以在Defining Functions文档中找到关于Python函数的更多内容。

类(Classes)

在Python中定义类的语法很简单:1class Greeter(object):

2 # Constructor

3 def __init__(self, name):

4 self.name = name # 创建一个实例变量

5

6 # 实例方法

7 def greet(self, loud = False):

8 if loud:

9 print('HELLO, %s!' % self.name.upper())

10 else:

11 print('Hello, %s' % self.name)

12

13g = Greeter('Fred') # 构建Greeter类的实例

14g.greet() # 调用实例的方法; 打印 "Hello, Fred"

15g.greet(loud = True)# 调用实例的方法; 打印 "HELLO, FRED!"

你可以在Classes文档中找到关于Python类的更多内容。