Colab 笔记本
本教程最初由Justin Johnson提供。

我们将在本课程的所有作业中使用 Python 编程语言。Python 本身就是一种出色的通用编程语言，但在一些流行的库（numpy、scipy、matplotlib）的帮助下，它成为了一个强大的科学计算环境。

我们希望你们中的许多人对 Python 和 numpy 有一定的经验；对于其他人来说，本节将作为 Python 编程语言及其在科学计算中的使用的速成课程。我们还将介绍笔记本，这是修改 Python 代码的一种非常方便的方式。你们中的一些人可能有不同语言的先前知识，在这种情况下，我们还建议参考： Matlab 用户的 NumPy、 R 用户的 Python 和/或 SAS 用户的 Python。

目录

Jupyter 和 Colab 笔记本
Python
Python 版本
基本数据类型
容器
列表
字典
套
元组
职能
课程
麻木的
数组
数组索引
数据类型
数组数学
广播
Numpy 文档
科学派
图像操作
MATLAB 文件
点之间的距离
Matplotlib
绘图
子图
图片
Jupyter 和 Colab 笔记本
在我们深入研究 Python 之前，我们想简单地谈谈笔记本。Jupyter notebook 可让您在 Web 浏览器中本地编写和执行 Python 代码。Jupyter notebook 让修改代码和零碎执行变得非常容易；因此，它们被广泛用于科学计算。另一方面，Colab 是谷歌的 Jupyter 笔记本，特别适用于机器学习和数据分析，并且完全在云中运行。Colab 基本上是类固醇上的 Jupyter 笔记本：它是免费的，无需设置，预装了许多软件包，易于与世界共享，并受益于免费访问 GPU 和 TPU 等硬件加速器（有一些警告）。

在 Colab 中运行教程（推荐）。如果您希望完全在 Colab 中运行本教程，请单击Open in Colab此页面顶部的徽章。

在 Jupyter Notebook 中运行教程。如果您希望使用 Jupyter 在本地运行 notebook，请确保您的虚拟环境已正确安装（按照设置说明），激活它，然后运行pip install notebook以安装 Jupyter notebook。接下来，打开笔记本并将其下载到您选择的目录，方法是右键单击页面并选择Save Page As。然后cd到该目录并运行jupyter notebook.

这应该会自动在http://localhost:8888. 如果一切正常，您应该会看到这样的屏幕，显示当前目录中所有可用的笔记本。单击jupyter-notebook-tutorial.ipynb 并按照笔记本中的说明进行操作。否则，您可以使用下面的代码片段继续阅读本教程。

Python
Python 是一种高级的、动态类型的多范式编程语言。Python 代码通常被称为几乎像伪代码，因为它允许您用很少的代码行表达非常强大的想法，同时非常易读。例如，下面是 Python 中经典快速排序算法的实现：

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]))

Prints “[1, 1, 2, 3, 6, 8, 10]”

Python 版本
截至 2020 年 1 月 1 日，Python 已正式放弃对python2. 对于此类，所有代码都将使用 Python 3.7。在继续本教程之前，请确保您已完成设置说明 并正确安装了虚拟环境。python3在激活环境后，您可以在命令行中仔细检查您的 Python 版本，方法是运行python --version.

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

数字：整数和浮点数的工作方式与您对其他语言的期望一样：

x = 3
print(type(x)) # Prints “<class ‘int’>”
print(x) # Prints “3”
print(x + 1) # Addition; prints “4”
print(x - 1) # Subtraction; prints “2”
print(x * 2) # Multiplication; prints “6”
print(x ** 2) # Exponentiation; prints “9”
x += 1
print(x) # Prints “4”
x *= 2
print(x) # Prints “8”
y = 2.5
print(type(y)) # Prints “<class ‘float’>”
print(y, y + 1, y * 2, y ** 2) # Prints “2.5 3.5 5.0 6.25”
请注意，与许多语言不同，Python 没有一元递增 ( x++) 或递减 ( x–) 运算符。

Python 还具有用于复数的内置类型；您可以在文档中找到所有详细信息 。

布尔值： Python 实现了布尔逻辑的所有常用运算符，但使用英文单词而不是符号（&&、||等）：

