超级全Numpy模块

在这里插入图片描述
一、介绍
Numpy —— Python开源的科学计算工具包
高级的数值编程工具,是许多高级工具的构建基础,比如Pandas(重点针对二维数组)

强大的N维数组对象:ndarray(二维,三维)
对数组结构数据进行矩阵运算(不用遍历循环)
随机数、线性代数、傅立叶变换等功能
二、Numpy基础数据结构
Numpy数组是一个多维数组对象,称为ndarray,由两部分组成:
①实际的数据
②描述这些数据的元数据

方法 作用
ar 输出数组,注意数组的格式:中括号,元素之间没有逗号。交互方式下输出,会有array(数组)
ar.ndim 输出数组维度的个数(轴数/维度/秩),维度的数量也称rank
ar.shape 数组的维度,对于n行m列的数组,shape为(n,m)
ar.size 数组的元素总数,对于n行m列的数组,元素总数为n*m
type(ar) 函数,查看变量的类型:<class ‘numpy.ndarray’>
ar.dtype 方法,查看数值的类型:int64
ar.itemsize 数组中每个元素的字节大小,int32类型字节为4,float64的字节为8
ar.data 包含实际数组元素的缓冲区,由于一般通过数组的索引获取元素,所以通常不需要使用这个属性

import numpy as np

# 一维数组
ar = np.array([1, 2, 3, 4, 5, 6])
print([1, 2, 3, 4, 5, 6])  # [1, 2, 3, 4, 5, 6]
print(ar)  # [1 2 3 4 5 6] 数组是没有逗号的
print(ar.ndim)  # 看数据有多少个轴,这里是一维数组 1
print(ar.dtype)  # int64
print(ar.shape)  # (6,)
print(ar.size)  # 6
print(type(ar), ar.dtype)  # <class 'numpy.ndarray'> int64
print(ar.itemsize)  # 8
print(ar.data)  # <memory at 0x1110524c8>

---------------------------------------------------------

# 二维数组
ar1 = np.array([[1, 2, 3, 4, 5, 6], [2, 3, 4, 5, 6, 7]])
print(ar1)  # [[1 2 3 4 5 6]
                #  [2 3 4 5 6 7]]
print(ar1.ndim)  # 二维数组 2
print(type(ar1), ar1.dtype)  # <class 'numpy.ndarray'> int64
print(ar1.shape)  # (2, 6)
print(ar1.size)  # 12
print(ar1.itemsize)  # 8
print(ar1.data)  # <memory at 0x11164f3a8>

---------------------------------------------------------

# 三维数组(两个二维数组)
ar2 = np.array([[[1, 2, 3, 4, 5, 6], [2, 3, 4, 5, 6, 7], [3, 4, 5, 6, 7, 8]],
                [[1, 2, 3, 4, 5, 6], [2, 3, 4, 5, 6, 7], [3, 4, 5, 6, 7, 8]]])
print(ar2)  # 生成两个二维数组,就是三维数组
            # [[[1 2 3 4 5 6]
              # [2 3 4 5 6 7]
              # [3 4 5 6 7 8]]
            
             # [[1 2 3 4 5 6]
              # [2 3 4 5 6 7]
              # [3 4 5 6 7 8]]]
print(ar2.ndim)  # 三维数组 3
print(type(ar2), ar2.dtype)  # <class 'numpy.ndarray'> int64
print(ar2.shape)  # (2, 3, 6)
print(ar2.size)  # 36
print(ar2.itemsize)  # 8
print(ar2.data)  # <memory at 0x10093da98>

三、数组的创建
1、array()函数,括号内可以是列表、元组、数组、生成器等。

方法 作用
np.arry(列表、元组、数组、生成器) 如:np.array(range(10)) ,如果有两个嵌套序列,长度不一样就会变成一维数组
np.arange(5,12,2) 类似range() 返回5-11的数,步长为2

import numpy as np

ar = np.array(range(10))
print(ar)  # [0 1 2 3 4 5 6 7 8 9]
print(ar.shape)  # (10,)

ar1 = np.arange(10)  
print(ar1)  # [0 1 2 3 4 5 6 7 8 9]
print(ar1.shape)  # (10,)

ar2 = np.array([1, 2, 3, 4, 5, 6])
print(ar2)  # [1 2 3 4 5 6]
print(ar2.shape)  # (6,)

