Bootstrap

Python --NumPy库基础方法（3）

NumPy

Numpy(Numerical Python) 是科学计算基础库，提供大量科学计算相关功能，比如数据统计，随机数生成等。其提供最核心类型为多维数组类型（ndarray），支持大量的维度数组与矩阵运算，Numpy支持向量处理ndarray对象，提高程序运算速度。

本期我们接着介绍numpy中的方法：

数学函数

Numpy支持向量处理ndarray对象，提高程序运算速度。
在这里插入图片描述

求每个元素的倒数

import numpy as np
#求每个元素的倒数
#numpy.reciprocal() 函数返回参数逐元素的倒数。

a=np.arange(1,10,dtype=float).reshape(3,3)
np.reciprocal(a)
---------------------------
array([[1.        , 0.5       , 0.33333333],
       [0.25      , 0.2       , 0.16666667],
       [0.14285714, 0.125     , 0.11111111]])

square()函数

#square函数的使用------------->每个元素平方

#一维数组
a = np.arange(1,10)
np.square(a)
-------------
array([ 1,  4,  9, 16, 25, 36, 49, 64, 81], dtype=int32)
===============================================================
#二维数组
aa=np.arange(1,13).reshape(3,4)
np.square(aa)
---------------
array([[  1,   4,   9,  16],
       [ 25,  36,  49,  64],
       [ 81, 100, 121, 144]], dtype=int32)

sign()函数

#sign()函数的使用--------->表示各元素的符号

a = np.arange(-5,5)
np.sign(a)
--------------
array([-1, -1, -1, -1, -1,  0,  1,  1,  1,  1])

modf()函数

#modf()函数的使用---------->将各元素的小数部分和整数部分分别打印出来

b = np.arange(-5,5,0.4)
np.modf(b)
----------------------
(array([-0.00000000e+00, -6.00000000e-01, -2.00000000e-01, -8.00000000e-01,
        -4.00000000e-01, -1.00000000e+00, -6.00000000e-01, -2.00000000e-01,
        -8.00000000e-01, -4.00000000e-01, -1.00000000e+00, -6.00000000e-01,
        -2.00000000e-01,  2.00000000e-01,  6.00000000e-01,  5.32907052e-15,
         4.00000000e-01,  8.00000000e-01,  2.00000000e-01,  6.00000000e-01,
         7.10542736e-15,  4.00000000e-01,  8.00000000e-01,  2.00000000e-01,
         6.00000000e-01]),
 array([-5., -4., -4., -3., -3., -2., -2., -2., -1., -1., -0., -0., -0.,
         0.,  0.,  1.,  1.,  1.,  2.,  2.,  3.,  3.,  3.,  4.,  4.]))

三角函数

#三角函数的使用------------>计算三角函数值

x=np.linspace(1,10,10)
y = np.sin(x)
y
----------------------
array([ 0.84147098,  0.90929743,  0.14112001, -0.7568025 , -0.95892427,
       -0.2794155 ,  0.6569866 ,  0.98935825,  0.41211849, -0.54402111])

around、floor、ceil函数

decimals: 舍入的小数位数。 默认值为0。 如果为负，整数将四舍五入到小数点左侧的位置
numpy.floor() 返回数字的下舍整数。
numpy.ceil() 返回数字的上入整数。

#around、floor、ceil函数的使用
a = np.array([1.0,4.55,123,0.567,25.532])

#numpy.around() 函数返回指定数字的四舍五入值。
#格式：numpy.around(a,decimals）
np.around(a)
----------------
array([  1.,   5., 123.,   1.,  26.])
================================================
#numpy.floor() 返回数字的下舍整数。
np.floor(a)
--------------
array([  1.,   4., 123.,   0.,  25.])
===================================================
#numpy.ceil() 返回数字的上入整数。
np.ceil(a)
--------------
array([  1.,   5., 123.,   1.,  26.])

算术函数

如果参与运算的两个对象 都是ndarray，并且形状相同，那么会对位彼此之间进行（+ - * /）运算。NumPy 算术函数包含简单的加减乘除: add()，subtract()，multiply() 和 divide()。

算术函数的使用

#算术函数
​
a=np.arange(9,dtype=np.float).reshape(3,3)
b=np.array([10,5,2])
a
array([[0., 1., 2.],
       [3., 4., 5.],
       [6., 7., 8.]])
==================================
#add函数（加）
np.add(a,b)
------------
array([[10.,  6.,  4.],
       [13.,  9.,  7.],
       [16., 12., 10.]])
==================================
#subtract函数（减）
np.subtract(a,b)   #a-b
-----------------
array([[-10.,  -4.,   0.],
       [ -7.,  -1.,   3.],
       [ -4.,   2.,   6.]])
==================================
#multiply函数（乘）
np.multiply(a,b)
--------------------
array([[ 0.,  5.,  4.],
       [30., 20., 10.],
       [60., 35., 16.]])
====================================
#divide函数（除）
np.divide(a,b)
-----------------
array([[0. , 0.2, 1. ],
       [0.3, 0.8, 2.5],
       [0.6, 1.4, 4. ]])

算术函数中out参数

#算数函数中out参数的使用

x=np.arange(5)
y=np.empty_like(x)
np.multiply(x,10,out=y)  #将x乘10赋值给y
y
-----------------
array([ 0, 10, 20, 30, 40])

mod()函数

numpy.mod() 计算输入数组中相应元素的相除后的余数。

#mod()函数的使用
#numpy.mod() 计算输入数组中相应元素的相除后的余数。

a=np.array([10,10,30])
b=np.array([3,5,7])
np.mod(a,b)
-------------------------
array([1, 0, 2], dtype=int32)

统计函数

