Python数组知识：numpy语法

numpy：数组创建

import numpy as np

# array创建数组：
# 参数：object，要传入序列，可以是一维、多维数组
# dtype：数组元素的数据类型，如果没有指定dtype，numpy会自动根据输入的内容来判断数据类型
# order：按哪种储存方式存数据，C-按行存，F-按列存
# ndmin：指定数组的维度，在整个数组外添加一个维度，不能修改数组的形状
a = np.array([1, 2, 3, 4, 5, 6], dtype=np.int32, order='C', ndmin=2)
print(a)
print(type(a))
print(a.dtype)
# 创建二维数组
a = np.array([[1, 2, 3], [4, 5, 6]])
print(a)
# shape：描述ndarray数组形状，数据类型：元组(n,m)，形状表示为n行，m列
print(a.shape)
# zeros：根据指定形状创建数组，数组元素默认以0填充
a = np.zeros((2, 3))
print(a)
# ones：根据指定形状创建数组，数组元素默认以1填充
a = np.ones((3, 2))
print(a)
# full：根据指定形状创建数组，数组元素以fill_value指定值填充
a = np.full((3, 3), 5)
print(a)
# arange(start,stop,step)：创建一个元素为等差数列的一维数组
# start：起始值
# stop：终止值（不包含）
# step：步长
a = np.arange(1, 10, 1)
print(a)
a = np.arange(1, 10, 2)
print(a)
a = np.arange(9, 0, -1)
print(a)
# linspace()：根据份数创建一个元素为等差数列的一维数组
# start：起始值
# stop：终止值（包含）
# num：序列的份数，默认为50
# endpoint：默认为True，此时包含终止值，为False时表示不包含终止值
a = np.linspace(0, 10, 10, endpoint=False)
print(a)
# astype()：转换数组中元素的数据类型
a = np.array([1, 2, 3])
print(a.dtype)
b = a.astype(np.float64)
print(b)
print(b.dtype)

numpy：属性

import numpy as np

# shape：返回数组的形状，返回类型为元组
# shape也可以通过赋值来修改数组的形状，修改后的形状会影响原数组
a = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
print(a.shape)
# shape修改数组形状，总元素个数不能被改变
a.shape = (3, 1, 3)
print(a)
# ndim：表示数组的维度数，二维数组则打印2，三维数组则打印3，以此类推
print(a.ndim)
# flags：返回数组的内存信息
print(a.flags)

numpy：索引

import numpy as np

# numpy切片：操作方法同python切片(start:stop:step)
# 切片得到的结果是原数组的视图
# 若修改视图数据，原数组元素会受影响
a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
a1 = a[1:3]
print(a1)
# 二维数组切片，按行和列进行切片，行和列以逗号分割
# 左边是行的切片，右边是列的切片
a2 = a[1:3, 1:3]
print(a2)
# 根据行下标和列下标取值
a3 = a[1, 1]
print(a3)
# ...：保留整行数据，等同于为"::"
a4 = a[::, 1:3]
print(a4)
a5 = a[..., 1:3]
print(a5)
# 整数数组索引,主要用于查找特定位置的元素
# 通过整数数组索引得到的新数组是原数组的副本
# 修改新数组的元素不影响原数组
a = np.array([[1, 2, 3], [4, 5, 6]])
a1 = a[[0, 1, 0], [0, 1, 2]]
print(a1)
a1[0] = 100
print(a1)
print(a)
# 布尔索引
a = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
index = a > 5
print(index)
a1 = a[a > 5]
print(a1)
a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
a1 = a[a > 5]
print(a1)
a2 = a[a % 2 == 0]
print(a2)
# 布尔索引：所有行中的第二列大于五
a3 = a[a[:, 2] > 5]
print(a3)
print(a[:, a[1] > 5])
# 逻辑表达式：&——与,|——或,~——非
a4 = a[(a % 2 == 0) & (a > 5)]
print(a4)

numpy：广播

import numpy as np

# 广播：用来将两个不同形状的数组进行数值计算
# 核心思想：将其中一个数组通过横向或纵向进行一定次数的数据重复
# 使该数组变得与另一个数组的形状相同，然后进行计算
# 前提：要做数据重复的数组的其中一个维度必须是1，才能做广播
a = np.array([[1, 2, 3], [4, 5, 6]])
b = np.array([10, 20, 30])
# a的形状为(2,3)，b的形状为(1,3)
# 因为b中行的维度为1，所以可以通过广播机制进行数据重复
# b重复行数据，变成(2,3)，然后与a进行相加
result = a + b
print(result)
# d形状为(2,1)，e的形状为(1,3)
# 根据维度为一的先后顺序，先变形e，复制e的行，形状变为(2,3)
# 然后再变形d，复制d的列，形状变为(2,3)，然后再将两者进行相加
d = np.array([[1], [2]])
e = np.array([10, 20, 30])
f = d + e
print(f)

