[人工智能]numpy

Numpy概述

NumPy 是 Python 语言的一个扩展程序库，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。NumPy 是一个运行速度非常快的数学库，主要用于数组计算，主要功能包括线性代数、傅里叶变换、随机数生成等功能。底层核心是ndarray。

Numpy特点

• 代码更简洁：Numpy直接以数组、矩阵为粒度进行计算，并且支持大量的数学函数；
• 性能更高效：Numpy底层采用C语言实现、释放了GIL锁、算法更先进；
• 是其他数据科学库的基础：Numpy是Pandas、SciPy、Scikit-Learn、Tensorflow等库的基础

Numpy安装

pip install numpy
pip install numpy -i https://pypi.douban.com/simple/

若pip安装不成功可以通过wheel方式安装

# whl文件名称是：numpy-1.21.1-cp38-cp38-win_amd64.whl，若安装不成功，将其名称改为numpy-1.21.1-cp38-none-win_amd64.whl
pip install numpy-1.21.1-cp38-cp38-win_amd64.whl
pip install numpy-1.21.1-cp38-none-win_amd64.whl

获取当前版本

import numpy as np
print(np.__version__)

获取帮助信息

import numpy as np
print(help(np.info(np.random.rand)))

ndarray对象

NumPy 最重要的一个特点是其 N 维数组对象 ndarray，它是一系列同类型数据的集合，以 0 下标为开始进行集合中元素的索引。

ndarray特点

• ndarray 对象是用于存放同类型元素的多维数组
• ndarray 中的每个元素在内存中都有相同存储大小的区域

ndarray内部结构

• 一个指向数据（内存或内存映射文件中的一块数据）的指针。
• 数据类型或 dtype，描述在数组中的固定大小值的格子。
• 一个表示数组形状（shape）的元组，表示各维度大小的元组。
• 一个跨度元组（stride），其中的整数指的是为了前进到当前维度下一个元素需要"跨过"的字节数。

性能对比

import numpy as np
import time

def sum(n):
    param1 = [i ** 2 for i in range(n)]
    param2 = [i ** 3 for i in range(n)]
    result = []
    for i in range(n):
        result.append(param1[i] + param2[i])
    return result

time_begin = time.time()
sum(1000000)
time_end = time.time()
print(time_end - time_begin)  # 622ms

def sum1(n):
    param1 = np.arange(n) **2
    param2 = np.arange(n) **3
    return param1 + param2

time_start = time.time()
sum1(1000000)
time_stop = time.time()
print(time_stop - time_start)  # 9ms

Numpy基本操作

创建数组

array函数

import numpy as np
np.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)

import numpy as np

arr1 = np.array([1, 2, 3])
print(arr1)  # 一维数组

arr2 = np.array([[1, 2, 3], [4, 5, 6]])
print(arr2)  # 二维数组

arr3 = np.array([[[1, 2], [3, 4]], [[1, 2], [3, 4]]])
print(arr3)  # 三维数组

# 通过指定维数(ndim)创建数组
arr4 = np.array([1, 2, 3, 4, 5], ndmin=2)
print(arr4)  # [[1 2 3 4 5]]

python列表创建数组

import numpy as np

num_list = [4, 5, 6, 7]
result = np.array(num_list)
print(result)  # [4 5 6 7]
print(type(result))  # <class 'numpy.ndarray'>
print(result.size)  # 4
print(result.shape)  # (4,)

python元组创建数据

import numpy as np

num_list = (4, 5, 6, 7)
result = np.array(num_list)
print(result)  # [4 5 6 7]
print(type(result))  # <class 'numpy.ndarray'>
print(result.size)  # 4
print(result.shape)  # (4,)

python集合创建数组

import numpy as np

# 采用集合创建numpy数组时，将集合整体作为数组的一个元素
num_list = {4, 5, 6, 7}
result = np.array(num_list)
print(result)  # {4, 5, 6, 7}
print(type(result))  # <class 'numpy.ndarray'>
print(result.size)  # 1
print(result.shape)  # ()

字典创建数组

import numpy as np

# 采用字典创建numpy数组时，将字典整体作为数组的一个元素
dic_list = {
    "name": "Mary",
    "age": 18
}
result3 = np.array(dic_list)
print(result3)  # {'name': 'Mary', 'age': 18}
print(type(result3))  # <class 'numpy.ndarray'>
print(result3.size)  # 1
print(result3.shape)  # ()

通过集合和字典创建时属性值与预期不同。通常numpy与list结合使用

数据类型dtype

默认类型

import numpy as np

num_list = np.array([3, 5, 6, 8])
print(num_list.dtype)  # int32