ar3 = np.array([[1, 2, 3, 4, 5, 6],[1, 2, 3, 4, 5, 6]])
print(ar3)  # [[1 2 3 4 5 6]
                # [1 2 3 4 5 6]]
print(ar3.shape)  # (2, 6)

# 包含字母的话,会将数字也转化为字符串
ar4 = np.array([[1, 2, 3, 4, 5, 6],['a','b','c','d','e','f']])
print(ar4)  # [['1' '2' '3' '4' '5' '6']
                # ['a' 'b' 'c' 'd' 'e' 'f']]
print(ar4.shape)  # (2, 6)

# 两个嵌套序列,长度不一样就会变成一维数组
ar5 = np.array([[1, 2, 3, 4, 5],['a','b','c','d','e','f']])
print(ar5)  # [list([1, 2, 3, 4, 5]) list(['a', 'b', 'c', 'd', 'e', 'f'])]
print(ar5.ndim)  # 1

# 先得到值,再变成形状
print(np.random.rand(10).reshape(2,5))  # [[0.01606221 0.48034613 0.78372017 0.45386013 0.96975338]
                                            # [0.85711056 0.67823132 0.89495505 0.00421232 0.85041392]]

2、arange(),类似range(),在给定间隔内返回均匀间隔的值。

print(np.arange(10))  # 返回整型0-9  [0 1 2 3 4 5 6 7 8 9]
print(np.arange(10.0))  # 返回浮点型0.0-9.0  [0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]
print(np.arange(5,12))  # 返回5-11  [ 5  6  7  8  9 10 11]
print(np.arange(5.0,12,2))  # 返回5.0-12.0,步长为2  [ 5.  7.  9. 11.]
print(np.arange(10000))  # 如果数组太大而无法打印,Numpy会自动跳过数组的中心部分,并只打印边角  [   0    1    2 ... 9997 9998 9999]

3、linspace():返回在间隔[开始,停止]上计算num个均匀间隔的样本

np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None) 如np.linspace(10, 20, 11)
方法 作用
start,stop 起始值,结束值
num 生成样本数,默认为50
endpoint 默认值为True,即包含最后一个值,endpoint=False指不包含最后一个值
retstep 默认值为False,即步长不显示出来,如果retstep=True就会返回样本的步长(间距)。返回(样本,步骤),其中步长是样本之间的间距—>输出为一个包含2个元素的元组,第一个元素为array,第二个为步长实际值

import numpy as np

# 10/19=0.52631579
print(np.linspace(10, 20, num=20))
# 输出>>>:[10.         10.52631579 11.05263158 11.57894737 12.10526316 12.63157895
#  13.15789474 13.68421053 14.21052632 14.73684211 15.26315789 15.78947368
#  16.31578947 16.84210526 17.36842105 17.89473684 18.42105263 18.94736842
#  19.47368421 20.        ]

# 10/20=0.5
print(np.linspace(10, 20, num=21))
# 输出>>>:[10.  10.5 11.  11.5 12.  12.5 13.  13.5 14.  14.5 15.  15.5 16.  16.5
# 17.  17.5 18.  18.5 19.  19.5 20. ]

print(np.linspace(10, 20, num=21, endpoint=False))  #endpoint表示是否包含最后一个值,默认为True
# 输出>>>: [10.         10.47619048 10.95238095 11.42857143 11.9047619  12.38095238
#  12.85714286 13.33333333 13.80952381 14.28571429 14.76190476 15.23809524
#  15.71428571 16.19047619 16.66666667 17.14285714 17.61904762 18.0952381
#  18.57142857 19.04761905 19.52380952]

print(np.linspace(10, 20, num=21, retstep=True))  # 默认为False,如果为True,则输出元组和步长;如果为False,则不显示步长
# 输出>>>:retstep=False
# [10.  10.5 11.  11.5 12.  12.5 13.  13.5 14.  14.5 15.  15.5 16.  16.5
#  17.  17.5 18.  18.5 19.  19.5 20. ]
# 输出>>>:retstep=True
# (array([10. , 10.5, 11. , 11.5, 12. , 12.5, 13. , 13.5, 14. , 14.5, 15. ,
#        15.5, 16. , 16.5, 17. , 17.5, 18. , 18.5, 19. , 19.5, 20. ]), 0.5)

4、zeros() | zeros_like() | ones() | ones_like():自动填充的0,1数组

