Numpy

ndarray对象创建

np.array

# 这会调整数组大小  
import numpy as np 
 
a = np.array([[1,2,3],[4,5,6]]) a.shape =  (3,2)  
print a 

np.zeros、np.ones

import numpy as np 
x = np.zeros((5,), dtype = np.int)  
print x

import numpy as np 
x = np.ones([2,2], dtype =  int)  
print x

np.asarray

# 将列表转换为 ndarray 
import numpy as np 
 
x =  [1,2,3] 
a = np.asarray(x)  

# 来自元组的 ndarray  
import numpy as np 
 
x =  (1,2,3) 
a = np.asarray(x)  
print a

range

# 使用 range 函数创建列表对象  
import numpy as np 
list = range(5)  
print list
 
# 从列表中获得迭代器  
import numpy as np 
list = range(5) 
it = iter(list)  
# 使用迭代器创建 ndarray 
x = np.fromiter(it, dtype =  float)  
print x

np.arange

import numpy as np
# 设置了 dtype
x = np.arange(5, dtype =  float)  
print x

# 设置了起始值和终止值参数  
import numpy as np
x = np.arange(10,20,2)  
print x
[10  12  14  16  18]

np.linspace

 
import numpy as np
x = np.linspace(10,20,5)  
print x

[10.   12.5   15.   17.5  20.]

np.logspace

import numpy as np
# 默认底数是 10
a = np.logspace(1.0,  2.0, num =  10)  
print a

# 将对数空间的底数设置为 2  
import numpy as np
a = np.logspace(1,10,num =  10,  base  =  2)  
print a
[ 2.     4.     8.    16.    32.    64.   128.   256.    512.   1024.]

切片和索引

通过将由冒号分隔的切片参数（start:stop:step）直接提供给ndarray对象
import numpy as np
a = np.arange(10)
b = a[2:7:2]  
print b
[2  4  6]

对始于索引的元素进行切片

import numpy as np
a = np.arange(10)  
print a[2:]
 [2  3  4  5  6  7  8  9]
 
# 对索引之间的元素进行切片  
import numpy as np
a = np.arange(10)  
print a[2:5]
[2  3  4]

import numpy as np
a = np.array([[1,2,3],[3,4,5],[4,5,6]])  
print a
# 对始于索引的元素进行切片  
print  '现在我们从索引 a[1:] 开始对数组切片'  
print a[1:]
 
[[1 2 3]
 [3 4 5]
 [4 5 6]]
 
现在我们从索引 a[1:] 开始对数组切片
[[3 4 5]
 [4 5 6]]

切片还可以包括省略号（…），来使选择元组的长度与数组的维度相同。 如果在行位置使用省略号，它将返回包含行中元素的ndarray。

# 最开始的数组  
import numpy as np
a = np.array([[1,2,3],[3,4,5],[4,5,6]])  
print  '我们的数组是：'  
print a
print  '\n'  
# 这会返回第二列元素的数组：  
print  '第二列的元素是：'  
print a[...,1]  
print  '\n'  
# 现在我们从第二行切片所有元素：  
print  '第二行的元素是：'  
print a[1,...]  
print  '\n'  
# 现在我们从第二列向后切片所有元素：
print  '第二列及其剩余元素是：'  
print a[...,1:]

 
我们的数组是：
[[1 2 3]
 [3 4 5]
 [4 5 6]]
 
第二列的元素是：
[2 4 5]
 
第二行的元素是：
[3 4 5]
 
第二列及其剩余元素是：
[[2 3]
 [4 5]
 [5 6]]

高级索引

import numpy as np 
 
x = np.array([[1,  2],  [3,  4],  [5,  6]]) 
y = x[[0,1,2],  [0,1,0]]  
print y

[1  4  5]
     
该结果包括数组中(0,0)，(1,1)和(2,0)位置处的元素。

获取了 4X3 数组中的每个角处的元素。 行索引是[0,0]和[3,3]，而列索引是[0,2]和[0,2]。
  
import numpy as np 
x = np.array([[  0,  1,  2],[  3,  4,  5],[  6,  7,  8],[  9,  10,  11]])  
print  '我们的数组是：'  
print x 
print  '\n' 
rows = np.array([[0,0],[3,3]]) 
cols = np.array([[0,2],[0,2]]) 
y = x[rows,cols]  
print  '这个数组的每个角处的元素是：'  
print y
 
