【一】Numpy模块

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))
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 212,294评论 6赞 493
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 90,493评论 3赞 385
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 157,790评论 0赞 348
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 56,595评论 1赞 284
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 65,718评论 6赞 386
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 49,906评论 1赞 290
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 39,053评论 3赞 410
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 37,797评论 0赞 268
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 44,250评论 1赞 303
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 36,570评论 2赞 327
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,711评论 1赞 341
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 34,388评论 4赞 332
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 40,018评论 3赞 316
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,796评论 0赞 21
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,023评论 1赞 266
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 46,461评论 2赞 360
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 43,595评论 2赞 350

推荐阅读更多精彩内容

  • Numpy的详细教程
    基础篇NumPy的主要对象是同种元素的多维数组。这是一个所有的元素都是一种类型、通过一个正整数元组索引的元素表格(...
    oyan99阅读 5,115评论 0赞 18
  • numpy
    介绍 NumPy 是一个 Python 包。 它代表 “Numeric Python”。 它是一个由多维数组对象和...
    喔蕾喔蕾喔蕾蕾蕾阅读 1,763评论 0赞 5
  • NumPy说明
    NumPy是Python中关于科学计算的一个类库，在这里简单介绍一下。 来源：https://docs.scipy...
    灰太狼_black阅读 1,224评论 0赞 5
  • NumPy入门
    qq:875880047 NumPy简介 • 官网链接:http://www.numpy.org/ • NumPy...
    d76d0c9d2b04阅读 555评论 0赞 2
  • NumPy一篇入门
    NumPy是Python数值计算最重要的基础包，提供大多数的科学计算方法。其本身并没有多么高级的数据分析功能，但是...
    BubbleL阅读 2,042评论 0赞 14