np.zeros((3, 5), dtype=np.int )、np.ones_like(ar)
方法 作用
np.zeros(shape,dtype=int,order=‘C’) 返回指定维度和类型的数组,用0填充
shape 数组维度,二维以上需要用(),且输入参数为整数
dtype 数据类型,默认numpy.float64
order 表示是否以行为主存储多维数据(C-style)或以列为主存储column-major (Fortran-style)顺序输入,默认为C,还有F

import numpy as np

print(np.zeros(10))  # 第一个是参数 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
print(np.zeros((2, 5)))
# >>>输出:[[0. 0. 0. 0. 0.]
        # [0. 0. 0. 0. 0.]]
print(np.zeros((3, 5)))
# >>>输出:[[0. 0. 0. 0. 0.]
         #  [0. 0. 0. 0. 0.]
         #  [0. 0. 0. 0. 0.]]

print(np.zeros((2, 7),dtype=np.int))  # 浮点数转化为整数
# >>>输出:[[0 0 0 0 0 0 0]
        #  [0 0 0 0 0 0 0]]

ar = np.array([list(range(10)),list(range(10,20))])
print(ar)
# >>>输出:[[ 0  1  2  3  4  5  6  7  8  9]
        #  [10 11 12 13 14 15 16 17 18 19]]
print(np.zeros_like(ar))  # 用0填充一个像ar形式的数组
# >>>输出:[[0 0 0 0 0 0 0 0 0 0]
        #  [0 0 0 0 0 0 0 0 0 0]]

# 用1填充
print(np.ones(9))  # [1. 1. 1. 1. 1. 1. 1. 1. 1.]
print(np.ones((2,3,4)))  # 2个3行4列的二维数组
# >>>输出:[[[1. 1. 1. 1.]
        #   [1. 1. 1. 1.]
        #   [1. 1. 1. 1.]]
        #
        #  [[1. 1. 1. 1.]
        #   [1. 1. 1. 1.]
        #   [1. 1. 1. 1.]]]
print(np.ones_like(ar))
# >>>输出:[[1 1 1 1 1 1 1 1 1 1]
        #  [1 1 1 1 1 1 1 1 1 1]]

5、eye():创建一个正方的N*N的单位矩阵,对角线值为1,其余为0

print(np.eye(5))
# >>>输出:[[1. 0. 0. 0. 0.]
       #  [0. 1. 0. 0. 0.]
       #  [0. 0. 1. 0. 0.]
       #  [0. 0. 0. 1. 0.]
       #  [0. 0. 0. 0. 1.]]

ndarray的数据类型

数据类型 解释
bool 用一个字节存储的布尔类型(True或False)
inti 由所在平台决定其大小的整数(一般为int32或int64)
int8 一个字节大小,-128~127
int16 整数,-32768~32767
int32 整数,-231~232-1
int64 整数,-263~263-1
uint8 无符号整数,0~255
uint16 无符号整数,0~65535
uint32 无符号整数,0~232-1
uint64 无符号整数,0~264-1
float16 半精度浮点数:16位,正负号1位,指数5位,精度10位
float32 单精度浮点数:32位,正负号1位,指数8位,精度23位
float64或float 双精度浮点数:64位,正负号1位,指数11位,精度52位
complex64 复数,分别用两个32位浮点数表示实部和虚部
complex128或complex 复数,分别用两个64位浮点数表示实部和虚部
练习:

import numpy as np

"""1、分别按照要求,生成一个一维数组、二维数组,并且查看其shape"""
# 一维
print(np.array((1, 2, 'a', 'hello', [1, 2, 3], {'two': 200, 'one': 100})))
# >>>输出:[1 2 'a' 'hello' list([1, 2, 3]) {'two': 200, 'one': 100}]
print(np.array((1, 2, 'a', 'hello', [1, 2, 3], {'two': 200, 'one': 100})).shape)  # (6,)

# 二维
print(np.array(([0, 1, 2, 3, 4, 5], ['a', 'b', 'c', 'd', 'e', 'f'], ['True', 'False', 'True', 'False', 'True', 'True'])))
# >>>输出:[['0' '1' '2' '3' '4' '5']
        #  ['a' 'b' 'c' 'd' 'e' 'f']
        #  ['True' 'False' 'True' 'False' 'True' 'True']]
print(np.array(([0, 1, 2, 3, 4, 5], ['a', 'b', 'c', 'd', 'e', 'f'],['True', 'False', 'True', 'False', 'True', 'True'])).shape)  # (3, 6)