t = True
f = False
print(type(t)) # Prints “<class ‘bool’>”
print(t and f) # Logical AND; prints “False”
print(t or f) # Logical OR; prints “True”
print(not t) # Logical NOT; prints “False”
print(t != f) # Logical XOR; prints “True”
字符串： Python 对字符串有很好的支持：

hello = ‘hello’ # String literals can use single quotes
world = “world” # or double quotes; it does not matter.
print(hello) # Prints “hello”
print(len(hello)) # String length; prints “5”
hw = hello + ’ ’ + world # String concatenation
print(hw) # prints “hello world”
hw12 = ‘%s %s %d’ % (hello, world, 12) # sprintf style string formatting
print(hw12) # prints “hello world 12”
字符串对象有很多有用的方法；例如：

s = “hello”
print(s.capitalize()) # Capitalize a string; prints “Hello”
print(s.upper()) # Convert a string to uppercase; prints “HELLO”
print(s.rjust(7)) # Right-justify a string, padding with spaces; prints " hello"
print(s.center(7)) # Center a string, padding with spaces; prints " hello "
print(s.replace(‘l’, ‘(ell)’)) # Replace all instances of one substring with another;
# prints “he(ell)(ell)o”
print(’ world '.strip()) # Strip leading and trailing whitespace; prints “world”
您可以在文档中找到所有字符串方法的列表。

容器
Python 包含多种内置容器类型：列表、字典、集合和元组。

列表
列表是数组的 Python 等价物，但可以调整大小并且可以包含不同类型的元素：

xs = [3, 1, 2] # Create a list
print(xs, xs[2]) # Prints “[3, 1, 2] 2”
print(xs[-1]) # Negative indices count from the end of the list; prints “2”
xs[2] = ‘foo’ # Lists can contain elements of different types
print(xs) # Prints “[3, 1, ‘foo’]”
xs.append(‘bar’) # Add a new element to the end of the list
print(xs) # Prints “[3, 1, ‘foo’, ‘bar’]”
x = xs.pop() # Remove and return the last element of the list
print(x, xs) # Prints “bar [3, 1, ‘foo’]”
像往常一样，您可以在文档中找到有关列表的所有详细信息 。

切片： 除了一次访问一个列表元素外，Python 提供了简洁的语法来访问子列表；这被称为切片：

nums = list(range(5)) # range is a built-in function that creates a list of integers
print(nums) # Prints “[0, 1, 2, 3, 4]”
print(nums[2:4]) # Get a slice from index 2 to 4 (exclusive); prints “[2, 3]”
print(nums[2:]) # Get a slice from index 2 to the end; prints “[2, 3, 4]”
print(nums[:2]) # Get a slice from the start to index 2 (exclusive); prints “[0, 1]”
print(nums[:]) # Get a slice of the whole list; prints “[0, 1, 2, 3, 4]”
print(nums[:-1]) # Slice indices can be negative; prints “[0, 1, 2, 3]”
nums[2:4] = [8, 9] # Assign a new sublist to a slice
print(nums) # Prints “[0, 1, 8, 9, 4]”
我们将在 numpy 数组的上下文中再次看到切片。

循环：您可以像这样循环列表的元素：

animals = [‘cat’, ‘dog’, ‘monkey’]
for animal in animals:
print(animal)

Prints “cat”, “dog”, “monkey”, each on its own line.

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

animals = [‘cat’, ‘dog’, ‘monkey’]
for idx, animal in enumerate(animals):
print(’#%d: %s’ % (idx + 1, animal))

Prints “#1: cat”, “#2: dog”, “#3: monkey”, each on its own line

列表推导： 在编程时，我们经常希望将一种类型的数据转换为另一种类型的数据。作为一个简单的示例，请考虑以下计算平方数的代码：

nums = [0, 1, 2, 3, 4]
squares = []
for x in nums:
squares.append(x ** 2)
print(squares) # Prints [0, 1, 4, 9, 16]
您可以使用列表推导来简化此代码：

nums = [0, 1, 2, 3, 4]
squares = [x ** 2 for x in nums]
print(squares) # Prints [0, 1, 4, 9, 16]
列表推导还可以包含条件：

nums = [0, 1, 2, 3, 4]
even_squares = [x ** 2 for x in nums if x % 2 == 0]
print(even_squares) # Prints “[0, 4, 16]”

字典
字典存储（键，值）对，类似于MapJava 中的 a 或 Javascript 中的对象。你可以像这样使用它：

d = {‘cat’: ‘cute’, ‘dog’: ‘furry’} # Create a new dictionary with some data
print(d[‘cat’]) # Get an entry from a dictionary; prints “cute”
print(‘cat’ in d) # Check if a dictionary has a given key; prints “True”
d[‘fish’] = ‘wet’ # Set an entry in a dictionary
print(d[‘fish’]) # Prints “wet”

print(d[‘monkey’]) # KeyError: ‘monkey’ not a key of d

print(d.get(‘monkey’, ‘N/A’)) # Get an element with a default; prints “N/A”
print(d.get(‘fish’, ‘N/A’)) # Get an element with a default; prints “wet”
del d[‘fish’] # Remove an element from a dictionary
print(d.get(‘fish’, ‘N/A’)) # “fish” is no longer a key; prints “N/A”
您可以在文档中找到所有您需要了解的有关字典 的信息。

循环：很容易遍历字典中的键：

d = {‘person’: 2, ‘cat’: 4, ‘spider’: 8}
for animal in d:
legs = d[animal]
print(‘A %s has %d legs’ % (animal, legs))

Prints “A person has 2 legs”, “A cat has 4 legs”, “A spider has 8 legs”

如果要访问键及其对应的值，请使用以下items方法：

d = {‘person’: 2, ‘cat’: 4, ‘spider’: 8}
for animal, legs in d.items():
print(‘A %s has %d legs’ % (animal, legs))

Prints “A person has 2 legs”, “A cat has 4 legs”, “A spider has 8 legs”

字典推导： 这些类似于列表推导，但允许您轻松构建字典。例如：

nums = [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) # Prints “{0: 0, 2: 4, 4: 16}”

套
集合是不同元素的无序集合。作为一个简单的示例，请考虑以下内容：

animals = {‘cat’, ‘dog’}
print(‘cat’ in animals) # Check if an element is in a set; prints “True”
print(‘fish’ in animals) # prints “False”
animals.add(‘fish’) # Add an element to a set
print(‘fish’ in animals) # Prints “True”
print(len(animals)) # Number of elements in a set; prints “3”
animals.add(‘cat’) # Adding an element that is already in the set does nothing
print(len(animals)) # Prints “3”
animals.remove(‘cat’) # Remove an element from a set
print(len(animals)) # Prints “2”
像往常一样，你想知道的关于集合的一切都可以 在文档中找到。

循环： 对集合进行迭代与对列表进行迭代具有相同的语法；但是，由于集合是无序的，因此您不能对访问集合元素的顺序做出假设：

animals = {‘cat’, ‘dog’, ‘fish’}
for idx, animal in enumerate(animals):
print(’#%d: %s’ % (idx + 1, animal))

Prints “#1: fish”, “#2: dog”, “#3: cat”

集合推导： 像列表和字典一样，我们可以使用集合推导轻松构造集合：

from math import sqrt
nums = {int(sqrt(x)) for x in range(30)}
print(nums) # Prints “{0, 1, 2, 3, 4, 5}”

元组
元组是一个（不可变的）有序值列表。元组在许多方面类似于列表。最重要的区别之一是元组可以用作字典中的键和集合的元素，而列表不能。这是一个简单的例子：

d = {(x, x + 1): x for x in range(10)} # Create a dictionary with tuple keys
t = (5, 6) # Create a tuple
print(type(t)) # Prints “<class ‘tuple’>”
print(d[t]) # Prints “5”
print(d[(1, 2)]) # Prints “1”
该文档有更多关于元组的信息。

职能
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))

Prints “negative”, “zero”, “positive”

我们经常会定义函数来接受可选的关键字参数，如下所示：

def hello(name, loud=False):
if loud:
print(‘HELLO, %s!’ % name.upper())
else:
print(‘Hello, %s’ % name)

hello(‘Bob’) # Prints “Hello, Bob”
hello(‘Fred’, loud=True) # Prints “HELLO, FRED!”
文档中有更多关于 Python 函数 的信息。

课程
在 Python 中定义类的语法很简单：

class Greeter(object):

# Constructor def __init__(self, name):self.name = name # Create an instance variable# Instance method def greet(self, loud=False):if loud:print('HELLO, %s!' % self.name.upper())else:print('Hello, %s' % self.name)

g = Greeter(‘Fred’) # Construct an instance of the Greeter class
g.greet() # Call an instance method; prints “Hello, Fred”
g.greet(loud=True) # Call an instance method; prints “HELLO, FRED!”
您可以在文档中关于 Python 类 的信息。

麻木的
Numpy是 Python 中科学计算的核心库。它提供了一个高性能的多维数组对象，以及用于处理这些数组的工具。如果您已经熟悉 MATLAB，您可能会发现 本教程对开始使用 Numpy 很有用。

数组
一个 numpy 数组是一个值的网格，所有的类型都是相同的，并且由一个非负整数的元组索引。维数是数组的秩；数组的形状 是一个整数元组，给出了数组沿每个维度的大小。

我们可以从嵌套的 Python 列表中初始化 numpy 数组，并使用方括号访问元素：

import numpy as np

a = np.array([1, 2, 3]) # Create a rank 1 array
print(type(a)) # Prints “<class ‘numpy.ndarray’>”
print(a.shape) # Prints “(3,)”
print(a[0], a[1], a[2]) # Prints “1 2 3”
a[0] = 5 # Change an element of the array
print(a) # Prints “[5, 2, 3]”

b = np.array([[1,2,3],[4,5,6]]) # Create a rank 2 array
print(b.shape) # Prints “(2, 3)”
print(b[0, 0], b[0, 1], b[1, 0]) # Prints “1 2 4”
Numpy 还提供了许多函数来创建数组：

import numpy as np

a = np.zeros((2,2)) # Create an array of all zeros
print(a) # Prints “[[ 0. 0.]
# [ 0. 0.]]”

b = np.ones((1,2)) # Create an array of all ones
print(b) # Prints “[[ 1. 1.]]”

c = np.full((2,2), 7) # Create a constant array
print© # Prints “[[ 7. 7.]
# [ 7. 7.]]”

d = np.eye(2) # Create a 2x2 identity matrix
print(d) # Prints “[[ 1. 0.]
# [ 0. 1.]]”

e = np.random.random((2,2)) # Create an array filled with random values
print(e) # Might print “[[ 0.91940167 0.08143941]
# [ 0.68744134 0.87236687]]”
您可以在文档中阅读有关创建数组的其他方法 。

数组索引
Numpy 提供了几种索引数组的方法。

切片： 类似于 Python 列表，numpy 数组可以切片。由于数组可能是多维的，因此您必须为数组的每个维度指定一个切片：

import numpy as np

Create the following rank 2 array with shape (3, 4)

[[ 1 2 3 4]

[ 5 6 7 8]

[ 9 10 11 12]]

a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])

