Python数据分析|Numpy库的使用

数组创建

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

创建0D数组

0-D 数组，或标量（Scalars），是数组中的元素。数组中的每个值都是一个 0-D 数组。

import numpy as np
arr=np.array(61)
print(arr)

创建1D数组

其元素为0-D数组的数组

import numpy as np
arr=np.array([1,2,3,4,5,6])
print(arr)

创建2D数组

其元素为 1-D 数组的数组，称为 2-D 数组。
它们通常用于表示矩阵或二阶张量。

import numpy as np
arr=np.array([1,2,3],[4,5,6])
print(arr)

创建3D数组

其元素为 2-D 数组的数组，称为 3-D 数组。

import numpy as np
arr = np.array([[[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]]])
print(arr)

ndim检查数组维数

import numpy as np

a = np.array(42)
b = np.array([1, 2, 3, 4, 5])
c = np.array([[1, 2, 3], [4, 5, 6]])
d = np.array([[[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]]])

print(a.ndim) 
print(b.ndim) 
print(c.ndim) 
print(d.ndim)

ps:记不住是几维数组可以看最外面的数组【】有几个，有三个就是三位数组

转载一篇文章，有利于理解数组概念

数组索引

与列表相同，访问数组的第几个元素，print（arr[2]）

访问2D数组

import numpy as np
arr = np.array([[1,2,3,4,5], [6,7,8,9,10]])
arr1 = np.array([[1,2,3,4,5], [6,7,8,9,10]])
print('2nd element on 1st dim: ', arr[0, 1])
print('5th element on 2nd dim: ', arr1[1, 4])

此处的arr[0,1]为第一行的第二列元素
arr1[1,4]指的是第二行的第五列元素

访问3D数组

import numpy as np
arr = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])
print(arr[0, 1, 2])#访问第一个数组中的第二行，第三列对应的元素

神奇索引

将数据复制到一个新的数组中

import numpy as np
arr=np.arange(32).reshape(8,4)
arr
arr[[1,5,7,2],[0,3,1,2]]#数组中的（1,0），（5,3），（7,1），（2,2）这四个元素被选中
arr[[1,5,7,2],[:,[0,3,1,2]]]#按照原处理逻辑生成二维数组

数组切片

python 中裁切的意思是将元素从一个给定的索引带到另一个给定的索引。
我们像这样传递切片而不是索引：[start：end]。
我们还可以定义步长，如下所示：[start：end：step]。
如果我们不传递 start，则将其视为 0。
如果我们不传递 end，则视为该维度内数组的长度。
如果我们不传递 step，则视为 1。

import numpy as np
arr=np.array([1,2,3,4,5,6,7])
print(arr.ndim)
print(arr[1:5])
print(arr[4:])
print(arr[:4])#左闭右开
print(arr[1:-3])
print(arr[-3:-1])
print(arr[1:5:2])#左闭右开,从2开始到6结束，步长为2
print(arr[::2])#返回数组中相隔的元素

裁切2D数组

import numpy as np
arr = np.array([[1,2,3,4,5], [6,7,8,9,10]])
print(arr.ndim)
print(arr)
print(arr[1,1:4])#第二行，第二到第四列元素
print(arr[0:2,2])#前两行，第三列元素
print(arr[0:2,1:4])#前两行，第二到第四列元素

裁切3D数组

和二维数组的区别是，先选择第几个数组，再进行切片

import numpy as np

arr = np.array([[[1,2,3],[4,5,6]],[[7,8,9],[10,11,12]]])

print(arr.ndim)
print(arr)
print(arr[0,1,-2])
print(arr[0,0:2,2])#选择第一个数组，前两行的第三列元素
print(arr[1,0:2,-2:-1])#选择第二个数组，前两行的倒数第二个元素，注意负索引最后一个元素的索引为-1，且左闭右开

布尔数值裁切

import numpy as np
from numpy import random
name=np.array(["bob","david","bob","lily","bob"])
arr=random.randn(5,4)
name=="bob"#布尔数值组的长度必须和数组轴长度一致
arr[name=="bob"]#输出布尔值为true对应的行轴

numpy数据类型

此前，我们先回顾一下Python中的数据类型

• strings - 用于表示文本数据（字符串），文本用引号引起来。例如 “ABCD”。
• integer - 用于表示整数。例如 -1, -2, -3。
• float - 用于表示实数。例如 1.2, 42.42。
• boolean - 用于表示 True 或 False。
• complex - 用于表示复数。例如 1.0 + 2.0j，1.5 + 2.5j

在numpy中的数据类型，可以通过一个字符引用，一下是numpy中所有数据类型的列表以及用于表示他们的字符

表示方法	含义
i	整数
b	布尔
u	无符号整数
f	浮点
c	复合浮点数
m	timedelta
M	datetime
O	对象
S	字符串
U	Unicode字符串
V	固定的其他类型的内存块