我们的数组是：                                                                 
[[ 0  1  2]                                                                   
 [ 3  4  5]                                                                   
 [ 6  7  8]                                                                   
 [ 9 10 11]]
 
这个数组的每个角处的元素是：                                      
[[ 0  2]                                                                      
 [ 9 11]] 

import numpy as np 
x = np.array([[  0,  1,  2],[  3,  4,  5],[  6,  7,  8],[  9,  10,  11]])  
print  '我们的数组是：'  
print x 
print  '\n'  
# 切片
z = x[1:4,1:3]  
print  '切片之后，我们的数组变为：'  
print z 
print  '\n'  
# 对列使用高级索引 
y = x[1:4,[1,2]] 
print  '对列使用高级索引来切片：'  
print y
 
我们的数组是：
[[ 0  1  2] 
 [ 3  4  5] 
 [ 6  7  8]
 [ 9 10 11]]
 
切片之后，我们的数组变为：
[[ 4  5]
 [ 7  8]
 [10 11]]
 
对列使用高级索引来切片：
[[ 4  5]
 [ 7  8]
 [10 11]] 

布尔索引

import numpy as np 
x = np.array([[  0,  1,  2],[  3,  4,  5],[  6,  7,  8],[  9,  10,  11]])  
print  '我们的数组是：'  
print x 
print  '\n'  
# 现在我们会打印出大于 5 的元素  
print  '大于 5 的元素是：'  
print x[x >  5]
 
我们的数组是：
[[ 0  1  2] 
 [ 3  4  5] 
 [ 6  7  8] 
 [ 9 10 11]] 
 
大于 5 的元素是：
[ 6  7  8  9 10 11] 

 这个例子使用了~（取补运算符）来过滤NaN。
 
import numpy as np 
a = np.array([np.nan,  1,2,np.nan,3,4,5])  
print a[~np.isnan(a)]
[ 1.   2.   3.   4.   5.] 

广播

术语广播是指 NumPy 在算术运算期间处理不同形状的数组的能力。 对数组的算术运算通常在相应的元素上进行。 如果两个阵列具有完全相同的形状，则这些操作被无缝执行。

 
import numpy as np 
 
a = np.array([1,2,3,4]) 
b = np.array([10,20,30,40]) 
c = a * b 
print c

如果两个数组的维数不相同，则元素到元素的操作是不可能的。 然而，在 NumPy 中仍然可以对形状不相似的数组进行操作，因为它拥有广播功能。 较小的数组会广播到较大数组的大小，以便使它们的形状可兼容。

如果满足以下规则，可以进行广播：

ndim较小的数组会在前面追加一个长度为 1 的维度。

输出数组的每个维度的大小是输入数组该维度大小的最大值。

如果输入在每个维度中的大小与输出大小匹配，或其值正好为 1，则在计算中可它。

如果输入的某个维度大小为 1，则该维度中的第一个数据元素将用于该维度的所有计算。

如果上述规则产生有效结果，并且满足以下条件之一，那么数组被称为可广播的。

数组拥有相同形状。

数组拥有相同的维数，每个维度拥有相同长度，或者长度为 1。

数组拥有极少的维度，可以在其前面追加长度为 1 的维度，使上述条件成立。

下面的例称展示了广播的示例。

i

mport numpy as np 
a = np.array([[0.0,0.0,0.0],[10.0,10.0,10.0],[20.0,20.0,20.0],[30.0,30.0,30.0]]) 
b = np.array([1.0,2.0,3.0])  
print  '第一个数组：'  
print a 
print  '\n'  
print  '第二个数组：'  
print b 
print  '\n'  
print  '第一个数组加第二个数组：'  
print a + b
 
第一个数组：
[[ 0. 0. 0.]
 [ 10. 10. 10.]
 [ 20. 20. 20.]
 [ 30. 30. 30.]]
 
第二个数组：
[ 1. 2. 3.]
 
第一个数组加第二个数组：
[[ 1. 2. 3.]
 [ 11. 12. 13.]
 [ 21. 22. 23.]
 [ 31. 32. 33.]]
 

