NumPy入门知识点

一、下载安装Anaconda

镜像下载地址：Index of /anaconda/archive/ | 清华大学开源软件镜像站 | Tsinghua Open Source Mirror

安装步骤：

 

二、配置环境&下载扩展包

1.中文界面

（1）桌面 -> 此电脑 -> 右击 -> 点击属性 -> 高级系统设置

（2）高级 -> 环境变量

（3）用户变量：点击新建，变量名：LANG，变量值：zh_CN.UTF8

 2.扩展包

（1）阿里云镜像：!pip config set global.index-url https://mirrors.aliyun.com/pypi/simple/
# !pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple

（2）Jupyter Notebook 扩展包的安装：

!pip install jupyter_contrib_nbextensions

!jupyter contrib nbextension install --user

!pip install jupyter_nbextensions_configurator

!jupyter nbextensions_configurator enable --user

（3）代码自动美化：

!jupyter nbextension enable code_prettify/autopep8

（4）代码自动提示：

!jupyter nbextension enable hinterland/hinterland

"""
Autopep8(代码规范)
Hinterland(代码补全)
Collapsible Headings(标题折叠)
Highlight selected word(所选代码高亮)
Table of Contents(2)(文档目录)
Variable Inspector(变量检查)
Codefolding(代码折叠)
Codefolding in Editor(编辑器代码折叠)
Toggle all line numbers(代码行号)
Skip-Traceback(跳过回溯)
Freeze(冻结单元格)
"""

三、基本使用

1.进入文件夹

1.1  Jupyter Notebook 进入指定文件夹

（1）进入项目所在文件夹

（2）键盘Shift + 鼠标右键 -> 在此处打开命令窗口 -> 在弹出的命令窗口中输入: Jupyter Notebook -> 键盘Enter

1.2  Jupyter Notebook 默认文件夹路径

（1）右击Jupyter Notebook快捷方式图标

（2）点击属性 -> 快捷方式

（3）修改目标栏的 "%USERPROFILE%/" 为 需要访问的项目文件夹

2.帮助文档

（1） shift + tab 查看文档        tab 自动补齐

（2）help(time)         查看time模块的文档

3.读写文件

（1）写文件

%%writefile test.py
import numpy as np
print(np.random.randint(1, 5))

（2）运行文件

%run test.py

（3）加载文件 

%load test.py 

 4.查看变量

（1）当前变量信息

%who

（2）以列表形式显示当前变量信息

%who_ls

（3）查看变量信息

%whos

（4）清除所有变量

%reset

（5）单元格的两种模式：

命令行模式（蓝色）
编辑模式（绿色）
命令行模式下按Enter进入编辑模式，或点击单元格的内部区域
编辑模式下按Esc进入命令行模式，或点击单元格的外部区域

（6）编辑模式: 

1.编辑code，命令行模式下按y键切换
2.编辑markdown，命令行模式下按m键切换

（7）运行单元格    

ctrl + enter
        如果是code，则运行代码
        如果是markdown，则预览文档
    shift + enter 
        运行当前行，并选中下方单元格
    alt + enter
        运行当前行，并在下方新增一个单元格

四、数组的相关概念

1.基本概念

NumPy（Numerical Python），C语言，高性能，Python数组计算、矩阵运算和科学计算的核心库；一维数组、二维数组和多维数组，大量的函数和方法；广泛应用于数据分析、机器学习、图像处理等领域；数据分析三大剑客之一，以数组的形式对数据进行操作。

2.数据类型

名称	描述
bool_	布尔型数据类型（True 或者 False)
float_	float64 类型的简写
int_	默认的整数类型（类似于 C 语言中的long，int32 或 int64)
float16/32/64	半精度浮点数：1 个符号位，5个指数位，10个尾数位 单精度浮点数：1 个符号位，8 个指数位，23个尾数位 双精度浮点数,包括：1个符号位，11 个指数位，52 个尾数位
intc	和C 语言的 int 类型一样，一般是 int32 或 int 64
complex_	复数类型，与 complex128 类型相同
intp	用于索引的整数类型（类似于C的ssize_t， 通常为 int32或 int64）
complex64/128	复数，表示双 32 位浮点数（实数部分和虚数部分） 复数，表示双64 位浮点数（实数部分和虚数部分）
int8/16/32/64	代表与1字节相同的8位整数 代表与2字节相同的16位整数 代表与4字节相同的32位整数 代表与8字节相同的64位整数
str_	表示字符串类型
uint8/16/32/64	代表1字节 （8位） 无符号整数 代表与2字节相同的16位整数 代表与4字节相同的32位整数 代表与8字节相同的64位整数
string_	表示字节串类型也就是bytes类型