numpy：数组操作

import numpy as np

# 二维数组遍历
a = np.array([[1, 2, 3], [4, 5, 6]])
# 方法一：遍历结果是每一行的数据列表
# 默认将每一行数据当做一个整体，按照一维数组的遍历方法进行遍历
for i in a:
    print(i)
# 方法二：nditer迭代器
# order参数：指定遍历顺序，C——按行遍历，F——按列遍历
a = np.array([[1, 2, 3], [4, 5, 6]])
for i in np.nditer(a, order="C"):
    print(i, end=" ")
print()
for i in np.nditer(a, order="F"):
    print(i, end=" ")
print()
# flags:
# multi_index：除了遍历元素之外，还将输出元素对应的索引值
# external_loop：在遍历数组时，先将元素存到一个数组中，遍历完成后，将数组统一输出
it = np.nditer(a, flags=["multi_index"])
for i in it:
    print(i, it.multi_index)
for i in np.nditer(a, flags=["external_loop"]):
    print(i)
# reshape()：修改数组的形状
# 修改形状后产生的新数组是原数组的一个视图
# 修改新数组中的元素会影响原数组
# 修改形状要保证数组中的元素个数不变
a = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
a1 = a.reshape(3, 3)
print(a1)
a1[0, 0] = 100
print(a1)
print(a)
# -1：占位符，-1代表的维度为numpy自动计算的维度（但行和列不能同时为-1）
a = np.arange(1, 10).reshape(3, -1)
print(a)
# flat属性：将多维数组生成一维数组的迭代器，允许遍历该迭代器获取数据
a = np.arange(1, 7).reshape(2, 3)
for i in a.flat:
    print(i, end=" ")
print()
# flatten()：将多维数组扁平化为一维数组
# 生成的一维数组是原数组的副本，修改新数组的元素不会影响原数组
a = np.arange(9).reshape(3, 3)
a1 = a.flatten()
print(a1)
a1[0] = 100
print(a)
# ravel()：将多维数组扁平化为一维数组
# 生成的一维数组是原数组的视图，修改新数组的元素会影响原数组
a2 = a.ravel()
print(a2)
a2[0] = 100
print(a)

numpy：进阶数组操作

import numpy as np

# 数组转置
a = np.arange(6).reshape(2, 3)
print(a.shape)
# np.transpose()：转置方法，将数组进行转置
a1 = np.transpose(a)
print(a1.shape)
# T：数组的转置属性，将数组进行转置
a2 = a.T
print(a2.shape)
# expand_dims()：增加维度
# axis=0表示在行方向增加，axis=1表示在列方向增加
a = np.arange(1, 4)
# 在行上添加维度，即将子数组当做一个整体，在整体外添加一个维度
a1 = np.expand_dims(a, 0)
print(a1)
# 在列上添加维度，即对子数组的每一列添加一个维度
a2 = np.expand_dims(a, 1)
print(a2)
# squeeze()：降维，仅能移除维度为1的维度
# 若未指定axis或axis为None，则默认移除所有维度数为1的维度
a = np.array([[[1, 2, 3]]])
a1 = np.squeeze(a, 0)
print(a1)
a2 = np.squeeze(a, 1)
print(a2)
# a3 = np.squeeze(a, 2) # 维度为三，不可降维
# print(a3)
a4 = np.squeeze(a)
print(a4)
# hstack()：数组按水平方向拼接，前提：数组行数一致
a = np.arange(6).reshape(2, 3)
b = np.arange(4).reshape(2, 2)
c = np.hstack((a, b))
print(c)
# vstack()：数组按垂直方向拼接，前提：数组列数一致
a = np.arange(6).reshape(3, 2)
b = np.arange(4).reshape(2, 2)
c = np.vstack((a, b))
print(c)
# hsplit(a,[列索引])：数组按列切割，索引列表中的元素值在切割时不被包含
a = np.arange(12).reshape(3, 4)
a1 = np.hsplit(a, [1, 3])
print(a1[0], a1[1], a1[2])
# vsplit(a,[行索引])：数组按行切割，索引列表中的元素值在切割时不被包含
a2 = np.vsplit(a, [1, 2])
print(a2)
# np.dot
# 一维数组运算：做点积运算，a点乘b = a1*b1 + a2*b2 + ... + an*bn
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
c = np.dot(a, b)
print(c)
# 二维数组运算：矩阵相乘n*m m*p相乘，中间的维度（m）需要相同
# 结果数组的维度为n*p
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])
c = np.dot(a, b)
print(c)