数组上的迭代

import numpy as np
a = np.arange(0,60,5) 
a = a.reshape(3,4)  
print  '原始数组是：'  
print a print  '\n'  
print  '修改后的数组是：'  
for x in np.nditer(a):  
    print x,
 
原始数组是：
[[ 0 5 10 15]
 [20 25 30 35]
 [40 45 50 55]]
 
修改后的数组是：
0 5 10 15 20 25 30 35 40 45 50 55

数组操作

numpy.ndarray.flat

该函数返回数组上的一维迭代器，行为类似 Python 内建的迭代器
import numpy as np 
a = np.arange(8).reshape(2,4) 
print '原始数组：' 
print a 
print '\n' 
 
print '调用 flat 函数之后：' 
# 返回展开数组中的下标的对应元素 
print a.flat[5]
 
原始数组：
[[0 1 2 3]
 [4 5 6 7]]
 
调用 flat 函数之后：
5

numpy.ndarray.flatten

该函数返回折叠为一维的数组副本
order：‘C’ – 按行，‘F’ – 按列，‘A’ – 原顺序，‘k’ – 元素在内存中的出现顺序。

import numpy as np 
a = np.arange(8).reshape(2,4) 
 
print '原数组：' 
print a 
print '\n'  
# default is column-major 
 
print '展开的数组：' 
print a.flatten() 
print '\n'  
 
print '以 F 风格顺序展开的数组：' 
print a.flatten(order = 'F')
 
原数组：
[[0 1 2 3]
 [4 5 6 7]]
 
展开的数组：
[0 1 2 3 4 5 6 7]
 
以 F 风格顺序展开的数组：
[0 4 1 5 2 6 3 7]

np.squeeze

函数从给定数组的形状中删除一维条目

import numpy as np  
x = np.arange(9).reshape(1,3,3) 
 
print '数组 x：' 
print x 
print '\n'  
y = np.squeeze(x) 
 
print '数组 y：' 
print y 
print '\n'  
 
print '数组 x 和 y 的形状：' 
print x.shape, y.shape
 
数组 x：
[[[0 1 2]
 [3 4 5]
 [6 7 8]]]
 
数组 y：
[[0 1 2]
 [3 4 5]
 [6 7 8]]
 
数组 x 和 y 的形状：
(1, 3, 3) (3, 3)

np.concatenate

数组的连接是指连接。 此函数用于沿指定轴连接相同形状的两个或多个数组

numpy.concatenate((a1, a2, ...), axis)

 
import numpy as np 
a = np.array([[1,2],[3,4]]) 
 
print '第一个数组：' 
print a 
print '\n'  
b = np.array([[5,6],[7,8]]) 
 
print '第二个数组：' 
print b 
print '\n'  
# 两个数组的维度相同 
 
print '沿轴 0 连接两个数组：' 
print np.concatenate((a,b)) 
print '\n'  
 
print '沿轴 1 连接两个数组：' 
print np.concatenate((a,b),axis = 1)
 
第一个数组：
[[1 2]
 [3 4]]
 
第二个数组：
[[5 6]
 [7 8]]
 
沿轴 0 连接两个数组：
[[1 2]
 [3 4]
 [5 6]
 [7 8]]
 
沿轴 1 连接两个数组：
[[1 2 5 6]
 [3 4 7 8]]

np.stack

此函数沿新轴连接数组序列

numpy.stack(arrays, axis)
 
import numpy as np 
a = np.array([[1,2],[3,4]]) 
 
print '第一个数组：' 
print a 
print '\n'
b = np.array([[5,6],[7,8]]) 
 
print '第二个数组：' 
print b 
print '\n'  
 
print '沿轴 0 堆叠两个数组：' 
print np.stack((a,b),0) 
print '\n'  
 
print '沿轴 1 堆叠两个数组：' 
print np.stack((a,b),1)
 
第一个数组：
[[1 2]
 [3 4]]
 
第二个数组：
[[5 6]
 [7 8]]
 
沿轴 0 堆叠两个数组：
[[[1 2]
 [3 4]]
 [[5 6]
 [7 8]]]
 
沿轴 1 堆叠两个数组：
[[[1 2]
 [5 6]]
 [[3 4]
 [7 8]]]

