1  numpy基础：数组和矢量计算

• 1.1  创建ndarray
  • 1.1.1  使用array函数，它接受一切序列型对象
  • 1.1.2  使用zeros和ones函数创建数组
• 1.2  ndarray的数据类型
• 1.3  数组和标量之间的运算
• 1.4  基本的索引和切片
  • 1.4.1  切片索引
• 1.5  布尔型索引
  • 1.5.1  利用布尔型数组调整数值
  • 1.5.2  通过一维布尔数组设置整行或整列
• 1.6  花式索引
• 1.7  数组转置和轴对换
• 1.8  通用函数： 快速的元素级数组函数
• 1.9  利用数组进行数据处理
  • 1.9.1  将条件逻辑表述为数组运算
  • 1.9.2  数学和统计方法
  • 1.9.3  用于布尔型数组的方法
  • 1.9.4  排序
  • 1.9.5  唯一化以及其他的集合逻辑
• 1.10  用于数组的文件输入输出
  • 1.10.1  将数组以二进制的形式保存（暂时用不到）
  • 1.10.2  作为文本文件存取数组（暂时用不到，相关读写操作可以用pandas组件实现）
• 1.11  线性代数
• 1.12  随机数生成

随着机器学习等相关学科的兴起，python的使用量和关注程度日益上升，而numpy作为机器学习中必不可少的一个库，特地整理并记录如下。中间省略了一些我认为十分基础的部分，同时也增加了一些我认为十分有意思值得关注或者有益于理解numpy逻辑的部分。

numpy基础：数组和矢量计算

import numpy as np

data = np.array([[0.95, -0.24, -0.88], [0.56, 0.23, 0.91]])

data * 10
data

data

data * 10

• ndarray 是一个同构数据多维容器，即所有数据为相同类型

data.shape  # shape为属性   表示各维度大小的元组
data.dtype  # dtype说明数组数据类型的对象

创建ndarray

使用array函数，它接受一切序列型对象

data1 = [6, 7, 8, 6.5, 0, 1]
arr1 = np.array(data1)
arr1

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

使用zeros和ones函数创建数组

np.zeros(10)

np.zeros((2, 3))

np.empty((2, 2, 3))

• arange 是Python内置函数range的数组版本

np.arange(10)

ndarray的数据类型

• dtype用来将ndarray解释为特定数据类型

arr1 = np.array([1, 2], dtype=np.float64)

arr2 = np.array([1, 2], dtype=np.int32)

print(arr1.dtype)
print(arr2.dtype)

• 通过astype可以显示地转换dtype

arr = np.array([1.2, 1.3, 1, 3, 4])
arr.dtype

int_arr = arr.astype(np.int32)
int_arr.dtype

• 如果某字符串全部为数字，可以用astype将其转化为数值

numeric_strings = np.array(['1.2', '1.5'], dtype=np.string_)
numeric_strings.dtype

numeric_strings.astype(np.float64)

• astype可以接受其他ndarray.dtype作为输入。这应该不难理解。

• second

  ---

   print('hi')

数组和标量之间的运算

• 大小相等的数组之间的所有运算都是元素级的

arr = np.arange(10)

arr + arr

arr ** 0.5     # ** 表示指数

arr

基本的索引和切片

arr

• 切片时为 左包含右不包含

arr[5:8]

arr[5:8] = 12

• 数组切片后依旧是一个数组

arr

• 数组切片后，对切片的操作直接作用在源数组上

arr_slice = arr[5:8]
arr_slice[1] = 12345
arr

arr_slice[:] = 64

arr

• 如果要得到一个切片的副本而非视图，需要显示的使用arr[5:8].copy

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

• 对于2d数组的索引 以下两种方式是等价的

arr2d[0][2]

arr2d[0, 2]

• 下图为ndarrary数组的索引方式
  

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

arr3d

arr3d[0]

切片索引

arr[1:6]

• 对于多维度的数组，可以一次传入多个切片，中间用逗号，隔开

arr2d[:2, 1:]

• 通过将索引和切片结合，可以获得低维的切片

arr2d[1, :2]

arr2d[1]

arr2d

• 值得注意地：冒号表示选取整个轴

arr2d[:, :1]

• 二维数组切片示意图
  

布尔型索引

• 使用randn函数生成一些正态分布的随机数据