num_list1 = np.array([4.5, 2.4, 7.5])
print(num_list1.dtype)  # float64

num_list2 = np.array([1 + 3j, 3 + 5j])
print(num_list2.dtype)  # complex128

Numpy整形、浮点型、复数默认的值为int32、float64、complex128

指定类型创建数组

import numpy as np

arr = np.array([1, 2, 3, 4], dtype=bool)
print(arr)  # [ True  True  True  True]

arr1 = np.array([1, 2, 3, 4], dtype=np.float32)
arr1_1 = np.array([1, 2, 3, 4], dtype=float)
print(arr1)    # [1. 2. 3. 4.]
print(arr1_1)  # [1. 2. 3. 4.]

arr2 = np.array([1, 2, 3, 4], dtype=str)
print(arr2)  # ['1' '2' '3' '4']

arr3 = np.array([1, 2, 3, 4], dtype=np.complex64)
print(arr3)  # [1.+0.j 2.+0.j 3.+0.j 4.+0.j]

arr4 = np.array([1, 2, 3.5, '4'], dtype=object)
print(arr4)  # [1 2 3.5 '4']

通过指定类型创建数组时，np.int32与int等价；np.float64与float等价；np.complex128与complex等价。

Ndarray中的数据必须是同一类型，否则会自动向下转换。int -> float -> str

import numpy as np

arr1 = np.array([1,2,3,4,'5'])
print(arr1)   # ['1' '2' '3' '4' '5']

arr2 = np.array([1,2,3,4,5.0])
print(arr2)  # [1. 2. 3. 4. 5.]

数组属性

数组属性操作

import numpy as np

# 一维数组
arr1 = np.array([4, 5, 6])
print(type(arr1))  # <class 'numpy.ndarray'>
print(arr1.dtype)  # int32
print(arr1.size)  # 3
print(arr1.ndim)  # 1
print(arr1.shape)  # (3,)
print(arr1.itemsize)  # 4 (整形占4个字节)
print(arr1.nbytes)  # 12

# 二维数组
arr2 = np.array([[1, 2, 3], [4, 5, 6]])
print(type(arr2))  # <class 'numpy.ndarray'>
print(arr2.dtype)  # int32
print(arr2.size)  # 6
print(arr2.ndim)  # 2
print(arr2.shape)  # (2, 3)
print(arr2.itemsize)  # 4 (整形占4个字节)
print(arr2.nbytes)  # 24

shape()函数以元组的形式返回数组的形状，若数组是一维的，返回数组元素个数

改变数组维度

import numpy as np

arr = np.array([3, 5, 8, 5, 3, 7, 6, 3, 7])
print(arr)  # [3 5 8 5 3 7 6 3 7]
tar = arr.reshape(3, 3)
print(tar)
'''
[[3 5 8]
 [5 3 7]
 [6 3 7]]
'''

# ndarray.reshape 通常返回的是非拷贝副本，即改变返回后数组的元素，原数组对应元素的值也会改变。
tar[1, 1] = 100
print(arr)  # [3  5  8  5 100  7  6  3  7]
print(tar)
'''
[[  3   5   8]
 [  5 100   7]
 [  6   3   7]]
'''

数组访问

索引访问

import numpy as np

arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(arr[1, 1])  # 5
print(arr[1][1])  # 5
print(arr[1])     # [4 5 6]  访问数组第二行
print(arr[:,1])   # [2,5,8]  访问数组第二列

切片访问

一维数组

import numpy as np

arr = np.array([4, 5, 6, 7, 8, 9])
print(arr[1:3])  # [5 6]
print(arr[-2:])  # [8 9]
print(arr[:-2])  # [4 5 6 7]
print(arr[::])   # [4 5 6 7 8 9]
print(arr[::-1]) # [9 8 7 6 5 4]
print(arr[0:len(arr):3])  # [4, 7]

切片arr(begin, end, step)，其中范围为[begin, end)

二维数组

import numpy as np

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

'''
arr[:2] 结果为：
[
    [1 2 3 4]
    [5 6 7 8]
]

arr[:, :2]结果为：
[
    [ 1  2]
    [ 5  6]
    [ 9 10]
]
'''
print(arr[:2])
print(arr[:, :2])

n维数组切片访问返回的是n维数组

高级索引访问

通过布尔类型数组作为索引进行数据过滤

import numpy as np
arr = np.array([1, 2, 3, 4])
bool_arr = np.array([0, 1, 1, 0], dtype=bool)
print(bool_arr)  # [False True True False]
result = arr[bool_arr]
print(result)  # [2 3]