Use slicing to pull out the subarray consisting of the first 2 rows

and columns 1 and 2; b is the following array of shape (2, 2):

[[2 3]

[6 7]]

b = a[:2, 1:3]

A slice of an array is a view into the same data, so modifying it

will modify the original array.

print(a[0, 1]) # Prints “2”
b[0, 0] = 77 # b[0, 0] is the same piece of data as a[0, 1]
print(a[0, 1]) # Prints “77”
您还可以将整数索引与切片索引混合使用。但是，这样做会产生一个比原始数组排名更低的数组。请注意，这与 MATLAB 处理数组切片的方式完全不同：

import numpy as np

Create the following rank 2 array with shape (3, 4)

[[ 1 2 3 4]

[ 5 6 7 8]

[ 9 10 11 12]]

a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])

Two ways of accessing the data in the middle row of the array.

Mixing integer indexing with slices yields an array of lower rank,

while using only slices yields an array of the same rank as the

original array:

row_r1 = a[1, :] # Rank 1 view of the second row of a
row_r2 = a[1:2, :] # Rank 2 view of the second row of a
print(row_r1, row_r1.shape) # Prints “[5 6 7 8] (4,)”
print(row_r2, row_r2.shape) # Prints “[[5 6 7 8]] (1, 4)”

We can make the same distinction when accessing columns of an array:

col_r1 = a[:, 1]
col_r2 = a[:, 1:2]
print(col_r1, col_r1.shape) # Prints “[ 2 6 10] (3,)”
print(col_r2, col_r2.shape) # Prints “[[ 2]
# [ 6]
# [10]] (3, 1)”
整数数组索引： 当您使用切片索引到 numpy 数组时，生成的数组视图将始终是原始数组的子数组。相反，整数数组索引允许您使用来自另一个数组的数据构造任意数组。这是一个例子：

import numpy as np

a = np.array([[1,2], [3, 4], [5, 6]])

An example of integer array indexing.

The returned array will have shape (3,) and

print(a[[0, 1, 2], [0, 1, 0]]) # Prints “[1 4 5]”

The above example of integer array indexing is equivalent to this:

print(np.array([a[0, 0], a[1, 1], a[2, 0]])) # Prints “[1 4 5]”

When using integer array indexing, you can reuse the same

element from the source array:

print(a[[0, 0], [1, 1]]) # Prints “[2 2]”

Equivalent to the previous integer array indexing example

print(np.array([a[0, 1], a[0, 1]])) # Prints “[2 2]”
整数数组索引的一个有用技巧是从矩阵的每一行中选择或改变一个元素：

import numpy as np

Create a new array from which we will select elements

a = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])

print(a) # prints “array([[ 1, 2, 3],
# [ 4, 5, 6],
# [ 7, 8, 9],
# [10, 11, 12]])”

Create an array of indices

b = np.array([0, 2, 0, 1])

Select one element from each row of a using the indices in b

print(a[np.arange(4), b]) # Prints “[ 1 6 7 11]”

Mutate one element from each row of a using the indices in b

a[np.arange(4), b] += 10

print(a) # prints "array([[11, 2, 3],
# [ 4, 5, 16],
# [17, 8, 9],
# [10, 21, 12]])
布尔数组索引： 布尔数组索引可让您挑选出数组的任意元素。这种类型的索引通常用于选择满足某些条件的数组元素。这是一个例子：

import numpy as np

a = np.array([[1,2], [3, 4], [5, 6]])

bool_idx = (a > 2) # Find the elements of a that are bigger than 2;
# this returns a numpy array of Booleans of the same
# shape as a, where each slot of bool_idx tells
# whether that element of a is > 2.

print(bool_idx) # Prints “[[False False]
# [ True True]
# [ True True]]”

We use boolean array indexing to construct a rank 1 array

consisting of the elements of a corresponding to the True values

of bool_idx

print(a[bool_idx]) # Prints “[3 4 5 6]”

We can do all of the above in a single concise statement:

print(a[a > 2]) # Prints “[3 4 5 6]”
为简洁起见，我们省略了很多关于 numpy 数组索引的细节；如果您想了解更多信息，您应该 阅读文档。

数据类型
每个 numpy 数组都是相同类型元素的网格。Numpy 提供了大量可用于构造数组的数值数据类型。Numpy 在创建数组时会尝试猜测数据类型，但构造数组的函数通常还包含一个可选参数来显式指定数据类型。这是一个例子：

import numpy as np

x = np.array([1, 2]) # Let numpy choose the datatype
print(x.dtype) # Prints “int64”

x = np.array([1.0, 2.0]) # Let numpy choose the datatype
print(x.dtype) # Prints “float64”

x = np.array([1, 2], dtype=np.int64) # Force a particular datatype
print(x.dtype) # Prints “int64”
您可以在文档中阅读有关 numpy 数据类型的所有信息 。

数组数学
基本数学函数在数组上逐元素运算，并且可以作为运算符重载和 numpy 模块中的函数使用：

import numpy as np

x = np.array([[1,2],[3,4]], dtype=np.float64)
y = np.array([[5,6],[7,8]], dtype=np.float64)

Elementwise sum; both produce the array

[[ 6.0 8.0]

[10.0 12.0]]

print(x + y)
print(np.add(x, y))

Elementwise difference; both produce the array

[[-4.0 -4.0]

[-4.0 -4.0]]

print(x - y)
print(np.subtract(x, y))

Elementwise product; both produce the array

[[ 5.0 12.0]

[21.0 32.0]]

print(x * y)
print(np.multiply(x, y))