np.hstack

numpy.stack函数的变体，通过堆叠来生成水平的单个数组

import numpy as np 
a = np.array([[1,2],[3,4]]) 
 
print '第一个数组：' 
print a 
print '\n'  
b = np.array([[5,6],[7,8]]) 
 
print '第二个数组：' 
print b 
print '\n'  
 
print '水平堆叠：' 
c = np.hstack((a,b)) 
print c 
print '\n'
 
第一个数组：
[[1 2]
 [3 4]]
 
第二个数组：
[[5 6]
 [7 8]]
 
水平堆叠：
[[1 2 5 6]
 [3 4 7 8]]

np.vstack

numpy.stack函数的变体，通过堆叠来生成竖直的单个数组。

import numpy as np 
a = np.array([[1,2],[3,4]]) 
 
print '第一个数组：' 
print a 
print '\n'  
b = np.array([[5,6],[7,8]]) 
 
print '第二个数组：' 
print b 
print '\n'
 
print '竖直堆叠：' 
c = np.vstack((a,b)) 
print c
 
第一个数组：
[[1 2]
 [3 4]]
 
第二个数组：
[[5 6]
 [7 8]]
 
竖直堆叠：
[[1 2]
 [3 4]
 [5 6]
 [7 8]]

数组分割

np.split

np.hsplit

np.vsplit

np.resize

np.append

np.insert

np.delete

产生随机数

1.产生N维的均匀分布的随机数: np.random.rand(d1,d2,d3,…,dn)

2.产生n维的正态分布的随机数: np.random.randn(d1,d2,d3,…,dn)

3.产生n–m之间的k个整数：np.random.randint(n,m,k)

4.产生n个0–1之间的随机数: np.random.random(10)

5.从序列中选择数据: np.random.choice([2,5,7,8,9,11,3])

6.把序列中的数据打乱：np.random.shuffle(item)

np.random.rand

import numpy as np
 
#产生 5x5x5 维的均匀分布的随机数数组
print(np.random.rand(5,5,5))
 
#产生5x5x5维的正态分布的随机数数组
print(np.random.randn(5,5,5))
 
#产生n--m之间的k个整数 
print(np.random.randint(1,50,5))
 
#产生n个0--1之间的随机数
print(np.random.random(10))
 
#从序列中选择数据
print(np.random.choice([2,5,7,8,9,11,3]))
 
#把序列中的数据打乱
#np.random.shuffle(item) 不会参数返回值，改变的话是在原列表中修改的
item = [2,5,7,8,9,11,3]
np.random.shuffle(item)
print(item)

【0~1均匀分布float向量或数组】: 产生n个0-1之间的随机数: np.random.random(n)

如产生一个2×3×5维的0~1之间均匀分布的随机数数组如下

【n-m均匀分布int向量or数组】：产生n~m之间的个int型随机数数组：np.random.randint(n,m,size=d)

如产生一个2×3×4维的服从N ( 0 , 1 ) 的 N(0, 1)的N(0,1)的正态分布的随机数数组如下，我们可以看到只有少量在[-1,1]之外的随机数：

【随机抽取】：np.random.choice(list_or_array, size=None, replace=True, p=None)

这个choice的功能相比python内建的choice功能更强大，可以自定义每个元素被抽取概率以及是否有放回抽取

size：数组或列表的大小，1维填整数，多维填(d1,d2,....)
replace：是否是有放回抽取，True表示有，则可能多次抽取到重复值，False则不会抽取到重复值
p：列表或数组每个元素被抽取的概率prob，填写方式p=[p1,p2,…]，保证总概率=1即可

正态分布/高斯分布

生成高斯分布的概率密度随机数

numpy.random.normal(loc=0.0, scale=1.0, size=None)  

loc：float
    此概率分布的均值（对应着整个分布的中心centre）
scale：float
    此概率分布的标准差（对应于分布的宽度，scale越大越矮胖，scale越小，越瘦高）
size：int or tuple of ints
    输出的shape，默认为None，只输出一个值

nd1 = np.random.normal(loc=1,scale=2,size=2)
#array([-0.46982446, -1.28956852])

参考 :
https://blog.csdn.net/a373595475/article/details/79580734