# 三维(两个二维)
print(np.array(([[[0, 1, 2, 3, 4, 5],[0, 1, 2, 3, 4, 5]],[['a', 'b', 'c', 'd', 'e', 'f'],['True', 'False', 'True', 'False', 'True', 'True']]])))
# >>>输出:[[['0' '1' '2' '3' '4' '5']
        #   ['0' '1' '2' '3' '4' '5']]

        #  [['a' 'b' 'c' 'd' 'e' 'f']
        #   ['True' 'False' 'True' 'False' 'True' 'True']]]
print(np.array(([[[0, 1, 2, 3, 4, 5],[0, 1, 2, 3, 4, 5]],[['a', 'b', 'c', 'd', 'e', 'f'],['True', 'False', 'True', 'False', 'True', 'True']]])).shape)  # (2, 2, 6)

"""2、生成以一个一维数组,起始值为5,终点值为15,样本数为10"""
print(np.arange(5,15))  # [ 5  6  7  8  9 10 11 12 13 14]

"""3、按照要求创建以下数组"""
print(np.zeros((4,4)))
# >>>输出:[[0. 0. 0. 0.]
        #  [0. 0. 0. 0.]
        #  [0. 0. 0. 0.]
        #  [0. 0. 0. 0.]]

print(np.ones((2,3)))
# >>>输出:[[1. 1. 1.]
        #  [1. 1. 1.]]

print(np.eye((3),dtype=int))
# >>>输出:[[1 0 0]
        #  [0 1 0]
        #  [0 0 1]]

四、Numpy通用函数
1、数组形状:.T/.reshape()/.resize()
注意:.T/.reshape()/.resize()都是生成新的数组

方法 解释
ar.T 转置,例如原shape为(3,4)/(2,3,4),转置结果为(4,3)/(4,3,2),一维数组转置后结果不变
ar.reshape(2,5) 直接将已有数组改变形状,比如np.zero(2,3).reshape(3,4)生成数组后直接改变形状
re.reshape(np.arange(12),(3,4)) 参数内添加数组,目标形状
np.resize(np.arange(5),(3,4)) 数组提供新形状,而不更改其数据,所以元素数量需要一致

import numpy as np

ar1 = np.arange(10)
print(ar1)  # [0 1 2 3 4 5 6 7 8 9]
print(ar1.T)  # 转置 [0 1 2 3 4 5 6 7 8 9]
print(ar1.reshape(5,2))
# >>>输出:[[0 1]
        #  [2 3]
        #  [4 5]
        #  [6 7]
        #  [8 9]]

ar3 = np.arange(16)  # 元素要相同
print(ar3.reshape(4,4))
# >>>输出:[[ 0  1  2  3]
        #  [ 4  5  6  7]
        #  [ 8  9 10 11]
        #  [12 13 14 15]]
print(ar3.reshape(2,8))
# >>>输出:[[ 0  1  2  3  4  5  6  7]
        #  [ 8  9 10 11 12 13 14 15]]

ar2 = np.zeros((2,5))
print(ar2)
# >>>输出:[[0. 0. 0. 0. 0.]
        #  [0. 0. 0. 0. 0.]]
print(ar2.T)
# >>>输出:[[0. 0.]
        #  [0. 0.]
        #  [0. 0.]
        #  [0. 0.]
        #  [0. 0.]]
print(ar2.reshape(5,2))
# >>>输出:[[0. 0.]
        #  [0. 0.]
        #  [0. 0.]
        #  [0. 0.]
        #  [0. 0.]]

print(np.ones((10,10)).reshape(5,20))
# >>>输出:[[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. 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. 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.]]

print(np.reshape(np.arange(16),(2,8)))
# >>>输出:[[ 0  1  2  3  4  5  6  7]
#  [ 8  9 10 11 12 13 14 15]]

print(np.resize(np.arange(5),(3,4)))  # 如果数值不够,会默认排序
# >>>输出:[[0 1 2 3]
        #  [4 0 1 2]
        #  [3 4 0 1]]

print(np.resize(np.arange(12),(3,4)))  # 如果数值多了,依次做迭代
# >>>输出:[[ 0  1  2  3]
        #  [ 4  5  6  7]
        #  [ 8  9 10 11]]

print(np.resize(np.arange(14),(3,4)))
# >>>输出:[[ 0  1  2  3]
        #  [ 4  5  6  7]
        #  [ 8  9 10 11]]