Elementwise division; both produce the array

[[ 0.2 0.33333333]

[ 0.42857143 0.5 ]]

print(x / y)
print(np.divide(x, y))

Elementwise square root; produces the array

[[ 1. 1.41421356]

[ 1.73205081 2. ]]

print(np.sqrt(x))
请注意，与 MATLAB 不同的是，*它是元素乘法，而不是矩阵乘法。相反，我们使用该dot函数来计算向量的内积，将向量与矩阵相乘，以及将矩阵相乘。dot既可以作为 numpy 模块中的函数使用，也可以作为数组对象的实例方法使用：

import numpy as np

x = np.array([[1,2],[3,4]])
y = np.array([[5,6],[7,8]])

v = np.array([9,10])
w = np.array([11, 12])

Inner product of vectors; both produce 219

print(v.dot(w))
print(np.dot(v, w))

Matrix / vector product; both produce the rank 1 array [29 67]

print(x.dot(v))
print(np.dot(x, v))

Matrix / matrix product; both produce the rank 2 array

[[19 22]

[43 50]]

print(x.dot(y))
print(np.dot(x, y))
Numpy 提供了许多有用的函数来对数组执行计算；最有用的之一是sum：

import numpy as np

x = np.array([[1,2],[3,4]])

print(np.sum(x)) # Compute sum of all elements; prints “10”
print(np.sum(x, axis=0)) # Compute sum of each column; prints “[4 6]”
print(np.sum(x, axis=1)) # Compute sum of each row; prints “[3 7]”
您可以在文档中找到 numpy 提供的数学函数的完整列表 。

除了使用数组计算数学函数外，我们还经常需要重塑或以其他方式操作数组中的数据。此类操作的最简单示例是转置矩阵。要转置矩阵，只需使用T数组对象的属性：

import numpy as np

x = np.array([[1,2], [3,4]])
print(x) # Prints “[[1 2]
# [3 4]]”
print(x.T) # Prints “[[1 3]
# [2 4]]”

Note that taking the transpose of a rank 1 array does nothing:

v = np.array([1,2,3])
print(v) # Prints “[1 2 3]”
print(v.T) # Prints “[1 2 3]”
Numpy 提供了更多操作数组的函数；您可以在文档中查看完整列表 。

广播
广播是一种强大的机制，它允许 numpy 在执行算术运算时处理不同形状的数组。通常我们有一个较小的数组和一个较大的数组，并且我们希望多次使用较小的数组对较大的数组执行一些操作。

例如，假设我们要向矩阵的每一行添加一个常数向量。我们可以这样做：

import numpy as np

We will add the vector v to each row of the matrix x,

storing the result in the matrix y

x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])
v = np.array([1, 0, 1])
y = np.empty_like(x) # Create an empty matrix with the same shape as x

Add the vector v to each row of the matrix x with an explicit loop

for i in range(4):
y[i, :] = x[i, :] + v

Now y is the following

[[ 2 2 4]

[ 5 5 7]

[ 8 8 10]

[11 11 13]]

print(y)
这行得通；但是，当矩阵x非常大时，在 Python 中计算显式循环可能会很慢。请注意，将向量添加v到矩阵的每一行 相当于通过垂直堆叠多个副本x来形成矩阵，然后对和进行元素求和。我们可以像这样实现这种方法：vvvxvv

import numpy as np

We will add the vector v to each row of the matrix x,

storing the result in the matrix y

x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])
v = np.array([1, 0, 1])
vv = np.tile(v, (4, 1)) # Stack 4 copies of v on top of each other
print(vv) # Prints “[[1 0 1]
# [1 0 1]
# [1 0 1]
# [1 0 1]]”
y = x + vv # Add x and vv elementwise
print(y) # Prints “[[ 2 2 4
# [ 5 5 7]
# [ 8 8 10]
# [11 11 13]]”
Numpy 广播允许我们在不实际创建多个v. 考虑这个版本，使用广播：

import numpy as np

We will add the vector v to each row of the matrix x,

storing the result in the matrix y

