数据分析之numpy - 码农教程

ndarray概述创建n维数组接收的是列表类型，所有元素类型必须相同 shape表示各维度大小的元组 dtype表示数组数据类型对象

1、基本创建数据

ndarray1 = np.array([1, 2, 3, 4])
ndarray2 = np.array(list('abcdefg'))
ndarray3 = np.array([[11, 22, 33, 44], [10, 20, 30, 40]])

# 输出整个数组
print(ndarray3)
# 输出数组元素类型
print(ndarray3.dtype)
# 输出数组类型 mxn
print(np.shape(ndarray3))
# 输出数组指定元素
print(ndarray3[1][2])

zeros和zeros_like创建全0数组

ndarray4 = np.zeros(10)
ndarray5 = np.zeros((3, 3))
ndarray6 = np.zeros_like(ndarray3)  # 按照 ndarray3 的shape创建数组

ones和ones_like创建全1数组

# 创建数组，元素默认值是1
ndarray7 = np.ones(10)
ndarray8 = np.ones((3, 3))
# 修改元素的值
ndarray8[0][1] = 999
ndarray9 = np.ones_like(ndarray5)  # 按照 ndarray5 的shape创建数组

empty和empty_like创建空数组

用于创建空数组，空数据中的值并不为0,而是未初始化的随机值.
ndarray10 = np.empty(5)
ndarray11 = np.empty((2, 3))
ndarray12 = np.empty_like(ndarray11)

arange创建数组

# 产生0-9共10个元素
ndarray13 = np.arange(10)
# 产生从10-19共10个元素
ndarray14 = np.arange(10, 20)
# 产生10 12 14 16 18, 2为step
ndarray15 = np.arange(10, 20, 2)
# 将其形状改变为(2, 5)
ndarray14.reshape((2, 5))

eys创建对角矩阵数组

# 该函数用于创建一个N*N的矩阵，对角线为1，其余为0.
ndarray16 = np.eye(5)

使用astype函数转换数组类型如果浮点数转换为整数，则小数部分将会被截断 -- 取整如果某些字符串数组表示的全是数字，也可以用astype将其转换为数值类型

ndarray19 = np.array([2.4, 3.6, 4.8])
ndarray20 = ndarray19.astype(np.int64)

2.3 数组运算不需要循环即可对数据进行批量运算，叫做矢量化运算. 不同形状的数组之间的算数运算，叫做广播.

数组 + 数组对应元素相加数组 + 数字分别相加,相乘,相除一维 + 多维按行分别相加每行的元素个数相同多维 + 多维对应元素分别相加多维 * 多维形状相同对应元素分别相乘 (注意这里不是矩阵乘法) 矩阵乘法：条件--第一个行数 == 第二个的列数

arr14 = np.dot(arr6, arr12)

多维矩阵相乘.png

主要操作

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

元素类型转换

arr2 = arr.astype(np.float32)
 print(arr2)

数组转置 transpose 行变列，列变行

arr3 = arr.transpose()
print(arr3)

返回bool值，可以添加axis参数指定轴方向

np.any(): 至少有一个元素满足指定条件，返回True
np.all(): 所有的元素满足指定条件，返回True
arr2 = np.any(arr > 20)
 print(arr2)

取行

取下标行 arr[n]      print(arr[2])
取连续行 arr[m:n]    print(arr[1:3])
只取指定行            arr[[1,3,4]]  两个中括号

取列

获取指定下标的列  print(arr[:, 3]) # 一维数组形式
print(arr[:, 3:4]) # 以真实的列展示(竖着)
获取指定范围列 arr[:, 1:3] # print(arr[:, 1:3])
获取多个指定下标列 arr[:, [0,2]]  # print(arr[:, [0,2]])

获取指定连续行的指定连续列 arr[0:2 , 1:3]

print(arr[0:2 , 1:3])

获取不连续的行和列前面是行后面是列

arr2 = arr[np.ix_([0,2], [0,3])]

获取下标元素放入列表中[ 6, 11]

print(arr[[1,2], [2,3]])

判断列表是否为空

# if np.size(arr) != 0:
# print(f"数组大小为{np.size(arr)}")

拼接两数组行拼接在下面

arr1 = arr[0:2]
arr2 = arr[[4,5]]
newArr = np.vstack((arr1, arr2))
print(newArr)

列拼接在后面拼接

arr1 = arr[0:2]
arr2 = arr[[4,5]]
newArr = np.hstack((arr1, arr2))
print(newArr)

分别获取每行或每列的总和 axis=0 表示列 axis=1 表示行

# 平均值 mean
arr4 = np.sum(arr, axis=0)
print(arr4)

# 第n列的sum
print(np.sum(arr[:, 2]))

reshape(6,4) 查看数组大小 返回元祖
print(arr.shape)

按列均分为n份注意均分后的值必须是正整数，不能有小数，也就是总行数/要均分的份数，能整除

vsplit(arr, n) 按行均分为n份 ，返回列表  可通过下标获取
ret = np.hsplit(arr, 4)
print(ret[2])

排序 axis=0 按列升序排序 axis=1 按行升序排序

arr2 = np.sort(arr[[4,2,0]], axis=1)
 print(arr2)

怎么降序排序

# 按列降序     np.sort(arr[::-1])
arr3 = np.sort(arr[::-1])
print(arr3)