dtype检查数据类型

import numpy as np
arr=np.array([1,2,3,4])
print(arr.dtype)

astype()更改数据类型

import numpy as np
arr=ap.array([1.1,2.1,3.1])
print(arr.astype(int))#将浮点类数据转化为整型
print(arr)

数组副本vs视图

副本和视图之间的区别：
副本和数组视图之间的主要区别在于副本是一个新数组，而这个视图只是原始数组的视图。

副本拥有数据，对副本所做的任何更改都不会影响原始数组，对原始数组所做的任何更改也不会影响副本。

视图不拥有数据，对视图所做的任何更改都会影响原始数组，而对原始数组所做的任何更改都会影响视图。

数组副本

import numpy as np
arr=np.array([1,2,3,4,5])
x=arr.copy()
arr[0]=61
print(arr)
print(x)

对原始数组修改后，不会影响副本x中的元素

视图

输出数组都为[61,2,3,4,5]，修改原始数组会修改视图中的元素

import numpy as np
arr=np.array([1,2,3,4,5])
x=arr.view()
arr[0]=61
print(arr)
print(x)

创建视图，修改视图，将会同时影响原始数组与视图中的元素

import numpy as np
arr=np.array([1,2,3,4,5])
x=arr.view()
x[0]=31
print(arr)
print(x)

检查数组中是否拥有数据
每个 NumPy 数组都有一个属性 base，如果该数组拥有数据，则这个 base 属性返回 None。

否则，base 属性将引用原始对象。

import numpy as np

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

x = arr.copy()
y = arr.view()

print(x.base)#显示为null，副本中拥有数据
print(y.base)#视图中不含有数据，返回原始数组

数组形状

NumPy 数组有一个名为 shape 的属性，该属性返回一个元组，每个索引具有相应元素的数量。

import numpy as np
arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
print(arr.shape)#2维，每个维有四个元素，相当于二行四列

import numpy as np
arr = np.array([1, 2, 3, 4], ndmin=5)
print(arr)
print('shape of array :', arr.shape)

上例中的索引 4，我们的值为 4，因此可以说第 5 个 ( 4 + 1 th) 维度有 4 个元素。

数组重塑

利用reshape函数可以将数组进行重塑

升维重塑

import numpy as np
arr=np.array([1,2,3,4,5,6,7,8,9])
newarr=arr.reshape(3,3)
print(newarr)#将一维数组重塑成3*3
newarr=arr.reshape(3,3,1)#将一维数组重塑成3行3列，且每个小数组中仅含有一个元素
print(arr.reshape(3,3).base)#返回的是视图

官方来说，reshape（2,3,2）意为将有两个数组，其中包含3个数组，每个数组中包含2个元素

未知维度

当不明确每个数组中应该含有几个元素时，可以将reshape的第三个参数赋值为-1，numpy会自动计算该数字

import numpy as np

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

newarr = arr.reshape(2, 2, -1)

print(newarr)#返回的就是2*2,，每个数组中含有两个元素

降维重塑

import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6]])
newarr=arr.reshape(-1)
print(newarr)

数组迭代

迭代意味着逐一遍历元素。

当我们在 numpy 中处理多维数组时，可以使用 python 的基本 for 循环来完成此操作。

import numpy as np
arr = np.array([1, 2, 3])
for x in arr:
  print(x)#一维数组遍历所有元素
arr1=np.array([[1, 2, 3], [4, 5, 6]])
for x in arr1:
	print(x)#二维数组遍历所有行
	

如果我们迭代一个 n-D 数组，它将逐一遍历第 n-1 维。

如需返回实际值、标量，我们必须迭代每个维中的数组。

二维数组迭代

import numpy as np
arr=np.array([[1,2,3],[4,5,6]])
for x in arr:
    print(x)#遍历二维数组每行
    for y in x:
        print(y)#遍历二维数组每行中的每个元素

三维数组迭代

import numpy as np
arr = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])
for x in arr:
    print(x)#返回三维数组中的每个数组
    for y in x:
        print(y)#返回每个数组中的每行
        for z in y:
            print(z)#返回每行中的每个元素

nditer()迭代数组

函数 nditer() 是一个辅助函数，从非常基本的迭代到非常高级的迭代都可以使用。它解决了我们在迭代中面临的一些基本问题，让我们通过例子进行介绍。
迭代每个标量元素
在基本的 for 循环中，迭代遍历数组的每个标量，我们需要使用 n 个 for 循环，对于具有高维数的数组可能很难编写。

import numpy as np

arr = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
for x in np.nditer(arr):
  print(x)#直接返回每个数组中的每个元素

使用op_dtypes更改迭代中的数据类型

