python学习--numpy

import numpy as np

ndarray(同类型数据集合,以 0 下标开始索引元素) 内部至少包含以下内容:
    一个指向数据（内存或内存映射文件中的一块数据）的指针
    数据类型或 dtype，描述在数组中的元素类型(dtype 是一个类,每个支持的数据类型都是此类的一个实例)
    数组形状（shape）元组
    数组跨度（stride）元组,跨度可以是负数，这样会使数组在内存中后向移动，eg. obj[::-1](一维np.array切片) 或 obj[:,::-1] (2维np.array切片) (所以切片起始是一个复制的过程 ?)

1. numpy 与 list 的互相转化:

    构造 np.array() 时传入list将得到对应的ndarray, eg.二维 list 得到二维 np.array

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

    np.array 直接加 list() 强制转换得到对应的list, eg.二维 np.array 得到 list 组成的 list（看起来 v = d.tolist()转换的更完全）

v = tuple(map(str,list(d)))    #将d (ndarray) 转为list,然后把 list 中每一个值转成 str ,再组织成tuple

2. 除了提供使用list构造 np.array 之外, numpy还提供了其他方法, (const sequence random)

np.zeros(shape=10, dtype=np.float64)      # 返回 10个0 组成的一维 np.array
np.zeros(shape=(10,20), dtype=np.float64) # 返回 全0 组成的二维 np.array
np.ones(shape=10, dtype=np.float64)       # 返回 10个1 组成的一维 np.array
np.ones(shape=(10,20), dtype=np.float64)  # 返回 全1 组成的二维 np.array
np.full(shape=(10,20), fill_value=123, dtype=np.float64)  # 返回 一个二维 np.array, 默认值为123

np.linspace(start=1.0, stop=5.0, num=10, endpoint=False, retstep=True, dtype=np.float64)
                        # 创建一维 np.array (后面可以做 reshape() 转化为多维),
                        # 在 1.0-->5.0 按均匀间隔生成10个点,
                        # endpoint 默认 True, 表示包含5,
                        # retstep 默认 False, 为True则将 step 也返回
np.arange(start=10, stop=30, step=0.5, dtype=np.float64)
                        # 创建一维 np.array (后面可以做 reshape() 转化为多维),
                        # 生成前闭后开区间,步长为0.5, start 默认0, step 默认1,dtype 默认 int64

np.random.random(10)               # 生成10个[0,1)之间的随机浮点数,返回一维 np.array
np.random.random((2,3))            # 生成(2*3)个[0,1)之间的随机浮点数,返回二维 np.array
np.random.randint(low=0, high=10, size=5)      # 在[0,10)之间产生5个随机整数,返回一维 np.array
np.random.randint(low=0, high=10, size=(3,5))  # 在[0,10)之间产生3*5个随机整数,返回二维 np.array
np.random.normal(loc=0,scale=1,size=(2,3)) # 生成一个均值0,标准差1,的正态分布,存放在二维 np.array中

 还有一些直接生成矩阵的方法,eg.np.eye(4) 生成一个4*4的对角矩阵(单位矩阵)

3. np.array 的一些属性:

np_arr.ndim         # np.array 的维度,eg.三维就是 3
np_arr.shape        # np.array 每个维度的尺寸,eg. 三维就是三个数组成的元组
np_arr.dtype.name   # np.array 的类型名字
np_arr.itemsize     # np.array 每个元素字节数,eg. sizeof(float64)
np_arr.size         # np.array 的dim size (没有sizeof的)

np_arr.reshape(row=3,column=5)
np_arr.reshape(-1,5)    #numpy将自动计算-1对应的值

np_arr[a , b]      # access二维数组的第 a 行第 b 列元素(类似list的访问方式), a 和 b 还可以是 一个list,甚至 np.array (FancyIndexing,更灵活的切片)
np_arr[: , 3]      # 取二维数组的所有行,第3列组成的 np.array.(类似list的切片方式)
np_arr[: , 1:5]    # 取二维数组的所有行,第1-5列(左闭右开)组成的 np.array.(类似list的切片方式)
np_arr[: , 0:5:2]  # 取二维数组的所有行,第0-5列(左闭右开,步长2)组成的 np.array.(类似list的切片方式)
np_arr[: , ::-1]   # 取二维数组的所有行,并将列倒置组成的 np.array.(类似list的切片方式)
np_arr[np_arr[0] > 0, :]    # 以bool类型组成的list作为索引,会起到类似过滤的效果,eg. np_arr[list_a == 'ABC', :]

4. 关于 FancyIndexing

可以从一维度 np.array 中生成多维度 np.array,或从多维度 np.array 生成一维度 np.array 

a = np.arange(15)
b = np.array([[0,2],[1,3]])    #原始数据是一维,所以用一个 np.array 作为索引,此 index是二维,所以结果是二维
c = a[b]    # c 的维度与b相同,不同在于c中存放的数据可看作 以b中数据为 index 到a中拿取的数据
row = np.array([0,1,2])        #原始数据是二维,所以用两个 np.array 作为索引,此 index是一维,所以结果是一维
col = np.array([3,4,5])        #原始数据是二维,所以用两个 np.array 作为索引,此 index是一维,所以结果是一维
d = c[row,col]    # 假设c为二维度 np.array,则 d 就是取其中的三个位置处的点(0,3) (1,4) (2,5) 组成的一维度np.array

    若要从多维得到多维, row和col必须都是多维(不可以广播)