2、数组的复制 (赋值=,copy())
赋值:修改ar1中的值,ar2也会改变,他们指向的是同一个数值。——浅拷贝
copy():先ar1.copy(),再去修改,就不会改变ar2,copy方法重新开辟一块内存空间,将数组和数据完整拷贝。——深拷贝

import numpy as np

ar1 = np.arange(10)
ar2 = ar1
print(ar1 is ar2)  # True
ar1[2] = 100  # 属于浅拷贝
print(ar1, ar2)  # [  0   1 100   3   4   5   6   7   8   9] [  0   1 100   3   4   5   6   7   8   9]
ar3 = ar1.copy()  # 属于深拷贝
ar1[3] = 1000
print(ar1, ar3)  # [   0    1  100 1000    4    5    6    7    8    9] [  0   1 100   3   4   5   6   7   8   9]

s = np.arange(10)
print(np.resize(s,(2,6)))
# >>>输出:[[0 1 2 3 4 5]
        #  [6 7 8 9 0 1]]
print(s.resize(2,6))  # None
print(s)  # 更改了数据本身
# >>>输出:[[0 1 2 3 4 5]
        #  [6 7 8 9 0 0]]

3、数组类型的转换:.astype()
ar1.astype(np.int64)

import numpy as np

ar1 = np.arange(10, dtype=float)
ar2 = ar1.astype(np.int64)
print(ar1, ar1.dtype)  # [0. 1. 2. 3. 4. 5. 6. 7. 8. 9.] float64
print(ar2, ar2.dtype)  # [0 1 2 3 4 5 6 7 8 9] int64

4、数组堆叠

方法 解释
np.hstack((数组1,数组2)) 水平堆叠数组,括号内的如果是一维数组形状可以不一样,二维数组形状要一致(水平堆叠,堆着堆着缺位了就不行)
np.vstack((a,b)) 垂直堆叠数组
np.stack((a,b),axis=1) axis默认为0(可不写),即按照垂直堆叠,注意跟vstack的区别,axis=1即按照横向堆叠

import numpy as np

a = np.arange(5)
b = np.arange(5, 9)
print(a)  # [0 1 2 3 4]
print(b)  # [5 6 7 8]
print(np.hstack((a, b)))  # 横向连接 [0 1 2 3 4 5 6 7 8]

a = np.array([[1], [2], [3]])
b = np.array([['a'], ['b'],['c']])
print(a)
print(b)
print(np.hstack((a,b)))
# >>>输出:[['1' 'a']
        #  ['2' 'b']
        #  ['3' 'c']]
# ⚠️如果是垂直的,队列数组的列的数量要一致
print(np.vstack((a,b)))  # 竖向连接
# >>>输出:[['1']
        #  ['2']
        #  ['3']
        #  ['a']
        #  ['b']
        #  ['c']]

a = np.arange(5)
b = np.arange(5,10)
print(np.stack((a,b),axis=1))  # 默认为0,按照行连接,ax-s=1按照列进行连接
# >>>输出:[[0 5]
        #  [1 6]
        #  [2 7]
        #  [3 8]
        #  [4 9]]
print(np.stack((a,b)))  # 默认为0,按照行连接,ax-s=1按照列进行连接
# >>>输出:[[0 1 2 3 4]
        #  [5 6 7 8 9]]

5、数组拆分

方法 解释
np.hsplit(ar,n) 垂直拆分
np.vsplit(ar,n) 水平拆分

import numpy as np

ar = np.arange(16).reshape(4,4)
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]
#  [12 13 14 15]]
print(np.hsplit(ar,2))  # 横向拆分成列表
# >>>输出:[array([[ 0,  1],
        #        [ 4,  5],
        #        [ 8,  9],
        #        [12, 13]]), array([[ 2,  3],
        #        [ 6,  7],
        #        [10, 11],
        #        [14, 15]])]
print(np.hsplit(ar,2)[0])
# >>>输出:[[ 0  1]
        #  [ 4  5]
        #  [ 8  9]
        #  [12 13]]

print(np.vsplit(ar,2))  # 竖向拆分成两个列表
# >>>输出:[array([[0, 1, 2, 3],
        #        [4, 5, 6, 7]]), array([[ 8,  9, 10, 11],
        #        [12, 13, 14, 15]])]

print(np.vsplit(ar,4))  # [array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]]), array([[12, 13, 14, 15]])]

6、数组的简单运算

方法 解释

  • 加法
  • 减法
  • 乘法
    / 除法
    ** 求幂
    mean() 平均值
    min() 最小值
    max() 最大值
    std() 标准差
    var() 方差
    sum() 求和np.sum()——>axis=0按列求和,axis=1按行求和
    sort() 排序
