Numpy学习笔记

常用函数

np.linspace(）

---

• linspace (linear space) 线性等分适量
• 可以选择是否使用最后一个数

import numpy as np
print(np.linspace(0, 10, num =21,endpoint=True))
# [ 0.   0.5  1.   1.5  2.   2.5  3.   3.5  4.   4.5  5.   5.5  6.   6.5
#   7.   7.5  8.   8.5  9.   9.5 10. ]

numpy.arange(start,end,step,dtype)

---

• arrange 安排，排列

• 一个参数时，参数值为终点，起点取默认值0，步长取默认值1。

• 两个参数时，第一个参数为起点，第二个参数为终点，步长取默认值1。

• 三个参数时，第一个参数为起点，第二个参数为终点，第三个参数为步长。其中步长支持小数。末尾不足舍弃

• 默认dtype为int，左开右闭

import numpy as np
if __name__ == '__main__':
     print(np.arange(10))
     print(np.arange(2,10))
     print(np.arange(1,10,2))
     print(np.arange(10.0))
     # [0 1 2 3 4 5 6 7 8 9]
     # [2 3 4 5 6 7 8 9]
     # [1 3 5 7 9]
     # [0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]

numpy.tile(A,reps)

---

• A 是矩阵或者列表
• reps为元组 第一个数为维度 第二个数为在各维度上重复A多少次

import numpy as np
if __name__ == '__main__':
    data = [1,2]
    print(np.tile(data, (1, 1)), end='\n\n')
    print(np.tile(data, (1, 2)), end='\n\n')
    print(np.tile(data, (2, 1)), end='\n\n')
    print(np.tile(data, (2, 2)), end='\n\n')
    print(np.tile(data, (2, 3)), end='\n\n')
    # [[1 2]]
    # 
    # [[1 2 1 2]]
    # 
    # [[1 2]
    #  [1 2]]
    # 
    # [[1 2 1 2]
    #  [1 2 1 2]]
    # 
    # [[1 2 1 2 1 2]
    #  [1 2 1 2 1 2]]

np.array()

---

• 将序列转化为数组

import numpy as np
data = [['zpp',193,18],['lxx','傻子','小胖子']]
print(data)
data1 = np.array(data)
print(type(data1))
print(data1)
# [['zpp', 193, 18], ['lxx', '傻子', '小胖子']]
# <class 'numpy.ndarray'>
# [['zpp' '193' '18']
#  ['lxx' '傻子' '小胖子']]

numpy.ndim(A)

---

• 表示A的秩 一维为1，二维为2 ，三维为3

np.flatten()

---

• 将多维数组压薄成为一维向量 flatten(使变薄)
• 默认是按行压缩，也可以选择按列压缩

import  numpy as np
a = np.array(
        [
            [1,2,3],
            [2,54,6]
        ]
)
print(a.flatten())
print(type(a.flatten()))
# [ 1  2  3  2 54  6]
# <class 'numpy.ndarray'>

np.reshape()

---

• 自定义数组大小
• numpy还有可以增加维度和减少维度的函数，可以用reshape 自定义数组大小也可以实现这样的功能

np.transpose()

---

• 翻转数组 np.transpose(A) 和 A.T是一样的
• 对一维向量的翻转是没有意义的，保持不变

import numpy
import numpy as np

a = np.arange(1,4, dtype=np.float_).reshape(1, 3)
print(a)
print(a.shape)
print(a.T)

b = np.array([1,2,3])
print(b)
print(b.shape)
print(b.T)

# [[1. 2. 3.]]
# (1, 3)
# [[1.]
#  [2.]
#  [3.]]
# [1 2 3]
# (3,)
# [1 2 3]

np.all/any()

• all 判断是否全为true
• fasle 判断是否存在一个true
• 可以用来判断两个多维数组是否相等

import numpy as np
a = np.random.randint(1, 3, size=(3, 3))
b = np.random.randint(1, 3, size=(3, 3))
print(a==b)
print(np.all(a==b))
print(np.any(a==b))
#
# [[ True  True False]
#  [False False False]
#  [ True  True False]]
# False
# True

逻辑运算

numpy.argmax/argmin(A，axis)

---

• 无axis 返回多维数组的最大索引,这时的索引是一个数，范围是这个多维数组的size
• 有axis，axis=0 表示列， axis=1表示行

import  numpy as np
if __name__ == '__main__':
    data = [
        [1,4,5],
        [23,3,4],
        [2,4,0] ]
print(data)
print(np.argmin(data,axis=0))
print(np.argmax(data,axis=1))
print(np.argmin(data))
# [[1, 4, 5], [23, 3, 4], [2, 4, 0]]
# [0 1 2]
# [2 0 1]
# 8

numpy.max/min/mean(A，axis)

---

• 返回指定维度的最大值/最小值/平均值
• 不指定维度代表范围为全局

import numpy as np
data = np.random.randint(1, 10, (2, 3))
print(data)
print(data.max(axis=0))
print(data.min(axis=0))
print(data.mean(axis=0))

# [[5 1 5]
#  [9 3 4]]
# [9 3 5]
# [5 1 4]
# [7.  2.  4.5]
# 

numpy.sum()

---

• 参数很多，也可以求指定维度的和
• 不指定维度，默认全局
• 两种调用方式 np.sum(data1) 或者data1.sum()

import numpy as np
data1 = np.random.randint(1, 10, (2, 3))
print(data1, end='\n\n')
print(data1.sum())

print(np.sum(data1))

# [[7 1 6]
#  [8 8 4]]
# 
# 34
# 34

多维数组的线性代数

• 线性代数 linear algebra 在numpy的numpy.linalg库中

• 多维数组的+ - * / 是两数组对应元素互相作用，并且不要行列一样

• 即使是二维数组和二维数组相乘 因为没用定义其为矩阵类型，所以加减乘除不是按照矩阵的数学定义进行的

• 在numpy中，有矩阵库，numpy.matlib

• np.dot() 向量为点积，二维看做是矩阵形式的乘法

import numpy as np

a = np.arange(9, dtype=np.float_).reshape(3, 3)
print('第一个数组：')
print(a)
print('\n')
print('第二个数组：')
b = np.array([10, 10, 10])
print(b)
print('\n')
print('两个数组相加：')
print(np.add(a, b))
# 或者写为a+b
print('\n')
print('两个数组相减：')
print(np.subtract(a, b))
# 或者写为a-b
print('\n')
print('两个数组相乘：')
print(np.multiply(a, b))
# 或者写为a * b
print('\n')
print('两个数组相除：')
print(np.divide(a, b))
# 或者写为a-b

# 第一个数组：
# [[0. 1. 2.]
#  [3. 4. 5.]
#  [6. 7. 8.]]
# 
# 
# 第二个数组：
# [10 10 10]
# 
# 
# 两个数组相加：
# [[10. 11. 12.]
#  [13. 14. 15.]
#  [16. 17. 18.]]
# 
# 
# 两个数组相减：
# [[-10.  -9.  -8.]
#  [ -7.  -6.  -5.]
#  [ -4.  -3.  -2.]]
# 
# 
# 两个数组相乘：
# [[ 0. 10. 20.]
#  [30. 40. 50.]
#  [60. 70. 80.]]
# 
# 
# 两个数组相除：
# [[0.  0.1 0.2]
#  [0.3 0.4 0.5]
#  [0.6 0.7 0.8]]

• numpy.dot() 对于两个一维的数组，计算的是这两个数组对应下标元素的乘积和(数学上称之为内积)；对于二维数组，计算的是两个数组的矩阵乘积

import numpy as np

a = np.arange(9, dtype=np.float_).reshape(3, 3)
print('第一个二维数组：')
print(a)
print('\n')
print('第二个二维数组：')
b = np.arange(0,9).reshape(3,3)
print(b)
print('\n')
print('矩阵相乘:\n',np.dot(a,b))