Numpy使用Python进行数据科学

Unsplash上的照片

NumPy是使用Python进行科学计算的基本软件包。

在“使用Python进行数据科学”系列的第1部分中 ，我们介绍了Python数值计算的基本内置函数。 在这一部分中，我们将研究Numpy库。

NumPy是使用Python进行科学计算的基本软件包。 它包含以下内容：

• 强大的N维数组对象
• 复杂的（广播）功能
• 集成C / C ++和Fortran代码的工具
• 有用的线性代数，傅立叶变换和随机数功能

除了其明显的科学用途外，NumPy还可以用作通用数据的高效多维容器。 可以定义任意数据类型。 这使NumPy可以无缝，快速地与各种数据库集成。

太好了，让我们看看如何使用Numpy库进行基本的数组操作。

numpy库

首先，我们需要在Python中导入numpy。

import numpy as np

让我们创建一个numpy数组。

np.array([4,5,6])

输出：array（[4,5,6]）

现在，让我们创建一个多维数组。

mul=np.array([[5,4,6],[7,8,9],[10,11,12]])
mul

输出：array（[[4，5，6]，
[7，8，9]，[10,11,12]]）

检查形状（数组的行和列）。

mul.shape

输出：（3，3）

创建一个介于1和60之间且间隔为2的均匀间隔的数组。

dif=np.arange(1,60,2)
dif

输出： array（[1，3，5，7，9，11，13，15，17，19，21，23，25，27，29，31，33，
35、37、39、41、43、45、47、49、51、53、55、57、59]）

将上述阵列重塑为所需的形状。

dif.reshape(10,3)

输出：array（[[1，3，5]，
[7，9，11]，
[13、15、17]，
[19，21，23]，
[25，27，29]，
[31，33，35]，
[37，39，41]，
[43，45，47]，
[49，51，53]，
[55，57，59]]）

在间隔1和8之间生成一个均匀间隔的列表。（在此处花点时间了解'linspace'和'arange'之间的区别）

gen = np.linspace(1,8,40)
gen

输出：array（[1。，1.17948718，1.35897436，1.53846154，1.71794872，
1.8974359，2.07692308，2.25641026，2.43589744，2.61538462，
2.79487179、2.99743897、3.15384615、3.33333333、3.51282051，
3.69230769、3.87179487、4.05128205、4.23076923、4.41025641，
4.58974359，4.76923077，4.94871795，5.12820513，5.30769231，
5.48717949、5.66666667、5.884615385、6.02564103、6.20512821，
6.38461538，6.56410256，6.74358974，6.92307692，7.1025641，
7.28205128、7.46153846、7.64102564、7.82551282、8。]）

现在，更改数组的形状（“调整大小”功能更改数组的形状，与“更改形状”不同）

gen.resize(10,4)
gen

输出：array（[[1。，1.17948718，1.35897436，1.53846154]，
[1.71794872、1.8974359、2.07692308、2.25641026]，
[2.43589744、2.61538462、2.79497179、2.997435897]，
[3.15384615、3.3333333、3.51282051、3.69230769]，
[3.87179487、4.05128205、4.23076923、4.41025641]，
[4.58974359，4.76923077，4.94871795，5.12820513]，
[5.30769231，5.48717949，5.66666667，5.84615385]，
[6.02564103，6.20512821，6.38461538，6.56410256]，
[6.74358974，6.92307692，7.1025641，7.28205128]，
[7.46153846、7.64102564、7.82051282、8。]]）

创建一个所有元素都为一个的数组。

onarr = np.ones((4,4))
onarr

输出：array（[[1。，1.，1.，1.]，
[1.，1.，1.，1.]，
[1.，1.，1.，1.]，
[1.，1.，1.，1.]]）

创建一个填充零的数组。

zearr = np.zeros((4,4))
zearr

输出：array（[[0。，0.，0.，0.]，
[0.，0.，0.，0.]，
[0.，0.，0.，0.]，
[0.，0.，0.，0.]]）

创建对角线矩阵，对角线值= 1

dm = np.eye(3)
dm 

输出：array（[[1。，0.，0.]，
[0.，1.，0.]，
[0.，0.，1.]]）

仅从数组中提取对角线值。

np.diag(dm)

输出：array（[1。，1.，1.]）

创建一个由重复列表组成的数组

relist = np.array([1,2,3]*7)
relist

输出：array（[1、2、3、1、2、3、1、2、3、1、2、3、1、2、3、1、2、3、1、2、3]）

现在，使用重复函数将数组的每个元素重复n次。

np.repeat([1,2,3],3)

输出：array（[1、1、1、2、2、2、3、3、3]）

生成两个所需形状的数组，其中填充了0到1之间的随机值。

relist = np.random.rand(2,3)
print(relist)
de = np.random.rand(2,3)
print(de)

输出：

[[0.55523672 0.46815197 0.67590369]
[0.5331193 0.62780236 0.45044916]]

[[0.26215572 0.07380256 0.06592746]
[0.89782279 0.95603968 0.82052478]]

堆叠上面垂直创建的两个数组

st = np.vstack([de,relist])
st

输出：