ar = np.arange(6).reshape(2,3)
print(ar+10)  # 加法
# >>>输出:[[10 11 12]
        #  [13 14 15]]
print(ar*2)  # 乘法
# >>>输出:[[ 0  2  4]
        #  [ 6  8 10]]
print(1/(ar+1))  # 除法
# >>>输出:[[1.         0.5        0.33333333]
        #  [0.25       0.2        0.16666667]]
print(ar**0.5)  # 幂运算
# >>>输出:[[0.         1.         1.41421356]
        #  [1.73205081 2.         2.23606798]]
print(ar.mean())  # 求平均值 2.5
print(ar.max())  # 求最大值  5
print(ar.min())  # 求最小值  0
print(ar.std())  # 求标准差  1.707825127659933
print(ar.var())  # 求方差  2.9166666666666665
print(ar.sum(),np.sum(ar,axis=0))  # 求和,np.sum() -> axis为0,按列求和:axis为1,按行求和  15 [3 5 7]
print(np.sort(np.array([1,4,3,2,5,6])))  # 排序  [1 2 3 4 5 6]

练习:

import numpy as np

"""1、创建一个20个元素的数组,分别改变成两个形状:(4,5),(5,6) (提示:超出范围用resize)"""
print(np.arange(20).reshape(4, 5))
# >>>输出:[[ 0  1  2  3  4]
        #  [ 5  6  7  8  9]
        #  [10 11 12 13 14]
        #  [15 16 17 18 19]]
a = np.arange(20)  # 直接写会变成None,因为数据本身被改变了
print(np.resize(a,(5,6)))
# >>>输出:[[ 0  1  2  3  4  5]
        #  [ 6  7  8  9 10 11]
        #  [12 13 14 15 16 17]
        #  [18 19  0  1  2  3]
        #  [ 4  5  6  7  8  9]]


"""2、创建一个(4,4)的数组,把其元素类型改为字符串型"""
a = np.arange(16).reshape(4,4)
print(a.astype(np.str))  # dtype是查看数据类型,astype是转换
# >>>输出:[['0' '1' '2' '3']
        #  ['4' '5' '6' '7']
        #  ['8' '9' '10' '11']
        #  ['12' '13' '14' '15']]


"""3、根据要求创建数组,运用数组的运算方法得到结果:resule=ar*10+100,并求出result的均值及求和"""
ar = np.arange(16).reshape(4,4)
result = ar*10+100
print(result)
# >>>输出:[[100 110 120 130]
        #  [140 150 160 170]
        #  [180 190 200 210]
        #  [220 230 240 250]]
print(np.mean(result))  # 平均值 175.0
print(np.sum(result))  # 求和 2800

五、Numpy索引及切片
核心:基本索引及切片 / 布尔型索引及切片

基本索引及切片
ar[2]  ar[3][1]
ar[3,1]  ar[1:3]  ar[:2,1:]

import numpy as np

# 一维数组list
ar = np.arange(20)
print(ar)  # [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]
print(ar[4])  # 4
print(ar[:3])  # [0 1 2]
print(ar[::2])  # [ 0  2  4  6  8 10 12 14 16 18]

print('------------')

# 二维数组list(先行后列)
ar1 = np.arange(16).reshape(4,4)
print(ar1)
# >>>输出:[[ 0  1  2  3]
        #  [ 4  5  6  7]
        #  [ 8  9 10 11]
        #  [12 13 14 15]]
print(ar1[2])  # [ 8  9 10 11] 第三行
print(ar1[2][2])  # 10 第三行的第2个值
print(ar1[2,2])  # 10 第三行第三列
print(ar1[:1,2:])  # [[2 3]]  左闭右开,第一行第二列往后
print(ar1[:2,2:])  # 第一行到第二行的第二列到第三列
# >>输出:[[2 3]
        # [6 7]]

print('------------')

# 三维数组
ar3 = np.arange(12).reshape(3,2,2)
print(ar3)
# >>>输出:[[[ 0  1]
        #   [ 2  3]]
        #
        #  [[ 4  5]
        #   [ 6  7]]
        #
        #  [[ 8  9]
        #   [10 11]]]
print(ar3[2])
# >>输出:[[ 8  9]
        # [10 11]]
print(ar3[2][1])  # [10 11]
print(ar3[2][1][0])  # 10