迭代不同数据类型的数组
我们可以使用 op_dtypes 参数，并传递期望的数据类型，以在迭代时更改元素的数据类型。

NumPy 不会就地更改元素的数据类型（元素位于数组中），因此它需要一些其他空间来执行此操作，该额外空间称为 buffer，为了在 nditer() 中启用它，我们传参 flags=[‘buffered’]

import numpy as np

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

for x in np.nditer(arr, flags=['buffered'], op_dtypes=['S']):
  print(x)

以不同的步长迭代

import numpy as np
arr=np.array([[1,2,3,4],[5,6,7,8]])
for x in np.nditer(arr[:,::2]):
    print(x)#从第一列开始，步长为2

使用 ndenumerate() 进行枚举迭代

枚举是指逐一提及事物的序号。

有时，我们在迭代时需要元素的相应索引，对于这些用例，可以使用 ndenumerate() 方法。

import numpy as np

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

for idx, x in np.ndenumerate(arr):
  print(idx, x)#枚举一维数组中的元素及其索引

枚举二维数组中的元素

import numpy as np

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

for idx, x in np.ndenumerate(arr):
  print(idx, x)

数组连接

在 SQL 中，我们基于键来连接表，而在 NumPy 中，我们按轴连接数组。
我们传递了一系列要与轴一起连接到 concatenate() 函数的数组。如果未显式传递轴，则将其视为 0。

concatenate()

import numpy as np
arr1=np.array([1,2,3])
arr2=np.array([4,5,6])
arr=np.concatenate((arr1,arr2))
print(arr)

import numpy as np

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

arr2 = np.array([[5, 6], [7, 8]])

arr = np.concatenate((arr1, arr2), axis=1)
#沿着第一行，连接两个二维数组

print(arr)

stack()堆栈连接数组

堆栈与级联相同，唯一的不同是堆栈是沿着新轴完成的。

我们可以沿着第二个轴连接两个一维数组，这将导致它们彼此重叠，即，堆叠（stacking）。

我们传递了一系列要与轴一起连接到 concatenate() 方法的数组。如果未显式传递轴，则将其视为 0。

import numpy as np

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

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

arr = np.stack((arr1, arr2), axis=1)

print(arr)#上下堆起来，罗列数组，按照第一行连接数组

hstack()沿行堆叠

import numpy as np

arr1 = np.array([[1, 2, 3],[7,8,9]])

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

arr = np.hstack((arr1, arr2))

print(arr)#沿行堆叠两个二维数组，及123789,654456，最终形成的仍是二维数组

vstack()沿行堆叠

import numpy as np

arr1 = np.array([[1, 2, 3],[7,8,9]])

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

arr = np.vstack((arr1, arr2))

print(arr)#123654,789456

dstack()沿高度堆叠

import numpy as np

arr1 = np.array([[1, 2, 3],[7,8,9]])

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

arr = np.dstack((arr1, arr2))

print(arr)#16,25,34;74,85,96.

数组拆分

使用 array_split() 分割数组，将要分割的数组和分割数传递给它。

import numpy as np
arr=np.array([1,2,3,4,5,6])
newarr=np.array_split(arr,3)
print(newarr)#能够将数组分为三个部分
newarr1=np.array_split(arr,4)
print(newarr1)#将数组分为四个部分,12,34,5,6

**注释：**返回值是一个包含三个数组的数组。
如果数组中的元素少于要求的数量，它将从末尾进行相应调整。split()函数可以拆分，但不会自动调整，元素较少的时候会报错

拆分为数组

将一个数组拆分为三个数组，并分别访问三个数组

import numpy as np
arr=np.array([1,2,3,4,5,6])
newarr=np.array_split(arr,3)
print(newarr[0])
print(newarr[1])
print(newarr[2])

分割二维数组

import numpy as np
arr = np.array([[1, 2], [3, 4], [5, 6], [7, 8], [9, 10], [11, 12]])
newarr = np.array_split(arr)
print(newarr)#将6行的数组拆分为3个二维数组
newarr = np.array_split(arr, 3,axis=1)#沿行分割

hstack()按行拆分

import numpy as np

arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12], [13, 14, 15], [16, 17, 18]])

newarr = np.hsplit(arr, 3)

print(newarr)

同样的，vsplit()为按列拆分，dsplit（）为按高度拆分

数组搜索

where()函数搜索符合条件的元素索引

import numpy as np
arr = np.array([1, 2, 3, 4, 5, 4, 4])
x = np.where(arr == 4)
print(x)#搜索元素为4的索引，返回值为array([3,5,6])

searchsorted()排序搜索

下例，数组按序排列应为6,9，10,11,为了让数组按升序排列，searchsorted函数将返回其应该插入的索引

