python list去掉nan

文章目录

• Numpy是什么？
• array数组是什么？
• Numpy用来干什么
• 导入Numpy库
• 生成一般数组
• 生成多维数组
• 生成特殊类型数组

• `np.arange()`：生成固定范围的随机数组
• `np.linspace()`：构造等距分布，包含头尾
• `np.logspace()`：默认是10为底的
• `np.meshgrid()`：网格;立体索引
• `np.zeros`：构造全是0的矩阵
• `np.ones()`：构造全是1的矩阵
• `np.empty()`：构造空矩阵
• `np.zeros_like()`：生成与已知矩阵维度一样的0矩阵
• `np.ones_like()`：生成与已知矩阵维度一样的1矩阵
• `np.identity()`：生成单位矩阵

• 生成随机数组

• `np.random.rand()`:生成随机数组
• `np.random.randint()`：生成随机整数数组
• `np.random.random_sample()`：生成随机浮点数组
• `np.random.normal()`：构造随机高斯分布数组
• `np.random.randn()`：构造随机正态分布数组
• `np.set_printoptions`：设置精度参数
• `np.random.shuffle()`：洗牌array
• `np.random.seed()`：随机的种子
• `np.random.choice()`：从已知数组中随机选取相应大小的数组

• array结构自动向下转换
• ndarray基本属性操作

• `.dtype` 属性：值的类型
• `.shape` 属性：矩阵结构
• `.size`属性：值的总数
• `.ndim`：矩阵的维度
• `.fill()`：填充操作
• 索引
• `.copy()`：复制array
• bool索引
• `np.where()`：条件函数
• 指定数组类型
• `.nbytes`：占用字节数

• 元素级函数
• array数组的数值计算

• `np.sum()` 累加
• `.prod()`：累乘
• `.min()` / `.max()` 最小/大值
• `.argmin()` / `.argmax()` 找到最小/大索引位置
• `.mean()` ：均值
• `.std()`：标准差
• `.var()`：方差
• `.clip()`：限制
• `.round()`：四舍五入

• 集合关系

• `np.in1d()`：包含
• `np.intersect1d()`：交集
• `np.union1d()`：并集
• `np.setdiff1d()`：差集

• 排序操作（pandas做排序更方便）

• `.sort() ：升序排序`
• `.argsort()：索引位置排序`
• `.searchsorted()`：查找排序
• `.lexsort()`：分轴排序

• 数组形状操作

• 改变数据形状
• `np.newaxis`：创建一个新的维度
• `.squeeze()`： 去除多余的维度
• `.transpose()`/`.T`：数组的转置
• `np.concatenate()`：数组的连接
• `np.vstack()`：相对于轴=0的np.concatenate()
• `np.hstack()`：相对于轴=1的np.concatenate()
• `.flatten()` / `.ravel()`：拉平
• `np.r_` / `np.c_`：构造行/列向量

• 四则运算

• `np.multiply()`：对应位置相乘
• `np.dot()`：矩阵相乘
• 逻辑运算:`==`/`np.logical_and()`/`np.logical_or()`/`np.logical_not()`

• 文件读写

• 写文件
• python方法读文件
• np.loadtxt方法读文件
• 用`np.savetxt()`写文件
• 读写array结构

• 其他常用语句

• 打印当前Numpy版本
• `np.isnan()`：寻找缺失值
• `np.unique()`：去掉重复值
• `np.nonzero()`：找到一个数组中不为0的索引
• 将数组倒序排列
• `np.pad()`：在最外层加上一圈
• `help(np.info())`：打印一个函数的帮助文档，比如numpy.add
• 数组归一化操作
• `np.intersect1d()`：找到两个数组中相同的值
• `np.datetime64()` / `np.timedelta64()` 得到今天 明天 昨天的日期
• 得到一个月中所有的天
• `np.floor()`：得到一个数的整数部分
• `.flags.writeable`：构造一个数组，让它不能被改变
• `np.set_printoptions()`：打印大数据的部分值，全部值
• 找到在一个数组中，最接近一个数的索引
• 枚举：打印数组元素位置坐标与数值
• `np.bincount()`：统计数组中每个数值出现的次数
• 交换矩阵中的两行
• `np.bincount(z).argmax()`：找到一个数组中最常出现的数字
• 快速查找TOP K
• `np.all()`：判断是否数组之间全部对应相同、`np.any()`：判断数组之间是否存在对应相同
• 去除掉一个数组中，所有元素都相同的数据