布尔型索引及切片
用布尔型矩阵进行筛选、用判断矩阵做筛选

ar = np.arange(12).reshape(3,4)
print(ar)
# >>>输出:[[ 0  1  2  3]
        #  [ 4  5  6  7]
        #  [ 8  9 10 11]]
i = np.array([True, False, True])
j = np.array([True,True,False,False])
print(i)  # [ True False  True]
print(j)  # [ True  True False False]
print(ar[i, :])  # i为[True, False, True],所以保留第一行和第三行。在第一维度做判断,只保留True,这里第一维度就是行,ar[i,:]=ar[i] (简单书写格式)
print(ar[i])  # i为[True, False, True],所以保留第一行和第三行。
# >>>输出:[[ 0  1  2  3]
        #  [ 8  9 10 11]]
print(ar[:,j])
# >>>输出:[[0 1]
        #  [4 5]
        #  [8 9]]
print(ar>5,type(ar>5))  # 得到布尔型数组
# >>输出[[False False False False]
        #  [False False  True  True]
        #  [ True  True  True  True]]  <class 'numpy.ndarray'>
print(ar[ar>5])  # [ 6  7  8  9 10 11]
m=ar>5
print(ar[m])  # [ 6  7  8  9 10 11]

数组索引及切片的值更改、复制

# 一个变量赋值给一个索引/切片时,会自动改变/传播原始数组
ar = np.arange(10)
print(ar)  # [0 1 2 3 4 5 6 7 8 9]
ar[5]=100
ar[7:9]=200
print(ar)  # [  0   1   2   3   4 100   6 200 200   9]

# 复制
ar = np.arange(10)
b = ar.copy()
b[7:9]=200
print(ar)  # [0 1 2 3 4 5 6 7 8 9]
print(b)  # [  0   1   2   3   4   5   6 200 200   9]

练习:

import numpy as np

"""1、按照要求创建数组,通过索引,其ar[4]、ar[:2,3:]、ar[3][2]分别是多少"""
ar = np.arange(25).reshape(5,5)
print(ar)
# >>>输出:[[ 0  1  2  3  4]
        #  [ 5  6  7  8  9]
        #  [10 11 12 13 14]
        #  [15 16 17 18 19]
        #  [20 21 22 23 24]]
print(ar[4])  # [20 21 22 23 24]
print(ar[:2,3:])
# >>>输出:[[3 4]
        # [8 9]]
print(ar[3][2])  # 17

"""2、按照要求创建数组,筛选出元素值大于5的值并生成新的数组"""
ar1 = np.arange(10).reshape(2,5)
print(ar1)
# >>>输出:[[0 1 2 3 4]
        #  [5 6 7 8 9]]
# 先得到数值大于5的布尔型数组
print(ar1>5)
# >>>输出:[[False False False False False]
        #  [False  True  True  True  True]]
print(ar1[ar1>5])  # [6 7 8 9]

六、Numpy随机数
生成随机数——标准正态分布

import numpy as np

print(np.random.normal(size=(4,4)))  # 标准正太分布在的样本值
# >>>输出:[[ 0.20746965 -0.3569164   0.38399266 -0.23825531]
        #  [ 1.57586345  0.27676097  1.53261017 -0.67989618]
        #  [ 0.70885444  2.11183292 -0.26200058 -1.12189412]
        #  [ 1.30693012 -2.26592066  0.71060149  0.98172181]]

numpy.random.rand(d0,d1,…,dn):生成一个[0,1)之间的随机浮点数或N维浮点数组——均匀分布

import matplotlib.pyplot as plt

a = np.random.rand()
print(a,type(a))  # 0.12107076764770552 <class 'float'>
print(np.random.rand(4))  # [0.80754254 0.08681042 0.2263688  0.75740495]
print(np.random.rand(4,4))
# >>>输出:[[0.10622521 0.1824461  0.43269753 0.50436525]
        #  [0.62558373 0.62092662 0.21627639 0.33037642]
        #  [0.21505231 0.62251796 0.25274457 0.31889568]
        #  [0.8105953  0.25010622 0.2953291  0.35862557]]
print(np.random.rand(2,4)*100)
# >>输出:[[ 2.83133566 83.6997414  39.22047445 82.7726304 ]
        #  [41.17245844 53.29510729 48.11262487 45.82123088]]

# 随机分布
data1 = np.random.rand(1000)
data2 = np.random.rand(1000)
plt.scatter(data1,data2)
plt.show()