在这里插入图片描述

power()函数

#power()函数的使用
# numpy.power() 函数将第一个输入数组中的元素作为底数，计算它与第二个输入数组中相应元素的幂。

x = np.arange(1,5)
y = np.empty_like(x)
np.power(x,2,out=y)   #将x中的元素进行2次方，赋值给y
y
-----------------------
array([ 1,  4,  9, 16])

median ()函数

# median()函数的使用

a=np.array([4,2,1,5])  #计算偶数个元素的中位数（排序取平均）
np.median(a)
----
3.0
=================================
a=np.array([4,2,1])   #计算奇数个元素的中位数（排序取中值）
np.median(a)
----
2.0
==================================

a=np.arange(1,16).reshape(3,5)
print(np.median(a))
-------
8.0
==================================
#调用median函数，axis=1 行的中值
print(np.median(a,axis=1))
---------------
[ 3.  8. 13.]
================================
# 调用median函数，axis=0 列的中值
print(np.median(a,axis=0))
-----------------------------
[ 6.  7.  8.  9. 10.]

mean ()函数的

#mean ()函数的使用
#numpy.mean() 函数返回数组中元素的算术平均值。 如果提供了轴，则沿其计算。
#算术平均值是沿轴的元素的总和除以元素的数量。

a=np.arange(1,11).reshape(2,5)				  #a=array([[ 1,  2,  3,  4,  5],
      												  # [ 6,  7,  8,  9, 10]])
=====================
#所有元素和的平均值
np.mean(a)
--------
5.5
============
#每列的平均值
np.mean(a,axis=0)
------------------
array([3.5, 4.5, 5.5, 6.5, 7.5])
========================
#每行的平均值
np.mean(a,axis=1)
---------------------
array([3., 8.])

函数的使用

#函数的使用
​
a=np.random.randint(10,50,size=20)  #10-50内，生成20个随机整数
a
array([39, 39, 35, 49, 42, 24, 15, 28, 15, 35, 15, 24, 38, 35, 39, 23, 48,
       17, 12, 42])
=============================
#求最大值
np.max(a)
-----
49
==============
#求和
np.sum(a)
----
614
===================
#求最小值
np.min(a)
----
12
================
#计算一组数中最大值与最小值的差
np.ptp(a)
----
37
===============================
#删除数组中的重复数据，并进行排序
np.unique(a)
-------------
array([12, 15, 17, 23, 24, 28, 35, 38, 39, 42, 48, 49])
==================================
#返回数组中非0元素的索引
np.nonzero(a)
-------------------
(array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,
        17, 18, 19], dtype=int64),)

数组排序

排序中主要用到的方法是np.sort和np.argsort。其中np.sort()是对数组直接排序。而np.argsort()是返回排序后的原始索引。

一维数组排序

#一维数组
a=np.array([5,2,4,6,1,9])
print('sort排序后：',np.sort(a))
print('argsort排序：',np.argsort(a))
-------------------------------
sort排序后： [1 2 4 5 6 9]
argsort排序： [4 1 2 0 3 5]

按最后一列进行排序

#按最后一列进行排序
#可以先获取最后一列的数组
a=np.random.randint(100,size=(4,6))
b=a[:,-1]
print(b)
--------------
[93 72  1 66]
============================
#获取最后一列数组排序后的原始索引
index=np.argsort(b)
index
----------
array([2, 3, 1, 0], dtype=int64)
====================================
#使用facy_indexing汇总数组
print(a[index])
---------------------
[[51 50 18 92 29  1]
 [63 12  2 75 45 66]
 [61 72 74 86 16 72]
 [74 36 31 18 72 93]]

numpy广播机制

两个数组相加

# numpy广播机制

#  两个数组相加
b=np.array([5,5,5])
print(a+b)
-----------------
[5 6 7]

维度不相同的数组相加

广播的规则:

  1. 如果两个数组维度个数不同，那么小维度的数组形状会在左边补1

  2. 如果两个数组形状在任何一个维度上都不匹配，数组的形状会沿着维度为1的维度扩展到匹配上另一个数组的形状

  3. 如果没有维度形状为1，则会引发异常:

​ 0 1 2 0 0 0

​ 0 1 2 1 1 1

​ 0 1 2 2 2 2

# 维度不相同的数组相加

a = np.arange(3)   #一行
c = np.arange(3).reshape(3,1)   #三行一列
print(a+c)
---------------------
[[0 1 2]
 [1 2 3]
 [2 3 4]]

如果没有维度形状为1，则会引发异常

a = np.arange(6).reshape(2, 3)
b = np.arange(6).reshape(3, 2)
print(a + b)
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
~\AppData\Local\Temp\ipykernel_12724\2190402067.py in <module>
      1 a = np.arange(6).reshape(2, 3)
      2 b = np.arange(6).reshape(3, 2)
----> 3 print(a + b)

ValueError: operands could not be broadcast together with shapes (2,3) (3,2)

总结

到这为止，我们的NumPy库常用基础知识学习完全了，方法非常多，务必好好整理。

悦读

道可道，非常道；名可名，非常名。 无名，天地之始，有名，万物之母。 故常无欲，以观其妙，常有欲，以观其徼。 此两者，同出而异名，同谓之玄，玄之又玄，众妙之门。

最新收录
前端宝典之八：React状态管理全解析并手写实现
大数据各个工具随笔
Linux在远程X Server上显示图形界面
线程和锁原理
MyBatisPlus的使用
10.JVM-StringTable/StringPool
Python基于大数据的微博的舆论情感分析，微博评论情感分析可视化系统，附源码
详解最基本的数据顺序存储结构：顺序表
redis zset底层数据结构
python解析网页上的json数据落地到EXCEL
;