通过过滤条件访问

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

arr1 = arr[arr > 2]
print(arr1)  # [3 4]

通过传递判断条件进行数据过滤，其本质还是传递了一个布尔类型的ndarray数组

通过传递索引值过滤数据

import numpy as np
arr1 = np.array([1, 2, 3, 4])
print(np.where(arr1))  # (array([0, 1, 2, 3], dtype=int64),) 返回索引
print(np.where(arr1 > 2))  # (array([2, 3], dtype=int64),)
print(arr1[np.where(arr1 > 2)])  # [3 4]

通过传递判断条件进行数据过滤，其本质是传递了一个包含满足条件索引的ndarray数组

赋值访问

采用直接赋值方法，一改全改

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

采用copy()赋值彼此独立

arr1 = np.array([1, 2, 3, 4])
arr2 = arr1.copy()
arr2[1] = 100
print(arr1)  # [1 2 3 4]
print(arr2)  # [1 100 3 4]

遍历数组

通过nditer()进行遍历

import numpy as np

# 获取所有数据
arr = np.array([[9, 8, 7], [6, 5, 4], [3, 2, 1]])
for val in np.nditer(arr):
    print(val, end=",")  # 9,8,7,6,5,4,3,2,1,

# 获取部分数据
arr = np.array([[9, 8, 7], [6, 5, 4], [3, 2, 1]])
for val in np.nditer(arr[1]):
    print(val, end=",")  # 6,5,4,

通过ndenumerate()进行遍历

import numpy as np

arr = np.array([[9, 8, 7], [6, 5, 4], [3, 2, 1]])
for index,value in np.ndenumerate(arr):
    print(index,value)
    
'''
(0, 0) 9
(0, 1) 8
(0, 2) 7
(1, 0) 6
(1, 1) 5
(1, 2) 4
(2, 0) 3
(2, 1) 2
(2, 2) 1
'''

设置矩阵不可修改

import numpy as np

# numpy数组值默认可修改
arr = np.array([1, 9, 3, 4])
arr1 = arr
arr[1] = 30
print(arr)   # [1 30 3 4]
print(arr1)  # [1 30 3 4]

# 通过writeable属性可设置数组值不可变
arr1 = np.array([1, 2, 3, 4, 5])
arr1.flags.writeable = False
arr1[0] = 1  # 报错

数组生成函数

asarray()

import numpy as np

arr = np.array([1, 2, 3, 4])
tar = np.asarray(arr, dtype=np.float32)
print(arr)  # [1 2 3 4]  (不改变原始值)
print(tar)  # [1. 2. 3. 4.]

astype创建

import numpy as np

arr = np.array([1, 2, 3, 4])
tar = arr.astype(np.float32)
print(arr)  # [1 2 3 4]  (不改变原始值)
print(tar)  # [1. 2. 3. 4.] 

fill创建

import numpy as np

alist = np.array([4, 5, 6, 7])
alist.fill(7)
print(alist)  # [7 7 7 7]

arange(start, stop, step, dtype)

import numpy as np

print(np.arange(10))  # [0 1 2 3 4 5 6 7 8 9]
print(np.arange(2, 10, 2))  # [2 4 6 8]
print(np.arange(2, 20, 2, dtype=float))  # [ 2.  4.  6.  8. 10. 12. 14. 16. 18.]

linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

import numpy as np

print(np.linspace(2, 3, num=5))  # [2. 2.25 2.5  2.75 3. ]
print(np.linspace(2, 3, num=5, endpoint=False))  # [2. 2.2 2.4 2.6 2.8]
print(np.linspace(2, 3, num=5, retstep=True))  # (array([2.  , 2.25, 2.5 , 2.75, 3.  ]), 0.25)

print(np.linspace(1, 1, 10))  # [1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
print(np.linspace(1, 1, 10, retstep=True))  # (array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1.]), 0.0)

arange()和linspace()区别在于：前者是根据范围和步长生成等差数组；后者是通过范围和个数生成等差数组

np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)

import numpy as np

print(np.logspace(0, 3, 4))  # [   1.   10.  100. 1000.]
print(np.logspace(0, 5, 6, base=2))  # [ 1.  2.  4.  8. 16. 32.]

函数参数含义

empty()

import numpy as np

print(np.empty(3))  # 一维未初始化数组
print(np.empty((3, 3)))  # 二维未初始化数组
print(np.empty((3, 3), dtype=np.int16))  # 指定类型的二维空数组