五、创建数组

1.创建简单数组

通过 NumPy 的内置函数 array() 可以创建 ndarray 对象，其语法格式如下：

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

参数说明：

序号	参数	描述说明
1	object	表示一个数组序列
2	dtype	可选参数，通过它可以修改数组的数据类型
3	copy	可选参数，表示数组能否被复制，默认是True
4	ndmin	用于指定数组的维度
5	subok	可选参数，类型为bool值，默认False。为True，使用object的内部数据类型；False：使用object数组的数据类型

1.1创建一维数组

（1）数据为整数

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

#array([1, 2, 3, 4, 5])

（2）数据为小数

n2 = np.array([1.1,1.2,1.3,1.4])
n2

#array([1.1, 1.2, 1.3, 1.4])  

1.2创建二维数组

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

#array([[1, 2], [3, 4]])

1.3创建浮点型数组

lst = [1,2,3]
n4 = np.array(lst,dtype = float)   #用dtype设置数组元素的类型
n4

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

1.4数组的数据类型

# 通过 dtype 函数查看数组的元素数据类型

n4.dtype

#dtype('float64')

#通过 astype 函数转换数组元素类型

1.4.1转化为整型

 n4.astype(int)

#array([1, 2, 3])

1.4.2转化为浮点型

n4.astype(float)

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

1.4.3查看元素数据类型

#通过type查看元素数据类型

type(n4[0])

#numpy.float64

1.5复制数组

两个独立的数组

# 创建数组
n5 = np.array([1, 2, 3])

#通过设置 copy = True 实现复制数组

n6 = np.array(n5,copy=True)
n6        #array([1, 2, 3])

#通过 id 函数查看变量地址

id(n5)        #2666646595024

id(n6)        #2666627271728

1.6修改数组

（1）修改第1个元素为3

n6[0] = 3
n6        #array([3, 2, 3])

（2）修改第3个元素为1

n5[2] = 1
n5        #array([1, 2, 1])

1.7创建三维数组

#通过指定 ndmin 来实现定义数组的维数

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

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

2.创建指定维度和数值的数组

2.1创建指定维度的数组

（1）2行3列，未指定数据类型

n1 = np.empty(shape=[2,3])        #shape指定行数、列数

n11 = np.empty([2,3])

n1
n11

#array([[9.34577196e-307, 9.34598246e-307, 1.60218491e-306], [1.69119873e-306, 1.24611673e-306, 1.11262266e-307]])

（2）2行3列，指定数据类型

n2 = np.empty([2,3],dtype = int)        # 省略了shape关键字，dtype指定元素的数据类型
n2

#

array([[-254287744,        668,          0],
       [         0,     131074,          0]])

（3）3个元素，以0填充

n3 = np.zeros(3)
n3

#

array([0., 0., 0.])

#用 ndim 查看维度
n3.ndim        #  1

（4）3个元素，以1填充

n4 = np.ones(3)
n4

#

array([1., 1., 1.])

2.2创建以指定值填充的数组

#通过 full() 函数实现创建指定值填充的数组

#3行3列，以8填充

n5 = np.full([3,3],8)
n5

#

array([[8, 8, 8],
       [8, 8, 8],
       [8, 8, 8]])

2.3提取数组的对角线元素

#通过 diag() 函数提取数组的对角线元素

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

#

array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])

np.diag(n6)

#

array([0, 4, 8])

3.创建指定数值范围的数组

arange（生成区间数组）

根据 start 与stop 指定的范围以及 step 设定的步长，生成一个ndarray。

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

参数说明：

序号	参数	描述说明
1	start	起始值，默认为0
2	stop	终止值，不包含
3	step	步长，默认为1
4	dtype	返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型

3.1创建指定数值范围的数组

#数值范围[1, 12)，步长为2

n1 = np.arange(1,12,2)        #arange(开始值，结束值，步长)，其中结束值不包含
n1

#

array([ 1,  3,  5,  7,  9, 11])

3.2创建等差的数组

linspace() 创建等差数列

返回在间隔 [开始，停止] 上计算的num个均匀间隔的样本。数组是一个等差数列构成

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

参数说明：