x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])
v = np.array([1, 0, 1])
y = x + v # Add v to each row of x using broadcasting
print(y) # Prints “[[ 2 2 4]
# [ 5 5 7]
# [ 8 8 10]
# [11 11 13]]”
线条y = x + v虽有x形(4, 3)，但因广播而有形v； (3,)这条线就像v实际上有 shape一样(4, 3)，其中每一行都是 的副本v，并且总和是按元素执行的。

一起广播两个数组遵循以下规则：

如果数组的秩不同，则在较低秩数组的形状前面加上 1，直到两个形状的长度相同。
如果两个数组在一个维度上具有相同的大小，或者如果其中一个数组在该维度上的大小为 1，则称这两个数组在一个维度上是兼容的。
如果数组在所有维度上都兼容，则可以一起广播。
广播之后，每个数组的行为就好像它的形状等于两个输入数组的形状的元素最大值。
在一个数组的大小为 1 而另一个数组的大小大于 1 的任何维度中，第一个数组的行为就好像它是沿该维度复制的一样
如果此解释没有意义，请尝试阅读 文档 或此解释中的解释。

支持广播的函数称为通用函数。您可以在文档中找到所有通用函数的列表 。

以下是广播的一些应用：

import numpy as np

Compute outer product of vectors

v = np.array([1,2,3]) # v has shape (3,)
w = np.array([4,5]) # w has shape (2,)

To compute an outer product, we first reshape v to be a column

vector of shape (3, 1); we can then broadcast it against w to yield

an output of shape (3, 2), which is the outer product of v and w:

[[ 4 5]

[ 8 10]

[12 15]]

print(np.reshape(v, (3, 1)) * w)

Add a vector to each row of a matrix

x = np.array([[1,2,3], [4,5,6]])

x has shape (2, 3) and v has shape (3,) so they broadcast to (2, 3),

giving the following matrix:

[[2 4 6]

[5 7 9]]

print(x + v)

Add a vector to each column of a matrix

x has shape (2, 3) and w has shape (2,).

If we transpose x then it has shape (3, 2) and can be broadcast

against w to yield a result of shape (3, 2); transposing this result

yields the final result of shape (2, 3) which is the matrix x with

the vector w added to each column. Gives the following matrix:

[[ 5 6 7]

[ 9 10 11]]

print((x.T + w).T)

Another solution is to reshape w to be a column vector of shape (2, 1);

we can then broadcast it directly against x to produce the same

output.

print(x + np.reshape(w, (2, 1)))

Multiply a matrix by a constant:

x has shape (2, 3). Numpy treats scalars as arrays of shape ();

these can be broadcast together to shape (2, 3), producing the

following array:

[[ 2 4 6]

[ 8 10 12]]

print(x * 2)
广播通常会使您的代码更简洁、更快，因此您应该尽可能地使用它。

Numpy 文档
这个简短的概述涉及到您需要了解的有关 numpy 的许多重要事项，但还远未完成。查看 numpy 参考 以了解有关 numpy 的更多信息。

科学派
Numpy 提供了一个高性能的多维数组和基本工具来计算和操作这些数组。 SciPy 建立在此之上，并提供了大量对 numpy 数组进行操作的函数，可用于不同类型的科学和工程应用程序。

熟悉 SciPy 的最佳方法是 浏览文档。我们将重点介绍 SciPy 中可能对本课程有用的部分内容。

图像操作
SciPy 提供了一些处理图像的基本功能。例如，它具有将图像从磁盘读取到 numpy 数组、将 numpy 数组作为图像写入磁盘以及调整图像大小的功能。这是一个展示这些功能的简单示例：

from scipy.misc import imread, imsave, imresize

Read an JPEG image into a numpy array

img = imread(‘assets/cat.jpg’)
print(img.dtype, img.shape) # Prints “uint8 (400, 248, 3)”

We can tint the image by scaling each of the color channels

by a different scalar constant. The image has shape (400, 248, 3);

we multiply it by the array [1, 0.95, 0.9] of shape (3,);

numpy broadcasting means that this leaves the red channel unchanged,

and multiplies the green and blue channels by 0.95 and 0.9

respectively.

img_tinted = img * [1, 0.95, 0.9]

Resize the tinted image to be 300 by 300 pixels.

img_tinted = imresize(img_tinted, (300, 300))

Write the tinted image back to disk

imsave(‘assets/cat_tinted.jpg’, img_tinted)