'''
运行结果为：
[0.  0.5 1. ]

[[6.23042070e-307 4.67296746e-307 1.69121096e-306]
 [1.86921822e-306 1.29057407e-306 1.24611741e-306]
 [1.11261027e-306 2.07955588e-312 7.27378088e+175]]
 
[[     0      0      0]
 [     0   5200 -29400]
 [ 32761      0   5200]]
'''

empty() 返回一个一维或者多维数组，数组的元素不为空，为随机产生的数据。

zeros()

import numpy as np

print(np.zeros(5))
print(np.zeros((4, 4)))
print(np.zeros((4, 4), dtype=np.int32))

'''
返回结果为：
[0. 0. 0. 0. 0.]

[[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]
 
[[0 0 0 0]
 [0 0 0 0]
 [0 0 0 0]
 [0 0 0 0]]
'''

ones()

import numpy as np

print(np.ones(5))
print(np.ones((4, 4)))
print(np.ones((4, 4), dtype=np.int32))

'''
返回结果为：
[1. 1. 1. 1. 1.]

[[1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]
 
[[1 1 1 1]
 [1 1 1 1]
 [1 1 1 1]
 [1 1 1 1]]
'''

identity()

import numpy as np

# 默认类型为浮点型
arr = np.identity(3)
print(arr) 

# 指定类型创建
arr1 = np.identity(3, dtype=np.int32)
print(arr1)

identity只能创建方阵

*eye(N, M=None, k=0, dtype=float, order=‘C’, , like=None)

import numpy as np

print(np.eye(3))
'''
[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]
'''

arr = np.eye(3,4,k=1)
print(arr)
arr2 = np.eye(3,4,k=2)
print(arr2)
arr3 = np.eye(3,4,k=-1)
print(arr3)
arr4 = np.eye(3,4,k=-2)
print(arr4)
'''
      k=1                      k=2                       k=-1                      k=-2
[[0. 1. 0. 0.]            [[0. 0. 1. 0.]            [[0. 0. 0. 0.]            [[0. 0. 0. 0.]
 [0. 0. 1. 0.]            [0. 0. 0. 1.]              [1. 0. 0. 0.]             [0. 0. 0. 0.]
 [0. 0. 0. 1.]]           [0. 0. 0. 0.]]             [0. 1. 0. 0.]]            [1. 0. 0. 0.]]
'''

zeros_like() / ones_like()

# 根据已有
import numpy as np
arr = np.array([3, 4, 5, 6])
print(np.zeros_like(arr))  # [0 0 0 0]
print(np.ones_like(arr))  # [1 1 1 1]

arr1 = np.array([[1, 2, 3], [4, 5, 6]])
print(np.zeros_like(arr1))
print(np.ones_like(arr1))

数值计算

四则运算

Numpy支持数组之间的四则运算。

import numpy as np

arr1 = np.array([10, 20, 30])
arr2 = np.array([1, 2, 3])

# 加法
print(np.add(arr1, arr2))  # [11 22 33]
print(arr1 + arr2)  # [11 22 33]

# 减法
print(np.subtract(arr1, arr2))  # [9 18 27]
print(arr1 - arr2)  # [9 18 27]

# 乘法
print(np.multiply(arr1, arr2))  # [10 40 90]
print(arr1 * arr2)  # [10 40 90]

# 除法
print(np.divide(arr1, arr2))  # [10. 10. 10.]
print(arr1 / arr2)  # [10. 10. 10.]

推荐使用四则运算符实现size运算，书写简单。

比较运算

import numpy as np

arr1 = np.array([1, 20, 3])
arr2 = np.array([1, 2, 3])
print(arr1 == arr2)  # [True False  True]

逻辑运算

import numpy as np

arr1 = np.array([1, 2, 3])
arr2 = np.array([5, 0, 4])

print(np.logical_and(arr1, arr2))  # [ True False  True]
print(np.logical_or(arr1, arr2))  # [ True  True  True]
print(np.logical_not(arr1))  # [False False False]
print(np.logical_not(arr2))  # [False True False]
print(np.logical_xor(arr1, arr2))  # [False  True False]

Numpy函数

轴

数学函数

sin()/arcsin()

import numpy as np

arr = np.array([0, 30, 45, 60, 90])
print('含有正弦值的数组：')
sin = np.sin(arr * np.pi / 180)
print(sin)  # [0.   0.5   0.70710678   0.8660254   1.]

print('计算角度的反正弦，返回值以弧度为单位：')
inv = np.arcsin(sin)
print(inv)  # [0.   0.52359878   0.78539816   1.04719755   1.57079633]

print('通过转化为角度制来检查结果：')
print(np.degrees(inv))  # [0.   30.   45.   60.   90.]

