Numpy库学习笔记

导入numpy库

import numpy as np

数组的创建

1.array: 将输入数据（可以是列表，元组，以及其他序列）转换为Numpy数组。

a=np.array({1,2,3})
print(type(a))
<class 'numpy.ndarray'>

2.arange:Python内建函数range的数组版，返回一个数据。

b=np.arange(1,10)
print(type(b))

在其后直接进行操作

c=np.arange(1,10)**3
print(c)
c=np.array([1,2,3])*3
print(c)

3. 给数据指定数据类型

print(a.dtype)#int32或
a=np.array([1,2,3],dtype=float)
b=np.array([1,2,3],dtype='float32')
print(a.dtype,b.dtype)

4.array的一些属性

 a.shape：返回一个元组，表示array的维度，[形状，几行几列]

    例如:(1,2) 是一行两列，从左到右依次第一，二，n维。 有几个数字就有几个维度。

a=np.array(range(1,9))
print(a.shape)

b.ndim：返回一个数字，表示array维度的数目

a=np.array(range(1,9))
print(a.ndim)

c.size:返回一个数字，表示array中所有数据元素的数目

a=np.array(range(1,9))
print(a.size)

d.dtype:返回数组中元素的数据类型

a=np.array(range(1,9))
print(a.dtype)

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

5.使用ones创建全是1的数组

 np.ones(shape,dtype=None,order='C')

