基本概念

官网 https://docs.scipy.org/doc/
numpy的主要对象是同种元素的多维数组。
这是一个所有的元素都是一种类型、通过一个正整数元组索引的元素表格(通常是元素是数字)。
在numpy中维度(dimensions)叫做轴(axis)，轴的个数叫做秩(rank)。

• eg：

  [1, 2, 3]
  

  秩为1的数组，只有一个轴、轴长为3。
• eg：

  [[ 1.  0.  0.]
  [ 0.  1.  2.]]
  

  秩为2(它有两个维度).第一个维度长度为2，第二个维度长度为3。

numpy的数组类被称作ndarray。通常被称作数组。注意numpy.array和标准Python库类array.array并不相同，后者只处理一维数组和提供少量功能。更多重要ndarray对象属性有：

• ndarray.ndim 数组轴的个数，轴的个数被称作秩

• ndarray.shape 数组的维度。这是一个指示数组在每个维度上大小的整数元组。
  eg:一个2行3列的矩阵，它的shape属性将是(2,3),这个元组的长度是秩，即维度或者ndim属性

• ndarray.size 数组元素的总个数，等于shape属性中元组元素的乘积。

• ndarray.dtype 一个用来描述数组中元素类型的对象。

• ndarray.itemsize 数组中每个元素的字节大小。
  eg:

  import numpy as np
  arr = np.arange(15).reshape(3, 5)
  print("arr", arr)
  print("shape", arr.shape)  # (3,5)
  print("dtype", arr.dtype)  # (int32)
  print("size", arr.size)  # 15
  print("type", type(arr))  # <class 'nu py.ndarray'>
  

创建数组

• 使用array函数从常规的Python列表和元组创造数组。
  所创建的数组类型由原序列中的元素类型推导而来。

  import numpy as np
  arr = np.array([1, 2, 3, 4])
  # [1, 2, 3, 4]
  print(arr)
  

• 可以在创建时显示指定类型

  import numpy as np
  arr = np.array([1, 2, 3, 4],dtype=np.float32)
  # [1. 2. 3. 4.]
  print(arr)
  

• zeros创建一个全是0的数组
  参数：zeros(shape, dtype = float, order = 'C')

  import numpy as np
  arr = np.zeros((2,3))
  print(arr)
  #float64
  print(arr.dtype) 
  

• ones创建一个全1的数组
  参数：ones(shape, dtype=None, order='C')

  import numpy as np
  arr = np.ones((2,3))
  print(arr)
  #float64
  print(arr.dtype)
  

• empty创建一个内容随机并且依赖与内存状态的数组
  参数：empty(shape, dtype = float, order = 'C')

  import numpy as np
  arr = np.empty((2,3))
  print(arr)
  #float64
  print(arr.dtype)
  

• arange函数返回数组
  参数：arange(start = None, stop = None, step = None, dtype = None)
  由于有限的浮点数精度，通常无法预测获得的元素个数。

  import numpy as np
  arr = np.arange(10,40,10)
  #[10 20 30]
  print(arr)
  #int32
  print(arr.dtype)
  

• linspace 返回数组
  参数：linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

  import numpy as np
  arr = np.linspace(0,9,10)
  #[0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]
  print(arr)
  #float64
  print(arr.dtype)
  

random 类

numpy中利用random类获取随机数．

random()　

生成随机浮点数
默认为生成一个随机的浮点数，范围是在0.0~1.0之间，也可以通过参数size设置返回数据的size。

import numpy as np
# 生成一个随机的浮点数
r = np.random.random()
# 0.6590899579137934
print (r)
'''
[[0.89269339 0.56326053 0.79697541]
 [0.69644276 0.17902598 0.0084224 ]]
'''
# 指定size
print(np.random.random(size=(2,3)))

randint()

产生随机整数
参数: randint(low, high=None, size=None, dtype=’l’) 如果 high为None（默认值），则结果为[0，low ]
默认随机生一个整数int类型，可以指定这个整数的范围。

import numpy as np
# 产生 0-4 一个
print(np.random.randint(4))
# 产生 2-4 一个
print(np.random.randint(2,4))
# 产生 1-5 两个
print(np.random.randint(low=1,high=5,size=2))
# 产生 0-5 三个
print(np.random.randint(5, size=3))
# 产生 0-10 2行3列（2*3）
print(np.random.randint(10, size=(2, 3)))

normal() 　

高斯分布
参数: normal(loc=0.0, scale=1.0, size=None) loc：均值，scale：标准差，size：抽取样本的size 。

import numpy as np
import matplotlib.pyplot as plt
y=np.random.normal(0,1,5000)
print(y)
# 直方图
# 100个分块
plt.hist(y,bins=100)
plt.show()

randn()

正态分布产生一个浮点数或N维浮点数组 参数：randn(d0, d1, ..., dn)

import numpy as np
import matplotlib.pyplot as plt
y=np.random.randn(1000)
# 直方图
# 100个分块
plt.hist(y,bins=100)
plt.show()

standard_normal

标准正态分布产生一个浮点数或N维浮点数组 参数：standard_normal(size=None)

import numpy as np
import matplotlib.pyplot as plt
y=np.random.standard_normal((2000,1))
# 直方图
# 100个分块
plt.hist(y,bins=100)
plt.show()

rand()　

生成[0, 1) 间随机数

import numpy as np
# 0.7758272442386239
print(np.random.rand())
'''
[[0.07675678 0.72700556 0.31372113]
 [0.19674323 0.3332258  0.49691272]]
'''
print(np.random.rand(2,3))