cos()/arccos()

import numpy as np

arr = np.array([0, 30, 45, 60, 90])

print('arccos：')
cos = np.cos(arr * np.pi / 180)
print(cos)  # [1.00000000e+00   8.66025404e-01   7.07106781e-01   5.00000000e-01   6.12323400e-17]

print('反余弦：')
inv = np.arccos(cos)
print(inv)  # [0.    0.52359878   0.78539816   1.04719755   1.57079633]

print('角度制单位：')
print(np.degrees(inv))  # [0, 30, 45, 60, 90]

tan()/arctan()

import numpy as np

arr = np.array([0, 30, 45, 60, 90])

print('tan 函数：')
tan = np.tan(arr * np.pi / 180)
print(tan)  # [0.00000000e+00   5.77350269e-01   1.00000000e+00   1.73205081e+00   1.63312394e+16]

print('反正切：')
inv = np.arctan(tan)
print(inv)  # [0.   0.52359878   0.78539816   1.04719755   1.57079633]

print('角度制单位：')
print(np.degrees(inv))  # [0, 30, 45, 60, 90]

around(arr,decimals)

import numpy as np

arr = np.array([1.0, 5.55, 123, 0.567, 25.532])
print('原数组：')
print(arr)  # [1.   5.55   123.   0.567   25.532]

print('舍入后：')
print(np.around(arr))  # [1.   6.   123.   1.   26.]
print(np.around(arr, decimals=1))  # [1.   5.6   123.   0.6   25.5]
print(np.around(arr, decimals=-1))  # [0.   10.   120.   0.   30.]

如果decimals为负，整数将四舍五入到小数点左侧的位置

floor()

import numpy as np

arr = np.array([-1.7, 1.5, -0.2, 0.6, 10])
print(arr)  # [-1.7  1.5 -0.2  0.6  10.]
print(np.floor(arr))  # [-2.  1.  -1.  0.  10.]

ceil()

import numpy as np

arr = np.array([-1.7, 1.5, -0.2, 0.6, 10])
print(arr)  # [-1.7  1.5 -0.2  0.6  10.]
print(np.ceil(arr))  # [-1.  2. -0.  1. 10.]

算数函数

reciprocal()

import numpy as np

arr = np.array([10, 20, 30])
print(arr)  # [10 20 30]
print(np.reciprocal(arr))  # [0 0 0]

arr2 = np.array([10, 20, 30], dtype=np.float32)
print(arr2)  # [10. 20. 30.]
print(np.reciprocal(arr2))  # [0.1   0.05   0.03333334]

采用reciprocal()求取倒数时，元素必须是浮点型的

pow()

import numpy as np

# pow()将第一个输入数组中的元素作为底数，计算它与第二个输入数组中相应元素的幂
arr = np.array([10, 100, 1000])
print(arr)  # [10  100 1000]
print(np.power(arr, 2))  # [100   10000   1000000]
print(arr ** 2)  # [100   10000   1000000] (推荐)

pows = np.array([1, 2, 3])
print(pows)  # [1 2 3]
print(np.power(arr, pows))  # [10   10000   1000000000]

mod()

arr = np.array([10, 20, 30])
param = np.array([3, 5, 7])

print(arr)  # [10 20 30]
print(param)  # [3 5 7]
print(np.mod(arr, param))  # [1 0 2]
print(arr % param) # [1 0 2] (推荐)

统计函数

sum()

import numpy as np

# 求数组所有元素的和
num_list = np.array([[1, 2, 3], [4, 5, 6]])
print(num_list.sum())  # 21
print(np.sum(num_list))  # 21

# 按轴进行求和
print(num_list.sum(0))  # [5 7 9]
print(np.sum(num_list, 0))  # [5 7 9]
print(num_list.sum(1))  # [6 15]
print(np.sum(num_list, axis=1))  # [6 15]
print(np.sum(num_list, axis=-1))  # [6 15]  按最后一个轴进行累加

prod()

import numpy as np

# 求数组所有元素的积
num_list = np.array([[1, 2, 3], [4, 5, 6]])
print(num_list.prod())  # 720
print(np.prod(num_list))  # 720

# 按轴进行求积
print(num_list.prod(0))  # [4 10 18]
print(np.prod(num_list, 0))  # [4 10 18]
print(num_list.prod(1))  # [6 120]
print(np.prod(num_list, axis=1))  # [6 120]
print(np.prod(num_list, axis=-1))  # [6 120]  按最后一个轴进行累乘

cumsum()

import numpy as np

