Python&NumPy教程

時間  2020-05-02
標籤 python&numpy python numpy 教程 欄目 Python 简体版
原文   原文鏈接

img

Blog: https://blog.yilon.tophtml

咱們將在本課程的全部做業中使用Python編程語言。Python自己就是一種偉大的通用編程語言，而且它在一些其餘流行的Python庫(numpy、sciy、matplotlib)的幫助下，它成爲了一個強大的科學計算環境。python

咱們但願大家中大部分人會有一點Python和numpy的使用經驗；由於對於大部分人來講，本節將做爲關於Python編程語言和使用Python進行科學計算的快速速成課程。git

大家中的一些人可能之前學過Matlab接觸過相關的知識，若是是這樣的話，我推薦大家看一下這篇文章：Numpy對於Matlab用戶。github

你還能夠在 這裏找到 由 Volodymyr Kuleshov 和 Isaac Caswell 爲 CS 228 建立的本教程的IPython筆記版本。web

目錄：算法

#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 的版本

目前有兩種不一樣的受支持版本的Python，分別是2.7和3.5。有點使人困惑的是，Python 3.0引入了許多向後兼容的語言更改，所以爲2.7編寫的代碼可能沒法在3.5下運行，反之亦然。因此咱們下面全部的示例的代碼都使用Python 3.5來編程。api

你能夠經過運行 python -version 在命令行中查看Python的版本。數組

#基本數據類型

與大多數語言同樣，Python有許多基本類型，包括整數，浮點數，布爾值和字符串。這些數據類型的行爲方式與其餘編程語言類似。app

Numbers(數字類型)：表明的是整數和浮點數，它原理與其餘語言相同：

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還有用於複數的內置類型；你能夠在這篇文檔中找到全部的詳細信息。

Booleans(布爾類型): Python實現了全部經常使用的布爾邏輯運算符，但它使用的是英文單詞而不是符號 (&&, ||, etc.)：

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"

Strings(字符串類型)：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"

String對象有許多有用的方法；例如：

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"

你能夠在這篇文檔中找到全部String方法的列表。

#容器(Containers)

Python包含幾種內置的容器類型：列表、字典、集合和元組。

#列表(Lists)

列表其實就是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']"

像往常同樣，你能夠在這篇文檔中找到有關列表的全部詳細信息。

切片(Slicing): 除了一次訪問一個列表元素以外，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數組的上下文中再次看到切片。

(循環)Loops: 你能夠循環遍歷列表的元素，以下所示：

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

列表推導式(List comprehensions): 編程時，咱們常常想要將一種數據轉換爲另外一種數據。 舉個簡單的例子，思考如下計算平方數的代碼：

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

#字典

字典存儲（鍵，值）對，相似於Java中的Map或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"

你能夠在這篇文檔中找到有關字典的全部信息。

(循環)Loops: 迭代詞典中的鍵很容易：

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"

字典推導式(Dictionary comprehensions): 相似於列表推導式，可讓你輕鬆構建詞典數據類型。例如：

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}"

#集合(Sets)

集合是不一樣元素的無序集合。舉個簡單的例子，請思考下面的代碼：

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"

與往常同樣，你想知道的關於集合的全部內容均可以在這篇文檔中找到。

循環(Loops): 遍歷集合的語法與遍歷列表的語法相同；可是，因爲集合是無序的，所以不能假設訪問集合元素的順序：

animals = {'cat', 'dog', 'fish'}
for idx, animal in enumerate(animals):
    print('#%d: %s' % (idx + 1, animal))
# Prints "#1: fish", "#2: dog", "#3: cat"

集合推導式(Set comprehensions): 就像列表和字典同樣，咱們能夠很容易地使用集合理解來構造集合：

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

#元組(Tuples)

元組是（不可變的）有序值列表。 元組在不少方面相似於列表; 其中一個最重要的區別是元組能夠用做字典中的鍵和集合的元素，而列表則不能。 這是一個簡單的例子：

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"

這篇文檔包含有關元組的更多信息。

#函數(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))
# 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函數的信息。

#類(Classes)

在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

Numpy是Python中科學計算的核心庫。它提供了一個高性能的多維數組對象，以及用於處理這些數組的工具。若是你已經熟悉MATLAB，你可能會發現這篇教程對於你從MATLAB切換到學習Numpy頗有幫助。

#數組(Arrays)

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(c)               # 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提供了幾種索引數組的方法。

切片(Slicing): 與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提供了許多用於操做數組的函數；你能夠在這篇文檔中看到完整的列表。

#廣播(Broadcasting)

廣播是一種強大的機制，它容許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中計算顯式循環可能會很慢。注意，向矩陣 x 的每一行添加向量 v 等同於經過垂直堆疊多個 v 副原本造成矩陣 vv，而後執行元素的求和x 和 vv。 咱們能夠像以下這樣實現這種方法：

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實際上具備形狀(4，3)，其中每一行都是v的副本，而且求和是按元素執行的。

將兩個數組一塊兒廣播遵循如下規則：

  1. 若是數組不具備相同的rank，則將較低等級數組的形狀添加1，直到兩個形狀具備相同的長度。
  2. 若是兩個數組在維度上具備相同的大小，或者若是其中一個數組在該維度中的大小爲1，則稱這兩個數組在維度上是兼容的。
  3. 若是數組在全部維度上兼容，則能夠一塊兒廣播。
  4. 廣播以後，每一個數組的行爲就好像它的形狀等於兩個輸入數組的形狀的元素最大值。
  5. 在一個數組的大小爲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的更多信息。

#SciPy

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.

運行此代碼會生成如下圖表：

sine

經過一些額外的工做，咱們能夠輕鬆地一次繪製多條線，並添加標題，圖例和軸標籤：

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

sine_cosine

你能夠在這篇文檔中閱讀有關繪圖功能的更多信息。

#子圖

你可使用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()

sine_cosine_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()

cat_tinted_imshow

#文章出處

由NumPy中文文檔翻譯，原做者爲 Justin Johnson，翻譯至：http://cs231n.github.io/python-numpy-tutorial/。

Blog: https://blog.yilon.top

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程