Numpy是什么？

Numpy是针对多维数组（Ndarray）的一个科学计算包，这个包封装了多个可以用于数组间计算的函数供你直接调用。

array数组是什么？

数组是相同数据类型的元素按一定顺序排列的组合，需要注意的是必须是相同数据类型的，比如全是整数、全是字符串或者其他。

array = [1,2,3,4,5]
array = ['a','b','c','d','e']

Numpy用来干什么

矩阵的运算，有些python中没有的功能numpy中实现了

导入Numpy库

import numpy as np

生成一般数组

把列表结构转换为’numpy.ndarray’结构

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

>  <class 'numpy.ndarray'>

生成多维数组

给array()函数传入一个嵌套列表，直接将数据以嵌套列表的形式作为一个参数传给array()函数，这时会生成一个多维数组

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

再打印矩阵结构，可见该矩阵为2行3列：

array.shape
> (2, 3)

生成特殊类型数组

np.arange()：生成固定范围的随机数组

np.arange(start,stop,step)，生成一个以start开始（包括start），stop结束（不包括stop），step为步长的随机序列
当step参数省略不写时，步长默认是1

np.arange(10)
> array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

np.arange(2,20,2)
> array([ 2,  4,  6,  8, 10, 12, 14, 16, 18])

np.arange(2,20,2,dtype=np.float32)
> array([  2.,   4.,   6.,   8.,  10.,  12.,  14.,  16.,  18.], dtype=float32)

np.linspace()：构造等距分布，包含头尾

np.linspace(0,10,10)
> array([  0.        ,   1.11111111,   2.22222222,   3.33333333,
           4.44444444,   5.55555556,   6.66666667,   7.77777778,
           8.88888889,  10.        ])

np.logspace()：默认是10为底的

np.logspace(0,1,5)
> array([  1.        ,   1.77827941,   3.16227766,   5.62341325,  10.        ])

np.meshgrid()：网格;立体索引

x = np.linspace(-10,10,5)
x
> array([-10.,  -5.,   0.,   5.,  10.])

y = np.linspace(-10,10,5)
y
> array([-10.,  -5.,   0.,   5.,  10.])

x, y= np.meshgrid(x,y)
x
> array([[-10.,  -5.,   0.,   5.,  10.],
       [-10.,  -5.,   0.,   5.,  10.],
       [-10.,  -5.,   0.,   5.,  10.],
       [-10.,  -5.,   0.,   5.,  10.],
       [-10.,  -5.,   0.,   5.,  10.]])
y
> array([[-10., -10., -10., -10., -10.],
       [ -5.,  -5.,  -5.,  -5.,  -5.],
       [  0.,   0.,   0.,   0.,   0.],
       [  5.,   5.,   5.,   5.,   5.],
       [ 10.,  10.,  10.,  10.,  10.]])

np.zeros：构造全是0的矩阵

np.zeros(3)#给zeros()函数传入一个具体的值时，会生成一个相应长度的一个全为0的一维数组
> array([ 0.,  0.,  0.])

np.zeros((3,3))#给zeros()函数传入一对值时，会生成一个相应行、列数的一个全为0的多维数组
> array([[ 0.,  0.,  0.],
         [ 0.,  0.,  0.],
         [ 0.,  0.,  0.]])

np.ones()：构造全是1的矩阵

np.ones((3,3))#与zeros()函数的思路一致
> array([[ 1.,  1.,  1.],
         [ 1.,  1.,  1.],
         [ 1.,  1.,  1.]])

np.ones((3,3)) * 8
> array([[ 8.,  8.,  8.],
         [ 8.,  8.,  8.],
         [ 8.,  8.,  8.]])

指定格式：

np.ones((3,3),dtype = np.float32)
> array([[ 1.,  1.,  1.],
         [ 1.,  1.,  1.],
         [ 1.,  1.,  1.]], dtype=float32)

np.empty()：构造空矩阵

a = np.empty(6)
a.shape
> (6,)
a.fill(1)
a
> array([ 1.,  1.,  1.,  1.,  1.,  1.])

np.zeros_like()：生成与已知矩阵维度一样的0矩阵