# 计算累积和
arr = np.array([[1, 2, 3], [4, 5, 6]])
'''
[[1 2 3]
 [4 5 6]]
'''
print(arr)
print(np.cumsum(arr))  # [1  3  6 10 15 21]
print(np.cumsum(arr, dtype=float))  # [1.  3.  6. 10. 15. 21.]

''' 
[[1 2 3]
 [5 7 9]]
'''
print(arr.cumsum(axis=0))

'''
[[ 1  3  6]
 [ 4  9 15]]
'''
print(arr.cumsum(axis=1))

cumprod()

import numpy as np

# 计算累积乘积
arr = np.array([[1, 2, 3], [4, 5, 6]])
'''
[[1 2 3]
 [4 5 6]]
'''
print(arr)
print(np.cumprod(arr))  # [1   2   6  24 120 720]
print(np.cumprod(arr, dtype=float))  # [1.   2.   6.  24. 120. 720.]

''' 
[[ 1  2  3]
 [ 4 10 18]]
'''
print(arr.cumprod(axis=0))

'''
[[  1   2   6]
 [  4  20 120]]
'''
print(arr.cumprod(axis=1))

min()

import numpy as np

# 求数组所有元素最小值
arr = np.array([[1, 2, 3], [4, 5, 6]])
print(np.min(arr))  # 1

# 按轴计算最小值
print(np.min(arr, axis=0))  # [1 2 3]
print(arr.min(axis=1))  # [1 4]

max()

import numpy as np

# 求数组所有元素最大值
arr = np.array([[1, 2, 3], [4, 5, 6]])
print(np.max(arr))  # 6

# 按轴计算最大值
print(np.max(arr, axis=0))  # [4 5 6]
print(arr.max(axis=1))  # [3 6]

argmin()

import numpy as np

# 求数组所有元素最小值的索引
arr = np.array([[9, 1, 30], [4, 5, 6]])
print(arr.argmin())  # 1

# 按轴计算数组元素最小值的索引
print(arr.argmin(axis=0))  # [1 0 1]
print(arr.argmin(axis=1))  # [1,0]

argmax()

import numpy as np

# 求数组所有元素最大值的索引
arr = np.array([[9, 1, 30], [4, 5, 6]])
print(arr.argmax())  # 2

# 按轴计算数组元素最大值的索引
print(arr.argmax(axis=0))  # [0 1 0]
print(arr.argmax(axis=1))  # [2 2]

ptp()

import numpy as np

# 计算数组中元素最大值与最小值之差
arr = np.array([[3, 7, 5], [-8, 4, 3], [2, 4, 9]])
'''
[[ 3  7  5]
 [-8  4  3]
 [ 2  4  9]]
'''
print(arr)
print(np.ptp(arr))  # 17

# 按轴计算数组中元素最大值与最小值之差
print(np.ptp(arr, axis=1))  # [4 12 7]
print(np.ptp(arr, axis=0))  # [11 3 6]
print(arr.ptp(axis=-1))     # [4 12 7]  按最后一个轴求取元素最大值与最小值之差

median()

import numpy as np

# 计算数组中所有元素的中位数
arr = np.array([[3, 7, 5], [-8, 4, 3], [2, 4, 9]])
'''
[[ 3  7  5]
 [-8  4  3]
 [ 2  4  9]]
'''
print(arr)
print(np.median(arr))  # 4

# 按轴计算数组中元素的中位数
print(np.median(arr, axis=1))  # [5. 3. 4.]
print(np.median(arr, axis=0))  # [2. 4. 5.]
print(np.median(arr, axis=-1))  # [5. 3. 4.]

平均值

import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6]])
print(np.mean(arr))  # 3.5
print(np.mean(arr, axis=0))  # [2.5 3.5 4.5]
print(np.mean(arr, axis=1))  # [2. 5.]

标准差

import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6]])
print(np.std(arr))  # 1.707825127659933
print(np.std(arr, axis=0))  # [1.5 1.5 1.5]
print(np.std(arr, axis=1))  # [0.81649658 0.81649658]

方差

import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6]])
print(np.var(arr))  # 2.9166666666666665
print(np.var(arr, axis=0))  # [2.25 2.25 2.25]
print(np.var(arr, axis=1))  # [0.66666667 0.66666667]

数值限制

import numpy as np
num_list = np.array([1,2,3,4,5,6,7,8])
# 小于3的赋值为3，大于6赋值为6
print(num_list.clip(3,6))  # [3 3 3 4 5 6 6 6]

非0索引

import numpy as np