5. 运算

两个 np.array 之间 可以进行 eltwise 加减乘除运算 或具有广播功能的运算
类似的还有  np.minimum(a,b) (返回a b中对应元素更大的那个元素组成的np.array)

a+b   # 或 np.add(a,b),
a-b   # 或 np.sub(a,b),
a*b   # 或 np.mul(a,b),
a/b   # 或 np.div(a,b),
a+3 , a-3 , a*5 , a/5 # 广播
>     # 或 np.greater(a,b)(返回 np.array,元素为bool类型)(得到的结果也是可以作为index取值,过滤掉为False的那些值),eg.a[a>10,:].
<,==, &与 |或 # np.any(x==0) 返回bool,x中有任何一个元素 ==0 即返回True, np.all(x>0) x中所有元素均 >0 时返回True

map 操作

np.exp(a), np.sin(a), np.cos(a), np.tan(a), np.sqrt(a), np.abs(a) 对应元素操作后得到新的ndarray

reduce 操作(可用于统计运算)

a.sum(axis=0)    # 将第0维度取sum,reduce为1(省略axis的话则对全部元素求sum). eg. a.shape(3,4),则运算后shape为(1,4),相当于是对 每一列 取和
a.min(axis=1)    # 将第1维度取min,reduce为1.
a.max(axis=1)    # 取最大值
a.mean(axis=0)   # 取平均值
a.median(axis=0) # 取中位数

求索引 (类似的还有argmin)

np.argmax(a) 或 a.argmax()
# 寻找a中最大元素对应的index(多维数组则index是reshape成一维后对应的index)

np.argmax(a,axis=0) 或 a.argmax(axis=0)
# 沿着a的第0维度方向寻找max元素对应的index(返回一个第0维度为1,其他维度与a相同的np.array)
# 利用 FancyIndexing 可以找到某行或列对应元素的max元素

np.argsort(a,axis=0) 或 a.argsort(axis=0)
# 返回一个与 a 同维度的 np.array,其第0维度的值是 a的第0维度元素从小到大排序后
#   在原 np.array 该维度中的index
# 原型是 np.argsort(a, axis=-1, kind='quicksort', order=None)
#   (axis默认是最后一个维度, 若想整体排序可以使用reshape)
# 假设结果是b,利用 FancyIndexing 可以得到 排序了的 np.array,等同于直接
#   对原 np.array 做 np.sort(a,axis=0) 操作(返回副本,而a.sort(axis=0)将直接改变原值!)

#example:利用 argsort 和 FancyIndexing 实现 np.sort 相同的效果
a = np.random.randint(10,size=(5,4))
b = a.argsort(0)

# 假设 row 是这样
# [[2 1 0 2]
#  [4 2 1 1]
#  [0 3 4 0]
#  [3 0 2 3]
#  [1 4 3 4]]
# 那么 col 应该是这样(list或np.array都可)
# [[0, 1, 2, 3]
#  [0, 1, 2, 3]
#  [0, 1, 2, 3]
#  [0, 1, 2, 3]
#  [0, 1, 2, 3]]
row=b
#col=[[i for i in range(b.shape[1])] for j in range(b.shape[0])]
# np.broadcast_to(np_arr, shape=(a,b,c,d)),其中 np_arr 的shape必须是　(a/1, b/1, c/1, d/1)
# 即某个 dim 要么为1 要么和第二个 shape 参数对应的 dim 相等
col=np.broadcast_to(np.array([i for i in range(b.shape[1])]), row.shape)

print(a[row,col])    #等同于 a.sort(0) 后 print(a) 或 print(np.sort(a,0))

 类型转化

a.astype(float)    # 不管 np.array 原来的元素是什么类型,都将返回一个float组成的 np.array

 对于 二维 np.array,有一些专属于 矩阵 的操作
 矩阵点乘
    np.dot(a,b)  # 或 a.dot(b)  (需要满足矩阵点乘的shape要求  eg. a.shape=(3,5), b.shape=(5,4)  )
 矩阵转置  a.T
 矩阵求逆  (矩阵求逆的条件是矩阵的行数和列数目相同,矩阵 与其 逆矩阵 的 点乘 结果为 单位矩阵)
    np.linalg.inv(a), 或者 先将np.array转换为 A = np.matrix(a),再A.I

np.tile(np_arr, shape)  函数: 像铺瓷砖一样横向或纵向复制 array

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

res = np.tile(np_arr, shape=(1, 4))
# res = [[1 2 1 2 1 2 1 2]
#        [3 4 3 4 3 4 3 4]]

res = np.tile(np_arr, shape=(3, 1))
#res = [[1 2]
#       [3 4]
#       [1 2]
#       [3 4]
#       [1 2]
#       [3 4]]

res = np.tile(np_arr, shape=(3, 4))
# res = [[1 2 1 2 1 2 1 2]
#        [3 4 3 4 3 4 3 4]
#        [1 2 1 2 1 2 1 2]
#        [3 4 3 4 3 4 3 4]
#        [1 2 1 2 1 2 1 2]
#        [3 4 3 4 3 4 3 4]]

# https://www.runoob.com/numpy/numpy-tutorial.html