序号	参数	描述说明
1	start	必填项，序列的起始值
2	stop	必填项，序列的终止值，如果endpoint为true， 该值包含于数列中
3	num	要生成的等步长的样本数量，默认为50
4	endpoint	该值为 true 时，数列中包含stop值，反之不包含，默认是True
5	retstep	如果为 True 时，生成的数组中会显示间距，反之不显示
6	dtype	ndarray 的数据类型

（1）7500-10000，6等分，结束点包含

n2 = np.linspace(7500,10000,6,endpoint=True)        # 将 endpoint 设置为 True 实现取值范围包括结束值
n2

#

array([ 7500.,  8000.,  8500.,  9000.,  9500., 10000.])

（2）7500-10000，6等分，结束点不含

n3 = np.linspace(7500,10000,6,endpoint=False)        #将 endpoint 设置为 False 实现取值范围不包括结束值
n3

#

array([7500.        , 7916.66666667, 8333.33333333, 8750.        ,
       9166.66666667, 9583.33333333])

3.3创建等比数组

返回在间隔 [开始，停止] 上计算的num个均匀间隔的样本。数组是一个等比数列构成

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

参数说明：

序号	参数	描述说明
1	start	必填项，序列的起始值
2	stop	必填项，序列的终止值，如果endpoint为true， 该值包含于数列中
3	num	要生成的等步长的样本数量，默认为50
4	endpoint	该值为 true 时，数列中包含stop值，反之不包含，默认是True
5	base	对数log的底数
6	dtype	ndarray 的数据类型

np.logspace(A,B,C,base=D)

A：生成数组的起始值为D的A次方 

B：生成数组的结束值为D的B次方

C：总共生成C个数

D：指数型数组的底数为D，当省略base=D时，默认底数为10

#以2为底数，从2的1次方到2的10次方，5个元素

n4 = np.logspace(1,10,num=5,base=2)        #num表示取值数量，base表示以什么为底数
n4

#

array([   2.        ,    9.51365692,   45.254834  ,  215.2694823 ,
       1024.        ])

4.生成随机数组

4.1生成随机数组

4.1.1小数数组

（1）[0, 1)的一维数组，5个元素，小数

np.random.rand(5)    # 默认取值范围是[0,1)

#

array([0.9967288 , 0.5707764 , 0.53177897, 0.37180087, 0.74049533])

（2）[0, 1)的二维数组，2行5列，小数

np.random.rand(2,5)

#

array([[0.95423195, 0.14394678, 0.58088134, 0.20928571, 0.40105899],
       [0.02799011, 0.02284569, 0.33758537, 0.71509059, 0.66456588]])

（3）[0, 10)的二维数组，2行3列，小数

np.random.uniform(0,10,[2,3])

#

array([[1.79275999, 0.10721961, 2.26760527],
       [5.45795694, 3.26566066, 9.57342661]])

4.1.2正态分布数组

（1）满足正态分布的一维数组，5个元素

# n: normal
arr = np.random.randn(5)
arr

#

array([-0.68426253,  1.0070584 ,  0.4077303 , -1.39352282, -1.28414992])

（2）满足正态分布的二维数组，2行5列

np.random.randn(2,5)

#

array([[-0.1088344 , -1.70272528, -1.05710009, -1.54215082, -1.06530774],
       [-0.2659545 , -0.78422115,  0.78627833,  0.51634213, -0.06934132]])

（3）满足正态分布的一维数组，100个元素；均值为0，标准差为1

#loc：均值；scale：标准差
arr1 = np.random.normal(loc=0,scale=1,size=100)
arr1

#