shuffle() 　

随机打乱序列将序列的所有元素随机排序

import numpy as np
x=np.arange(10)
# [0 1 2 3 4 5 6 7 8 9]
print(x)
np.random.shuffle(x)
# 并没有产生新的数组
# [7 6 1 9 3 8 4 2 5 0]
print(x)

choice()

随机选取序列的一个元素，可以从序列(字符串、列表、元组等)中随机选取，返回一个列表，元组或字符串的随机项。

import numpy as np
x=np.arange(10)
# [0 1 2 3 4 5 6 7 8 9]
print(x)
# 5
print(np.random.choice(x))
# 输出6个小于5的元素  
# [1 3 2 2 1 1]
print(np.random.choice(5, 6))
import numpy as np
# 每个条目出现的概率。如果没有就均匀分布
# [0 3 2]
print(np.random.choice(5, 3, p=[0.1, 0, 0.3, 0.6, 0]))
x = ['a', 'b', 'c', 'd']
# ['a' 'c']
print(np.random.choice(x, 2, p=[0.1, 0, 0.9, 0]))

RandomState()

指定种子值，如不设置种子值时,np.random.randint(10)可能产生0-10内的任意整数，且每次产生的数字可能是任意一种。
设置种子值后,np.random.RandomState(0).randint(10)可能产生0-10内的任意整数，如果种子值不变则每次运行程序产生的数字一样。

import numpy as np

print(np.random.RandomState(0).randint(10))
print(np.random.RandomState(2).randint(10))
print(np.random.randint(10))

基本运算

数组的算术运算是按元素的。新的数组被创建并且被结果填充。

import numpy as np
a = np.array([1, 3, 5, 7, 9])
b = np.array([2, 4, 6, 8, 10])
# +
print(a+b)
# -
print(a-b)
# *
print(a*b)
# /
print(a/b)
# ^ **平方
print(b**2)
# %
print(b % 3)
# 并没有产生新的数组
print('------')
b += 2
print(b)
# -=
b -= 2
print(b)
# *=
b *= 2
print(b)

通用函数(ufunc)

numpy提供常见的数学函数如sin,cos和exp叫作“通用函数”(ufunc)。
这些函数作用按数组的元素运算，产生一个数组作为输出。

import numpy as np
x =np.arange(5)
# [0 1 2 3 4]
print(x)

# [ 0.          0.84147098  0.90929743  0.14112001 -0.7568025 ]
print(np.sin(x))
# [ 1.          0.54030231 -0.41614684 -0.9899925  -0.65364362]
print(np.cos(x))
# [0.         1.         1.41421356 1.73205081 2.        ]
print(np.sqrt(x))
# [ 1.          2.71828183  7.3890561  20.08553692 54.59815003]
print(np.exp(x))

索引，切片和迭

索引模式：start:stop:step

• 一维数组可以被索引、切片和迭代，就像列表和其它Python序列。
• 多维数组可以每个轴有一个索引。这些索引由一个逗号分割的元组给出。
• 当少于轴数的索引被提供时，确失的索引被认为是整个切片。
• 迭代多维数组是就第一个轴而言的。
• 对每个数组中元素进行运算，可以使用flat属性，该属性是数组元素的一个迭代器。

import numpy as np
x=np.arange(10)**2
# [ 0  1  4  9 16 25 36 49 64 81]
print(x)
# 1
print(x[1])
# [1 4]
print(x[1:3])
# [1 9] 
print(x[1:5:2])#start:stop:step

idx=[1,2,3]
# [1 4 9]
print(x[idx])
for item in x :
    print(item)
#--------------
m=np.arange(20).reshape(4,5)**2
'''
[[  0   1   4   9  16]
 [ 25  36  49  64  81]
 [100 121 144 169 196]
 [225 256 289 324 361]]
'''
print(m)
# 多维索引
# 169
print(m[2,3])
'''
[[  9]
 [ 64]
 [169]]
'''
print(m[0:3,3:4])# 0,1,2 行 3列
# [225 256 289 324 361]
print(m[-1])

for item in m.flat:
    print(item)

形状操作

• reshape函数改变参数形状并返回它，而resize函数改变数组自身

import numpy as np

x = np.arange(12)
# [ 0  1  2  3  4  5  6  7  8  9 10 11]
print(x)
# (12,)
print(x.shape)
# reshape函数改变参数形状并返回它，而resize函数改变数组自身。
# 返回新的数组
print(x.reshape(3, 4))
x.resize(3, 4)
print(x)
x.shape = (3, 4)
print(x)
# [ 0  1  2  3  4  5  6  7  8  9 10 11]
print(x.ravel())

a = np.array([[1, 2],
              [3, 4]])
b = np.array([[5, 6],
              [7, 8]])
'''
[[1 2]
 [3 4]
 [5 6]
 [7 8]]
'''
print(np.vstack((a, b)))
'''
[[1 2 5 6]
 [3 4 7 8]]
'''
print(np.hstack((a, b)))

布尔数组索引

import numpy as np

x = np.arange(12).reshape(3, 4)
'''
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
'''
print(x)
y = x > 6
'''
[[False False False False]
 [False False False  True]
 [ True  True  True  True]]
'''
print(y)

x[y]=100
'''
[[  0   1   2   3]
 [  4   5   6 100]
 [100 100 100 100]]
'''
print(x)

ref

方法

类型