按行降序先将数据变为负数然后升序排序 np.sort(-arr, axis=1) 再加个符号，把负数变为整数

 array = -np.sort(-arr, axis=1)   #降序
 print(array)

矩阵按其第一列元素大小顺序来对整个矩阵进行行排序

arr5 = np.array([[5, 4, 6], [3, 6, 3], [9, 4, 1]])
print(arr5)
mat1=arr5[arr5[:,0].argsort()]
print(mat1)

一元ufunc：

ceil(x): 向上最接近的整数，参数是 number 或 ndarray
floor(x): 向下最接近的整数，参数是 number 或 ndarray
rint(x): 四舍五入，参数是 number 或 ndarray
negative(x): 元素取反，参数是 number 或 ndarray
abs(x)：元素的绝对值，参数是 number 或 ndarray
square(x)：元素的平方，参数是 number 或 ndarray
aqrt(x)：元素的平方根，参数是 number 或 ndarray
sign(x)：计算各元素的正负号, 1(正数)、0（零）、-1(负数)，参数是 number 或 ndarray
modf(x)：将数组的小数和整数部分以两个独立数组的形式返回，参数是 number 或 ndarray
isnan(x): 判断元素是否为 NaN(Not a Number)，返回bool，参数是 number 或 ndarray

二元ufunc：

add(x, y): 元素相加，x + y，参数是 number 或 ndarray
subtract(x, y): 元素相减，x - y，参数是 number 或 ndarray
multiply(x, y): 元素相乘，x * y，参数是 number 或 ndarray
divide(x, y): 元素相除，x / y，参数是 number 或 ndarray
floor_divide(x, y): 元素相除取整数商(丢弃余数)，x // y，参数是 number 或 ndarray
mod(x, y): 元素求余数，x % y，参数是 number 或 array
power(x, y): 元素求次方，x ** y，参数是 number 或 array

三元ufunc：

where(condition, x, y): 三元运算符，x if condition else y，条件满足返回x，否则返回y，
参数condition 是条件语句，参数 x 和 y 是 number 或 ndarray

按下标依次迭代arr1和arr2两个数组的每个元素，并比较元素大小，如果结果为True，返回当前arr1的元素，否则返回当前arr2的元素，并将结果构建为一个数组。
arr3 = np.where(arr1 > arr2, arr1, arr2)
print(arr3)

多维数组默认统计全部数据，添加axis参数可以按指定轴心统计，值为0则按列统计，值为1则按行统计。

np.mean(x [, axis])：所有元素的平均值，参数是 number 或 ndarray
np.sum(x [, axis])：所有元素的和，参数是 number 或 ndarray
np.max(x [, axis])：所有元素的最大值，参数是 number 或 ndarray
np.min(x [, axis])：所有元素的最小值，参数是 number 或 ndarray
np.std(x [, axis])：所有元素的标准差，参数是 number 或 ndarray
np.var(x [, axis])：所有元素的方差，参数是 number 或 ndarray
np.argmax(x [, axis])：最大值的下标索引值，参数是 number 或 ndarray
np.argmin(x [, axis])：最小值的下标索引值，参数是 number 或 ndarray
np.cumsum(x [, axis])：返回一个一维数组，每个元素都是之前所有元素的 累加和，参数是 number 或 ndarray
np.cumprod(x [, axis])：返回一个一维数组，每个元素都是之前所有元素的 累乘积，参数是 number 或 ndarray

ndarray支持常用的增加和删除操作，以及数组合并。

append()：在数组后面追加元素
insert()：在指定下标插入元素
delete()：删除指定行/列数据
concatenate((arr1, arr2, ...), axis=0)：合并多个数组

unique(x)         :去重，并返回有序结果.
intersect1d(x, y) :公共元素，并返回有序结果, x & y
union1d(x, y)     :计算x和y的并集，并返回有序结果, x | y
setdiff1d(x, y)   :集合的差，即元素在x中且不在y中. x - y, y - x
in1d(x, y)        :得到一个表示“x的元素是否包含于y”的布尔型数组.
setxor1d(x, y)    :对称差集，两个数组中互相不包含的元素。x ^ y

arr2 = np.array([1, 3, 2])
arr3 = np.array(["l", "o", "u", "d", "b"])
arr4 = np.unique(arr2)
print(arr4)

arr5 = np.multiply(arr2, arr3)
 print(arr5)

数组中每一个元素都进行==运算，返回一个数组,如果相等返回True 不等返回False

names = np.array(['aaa', 'bbb', 'ccc', 'ddd', 'eee', 'fff', 'ggg'])
mask = names == "aaa"
# [ True False False False False False False]

使用numpy提供的where函数三目运算符如果符合条件结果为值1 否则为值2 将结果添加到数组中使用格式为: result = np.where(条件, 值1, 值2)

元素替换

# 将大于20的元素替换成666
ret1 = np.where(ndarray3 > 20, 666, ndarray3)

# 将大于13，并且小于17的元素替换成100
ret2 = np.where(ndarray3 > 13, np.where(ndarray3 < 17, 100, ndarray3), ndarray3)

按条件筛选元素矩阵名[矩阵名>数值] 对矩阵元素进行筛选，以列表形似返回符合条件的元素

newArr= arr[arr>5] # 输出 [6 7 8]