参数order：{‘C','F'}，可选规定返回数组元素在内存的储存顺序：C(C语言）-rowmajor；F（Fortran）column-major

a=np.ones(3)
print(a)

多维（多加一个括号）

a=np.ones((2,3))
print(a)

6.创建全是0的数组

同上只需把ones改为zeros

a=np.zeros((4,4))
print(a)

7.full创建指定值的数组

np.full(shape,fill-value,dtype=None,order='C')

例：创建一个元素全是888的数组

a=np.full(3,888)
print(a)

多维

b=np.full((4,4),88)
print(b)

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

多维数组

一维数组的定义：当数组中每个元素都只带有一个下标时，称这样的数组为一维数组，一维数组实质上时一组相同类型数据的线性集合

二维数组的定义：通常称矩阵，本质上时以数组为数组元素的数组

如[[11,22],[22,99]]

三维 例：使用zeros创建一个多维数组

a=np.zeros((4,6,2))
print(a)

2列6行4层

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

ones_like,zeros_like,full_like,创建形状相同的数组

np.ones_like(a,dtype=  ,order=    ,subok=  )

a=np.array([[1,2,3],[4,5,6]])
b=np.ones_like(a)
print(b)
c=np.zeros_like(a)
print(c)
d=np.full_like(a,9)
print(d)

random模块生成随机数组

np.random.randn(d0,d1,......,dn)

传n个数就是n维

需要四舍五入的话：

np.round(a,n)保留到小数点后n位

c=np.round(a,1)
print(c)

resharp不改值修改形状

1.改变数组的形状（不改变值）

a=np.arange(9).reshape(3,3)
print(a)

2.resharp后括号里的数字乘积与arange括号中相同

b=a.reshape(9)
print(b)

3.将一个多维数组展开变成一个一维数组

a.flatten()

a=np.arange(9).reshape(3,3)
a.flatten()
print(a)

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

数组计算

1.直接加上某个数（数组中每个元素都加上该数）（加减乘除适用）

2.形状相同的两个数组相加（对应位置相加）（加减乘除适用）

a=np.zeros((2,3))
b=np.ones((2,3))
print(a+b)






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

Process finished with exit code 0

3.广播原则（什么情况下两个数组可以相加）

1.形状相同

2.（1）

（2） 

 解释：

形状不同时：

1.两个数组最后两个数相同（行列相同）

2.两个数组其中一个最后两个数为1，且两个数组最后两个数字另一个相同

 

特殊：

 

 也可以。

基础索引与切片

1.一维数组

一维数组（与pythonzhong的列表一样）

2.二维数组

二维数组索引用行列坐标，类似于我们EXCEL中的offset

 例如：如下二维数组中

 A[0,0]---0       A[2]---第三行   A[0:2,0:2]----一到二行的一到二列

布尔索引

1. 利用布尔索引筛选出数组中大于5的数

数组=np.arange(10)
筛选=数组>5#布尔索引
print(筛选)
print(数组[筛选])

小于于5为0，大于等于5为1

数组=np.arange(10)
print(数组)
数组[数组<5]=0
数组[数组 >= 5] = 1#其中的(数组>=5)相当于一个布尔索引
print(数组)

 给数组大于5的数加上100

数组=np.arange(10)
print(数组)
数组[数组>5]+=100
print(数组)

 2.二维数组

给二维数组每个数加上n的操作同一维数组

[[ 1  2  3  4  5]
 [ 6  7  8  9 10]
 [11 12 13 14 15]
 [16 17 18 19 20]]

 筛选出其中大于5的数

筛选=数组>5
print(数组[筛选])

 第三列大于5的筛选出来并赋值为500

筛选=数组[:,2]>5
数组[:,3][筛选]=500
print(数组)

错误示范

数组[数组[:,3]>5]=500
print(数组)

输出
[[  1   2   3   4   5]
 [500 500 500 500 500]
 [500 500 500 500 500]
 [500 500 500 500 500]]


索引与数组不匹配
索引是[False  True  True  True]
自动广播展开了

找出大于5的数

数组=np.arange(1,21).reshape(4,5)
筛选=数组>5
print(数组[筛选])

 找出偶数或小于7的数

数组=np.arange(1,21).reshape(4,5)
筛选=(数组%2==0)|(数组>7)
print(数组[筛选])#带上括号

神奇索引

使用整数数组进行数据索引

a=np.arange(1,10)
print(a)
print('-'*40)
print(a[[1,2,3]])#使用一个数组作为索引

二维数组的神奇索引

a=np.arange(20).reshape(4,5)
print(a)
print('-'*30)
print(a[[1,2]])#使用数组作为索引，返回多个行

二维数组获取第几行第几列

a=np.arange(20).reshape(4,5)
print(a)
print('-'*30)
print(a[[1,2],[1,2]])#使用数组作为索引，返回第2行第2列，第3行第三列

二维数组只要第几列

a=np.arange(20).reshape(4,5)
print(a)
print('-'*30)
print(a[:,[0,1]])

数组.argsort()返回排序后的索引

例：排序，选出最大的三个数

suo=a.argsort()[-3:]

Numpy的轴

数组的形状shape

索引对应轴  如shape(1,2,3)对应索引[0,1,2]

则分别对应0轴1轴2轴 （行是1）

 几维就有几个轴

沿轴切片

[1:2,1:2.....]

[  0,   1,  2..]分别在0，1，2轴上切

 数组转置换轴

1.    .reshape()方法

2.数组.transpose()

a=np.arange(12).reshape(3,4)
print(a)
print('-'*30)
print(a.transpose())
print(a.transpose().shape)

3.轴转置 swapaxes方法

a=np.arange(12).reshape(3,4)
print(a)
print('-'*30)
print(a.swapaxes(1,0))#参数表示0轴与1轴相互转置

random随机函数

1.seed向随机数生成器传递随机状态种子

import random
random.seed(100)#种子
print(random.randint(1,56))

第一次生成的随机数固定，再次执行随机数不会改变，（没有种子会变）

2.rand返回[0,1]之间，从均匀分布之间抽取样本

a=np.random.rand(3,2)#生成一个三行两列的数组，随机数在（0，1）之间
print(a)

3.randn返回正态分布  N(0,1)的随机数

a=np.random.randn(3,2)
print(a)#正态分布

4.randint随机整数

a=np.random.randint(1,10,size=(4,3))#生成1到10之间，尺寸为4行3列的数组
print(a)

5.random

a=np.random.random(10)#生成0到1之间10个随机数组
print(a)

6.choice从一堆数中生成随机数

a=np.random.choice(10,(5,2))#0到9之间的随机数，生成规格5行2列
print(a)
print('-'*30)
b=np.random.choice([1,2,3],(4,5))#从1，2，3中选一个4行5列的数组
print(b)
print('-'*30)

7.shuffle把数组进行随机排列

a=np.arange(10)
np.random.shuffle(a)
print(a)#一维数组按个排序
print('-'*30)
b=np.arange(10).reshape(2,5)
np.random.shuffle(b)
print(b)
print('-'*30)#二维数组按行排序，只改变行间的顺序
c=np.arange(12).reshape(2,2,3)
np.random.shuffle(c)
print(c)#三维数组按个拍

多维数组按最高的一维拍（如二维按行排序）

8.permutation把一个数组或数字全排列

permutation创建一个新的数组，不改变原来数组，shuffl改变原来数组

a=np.random.permutation(10)#yushuffle不同其可以直接创建一个数组，二维以上不行
print(a)

其他作用与shuffle基本一致

9.normal生成正态分布数字

数组=np.random.normal(1,10,10)#平均值1，方差10，10个数

通用函数

通用函数也可以称作ufunc，是一种在数组数据中进行 逐个元素 操作的函数。某些简单函数接受了一个或多个标量数值并产生一个或多个标量结果，而通用函数就是对这些函数的向量化封装。

1.一元通用函数

简单的逐个元素转换 例子：

a=np.arange(10)
print(np.abs(a))

2.二元通用函数

列子：接受两个数组并返回一

 数学和统计方法

一维数组

 prod是累乘

二维数组

 cumsum与cumprod相于把二维展开为一维，同一维的操作方法

numpy的axis的用途（0是按行，1是按列）

按行或按列操作 例：按行竖着加

a=np.arange(12).reshape(4,3)
print(a)
print(np.sum(a,axis=0))

按列横着加

a=np.arange(12).reshape(4,3)
print(a)
print(np.sum(a,axis=1))

数组满足条件个数的计算

1.将条件逻辑作为数组操作

where用法 例：筛选出数组中大于3的数改为500 ，其余为1000

import numpy as np
a=np.arange(12).reshape(4,3)
b=np.where(a>3,500,100)#不能修改原数组
print(b)

2.布尔数值方法  any 与all

例：求大于3的元素个数（利用布尔索引，T为1，F为0）

import numpy as np
a=np.arange(12).reshape(4,3)
print((a>3).sum())

any与all（检查数组中的值）

import numpy as np
a=np.array([True,False])
print(a.all())#全真则真
print(a.any())#一真则真

按值的大小进行排序

一维排序

import numpy as np
a=np.array([2,5,1,9,3,6])
a.sort()
print(a)

二维数组的排序

import numpy as np
a=np.array([2,5,1,9,9,6,3,6]).reshape(2,4)
print(a)
print('-'*30)
print(np.sort(a))
print(np.sort(a,axis=0))

有按行排序与按列排序

0是按行 1是按照列

按行是上下，按列是左右

从小到大的索引argsort

一维（升序，返回排序后的索引）

import numpy as np
a=np.array([2,5,1,9,9,6,3,6])
print(a.argsort())

二维（axis，默认最后一维）

import numpy as np
a=np.array([2,5,1,9,9,6,3,6]).reshape(2,4)
print(a.argsort())

唯一值与其他集合逻辑和in1d

1.唯一值（去重）

import numpy as np
a=np.array([2,5,1,9,9,6,3,6]).reshape(2,4)
print(np.unique(a))

2. j检查一个数组中的元素是否在另一数组中

返回一个布尔·索引

import numpy as np
a=np.array([2,5,1,9,9,6,3,6]).reshape(2,4)
b=np.in1d(a,[1,2])
print(b)

 浅拷贝，深拷贝

如果想复制一个数组，不能直接 a=b 或a=b[:](切片)，否则后来的修改会影响之前的

浅拷贝

a=b[:]

深拷贝

a=b.copy

linspace方法在某个区间平分

x=np.linspace(0,14,100)

1 到14平分为100份

线代上课

导入numpy

定义矩阵

import numpy as np
D=np.array([[1,2,-4],[-2,2,1],[-3,4,-2]])#定义矩阵 二维数组
print(np.linalg.det(D))#计算二阶行列式

 np.linalg.det计算矩阵

np.linalg.det(矩阵)#计算矩阵值