array([-2.41589256e+00,  2.40151634e+00,  8.20584215e-01,  5.31853943e-01,
       -5.46841251e-01,  1.41620888e-01,  1.64635179e-02, -6.65680994e-01,
       -9.97016991e-01,  8.28326549e-01, -5.52942682e-01,  8.55529174e-01,
        3.59779269e-01, -1.39258616e-01, -4.97591878e-02, -9.27435063e-01,
        7.97171110e-02,  9.23083006e-01, -1.72049137e+00,  6.39821205e-01,
        4.70985102e-01, -3.67203444e-01,  1.65801749e+00, -8.82267299e-01,
       -5.12518896e-01,  1.12672936e+00, -1.08713730e+00,  3.35485658e-01,
       -7.74061501e-01,  7.00979529e-01,  6.25297519e-01,  6.51303680e-01,
       -3.55855752e-01, -2.02022440e+00, -6.93819301e-01,  1.28247267e+00,
       -1.70989157e-01,  1.11181381e+00,  1.36675562e+00,  2.48366151e-01,
        1.07880169e+00,  1.44404180e-01, -1.74040610e+00,  1.06257179e+00,
        2.13883891e+00, -9.82531825e-02,  9.61697558e-02, -2.16053046e+00,
        2.85793945e-02,  4.50723621e-02, -1.12725881e+00, -8.70447857e-01,
        3.96592170e-01,  1.32313237e+00,  1.49113936e+00,  4.79281418e-01,
       -1.70623574e+00,  7.17041522e-01,  3.93613111e-01, -8.01570740e-01,
        6.77232766e-01, -1.31031607e-01,  4.69590990e-02,  4.85011578e-01,
       -1.66054763e-01, -5.85721348e-02,  5.37987286e-02,  1.57888613e+00,
       -5.19847199e-01,  6.13099315e-01,  2.09019576e-01, -3.60280231e-01,
       -2.09651116e-01,  1.37913236e+00, -1.24944065e+00,  2.09451504e+00,
        6.12023818e-01,  1.46528207e-01, -3.50763841e-04, -4.27085603e-01,
        9.87510817e-02, -1.14277715e+00, -4.38456420e-01,  4.93430537e-02,
        1.32933295e+00, -1.72436492e+00, -5.40709580e-01, -8.33509753e-01,
       -6.04710351e-02, -2.59223893e-01, -2.12301911e+00, -1.32497567e-01,
        1.00469928e+00, -9.36746638e-01, -5.77884652e-02, -1.38796026e+00,
       -7.20013894e-01,  1.64869760e+00,  1.71438368e+00,  2.89509625e-01])

4.1.3整数数组

（1）[1, 3)的一维数组，10个元素，整数

np.random.randint(1,3,10)

#

array([2, 2, 2, 2, 2, 1, 2, 2, 2, 1])

（2）[5, 10)的一维数组，1个元素，整数

np.random.randint(5,10)        #    9

（3）[0, 5)的二维数组，2行5列，整数

np.random.randint(0,5,[2,5])

#

array([[3, 0, 3, 4, 3],
       [0, 0, 4, 0, 4]])

4.1.4随机种子

作用：重复运行代码而数值不变

#随机种子必须与随机数函数在同一个代码块
np.random.seed(1)
np.random.randint(1,10,4)

#

array([6, 9, 6, 1])

4.1.5打乱数组

lst = [1,2,3,4,5]
np.random.shuffle(lst)   #不需要重新赋值
lst

#

[4, 1, 2, 3, 5]

4.2数组的属性

NumPy 的数组中比较重要 ndarray 对象属性有：

属性	说明
ndarray.ndim	秩，即轴的数量或维度的数量
ndarray.shape	数组的维度，对于矩阵，n行m列
ndarray.size	数组元索的总个数，相当于 .shape 中n*m 的值
ndarray.dtype	ndarray 对象的元素类型
ndarray.itemsize	ndarray对象中每个元素的大小，以字节为单位

arr1 = np.random.rand(5, 6)
arr1

#

array([[0.84631092, 0.31327352, 0.52454816, 0.44345289, 0.22957721,
        0.53441391],
       [0.91396202, 0.45720481, 0.43069857, 0.93912779, 0.77838924,
        0.71597052],
       [0.8027575 , 0.09280081, 0.51815255, 0.86502025, 0.82914691,
        0.82960336],
       [0.27304997, 0.0592432 , 0.67052804, 0.59306552, 0.6716541 ,
        0.41178788],
       [0.1975509 , 0.28962964, 0.14212014, 0.78331447, 0.41253884,
        0.03417131]])

4.2.1查看元素数量

数组元素的总个数，相当于.shape 中 n*m 的值

arr1.size        #  arr1的元素数量为 30

4.2.2查看数组形状

返回一个包含数组维度的元组，对于矩阵，n行m列，它也可以用于调整数组维度

arr1.shape        #arr1为5行6列的数组 (5, 6)

4.2.3查看数组维度

返回数组的维度（秩）：轴的数量，或者维度的数量，是一个标量，一维数组的秩为 1，二维数组的秩为 2

arr1.ndim        # arr1为 2 维数组

4.2.4查看数组类型

方法dtype()

ndarray 对象的元素类型

arr1.dtype        #  dtype('float64')