names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])
data = np.random.randn(7, 4)  # 书中只使用了 randn 有误

names

data

data[:2, 2:]

names == 'Bob'

• 这个布尔数组可以用于索引 数组长度必须和被索引数组长度一致

data[names == 'Bob']

• - 可以用来对布尔值进行取反

• 在Python中 与 和 或 只用一个符号来表示

mask = (names == 'Bob') | (names == 'Will')

mask

data[mask]

利用布尔型数组调整数值

data[data < 0] = 0

data

通过一维布尔数组设置整行或整列

data[names != 'Joe'] = 7

data

花式索引

• 利用整数数组进行索引

arr = np.empty((8, 4))
for i in range(arr.shape[0]):
    arr[i] = i

arr

# 在选取特定顺序行子集时，可以传入一个用于指定顺序的整数列表或ndarray

arr[[4, 3, 0, 6]]

• 使用 负数 索引会从末尾开始选取行

arr[[-1, -5, -7]]

• 一次传入多个索引数组，相当于是分别对行和列索引，返回对应位置的元素

arr = np.arange(32).reshape((8, 4))
arr  # arange 和 reshape 搭配使用可以快速构造一些简单数组

arr[[1, 5, 7, 3], [0, 3, 1, 2]]

arr[[1, 5, 7, 3]][:, [0, 3, 1, 2]]

• np.ix_可以将连个一维整数数组转换为选取方形区域的索引器

arr[np.ix_([1, 5, 7, 2], [0, 3, 1, 2])]

• 花式索引会复制一个数组的副本

数组转置和轴对换

• 转置时重塑的一种特殊形式，它返回源数据的视图

arr = np.arange(15).reshape((3, 5))
arr

arr.T

arr = np.random.randn(6, 3)

np.dot(arr.T, arr)

arr = np.arange(16).reshape((2, 2, 4))
arr

arr.transpose((1, 0, 2))

通用函数： 快速的元素级数组函数

arr = np.arange(10)
np.sqrt(arr)

np.exp(arr)

x = np.random.randn(8)
y = np.random.randn(8)

x

y

np.maximum(x, y)

arr = np.random.randn(8) * 5
np.modf(arr)

arr

利用数组进行数据处理

points = np.arange(-5, 5, 0.01)
xs, ys = np.meshgrid(points, points)
ys

ys.shape

import matplotlib.pyplot as plt
z = np.sqrt(xs ** 2 + ys ** 2)
z

plt.imshow(z, cmap=plt.cm.gray)

plt.title('Image plot of $\sqrt{x^2 + y^2}$ for a grid of values')

将条件逻辑表述为数组运算

xarr = np.array([1.1, 1.2, 1.3, 1.4, 1.5])
yarr = np.array([2.1, 2.2, 2.3, 2.4, 2.5])
cond = np.array([True, False, True, True, False])

result = [(x if c else y) for x, y, c in zip(xarr, yarr, cond)]
result

# 使用np.where来实现
result = np.where(cond, xarr, yarr)
result

arr = np.random.randn(4, 4)
arr

np.where(arr > 0, 2, -2)

np.where(arr > 0, 2, arr)

数学和统计方法

arr = np.random.randn(5, 4)

arr.mean()

np.mean(arr)

• 既可以作为数组的一个实例方法调用，也可以作为Numpy的顶级函数使用。

arr.mean(1)

arr = np.arange(9).reshape((3, 3))

arr.cumsum(0)

arr.cumsum(1)  # cumsum 为依次相加，参数为轴的方向

arr.cumprod(0)

• 基本数组统计方法
  

用于布尔型数组的方法

arr = np.random.randn(100)

(arr > 0 ).sum()   # 可以用sum函数对布尔值进行计数

45

bools = np.random.randn(5)

bools = np.where(bools > 0 , True,False)

bools

array([False, False,  True, False, False], dtype=bool)

bools.any()

True

bools.all()  # any 和 all 用来检测数组中真值的数量，存在，全部都是

False

排序

arr = np.random.randn(9)

arr

array([ 0.56648394,  0.09646596,  2.52960358,  1.01392528,  1.01635798,
        0.50707351,  0.6003978 ,  0.40438106, -0.40787323])

arr.sort()

arr

array([-0.40787323,  0.09646596,  0.40438106,  0.50707351,  0.56648394,
        0.6003978 ,  1.01392528,  1.01635798,  2.52960358])