arr = np.array([1, 0, 2, 3, 4, 0, 3, 0])
print(np.nonzero(arr))  # (array([0, 2, 3, 4, 6], dtype=int64),)
print(arr.nonzero())  # (array([0, 2, 3, 4, 6], dtype=int64),)

排序操作

import numpy as np
arr = np.array([[1.5, 1.3, 7.5], [5.6, 7.8, 1.2]])
print(arr)
print(np.sort(arr))
print(np.sort(arr, axis=0))
'''
[[1.5 1.3 7.5]
 [5.6 7.8 1.2]]
 
[[1.3 1.5 7.5]
 [1.2 5.6 7.8]]
 
[[1.5 1.3 1.2]
 [5.6 7.8 7.5]]
'''

排序默认是按最后一个轴进行排序

随机模块

随机浮点数

'''
 rand(d0, d1, ..., dn)：生成[0, 1)之间的随机小数，数值来源于均匀分布抽样
 random(size=None)：生成[0, 1)之间的随机小数，数值来源于均匀分布抽样
 randn(d0, d1, ..., dn)生成(-∞,+∞)之间的随机小数，数值来源于标准正态分布抽样
 
 随机小数注意事项：
 1. ranf、random、sample、random_sample调用的都是random_sample方法；
 2. rand和random_sample效果等价，只是输入参数不同；
 3. rand()和randn()都是生成随机小数，区别在于：生成数值的区间不同、分布不同。
'''
import numpy as np

print(np.random.rand()) # 返回[0, 1)之间的随机小数
print(np.random.random_sample()) # 返回[0, 1)之间的随机小数
print(np.random.randn()) # 返回(-∞,+∞)之间的随机小数

print(np.random.rand(3,2)) # 返回一个三行两列的矩阵，数值范围[0, 1)
print(np.random.random_sample(size=(3，2))) # 返回一个三行两列的矩阵，数值范围[0, 1)
print(np.random.randn(3,2)) # 返回一个三行两列的矩阵，数值范围(-∞,+∞)

rand()和randn()都是生成随机小数，区别在于：区间不同、分布不同

随机整数

# randint(low, high=None, size=None, dtype=None)
import numpy as np

print(np.random.randint(1, 10))  # 产生一个[1,10)之间的随机整数
print(np.random.randint(10))  # 产生一个[0,10)之间的整数(省略high，生成[0,low)之间的随机整数）
print(np.random.randint(1, 10, 3))  # 生成三个[1,10)范围内的随机整数
print(np.random.randint(1, 10, size=(3, 3)))  # 产生一个3*3矩阵，矩阵数值是[1,10)之间的随机整数

print(np.random.randint(1, high=[3, 5, 10])) # 产生三个上限不同的随机整数
print(np.random.randint([1, 5, 7], 10)) # 产生三个下限不同的随机整数

正态分布

# normal(loc=0.0, scale=1.0, size=None) （均值,标准差,矩阵形状）
import numpy as np

'''
[[ 0.16360434  1.97129715 -0.72202865  5.54525616]
 [ 5.30084075  1.16655326 -0.09644836  3.38361816]]
'''
print(np.random.normal(3, 2.5, size=(2, 4)))

'''
[[ 0.08705979  1.34058832  0.49562195  0.65479645]
 [-1.41341949  0.90500061  0.14599449 -2.47971539]]
'''
print(np.random.normal(size=(2, 4)))

'''
[[ 0.222 -0.703 -0.024  1.498]
 [-0.413  0.283  0.463 -1.421]]
'''
np.set_printoptions(precision=3)  # 设置打印精度
print(np.random.normal(size=(2, 4)))

洗牌

import numpy as np
arr = np.arange(10)
print(arr)  # [0 1 2 3 4 5 6 7 8 9]
np.random.shuffle(arr)
print(arr)  # [1 0 6 3 2 4 8 9 7 5]

随机种子

# 当指定随机种子后再生成随机数时，每次生成的值都是相同的，不会改变。便于多参数调参时，固定部分参数
import numpy as np
np.random.seed(10)
arr = np.random.randint(1,10,3)
print(arr) # [5 1 2]

高斯分布

import numpy as np
np.set_printoptions(precision=3)  # 设置打印精度
mu, sigma = 0, 0.1
print(np.random.normal(mu, sigma, 10))

文件操作

文件读取

numpy通过loadtxt()读取文本文件

loadtxt(fname, dtype=float, delimiter=None, skiprows=0, usecols=None, max_rows=None)

import numpy as np

# 文件中数据默认空格分隔
arr = np.loadtxt("first.txt")

# 当不是以空格分隔时，需要指定分隔符号
arr2 = np.loadtxt("second.txt",delimiter=",")