数组（[[0.26215572，0.07380256，0.06592746]，
[0.89782279、0.95603968、0.82052478]，
[0.55523672、0.46815197、0.67590369]，
[0.5331193、0.62780236、0.45044916]]）

现在，让我们水平堆叠它们。

sh = np.hstack([de,relist])
sh

输出：

数组（[[0.26215572，0.07380256，0.06592746，0.55523672，0.46815197，
0.67590369]，
[0.89782279、0.95603968、0.82052478、0.5331193、0.62780236，
0.45044916]]）

太好了，现在让我们执行一些数组操作。 首先让我们创建两个随机数组

r1 = np.random.rand(2,2)
r2 = np.random.rand(2,2)
print(r1)
print(r2)

输出：

[[0.02430146 0.14448542]
[0.54428337 0.40332494]]

[[0.77574886 0.08747577]
[0.51484157 0.92319888]

让我们进行元素明智的加法。

r3 = r1+ r2
r3

输出：数组（[[--0.75144739，0.05700965]，
[0.02944179，-0.51987394]]）

元素明智的减法。

r4 = r1 - r2
r4

输出：数组（[[--0.75144739，0.05700965]，
[0.02944179，-0.51987394]]）

让我们将每个元素加到3。

r5 = r1**3
r5

输出：array（[[[0.65228631，0.24993365]，
[0.97976155，0.71554632]]）

现在，让我们执行两个数组r1和r2的点积，而不是按元素进行运算。

r6 = r1.dot(r2)
r6

输出：array（[[0.09323893，0.13551456]，
[0.62987564，0.41996073]]）

让我们创建一个新数组并将其转置。

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

输出：

数组（[[1，2]，
[3，4]]）

sh.T

输出：

数组（[[1，3]，
[2，4]]）

现在，检查数组中元素的数据类型。

sh.dtype

输出：dtype（'int32'）

更改数组的数据类型。

rs = a.astype('f')
rs.dtype

输出：dtype（'float32'）

现在，让我们看一下数组中的一些数学函数，从数组的总和开始。

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

输出：15

数组元素的最大值。

c.max()

输出5

数组元素的均值

c.mean()

输出3

现在，让我们检索数组最大值的索引。

c.argmax()

输出4

c.argmin()

输出：0

创建一个由前十个整数的平方组成的数组。

dim = np.arange(10)**2
dim

输出：array（[0，1，4，9，16，25，36，49，64，81]，dtype = int32）

使用索引访问上述数组中的值

dim[2]

输出4

dim[1:5]

输出：array（[1，4，9，16]，dtype = int32）

使用负号可以反向访问变量。

dim[-1:]

输出：array（[81]，dtype = int32）

现在，根据步长访问数组的某些元素。

dim[1:10:2] #dim[start:stop:stepsize] 

输出：array（[1，9，25，49，81]，dtype = int32）

创建一个多维数组

en = np.arange(36)
en.resize(6,6)
en

输出：array（[[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，25，26，27，28，29]，
[30，31，32，33，34，35]]）

访问第二行和第三列

en[1,2]

输出8

访问第二行和第3列至第7列。请注意，行和列的编号从0开始。

en[1, 2:6]

输出：array（[8，9，10，11]）

选择直到第二行的所有行以及除最后一列以外的所有列

en[:2,:-1]

输出：array（[[0，1，2，3，4]，
[6，7，8，9，10]]）

从大于20的数组中选择值。

en[en>20]

输出：array（[21，22，23，24，25，26，27，28，29，30，31，32，33，34，35]）

如果元素值大于20，则将数组元素的值分配为20。

en[en>20] = 20
en

输出：array（[[0，1，2，3，4，5]，
[6，7，8，9，10，11]，
[12、13、14、15、16、17]
[18，19，20，20，20，20]，
[20，20，20，20，20，20]，
[20，20，20，20，20，20]]）

要将数组复制到另一个变量，请始终使用复制功能。

fun = en.copy()
fun

输出：array（[[0，1，2，3，4，5]，
[6，7，8，9，10，11]，
[12、13、14、15、16、17]
[18，19，20，20，20，20]，
[20，20，20，20，20，20]，
[20，20，20，20，20，20]]）

创建一个数组，其中包含一组介于1到10之间的随机整数。将数组指定为形状4 * 4

gom = np.random.randin(1,10,(4,4))
gom

输出：array（[[9，7，1，4]，
[1、4、3、6]，
[2，5，5，1]，
[2，2，9，9]]）

太好了，我们已经研究了在Numpy中创建，访问和操作数组。 在本系列的下一部分中，我们将研究一个基于Numpy库构建的库-Pandas。 Pandas是一个库，可在Python中简化数据操作和分析。 它为数值表和时间序列提供数据结构和运算。

资源：

1. 大量文件
2. Python专业化的应用数据科学。

在LinkedIn上连接，然后查看Github（如下）以获取完整的笔记本。

harunshimanto / Python-ML数据科学的危险工具
用于ML数据科学的Python危险工具-使用Python学习数据科学和机器学习。 github.com

您可以告诉我您的想法，如果您喜欢写作，请单击拍击👏按钮。

谢谢大家。

From: https://hackernoon.com/numpy-with-python-for-data-science-16ff2f646591