array1 = np.array([1,2,3,4])
np.zeros_like(array1)
>  array([0, 0, 0, 0])

np.ones_like()：生成与已知矩阵维度一样的1矩阵

np.ones_like(tang_array)
> array([1, 1, 1, 1])

np.identity()：生成单位矩阵

np.identity(5)
> array([[ 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.]])

生成随机数组

np.random.rand():生成随机数组

np.random.rand()传入一个值时，生成一个相应长度的且位于(0,1)之间的随机数组，传入一对值时，生成相应行、列数的多维数组，且数组中的值介于(0,1)之间

np.random.rand()
> 0.5595234784766201

np.random.rand(3,2)#所有的值都是从0到1
> array([[ 0.87876027,  0.98090867],
         [ 0.07482644,  0.08780685],
         [ 0.6974858 ,  0.35695858]])

np.random.randint()：生成随机整数数组

左闭右开，返回整数数组

np.random.randint(0,10,3)#0到10之间取3个整数，左闭右开,0可以省略
> array([7, 7, 5])

np.random.randint(10,size = (5,4))#返回的是从0到10随机的整数，左闭右开
> array([[8, 0, 3, 7],
         [4, 6, 3, 4],
         [6, 9, 9, 8],
         [9, 1, 4, 0],
         [5, 9, 0, 5]])

np.random.random_sample()：生成随机浮点数组

左闭右开，返回浮点数组

np.random.random_sample()
> 0.8279581297618884

np.random.normal()：构造随机高斯分布数组

mu, sigma = 0,0.1
np.random.normal(mu,sigma,10)
> array([ 0.05754667, -0.07006152,  0.06810326, -0.11012173,  0.10064039,
       -0.06935203,  0.14194363,  0.07428931, -0.07412772,  0.12112031])

np.random.randn()：构造随机正态分布数组

np.random.randn(3)
> [-0.30826271, 0.38873466, -0.62074553]

np.set_printoptions：设置精度参数

np.set_printoptions(precision = 2)
mu, sigma = 0,0.1
np.random.normal(mu,sigma,10)
> array([ 0.01,  0.02,  0.12, -0.01, -0.04,  0.07,  0.14, -0.08, -0.01, -0.03])

np.random.shuffle()：洗牌array

array1 = np.arange(10)
array1
> array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

np.random.shuffle(array1)
array1
> array([6, 2, 5, 7, 4, 3, 1, 0, 8, 9])#每次洗牌结果不一样

np.random.seed()：随机的种子

按照一种模式随机，保证按相同的模式不变

np.random.seed(0)# 0号种子

mu, sigma = 0,0.1
np.random.normal(mu,sigma,10)#构造高斯分布
> array([-0.0458027 ,  0.04351635, -0.05835951,  0.08168471,  0.06727208,
       -0.01044111, -0.05312804,  0.10297327, -0.04381356, -0.11183182])
#再次运行以上，得到一样的随机数

np.random.choice()：从已知数组中随机选取相应大小的数组

np.random.choice(a,size = None,replace = None,p = None)，a可以是一个数组，也可以是一个整数，当a是一个数组时表示从该数组中随机采样，当a为整数时，表示从range(int)中采样

np.random.choice(5,3)
> array([2,1,1])

np.random.choice(5,(2,3))
> array([[2,4,2]
   [0,3,2]])

array结构自动向下转换

对于ndarray结构来说，里面所有的元素必须是同一类型的 如果不是的话，会自动的向下进行转换

如果其中一个是浮点类型，其他的都会转换为浮点类型

list1 = [1,2,3,4,5.0]
array1 = np.array(list1)
array1
>  array([1., 2., 3., 4., 5.])

如果其中一个是字符串类型，其他也都会转换为字符串类型