左：原始图像。右图：着色和调整大小的图像。

MATLAB 文件
函数scipy.io.loadmat和scipy.io.savemat允许您读取和写入 MATLAB 文件。您可以在文档中了解它们 。

点之间的距离
SciPy 定义了一些有用的函数来计算点集之间的距离。

该函数scipy.spatial.distance.pdist计算给定集合中所有点对之间的距离：

import numpy as np
from scipy.spatial.distance import pdist, squareform

Create the following array where each row is a point in 2D space:

[[0 1]

[1 0]

[2 0]]

x = np.array([[0, 1], [1, 0], [2, 0]])
print(x)

Compute the Euclidean distance between all rows of x.

d[i, j] is the Euclidean distance between x[i, :] and x[j, :],

and d is the following array:

[[ 0. 1.41421356 2.23606798]

[ 1.41421356 0. 1. ]

[ 2.23606798 1. 0. ]]

d = squareform(pdist(x, ‘euclidean’))
print(d)
您可以在文档中阅读有关此功能的所有详细信息 。

一个类似的函数 ( scipy.spatial.distance.cdist) 计算两组点之间所有对之间的距离；您可以在文档中了解它 。

Matplotlib
Matplotlib是一个绘图库。本节简要介绍该matplotlib.pyplot模块，该模块提供了一个类似于 MATLAB 的绘图系统。

绘图
matplotlib 中最重要的函数是plot，它允许您绘制 2D 数据。这是一个简单的例子：

import numpy as np
import matplotlib.pyplot as plt

Compute the x and y coordinates for points on a sine curve

x = np.arange(0, 3 * np.pi, 0.1)
y = np.sin(x)

Plot the points using matplotlib

plt.plot(x, y)
plt.show() # You must call plt.show() to make graphics appear.
运行此代码会产生以下图：

只需一点点额外的工作，我们就可以轻松地一次绘制多条线，并添加标题、图例和轴标签：

import numpy as np
import matplotlib.pyplot as plt

Compute the x and y coordinates for points on sine and cosine curves

x = np.arange(0, 3 * np.pi, 0.1)
y_sin = np.sin(x)
y_cos = np.cos(x)

Plot the points using matplotlib

plt.plot(x, y_sin)
plt.plot(x, y_cos)
plt.xlabel(‘x axis label’)
plt.ylabel(‘y axis label’)
plt.title(‘Sine and Cosine’)
plt.legend([‘Sine’, ‘Cosine’])
plt.show()

您可以在文档中阅读有关该plot功能 的更多信息。

子图
subplot您可以使用该功能在同一图中绘制不同的东西。这是一个例子：

import numpy as np
import matplotlib.pyplot as plt

Compute the x and y coordinates for points on sine and cosine curves

x = np.arange(0, 3 * np.pi, 0.1)
y_sin = np.sin(x)
y_cos = np.cos(x)

Set up a subplot grid that has height 2 and width 1,

and set the first such subplot as active.

plt.subplot(2, 1, 1)

Make the first plot

plt.plot(x, y_sin)
plt.title(‘Sine’)

Set the second subplot as active, and make the second plot.

plt.subplot(2, 1, 2)
plt.plot(x, y_cos)
plt.title(‘Cosine’)

Show the figure.

plt.show()

您可以在文档中阅读有关该subplot功能 的更多信息。

图片
您可以使用该imshow功能显示图像。这是一个例子：

import numpy as np
from scipy.misc import imread, imresize
import matplotlib.pyplot as plt

img = imread(‘assets/cat.jpg’)
img_tinted = img * [1, 0.95, 0.9]

Show the original image

plt.subplot(1, 2, 1)
plt.imshow(img)

Show the tinted image

plt.subplot(1, 2, 2)

A slight gotcha with imshow is that it might give strange results

if presented with data that is not uint8. To work around this, we

explicitly cast the image to uint8 before displaying it.

plt.imshow(np.uint8(img_tinted))
plt.show()

总结

以上是生活随笔为你收集整理的Python Numpy 教程（使用 Jupyter 和 Colab）的全部内容，希望文章能够帮你解决所遇到的问题。

如果觉得生活随笔网站内容还不错，欢迎将生活随笔推荐给好友。