随机均匀分布
在这里插入图片描述

numpy.random.randn(d0,d1,…,dn):生成一个浮点数或N维浮点数组——正态分布
以给定的形状创建一个数组,数组元素来符合标准正态分布N(0,1);若要获得的一般正态分布N(μ,σ2)则可用。sigma*np.random.randn(…)+mu进行表示

import matplotlib.pyplot as plt
data3 =np.random.randn(1000)
data4 = np.random.randn(1000)

plt.scatter(data3,data4)
plt.show()
正态分布
numpy.random.randint(low,high=None,size=None,dtype='l')——生成既定区间内的随机整数或N维整数数组
若high不为None时,取[low,high)之间随机整数,否则取值[0,low)之间随机整数,且high必须大于low。
dtype参数:只能是int类型
print(np.random.randint(2))  # 1 [0,2)
print(np.random.randint(2,10))  # 7
print(np.random.randint(10,size=10))  # [6 5 9 1 0 7 2 6 8 8]
print(np.random.randint(10,size=(2,5)))
# >>输出:[[9 9 6 8 8]
        #  [8 4 2 7 6]]
print(np.random.randint(10,50,size=(2,5)))
# >>>输出:[[44 21 12 33 11]
        #  [26 13 40 48 24]]

练习:

import numpy as np

"""1、请按照要求创建数组ar,再将ar[:2,2:]的值改为[0,1)的随机数"""
# ar = np.arange(25).reshape(5,5)
# print(ar.astype(np.float))
ar = np.arange(25, dtype=np.float32).reshape(5, 5)
print(ar)
# >>>输出:[[ 0.  1.  2.  3.  4.]
        #  [ 5.  6.  7.  8.  9.]
        #  [10. 11. 12. 13. 14.]
        #  [15. 16. 17. 18. 19.]
        #  [20. 21. 22. 23. 24.]]
ar[:2, :2] = np.random.rand(2, 2)
print(ar)
# >>>输出:[[ 0.94414437  0.42199293  2.          3.          4.        ]
        #  [ 0.31223404  0.6848395   7.          8.          9.        ]
        #  [10.         11.         12.         13.         14.        ]
        #  [15.         16.         17.         18.         19.        ]
        #  [20.         21.         22.         23.         24.        ]]


"""2、创建2个包含10个元素的正态分布一维数组"""
print(np.random.normal(size=(2,5)))
# >>>输出:[[-0.08070309 -0.22007649 -1.64426372 -0.08427305  0.16660503]
        #  [ 0.78231407 -0.54738434 -0.52553803  0.30823321  0.21906343]]
ar2=np.random.normal(size=(2,5))
print(np.vstack(ar2))
# >>>输出:[[ 0.95997134  0.71845804  1.35903736 -0.87302671 -0.60739824]
        #  [-2.02281529  0.54761807  0.32981195 -0.99052164  1.74089971]]

七、Numpy数据的输入输出
存储和读取数组数据.npy文件

import numpy as np
import os

path = os.chdir(r'/Users/wpr/Desktop/数据分析笔记')
ar = np.random.rand(5, 5)  # 生成均匀分布的二维数组
print(ar)
# 存成一个数组文件
np.save('arraydata.npy', ar)
print('完成')
print(np.load('arraydata.npy'))  # 读取

存储和读取文本文件

import numpy as np
import os

# 存成文本文件,默认是科学计数法,fmt是改变存储形式,这里变成了两位浮点数,delimiter是以什么分隔
np.savetxt('arraydate.txt', ar, delimiter=',', fmt='%.2f')
print(np.loadtxt('arraydate.txt', delimiter=','))
# >>输出:[[0.63 0.46 0.64 0.27 0.34]
        #  [0.49 0.03 0.67 0.69 0.47]
        #  [0.07 0.57 0.87 0.77 0.49]
        #  [0.42 0.9  0.47 0.58 0.99]
        #  [0.62 0.63 0.74 0.95 0.56]]  类型是float64

练习:

import numpy as np

"""创建一个10*10的整数随机数组,取值范围为0-100,并存为txt文件,用逗号分开"""
ar = np.random.randint(101, size=(10, 10))
print(ar)
np.savetxt('10*10随机整数.txt', ar, delimiter=',', fmt='%d')
print(np.loadtxt('10*10随机整数.txt', delimiter=',',dtype=int))

作者:一个无趣的人W
链接:https://www.jianshu.com/p/3339ad7517bf
来源:简书
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值