4.2.5ndarray.itemsize

以字节的形式返回数组中每一个元素的大小。

例如，一个元素类型为 float64的数组 itemsize 属性值为 8（float64 占用64个bits，每个字节长度为8，所以 64/8，占用8个字节）

4.3缺失值

nan表示缺失值

# python 中 None,表示空值
arr2 = np.array([1,2,np.nan,4])
arr2                                        # array([ 1., 2., nan, 4.])

arr2.dtype                                # dtype('float64')

4.3.1查看缺失值

np.isnan(arr2)        # array([False, False, True, False])

4.3.2填充缺失值

arr2[np.isnan(arr2)] = 0    # np.isnan()返回值为空的下标
arr2                # array([1., 2., 0., 4.])

4.3.3删除重复值

arr3 = np.array([1,2,3,3])
arr3                        # array([1, 2, 3, 3])

np.unique(arr3)                # array([1, 2, 3])

5.从已有数组中创建数组

5.1通过列表创建数组

lst = [1, 2, 3]

np.array(lst)        #array([1, 2, 3])

5.2通过元组创建数组

tup = (1, 2, 3)

np.array(tup)        #array([1, 2, 3])

5.3通过列表内嵌元组创建数组

lst_tup = [(1, 2), (3, 4)]

np.array(lst_tup)       

#

array([[1, 2],
       [3, 4]])

5.4通过元组内嵌元组创建数组

tup_tup = ((1, 2), (3, 4))

np.array(tup_tup)

#

array([[1, 2],
       [3, 4]])

5.5通过元组内嵌列表创建数组

tup_lst = ([1, 2], [3, 4])

np.array(tup_lst)

#

array([[1, 2],
       [3, 4]])

5.6通过字符串创建数组

string = 'python'
np.asarray(list(string))                #array(['p', 'y', 't', 'h', 'o', 'n'], dtype='<U1')

5.7通过可迭代对象创建数组

#可迭代对象：可以for循环遍历访问的对象
#迭代器：可以访问集合元素，并且能够记住访问的位置，但是访问只能向前不能后退

（1）可迭代对象创建数组
import time
lst = [1,2,3,4,5]
for x in lst:
    print(x)
    time.sleep(3)

np.array(lst)                # array([1, 2, 3, 4, 5])

（2）迭代器创建数组

import time
it = iter([1,2,3,4,5])

for x in it:
    print(x)
    time.sleep(3)

#

1
2
3
4
5

it = iter([1,2,3,4,5])
type(it)                # list_iterator

#数组元素类型依旧为迭代器
np.array(it)        # array(<list_iterator object at 0x000001FD99BFEA30>, dtype=object)

#数组元素类型为整型
np.fromiter(it,dtype=int)                # array([1, 2, 3, 4, 5])

5.8创建与给定数组类型与形状相同的数组

与给定数组具有相同的维度和数据类型的数组

5.8.1 empty_like

数值未初始化

np.empty_like([[1,2],[3,4]])

#

array([[-1784124592,         509],
       [          0,           0]])

5.8.2 zeros_like

以0填充

np.zeros_like([[1,2,3],[4,5,6]])

#

array([[0, 0, 0],
       [0, 0, 0]])

5.8.3 ones_like

以1填充

np.ones_like([[1.1,2.1],[3.1,4.1]])

#

array([[1., 1.],
       [1., 1.]])

5.8.4 full_like

以指定值填充

np.full_like([[1,2,3],[4,5,6]],fill_value=9)     #fill_value为指定的填充值

#

array([[9, 9, 9],
       [9, 9, 9]])

六、数组的基本操作

1.数组的运算

import numpy as np

# 创建两个一维数组
n1 = np.array([6, 7])
n2 = np.array([2, 3])

1.1四则运算

（1）加法运算

n1 + n2                #  array([ 8, 10])

（2）减法运算

n1 - n2                # array([4, 4])

（3）乘法运算

n1 * n2                # array([12, 21])

（4）除法运算

n1 / n2                # array([3. , 2.33333333])

1.2幂运算

n1 ** n2                # array([ 36, 343], dtype=int32)

1.3取整

相除后取整数部分

n1 // n2                # array([3, 2], dtype=int32)

1.4取余/取模

相除后取余数部分

n1 % n2                # array([0, 1], dtype=int32)

1.5求相反数

-n1                # array([-6, -7])

-n2                # array([-2, -3])

1.6求倒数

1/n1                # array([0.16666667, 0.14285714])