list1 = [1,2,3,4,'5']
array1 = np.array(list1)
array1
>  array(['1', '2', '3', '4', '5']

ndarray基本属性操作

.dtype 属性：值的类型

array1 = np.array([1,2,3,4,5])
array1.dtype
>  dtype('int32')

array2 = np.array([1,2,3,4,5.0])
array2.dtype
> dtype('float64')

array3 = np.array([1,2,3,4,'5'])
array3.dtype
> dtype('<U11')

.shape 属性：矩阵结构

列表没有shape方法
数组有shape方法，可以打印出矩阵结构

array1 = np.array([1,2,3,4,5])
array1.shape
> (5,)

array2 = np.array([[1,2,3],[4,5,6]])
array2.shape
> (2, 3)

也可以使用np.shape(array)

.size属性：值的总数

array1 = np.array([1,2,3,4,5])
array1.size
> 5

array2 = np.array([[1,2,3],[4,5,6]])
array2.size
> 6

也可以使用np.size(array)

.ndim：矩阵的维度

array1 = np.array([1,2,3,4,5])
array1.ndim
> 1

array2 = np.array([[1,2,3],[4,5,6]])
array2.ndim
> 2

.fill()：填充操作

array1.fill(0)
array1
> array([0, 0, 0, 0, 0])

索引

索引、切片，和python一样，还可以传入某个条件

array1 = np.array([1,2,3,4,5])
array1[0]
>  2
array1[3:]
>  array([4, 5])
array1[array1>2]
>  array([3, 4, 5])

多维数组索引：和多层列表一样，先行后列

array2 = np.array([[1,2,3],[4,5,6]])
array2[1,1]
> 5

多维数组切片：可以取出特定位置的值

array3 = np.array([[1,2,3],
                   [4,5,6],
                   [7,8,9]])
array3[:,1]#获取第2列的数据
> array([ 2, 5, 8])
array3[:,:3]#获取第1列到第3列的数据,不包括第三列
> array([1,2],
        [4,5],
        [7,8])

.copy()：复制array

数组传递后，改变数组某一个位置的值，原数组也发生变化

把数组array1传递到array2，并且把数组array2的第一行第一列的值改为100

array1 = np.array([[1,2,3],
                   [4,5,6],
                   [7,8,9]])
array2 = array1
array2[1,1] = 100
array1

> array([[  1,   2,   3],
         [  4, 100,   6],
         [  7,   8,   9]])

array1竟然也发生了变化，这是因为并没有给array2重新分配一个内存，而是使它指向了array1指向的位置，操纵array2，array1也会发生变化

要想array1 和array2互不干扰，需要使用.copy()

这样更改array2时，array1将保持独立，不发生变化

array2 = array1.copy()
array2[1,1] = 100
array1
> array([[  1,   2,   3],
         [  4, 10,   6],
         [  7,   8,   9]])

bool索引

值需要一一对应，并且大于0的数都是True

mask = np.array([0,0,0,1,2,3,0,0,1,1],dtype=bool)
mask
> array([False, False, False,  True,  True,  True, False, False,  True,  True], dtype=bool)

array1 = np.arange(0,100,10)
array1
> array([ 0, 10, 20, 30, 40, 50, 60, 70, 80, 90])

tang_array[mask]
> array([30, 40, 50, 80, 90])

np.where()：条件函数

np.where(condition, x, y)类似于Excel中的IF(conditions, True, False)函数，如果条件(condition)为真则返回x，如果条件为假则返回y

array1 = np.array([10,20,30,40,50])
np.where(array1 > 30)#返回符合条件的值对应的位置
> (array([3, 4], dtype=int64),)

array1[np.where(array1 > 30)]#返回符合条件的值
> array([40, 50])

指定数组类型

指定数组类型为float32

array1 = np.array([1,2,3,4,5],dtype=np.float32)
array1
> array([ 1.,  2.,  3.,  4.,  5.], 

dtype=float32)
tang_array.dtype
> dtype('float32')

指定任意数组类型

array2 = np.array([1,10,3.5,'str'],dtype = np.object)
array2
> array([1, 10, 3.5, 'str'], dtype=object)

用.asarray()把原始的数组进行转换

array3 = np.asarray(array2,dtype = np.float32)
> array([ 1.,  2.,  3.,  4.,  5.], dtype=float32)

array3
> array([ 1.,  2.,  3.,  4.,  5.], dtype=float32)

array2
> array([1, 2, 3, 4, 5])#不会改变原始的数组

还可以用.astype()直接指定数组格式，也不会改变原始数组

array4 = array2.astype(np.float32)
array4
array2
> array([ 1.,  2.,  3.,  4.,  5.], dtype=float32)
> array([1, 2, 3, 4, 5])

.nbytes：占用字节数

array1.nbytes
> 20

元素级函数

元素级函数就是针对数组中的每个函数执行相同的函数操作
相加
可以实现数组中每个值+1的操作：

array2 = array + 1
array2

>  array([2, 3, 4, 5, 6,])

可以实现两个数组中对应的值相加的操作：

array2 + array

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

相乘：

array2 * array

>  array([ 6, 12, 20, 30, 42])

绝对值：np.abs()

平方根：np.sqrt()

平方：np.square()

自然指数：np.exp()

分别计算以e为底、10为底、20为底的对数以及log(1+x)：np.log()、 np.log10()、 np.log20()、 np.log1p()

将小数和整数以独立的数组返回 np.modf()

判断是否是nan值并返回一个布尔值：np.isnan()

array数组的数值计算

np.sum() 累加

直接用：全加

array1 = np.array([[1,2,3],[4,5,6]])
np.sum(array1)
> 21

指定要进行的操作是沿着什么轴（维度）

array1 = np.array([[1,2,3],[4,5,6]])
np.sum(array1,axis=0)
> array([5, 7, 9])

np.sum(array1,axis=1)
> array([ 6, 15])

np.sum(array1,axis=-1)#倒数第一个轴
> array([ 6, 15])

也可以直接用array1.sum()

.prod()：累乘

array1 = np.array([[1,2,3],[4,5,6]])
array1.prod()
> 720

array1.prod(axis = 0)
> array([ 4, 10, 18])

array1.prod(axis = 1)
> array([  6, 120])

.min() / .max() 最小/大值

array1 = np.array([[1,2,3],[4,5,6]])
array1.min()
> 1

array1.min(axis = 0)
> array([1, 2, 3])

array1.min(axis = 1)
> array([1, 4])

array1.max()
> 1

.argmin() / .argmax() 找到最小/大索引位置

array1 = np.array([[1,2,3],[4,5,6]])
array1.argmin()
> 0

array1.argmin(axis = 0)
> array([0, 0, 0], dtype=int64)

array1.argmin(axis=1)
> array([0, 0], dtype=int64)

array1.argmax()
> 5

.mean() ：均值

array1 = np.array([[1,2,3],[4,5,6]])
array1.mean()
> 3.5

array1.mean(axis = 0)
> array([ 2.5,  3.5,  4.5])

.std()：标准差

array1 = np.array([[1,2,3],[4,5,6]])
array1.std()
> 1.707825127659933

array.std(axis = 1)
> array([ 0.81649658,  0.81649658])

.var()：方差

array1 = np.array([[1,2,3],[4,5,6]])
array1.var()
> 2.9166666666666665

.clip()：限制

array1 = np.array([[1,2,3],[4,5,6]])
array1.clip(2,4)#小于2的变成2，大于4的变成4
>array([[2, 2, 3],
        [4, 4, 4]])

.round()：四舍五入

array2 = np.array([1.2,3.56,6.41])
array2.round()
> array([ 1.,  4.,  6.])

四舍五入指定精度

array2.round(decimals=1)
> array([ 1.2,  3.6,  6.4])

集合关系

np.in1d()：包含

np.in1d(array1,array2) 判断array1中包含array2中的哪些值，如果包含则在对应位置返回True，否则返回False

array1 = np.array([1,2,3,4])
array2 = np.array([1,2,5])
np.in1d(array1,array2)
> array([ True, True, False, False])

np.intersect1d()：交集

array1 = np.array([1,2,3,4])
array2 = np.array([1,2,5])
np.intersect1d(array1,array2)
> array([ 1, 2])

np.union1d()：并集

array1 = np.array([1,2,3,4])
array2 = np.array([1,2,5])
np.union1d(array1,array2)
> array([ 1, 2, 3, 4, 5])

np.setdiff1d()：差集

差集就是返回在array1数组中存在，但是在array2数组中不存在的元素

array1 = np.array([1,2,3,4])
array2 = np.array([1,2,5])
np.setdiff1d(array1，array2)
> array([ 3, 4])

排序操作（pandas做排序更方便）

.sort() ：升序排序

array1 = np.array([[1.5,1.3,7.5],
                   [5.6,7.8,1.2]])
np.sort(array1)
> array([[ 1.3,  1.5,  7.5],
         [ 1.2,  5.6,  7.8]])

带轴参数排序（如不指定，默认的是-1）

np.sort(array1,axis = 0)
> array([[ 1.5,  1.3,  1.2],
         [ 5.6,  7.8,  7.5]])

.argsort()：索引位置排序

返回排序后原来的索引值

array1
> array([[ 1.5,  1.3,  1.2],
         [ 5.6,  7.8,  7.5]])

np.argsort(array1)
> array([[1, 0, 2],
         [2, 0, 1]], dtype=int64)

.searchsorted()：查找排序

在排好序的数组array1中找到另一个数组value插入数组array1后，value中的数分别在插入后的数组中的位置，返回一个数组

array1 = np.linspace(0,10,10)#在0和10之间按照相同间距插入10个数
array1#排好序的数组
> array([  0.        ,   1.11111111,   2.22222222,   3.33333333,
           4.44444444,   5.55555556,   6.66666667,   7.77777778,
           8.88888889,  10.        ])

values = np.array([2.5,6.5,9.5])#待插入的数组
np.searchsorted(array1,values)#找插入的数组的位置
> array([3, 6, 9], dtype=int64)#返回的位置数组

.lexsort()：分轴排序

倒序：-1*，默认正序

array1 = np.array([[1,0,6],
                   [1,7,0],
                   [2,3,1],
                   [2,4,0]])
index = np.lexsort([-1*array1[:,0],array1[:,2]])#第三列升序,第三列相同的情况下按第1列降序排列
index
> array([0, 1, 3, 2], dtype=int64)

array1 = array1[index]
array1
> array([[2, 4, 0],
         [1, 7, 0],
         [2, 3, 1],
         [1, 0, 6]])

数组形状操作

改变数据形状

使用.shape = ,，改变数据形状，或者使用.reshape(,)直接改变数据形状

array1 = np.arange(10)
array1
> array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

array1.shape = 2,5
array1
> array([[0, 1, 2, 3, 4],
         [5, 6, 7, 8, 9]])

array1.reshape(1,10)
> array([[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]])

注意不能改变数据的大小

array1 .shape = 3,4
> ValueError

np.newaxis：创建一个新的维度

array1 = np.arange(10)
array1.shape
> (10,)
array1 = array1[np.newaxis,:]
array1.shape
> (1, 10)

array1 = np.arange(10)
array1.shape
> (10,)
array1 = array1[np.newaxis,:]
array1.shape
> (10, 1)

array1 = np.arange(10)
array1.shape
array1 = array1[:,np.newaxis,np.newaxis]
array1.shape
> (10, 1, 1, 1)

.squeeze()： 去除多余的维度

array1 = np.arange(10)
array1.shape
array1 = array1[:,np.newaxis,np.newaxis]
array1.shape
> (10, 1, 1, 1)

array1 = array1.squeeze()
array1.shape
> (10,)

.transpose()/.T：数组的转置

array1 = np.array([[0, 1, 2, 3, 4],
                   [5, 6, 7, 8, 9]])
array1.transpose()
> array([[0, 5],
         [1, 6],
         [2, 7],
         [3, 8],
         [4, 9]])

或者用.T也是一样的
但是转置后原始的array没有变化，需要给新的array赋值

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

np.concatenate()：数组的连接

a = np.array([[123,456,678],[3214,456,134]])
b = np.array([[1235,3124,432],[43,13,134]])
a
b
> array([[ 123,  456,  678],
         [3214,  456,  134]])
> array([[1235, 3124,  432],
         [  43,   13,  134]])

c = np.concatenate((a,b))#括号内要写成元祖形式
c
> array([[ 123,  456,  678],
         [3214,  456,  134],
         [1235, 3124,  432],
         [  43,   13,  134]])

指定维度拼接（默认是0）

c = np.concatenate((a,b),axis = 1)
c
> array([[ 123,  456,  678, 1235, 3124,  432],
         [3214,  456,  134,   43,   13,  134]])
c.shape
> (2, 6)

np.vstack()：相对于轴=0的np.concatenate()

np.vstack((a,b))
> array([[ 123,  456,  678],
         [3214,  456,  134],
         [1235, 3124,  432],
         [  43,   13,  134]])

np.hstack()：相对于轴=1的np.concatenate()

np.hstack((a,b))
> array([[ 123,  456,  678],
         [3214,  456,  134],
         [1235, 3124,  432],
         [  43,   13,  134]])

.flatten() / .ravel()：拉平

a
> array([[ 123,  456,  678],
         [3214,  456,  134]])
       
a.flatten()
> array([ 123,  456,  678, 3214,  456,  134])

a
> array([[ 123,  456,  678],
         [3214,  456,  134]])
a.ravel()
> array([ 123,  456,  678, 3214,  456,  134])

np.r_ / np.c_：构造行/列向量

np.r_[0:10:1]
> array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

np.c_[0:10:1]
> array([[0],
         [1],
         [2],
         [3],
         [4],
         [5],
         [6],
         [7],
         [8],
         [9]])

四则运算

np.multiply()：对应位置相乘

x = np.array([5,5])
y = np.array([2,2])
np.multiply(x,y)

> array([10, 10])

np.dot()：矩阵相乘

x = np.array([5,5])
y = np.array([2,2])
np.dot(x,y)

> 20

x.shape = 2,1
y.shape = 1,2
x
y
np.dot(x,y)
>array([[5],
        [5]])
>array([[2, 2]])
>array([[10, 10],
        [10, 10]])

逻辑运算:==/np.logical_and()/np.logical_or()/np.logical_not()

y = np.array([1,1,1,4])
x = np.array([1,1,1,2])
x == y
> array([ True,  True,  True, False], dtype=bool)

np.logical_and(x,y)
> array([ True,  True,  True,  True], dtype=bool)

np.logical_or(x,y)
> array([ True,  True,  True,  True], dtype=bool)

np.logical_not(x,y)
> array([0, 0, 0, 0])

文件读写

写文件

%%writefile test1.txt
1 2 3 4 5 6
2 3 5 8 7 9
data = []

python方法读文件

with open('test.txt') as f:
    for line in f.readlines():
        fileds = line.split()
        cur_data = [float(x) for x in fileds]
        data.append(cur_data)
data = np.array(data)
data
> array([[ 1.,  2.,  3.,  4.,  5.,  6.],
         [ 2.,  3.,  5.,  8.,  7.,  9.]])

np.loadtxt方法读文件

‘tang2.txt’:路径最好放到和代码一起

skiprows : 去掉几行

delimiter = ‘,’ :分隔符

usecols = (0,1,4) ：指定使用哪几列

data = np.loadtxt('test.txt')
data
> array([[ 1.,  2.,  3.,  4.,  5.,  6.],
         [ 2.,  3.,  5.,  8.,  7.,  9.]])

np.loadtxt方法读文件，指定分隔符

%%writefile test2.txt
1,2,3,4,5,6
2,3,5,8,7,9
data = np.loadtxt('test2.txt',delimiter = ',')
data
> array([[ 1.,  2.,  3.,  4.,  5.,  6.],
         [ 2.,  3.,  5.,  8.,  7.,  9.]])

np.loadtxt方法读文件，指定分隔符，去掉某一行

%%writefile test.txt
x,y,z,w,a,b
1,2,3,4,5,6
2,3,5,8,7,9
data = np.loadtxt('tang2.txt',delimiter = ',',skiprows = 1)
data
> array([[ 1.,  2.,  3.,  4.,  5.,  6.],
       [ 2.,  3.,  5.,  8.,  7.,  9.]])

用np.savetxt()写文件

自定义不同保存格式和不同分隔符

array1 = np.array([[1,2,3],[4,5,6]])
np.savetxt('test.txt',array1)
np.savetxt('tang4.txt',tang_array,fmt='%d')
np.savetxt('tang4.txt',tang_array,fmt='%d',delimiter = ',')
np.savetxt('tang4.txt',tang_array,fmt='%.2f',delimiter = ',')

读写array结构

存一个np.save()

# 写
array1 = np.array([[1,2,3],[4,5,6]])
np.save(array1.npy',array1)
# 读一个
test = np.load('array1.npy')
test
> array([[1, 2, 3],
         [4, 5, 6]])

存多个np.savez()

array2 = np.arange(10)
array2
> array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
#读两个
np.savez('tang.npz',a=array1,b=array2)
data = np.load('tang.npz')
data.keys()
> ['b', 'a']

data['a']
> array([[1, 2, 3],
         [4, 5, 6]])

data['b']
> array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

其他常用语句

打印当前Numpy版本

print (np.__version__)

np.isnan()：寻找缺失值

#创建一个含有缺失值的数组，nan表示缺失值
array1 = np.array([1,2,np.nan,4])
array1
> array([1., 2., nan, 4.])
np.isnan(array1)
> array([False, False, True, False])

#找到缺失值以后就可以对缺失值进行填充，例如用0填充
array1[np.isnan(array1)] = 0
array1
> array([1., 2., 0., 4.])

np.unique()：去掉重复值

array1 = np.array([1,2,3,2,1])
np.unique(array1)
array1
> array([1, 2, 3])

np.nonzero()：找到一个数组中不为0的索引

np.nonzero([1,2,3,4,5,0,0,0,1234,0,1])
> (array([ 0,  1,  2,  3,  4,  8, 10], dtype=int64),)

将数组倒序排列

array1 = array1[::-1]

np.pad()：在最外层加上一圈

array1 = np.pad(array1,pad_width = 2,mode = 'constant',constant_values = 0)

help(np.info())：打印一个函数的帮助文档，比如numpy.add

print (help(np.info(np.add)))

数组归一化操作

array1 = np.random.random((5,5))
array_max =array1.max()
array_min = array1.min()
array1 = (array1-array_min)/(array_max - arraymin)

np.intersect1d()：找到两个数组中相同的值

np.intersect1d(array1,array2)

np.datetime64() / np.timedelta64() 得到今天 明天 昨天的日期

yesterday = np.datetime64('today','D') - np.timedelta64(1,'D')
today = np.datetime64('today','D')
tommorow = np.datetime64('today','D') + np.timedelta64(1,'D')

得到一个月中所有的天

np.arange('2017-10','2017-11',dtype='datetime64[D]')

np.floor()：得到一个数的整数部分

np.floor(array1)

.flags.writeable：构造一个数组，让它不能被改变

array1.flags.writeable = False

np.set_printoptions()：打印大数据的部分值，全部值

np.set_printoptions(threshold=5)
z = np.zeros((15,15))
z
> array([[ 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.]])

找到在一个数组中，最接近一个数的索引

array1 = np.arange(100)
array2 = np.random.uniform(0,100)
print (array2)
index = (np.abs(array1-array2)).argmin()
print (array1[index])

枚举：打印数组元素位置坐标与数值

array1 = np.arange(9).reshape(3,3)
for index,value in np.ndenumerate(array1):
    print (index,value)

np.bincount()：统计数组中每个数值出现的次数

z = np.array([1,1,1,2,2,3,3,4,5,8])
np.bincount(z)
> array([0, 3, 2, ..., 0, 0, 1], dtype=int64)#0有1个，1有3个，2有两个....

交换矩阵中的两行

z = np.arange(25).reshape(5,5)
z[[0,1]] = z[[1,0]]
z
> array([[ 5,  6,  7,  8,  9],
         [ 0,  1,  2,  3,  4],
         [10, 11, 12, 13, 14],
         [15, 16, 17, 18, 19],
         [20, 21, 22, 23, 24]])

np.bincount(z).argmax()：找到一个数组中最常出现的数字

z = np.random.randint(0,10,50)
print (np.bincount(z).argmax())
> 6

快速查找TOP K

#构建一个数组
z = np.arange(10000)
#打乱顺序
np.random.shuffle(z)
#寻找TOP5
n = 5
print (z[np.argpartition(-z,n)[:n]])

np.all()：判断是否数组之间全部对应相同、np.any()：判断数组之间是否存在对应相同

返回bool值

a = np.array([1,2,3,4])
b = np.array([1,2,3,5])
np.all(a == b)
> False

np.any(a == b)
> True

去除掉一个数组中，所有元素都相同的数据

np.set_printoptions(threshold=np.nan)#去除数组中，所有元素都相同的数据
z = np.random.randint(0,3,(10,3))
z
> array([[0, 0, 1],
         [2, 0, 0],
         [1, 0, 2],
         [2, 2, 2],
         [1, 1, 0],
         [1, 2, 2],
         [2, 0, 1],
         [2, 1, 0],
         [0, 2, 1],
         [0, 1, 2]])

e = np.all(z[:,1:] == z[:,:-1],axis = 1)#z的所有行的从第1列到最后一列的数是否都等于从最后一列到第一列的数
print (e)
> [False False False  True False False False False False False]