import numpy as np
arr = np.array([6, 10, 11, 9])
x = np.searchsorted(arr, 8)
print(x)

插入多个值后

import numpy as np
arr = np.array([1, 3, 5, 7])
x = np.searchsorted(arr, [2, 4, 6])
print(x)#返回的是一个索引数组

sort()数组排序

有序序列是拥有与元素相对应的顺序的任何序列，例如数字或字母、升序或降序。
NumPy ndarray 对象有一个名为 sort() 的函数，该函数将对指定的数组进行排序。

import numpy as np
arr = np.array([3, 2, 0, 1])
aarr1=np.array(['banana', 'cherry', 'apple'])
arr2=arr = np.array([True, False, True])
print(np.sort(arr))
print(np.sort(arr1))字符串按首字母
print(np.sort(arr2))布尔值先false，再true

对二维数组进行排序，结果是对每一维数组内部排序

import numpy as np
arr = np.array([[3, 2, 4], [5, 0, 1]])
print(np.sort(arr))

unique()唯一值与其他集合逻辑

import numpy as np
ints=np.array([3,3,3,2,2,2,12])
np.unique(ints)#将数组中的唯一值排序后形成新数组

数组过滤

从现有数组中取出一些元素并从中创建新数组称为过滤（filtering）。
在 NumPy 中，我们使用布尔索引列表来过滤数组。
布尔索引列表是与数组中的索引相对应的布尔值列表。
如果索引处的值为 True，则该元素包含在过滤后的数组中；如果索引处的值为 False，则该元素将从过滤后的数组中排除。

import numpy as np
arr=np.array([1,2,3,4,5])
x = [True, False, True, False, True]
newarr=arr[x]
print(newarr)#返回布尔值为true的元素组合成数组

根据所设条件，返回一个过滤器数组
法一

import numpy as np
arr = np.array([61, 62, 63, 64, 65])
filter_arr=[]
for x in arr:
    if x>62:
        filter_arr.append(True)
    else:
        filter_arr.append(False)
newarr=arr[filter_arr]
print(newarr)

法二

import numpy as np
arr = np.array([61, 62, 63, 64, 65])
filter_arr = arr > 62
newarr = arr[filter_arr]
print(filter_arr)
print(newarr)

法二中的第三行，直接判断是佛是符合条件的元素，代替写条件语句

random()生成随机数

from numpy import random
x = random.randint(100)#随机生0-100之间的随机数
print(x)

生0-1之间的随机浮点数

from numpy import random
x = random.rand()
y= random.rand(5)#生成包含五个随机浮点数的一维数组
z=random.rand(3,5)#生成三行二维数组，每个数组包含五个元素
print(x)

生成随机数组

randint()方法接受size参数，可以指定数量

from numpy import random
x=random.randint(100, size=(5))
z=random.randn(7,4)#随机生成7行4列的符合正态分布的随机数组
y=random.randint(100,size=(3,5))#生成三行的二维数组，每行含五个元素
print(x)

从数组生成随机数

choice() 方法使您可以基于值数组生成随机值。
choice() 方法将数组作为参数，并随机返回其中一个值。

from numpy import random
x = random.choice([3, 5, 7, 9])#返回数组中其中一个值
y=random.choice([3,5,7,9],size=(3,5))#数组中的元素随机生成三行，五列的数组
print(x)

ufuncs

where 布尔值数组或条件，用于定义应在何处进行操作。
dtype 定义元素的返回类型。
out 返回值应被复制到的输出数组。

zip()函数接受一系列可迭代对象作为参数，将不同对象中相对应的元素打包成一个元组（tuple），返回由这些元组组成的list列表，如果传入的参数的长度不等，则返回的list列表的长度和传入参数中最短对象的长度相同。简单来说，他把数组之间对应索引的元素组合成元祖。

x = [1, 2, 3, 4]
y = [4, 5, 6, 7]
z = []

for i, j in zip(x, y):
  z.append(i + j)
print(z)

同样的，可以用add实现

import numpy as np
x = [1, 2, 3, 4]
y = [4, 5, 6, 7]
z = np.add(x, y)
print(z)

maximum()引用两个数组中的最大值

import numpy as np
x=[7,34,2,8]
y=[4,5,6,7]
z=np.maximum(x,y)#返回[7,34,6,8]
print(z)

modf()返回浮点值数组的小数和整数

import numpy as np
arr=np.random.randn(7)*5
print(arr)
remainder,whole_part=np.modf(arr)
print(remainder)#返回小数
print(whole_part)#返回整数

in1d()检查一个数组中的值是否在另外一个数组中

import numpy as np
ints=np.array([3,3,3,2,2,2,12])
np.in1d(ints,[2,3])#判断2，3元素是否在数组中，结果将返回一串布尔值array([ True,  True,  True,  True,  True,  True, False])