1.7比较运算

（1）大于等于

n1 >= n2                #  array([ True, True])

（2）等于

n1 == n2                #  array([False, False])

（3）小于等于

n1 <= n2                # array([False, False])

（4）不等于

n1 != n2                 # array([ True, True])

1.8标量运算

# 创建等差数列数组
arr = np.linspace(1000, 10000, 10, dtype=int)
arr                                # array([ 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000, 10000])

#一个值称为标量
#一维的数组称为向量
#二维的数组称为矩阵
#二维以上的数组称为张量
#行数与列数相等的数组叫做方阵
arr/50                        # array([ 20., 40., 60., 80., 100., 120., 140., 160., 180., 200.])

1.9集合运算

创建两个[1, 5)的二维数组，2行3列，整数

a = np.random.randint(1, 5, (2, 3))
a

#

array([[1, 2, 3],
       [1, 4, 2]])

b = np.random.randint(1, 5, (2, 3))
b

#

array([[2, 4, 4],
       [1, 1, 2]])

（1）交集

交集，a数组和b数组共有的元素

np.intersect1d(a,b)                # array([1, 2, 4])

（2）并集

并集，a数组和b数组的元素合并

np.union1d(a,b)                # array([1, 2, 3, 4])

（3）包含

a.包含，a数组的每个元素是否包含在b数组内

np.in1d(a,b)                # array([ True, True, False, True, True, True])

b.包含，b数组的每个元素是否包含在a数组内

np.in1d(b,a)                # array([ True, True, True, True, True, True])

（4）差集

a.差集，a数组减去b数组的元素

np.setdiff1d(a,b)                # array([3])

b.差集，b数组减去a数组的元素

np.setdiff1d(b,a)                # array([], dtype=int32)

2.数组的索引和切片

ndarray对象的内容可以通过索引或切片来访问和修改，与Python中 list 的切片操作一样。

ndarray 数组可以基于 0-n 的下标进行索引

注意：区别在于数组切片是原始数组视图（这就意味着，如果做任何修改，原始都会跟
着更改）。这也意味着，如果不想更改原始数组，我们需要进行显式的复制，从而得到它的
副本 (.copy())。