# 当存在表头时，可通过skiprows跳过表头行，序号从1开始
arr3 = np.loadtxt("second.txt",delimiter=",",skiprows=1)

# 通过usecols属性可以指定采用哪几列数据构造数组
arr4 = np.loadtxt("second.txt", delimiter=",", skiprows=1, usecols=(1,3))

文件写入

写入txt文件

def savetxt(fname, arr, fmt='%.18e', delimiter=' ', newline='\n', header='', footer='', comments='# ', encoding=None):

# 默认分隔符为空格
import numpy as np

arr = np.array([[1, 2, 3], [4, 5, 6]])
np.savetxt("ff.txt", arr, fmt="%.3f", delimiter=",",header='数学 语文 英语', encoding="utf-8")

读写变量

读/写单一变量

# 单一变量/数组通常保存为npy格式文件
import numpy as np

arr = np.array([[1, 2, 3], [4, 5, 6]])
np.save("arr.npy", arr)  # 存储数组
data = np.load("arr.npy")  # 读取数组
print(data)  # [[1 2 3] [4 5 6]]

读/写多个变量

# 多个变量/数组通常保存为npz格式文件，其本质是一个压缩格式文件，内容有多个文件与保存的变量相对应
import numpy as np

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

np.savez("arr.npz", arr=arr, arr1=arr1)  # 存储数组
data = np.load("arr.npz")  # 读取数组
print(data['arr'])  # [[1 2 3] [4 5 6]]
print(data['arr1'])  # [3 4 5 6 7 8]

练习

1、 生成3*3 的二维数组，数组中数范围位[5.0,10.0)

2、

国内

大数据竞赛平台：https://www.datafountain.cn/

阿里天池 ： https://tianchi.aliyun.com/

华为云大赛：https://competition.huaweicloud.com/competitions

百度飞桨：https://aistudio.baidu.com/aistudio/index

智源数据开放研究中心：http://competition.baai.ac.cn/home/competition/ongoing

biendata：https://biendata.xyz/

MathorCup高校数学建模挑战赛：http://mathorcup.org/prize

DC竞赛-大数据竞赛平台：https://js.dclab.run/v2/index.html

国外

https://www.kaggle.com/

https://www.drivendata.org/

https://www.crowdanalytix.com/community

https://developer.amazon.com/alexaprize

https://datahack.analyticsvidhya.com/?utm_source=main-logo

https://www.kdd.org/kdd-cup

https://www.innocentive.com/our-solvers/

https://hackx.lk/

https://www.kdd.org/kdd-cup

4, 5, 6]])
np.savetxt(“ff.txt”, arr, fmt=“%.3f”, delimiter=“,”,header=‘数学 语文 英语’, encoding=“utf-8”)

### 读写变量

读/写单一变量

```python
# 单一变量/数组通常保存为npy格式文件
import numpy as np

arr = np.array([[1, 2, 3], [4, 5, 6]])
np.save("arr.npy", arr)  # 存储数组
data = np.load("arr.npy")  # 读取数组
print(data)  # [[1 2 3] [4 5 6]]

读/写多个变量

# 多个变量/数组通常保存为npz格式文件，其本质是一个压缩格式文件，内容有多个文件与保存的变量相对应
import numpy as np

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

np.savez("arr.npz", arr=arr, arr1=arr1)  # 存储数组
data = np.load("arr.npz")  # 读取数组
print(data['arr'])  # [[1 2 3] [4 5 6]]
print(data['arr1'])  # [3 4 5 6 7 8]

练习

1、 生成3*3 的二维数组，数组中数范围位[5.0,10.0)

2、

国内

大数据竞赛平台：https://www.datafountain.cn/

阿里天池 ： https://tianchi.aliyun.com/

华为云大赛：https://competition.huaweicloud.com/competitions

百度飞桨：https://aistudio.baidu.com/aistudio/index

智源数据开放研究中心：http://competition.baai.ac.cn/home/competition/ongoing

biendata：https://biendata.xyz/

MathorCup高校数学建模挑战赛：http://mathorcup.org/prize

DC竞赛-大数据竞赛平台：https://js.dclab.run/v2/index.html

国外

https://www.kaggle.com/

https://www.drivendata.org/

https://www.crowdanalytix.com/community

https://developer.amazon.com/alexaprize

https://datahack.analyticsvidhya.com/?utm_source=main-logo

https://www.kdd.org/kdd-cup

https://www.innocentive.com/our-solvers/

https://hackx.lk/

https://www.kdd.org/kdd-cup

创作打卡挑战赛

赢取流量/现金/CSDN周边激励大奖