arr = np.random.randn(5,3)

arr.sort(1)
arr        # sort函数可以用来对数组进行排序

array([[-0.09580399,  0.29251832,  1.03958502],
       [-0.56989704, -0.53186181,  0.5750816 ],
       [-0.8406608 ,  0.68156895,  2.12098301],
       [-0.35232795,  0.44457186,  1.13045437],
       [-0.74018734, -0.31642068,  1.46136771]])

• np.sort 方法会返回一个数组的副本；而实例本身调用sort方法则会修改数组本身

large_arr = np.random.randn(1000)
large_arr.sort()

large_arr[int(0.05 * len(large_arr))] # 计算 5% 分位数

-1.5427390296814982

唯一化以及其他的集合逻辑

names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])
np.unique(names)

array(['Bob', 'Joe', 'Will'],
      dtype='<U4')

• 数组的集合运算
  

用于数组的文件输入输出

将数组以二进制的形式保存（暂时用不到）

作为文本文件存取数组（暂时用不到，相关读写操作可以用pandas组件实现）

线性代数

x = np.arange(6).reshape((2,3))

x

array([[0, 1, 2],
       [3, 4, 5]])

y = np.arange(6).reshape((3,2))

x.dot(y)

array([[10, 13],
       [28, 40]])

y.dot(x)

array([[ 3,  4,  5],
       [ 9, 14, 19],
       [15, 24, 33]])

• numpy.linalg 中有一组标准的矩阵分解运算之类的函数

from numpy.linalg import inv,qr

X = np.random.randn(5,5)

mat = X.T.dot(X)

mat

array([[ 6.6222079 ,  2.37024094,  3.04849725, -6.13510153, -2.06561393],
       [ 2.37024094,  8.98202163,  4.6212979 , -3.02490862,  4.15413675],
       [ 3.04849725,  4.6212979 ,  5.14422425, -1.59640215,  2.76677395],
       [-6.13510153, -3.02490862, -1.59640215,  8.14871046,  4.16424202],
       [-2.06561393,  4.15413675,  2.76677395,  4.16424202,  6.8966607 ]])

inv(mat)

array([[  6.92376649,   7.23887753,  -2.51673305,  11.65615503,
         -8.31493388],
       [  7.23887753,   8.55271051,  -2.51461368,  13.22100216,
         -9.95764339],
       [ -2.51673305,  -2.51461368,   1.39594234,  -3.84337402,
          2.52150043],
       [ 11.65615503,  13.22100216,  -3.84337402,  21.04459734, -15.6373916 ],
       [ -8.31493388,  -9.95764339,   2.52150043, -15.6373916 ,  12.0828665 ]])

I = mat.dot(inv(mat))

np.where(np.fabs(I) < 0.01,0,I)

array([[ 1.,  0.,  0.,  0.,  0.],
       [ 0.,  1.,  0.,  0.,  0.],
       [ 0.,  0.,  1.,  0.,  0.],
       [ 0.,  0.,  0.,  1.,  0.],
       [ 0.,  0.,  0.,  0.,  1.]])

q,r = qr(mat)

q

array([[-0.66000935,  0.16706919, -0.25898634, -0.58912734, -0.34975791],
       [-0.23623257, -0.76590412,  0.41085523,  0.11550852, -0.41885655],
       [-0.3038317 , -0.28146184, -0.73802815,  0.52204446,  0.10606395],
       [ 0.61146138, -0.07062138, -0.41330024, -0.13285758, -0.65776848],
       [ 0.2058716 , -0.54888124, -0.22050263, -0.59110507,  0.50825156]])

r

array([[-10.03350621,  -6.08472005,  -5.07325425,  11.08876476,
          3.50744819],
       [  0.        ,  -9.85059669,  -5.88395418,  -1.12001765,
         -8.38504438],
       [  0.        ,   0.        ,  -2.63770457,  -2.76179267,
         -3.04205653],
       [  0.        ,   0.        ,   0.        ,  -1.11256208,
         -1.48877537],
       [  0.        ,   0.        ,   0.        ,   0.        ,
          0.04206382]])

---

• 常用的numpy.linalg函数
  
  

  ---

随机数生成

• 随机数组生成函数
  

参考来源

• 利用Python进行数据分析