为什么切片和区间会忽略最后一个元素
计算机科学家edsger w.dijkstra(艾兹格•W•迪科斯街），delattr这一风格的解释应该是比较好的：
•当只有最后一个位置信息时，我们可以快速看出切片和区间里有几个元素：range (3)和my_list[:3]
• 当起始位置信息都可见时，我们可以快速计算出切片和区间的长度，用有一个数减去第一个下标(stop-start)即可
•这样做也让我们可以利用任意一个下标把序列分割成不重叠的两部分，只要写成my_list[:x]和my_list[x:]就可以了。

import numpy as np

2.1创建一维数组

（1）array函数

切片操作：

正向索引从0开始

反向索引从-1开始

 

（2）arange函数

• 切片操作：arr[start:stop:step]
• start，开始值
• stop，结束值
• step，步长值

a.输出倒数第1个至倒数第3个元素(不含)

 b.输出倒数第3个至倒数第5个元素(不含),且步长为-1

c.输出倒数第5个至倒数最后1个元素(含),且步长为-1

 

2.2创建二维数组

• 切片操作

 

注意：切片还可以使用省略号"…”，如果在行位置使用省略号，那么返回值将包含所有行元素，反之，则包含所有列元素。

3.数组的重塑

import numpy as np

3.1 reshape重塑

重塑前后的元素个数必须一致，重塑后不会修改原数组

（1）创建一维数组并重塑

• 重塑为2行4列的二维数组 

 当重塑的元素数量多于原来数组的元素数量时会报错

• 重塑为2行3列的二维数组

• 重塑为6行1列的二维数组

 

（2）创建二维数组并重塑

• 重塑为3行2列的二维数组

 

• 重塑为一维数组(扁平化)

 

（3）将字符串转为数组并重塑

3.2 resize重塑

重塑前后的元素个数可以不一致，重塑后会修改原数组

（1） 重塑后比原尺寸小

自动截断

（2） 重塑后比原尺寸大 

以0填充

3.3 行列转置

• 创建3行4列的二维数组

4.数据的增删改查

import numpy as np

4.1创建两个二维数组

4.2合并数据

• 将多个数组合并为一个数组

（1）水平方向合并

（2）垂直方向合并

4.3拆分数据

• 将一个数组拆分为多个子数组

（1）水平方向拆分

（2）垂直方向拆分 

4.4新增数据

（1） 新增一行数据

（2）新增一列数据 

4.5删除数据

（1）删除第3行 

（2）删除第1列

（3）删除第2行和第3行

4.6修改数组

（1）修改第2行为[30,40]

（2）修改第2列为[20,40,60] 

（3）修改第3行第1列为50

（4）修改第1行第1列为10

4.7条件判断

• 创建[60,100)的一维数组，步长为10

• 大于80返回优秀, 否则返回一般 

• 筛选大于80的元素

4.8数组的赋值

4.9数组的视图

4.10数组的复制

七、矩阵的基本操作

1.数组与矩阵

数组：计算机程序设计领域的概念

矩阵：数学的概念

对于NumPy，矩阵是数组的分支

2.创建矩阵

import numpy as np

（1）创建矩阵

a.通过字符串创建矩阵

b.通过列表创建矩阵

c.通过数组创建矩阵

  

（2）创建3*3的0矩阵

（3）创建2*4的1矩阵

（4）创建3*3的矩阵

• 数值范围为[0,1)的小数

（5）创建3*5的矩阵

• 数值范围为[1,8)的整数

（6）创建4*4的对角矩阵

• 对角线元素为1，其他元素为0，即单位矩阵

（7）创建3*3的对角矩阵

• 对角线元素为[1, 2, 3]

3.矩阵的运算

import numpy as np

3.1矩阵的运算

（1）创建矩阵

（2）矩阵加法

（3）矩阵减法

（4）矩阵除法

（5）矩阵乘法

3.2数组的广播机制

广播(Broadcast)是 numpy 对不同形状(shape)的数组进行数值计算的方式，对数组的算术运算通常在相应的元素上进行。
如果两个数组a和b形状相同，即满足 a.shape == b.shape，那么a*b的结果就是 a与b数组对应位相乘。这要求维数相同，且各维度的长度相同。

但如果两个形状不同的数组呢？它们之间就不能做算术运算了吗？当然不是！为了保持数组形状相同，NumPy 设计了一种广播机制，这种机制的核心是对形状较小的数组，在横向或纵向上进行一定次数的重复，使其与形状较大的数组拥有相同的维度。

广播的规则：
•让所有输入数组都向其中形状最长的数组看齐，形状中不足的部分都通过在前面加1补齐。
•输出数组的形状是输入数组形状的各个维度上的最大值。
•如果输入数组的某个维度和输出数组的对应维度的长度相同或者其长度为1时，这个数组能够用来计算，否则出错。
•当输入数组的某个维度的长度为1时，沿着此维度运算时都用此维度上的第一组值。

（1）创建数组

（2）纵向广播

• 四则运算同理

 

 （3）横向广播

• 四则运算同理

3.3数组的点乘运算

#np.dot()
#如果数组a和数组b都是二维数组，则表示矩阵乘法
#如果数组a和数组b都是一维数组，则表示向量内积（对应位置的元素相乘，然后求和）
#如果两个参数中有一个是标量，则表示乘法运算
#如果数组a是多维数组，数组b是一维数组，则表示数组a的最后一个轴和数组b的乘积之和
#如果数组a是维数大于1，数组b是维数大于2，则表示a的最后一个轴与b的倒数第2个轴的乘积之和

3.4矩阵的乘法运算

4.矩阵的重塑

import numpy as np

4.1创建矩阵

• 3行*4列，[0,10)

4.2矩阵行列转置

4.3 reshape矩阵重塑

• 重塑前后的元素个数必须一致
• 重塑后不会修改原矩阵

（1）重塑为3行5列

（2）重塑为2行6列

（3）重塑为4行3列

4.4 resize矩阵重塑

• 重塑前后的元素个数可以不一致
• 重塑后会修改原矩阵

（1）重塑为2行3列

• 重塑后比原尺寸小
• 自动截断

（2）重塑为3行5列

• 重塑后比原尺寸大
• 以0填充

4.5逆矩阵

# 什么是逆矩阵？
# 如果a矩阵与b矩阵相乘等于单位矩阵，那么b矩阵称为a矩阵的逆
# 不是所有的矩阵都能求逆矩阵，即不是所有的矩阵都有逆矩阵
#单位矩阵：对角线元素为1，其他元素为0的矩阵

  

八、统计分析函数

1.数学运算函数

import numpy as np

1.1数学运算

• 通过函数进行数学运算
• 符号运算和函数运算均采用广播机制

（1）创建数组

（2）加法运算

（3）减法运算

（4）乘法运算

 

（5）除法运算

（6）幂运算

（7）取整

• 相除后取整数部分 

 （8）取余/取模

• 相除后取余数部分

（9）求相反数

（10）求倒数

  

1.2四舍五入

• 随机生成1行5列[1000,10000)的小数

（1）四舍五入取整

（2）四舍五入保留两位小数

（3）四舍五入取整到小数点左侧一位

  

1.3向上向下取整

（1）向上取整

（2）向下取整 

1.4累加与累乘

• x = [1, 2, 3, 4, 5]

（1）逐个元素累加

（2）所有元素累加

（3）逐个元素累乘

（4）所有元素累乘 

​ 

1.5指数运算

（1）e的x次方

• e为自然常数

（2）2的x次方 

（3）3的x次方

1.6对数运算

• 指数运算的逆运算
• 如果a的x次方等于b（a>0，且a≠1），那么x叫做以a为底b的对数

#举例：2的3次方等于8，那么3记作以2为底8的对数

（1）以e为底的对数

• e为自然常数

（2）以2为底的对数

（3）以10为底的对数

2.统计分析函数

import numpy as np

2.1创建数组

2.2对数组求和

（1）对数组求和

（2）对数组按行求和

（3）对数组按列求和

  

2.3对数组求平均值

若想求某一维度的平均值，设置 axis 参数，多维数组的元素指定

•axis =0.将从上往下计算
•axis = 1将从左往右计算 

（1）对数组求平均值

（2）对数组按行求平均值

（3） 对数组按列求平均值

2.4对数组求最大值

（1）对数组求最大值

（2）对数组按行求最大值

（3） 对数组按列求最大值

  

2.5加权平均值

• average

#mean 算术平均数：（64 + 98 + 93 + 14 + 74)/5
#average 加权平均数：按业务占比加权计算均值，消除极端值带来的影响

2.6中位数&方差&标准差

（1）中位数

中位数 np.median

又称中点数，中值
是按顺序排列的一组数据中居于中间位置的数，代表一个样本、种群或概率分布中的一个数值
•平均数：是一个"虚拟"的数，是通过计算得到的，它不是数据中的原始数据。

•中位数：是一个不完全"虛拟"的数。
•平均数：反映了一组数据的平均大小，常用来代表数据的总体 "平均水平”。

•中位数：像一条分界线，将数据分成前半部分和后半部分，因此用来代表一组数据的"中等水平"

（2）方差

（3）标准差

在概率统计中最常使用作为统计分布程度上的测量，是反映一组数据离散程度最常用的一种量化形式，是表示精确度的重要指标
•标准差定义是总体各单位标准值与其平均数离差平方的算术平均数的平方根。
简单来说，标准差是一组数据平均值分散程度的一种度量。
•一个较大的标准差，代表大部分数值和其平均值之间差异较大;
•一个较小的标准差，代表这些数值较接近平均值。

3.数组的排序

3.1创建数组

• 随机生成3行3列[1,100)的整数

3.2按行排序

• 按行元素排序

（1）升序

np.sort(a, axis=-1, kind=None, order=None)

默认为升序，没有调节排序方式的参数

（2）降序

3.3按列排序

• 按列元素排序

（1）升序

（2）降序

3.4排序后重构原数组

重构前后对象的内存地址不变

3.5数组的多级排序

• 随机生成两个数组
• 5个[1,100)的整数

九、练习题

import numpy as np

1.创建整型数组

• 创建0到10步长为1的一维数组

 

2.创建浮点型数组

• 创建5到10的5行3列的随机浮点型数组

 

3.创建布尔型数组

• 创建3行3列的随机布尔型数组

 

4.数组重塑 

5.垂直合并数组

6.水平合并数组 

7.两个数组的交集

8.两个数组的差集 

• arr1存在而arr2不存在的元素

9.条件提取元素

10.条件提取元素 

11.调整数组的列顺序

12.反转数组各行顺序

13.反转数组各列顺序

14.保留三位小数

15.求均值和中位数

16.求方差和标准差

17.求分位数

18.判断是否存在空值

19.替换数组的元素

20.求每行最大值

21.求每列最小值

22.求每行最小值与最大值的比值

23.过滤数组的空值

24.替换数组的空值

25.返回元素的索引