2.NumPy基础
文章目录
- 1、NumPy数组对象
- 2、创建多维数组
- 3、NumpPy数据类型
- 4、数组的索引和切片(一维、多维)
- 5、改变数组的维度
- 6、数组的组合
- 7、数组的分割
- 8、数组的属性
- 小结
1、NumPy数组对象
NumPy中的ndarray是一个多维数组对象，该对象由两部分组成：
1.实际的数据；
2.描述这些数据的元数据。
大部分的数组 *** 作仅仅修改元数据部分，而不改变底层的实际数据。
NumPy数组一般是同质的(但有一种特殊的数组类型例外，它是异质的)，即数组中的所有元素类型必须是一致的。这样的好处是数组中的元素均为同一类型，该数组所需的存储空间就很容易确定下来。
与Python一样，NumPy数组的下标是从0开始的。
# ndarry是python中的一个类对象
import numpy as np
a = np.array(5, dtype='int64')
print(a)
print(a.dtype) # 数组类型
print(a.shape) # 数组维度
print(type(a)) # 获取对象的类型。
数组的shape属性返回一个元组(tuple)，元组中的元素即为NumPy数组每一个维度上的大小。上面例子中的数组是一维的，因此元组中只有一个元素。
2、创建多维数组
array()函数可以依据给定的对象生成数组,给定的对象应是类数组(Python中的列表)，这样的类数组对象是array()函数的唯一必要参数，其余的诸多参数均为有默认值的可选参数。
# 创建一个2*2维数组
# 显示该数组的维度
import numpy as np
# arange函数创建的数组作为列表元素，把列表作为参数传给array函数，创建2×2数组
a = np.array([np.arange(0, 3), np.arange(0, 3)])
print(a)
print(a.shape)
print("ndarray对象的维度属性存储方式：", type(a.shape))
print(a.dtype) # shape属性返回一个tuple
# 创建一个3*3维数组
# 显示该数组的维度
import numpy as np
a = np.array([np.arange(0, 3), (2, 33, 44), [11, 21, 23]])
print(a)
print(a.shape)
print(a.dtype)
# 选取数组元素
import numpy as np
a = np.array([np.arange(0, 2), (11, 22)])
print(a)
print(a[0, 0]) # 对于数组a，要用a[m,n]选取各数组元素
print(a[0, 1])
print(a[1, 0])
print(a[1, 1])
3、NumpPy数据类型
Python支持的数据类型有整型、浮点型以及复数型，但这些类型不足以满足科学计算的需求，因此NumPy添加了很多其他的数据类型。在实际应用中，需要不同精度的数据类型， 它们占用的内存空间也是不同的。
在NumPy中，大部分数据类型名是以数字结尾的，这个数字表示其在内存中占用的位数。
数据类型 描述
bool 用一位存储的布尔类型(值为True或Fals)
inti 由所在平台决定其精度的整数(一般为int32或int64)
int8 整数，范围为-128至127
int16 整数，范围为-32768至32 767
int32 整数，范围为-2147483648至2 147 483 647)
int64 整数，范围为-9 223 372 036 854 775 808至9 223 372 036 854 775 807
uint8 无符号整数，范围为0至255
uint16 无符号整数，范围为0至65 535
uint32 无符号整数，范围为0至4 294 967 295
uint64 无符号整数，范围为0至18 446 744 073 709 551 615
float16 半精度浮点数（16位）：其中用1位表示正负号，5位表示指数，10位表示尾数
float32 单精度浮点数（32位）：其中用1位表示正负号，8位表示指数，23位表示尾数
float64/float 双精度浮点数（64位）：其中用1位表示正负号，11位表示指数，52位表示尾数
complex64 复数，分别用两个32位浮点数表示实部和虚部
complex128/complex 复数，分别用两个64位浮点数表示实部和虚部
import numpy as np
# 每一种数据类型均有对应的类型转换函数
a = np.float64(42)
print(a.dtype)
print(a)
b = np.int8(42.0)
print(b.dtype)
print(b)
c = np.bool(42)
print(type(c))
print(c)
d = np.bool(0)
print(type(d))
print(d)
e = np.bool(42.0)
print(type(e))
print(e)
f = np.float(True)
print(type(f))
print(f)
g = np.float(False)
print(type(g))
print(g)
h = np.arange(7, dtype=np.uint16) # 函数的参数中指定数据类型
print(h.dtype)
print(h)
# np.int(42.0 + 1.j) # 复数是不能转换为整数的
# np.float(42.0 + 1.j) # 复数是不能转换为整数的
j = np.complex(1.5) # 浮点数却可以转换为复数,虚部为0
print(type(j))
print(j)
import numpy as np
# 数据类型对象是numpy.dtype类的实例。数据类型对象可以给出单个数组元素在内存中占用的字节数
# dtype类的itemsize属性：
a = np.array([[1, 2], [3, 4]])
print(a.dtype.itemsize) # 此数据类型对象的元素大小
print(a.dtype.byteorder) # 指示此数据类型对象的字节顺序的字符
字符编码:NumPy可以使用字符编码来表示数据类型，这是为了兼容NumPy的前身Numeric。不推荐使用，但有时会用到。应该优先使用dtype对象来表示数据类型，而不是这些字符编码。
数据类型 描述
整数 i
无符号整数 u
单精度浮点数 f
双精度浮点数 d
布尔值 b
复数 D
字符串 S
unicode字符串 U
void(空) V
import numpy as np
a = np.array([np.arange(0, 3)], dtype="d")
print(a)
print(a.dtype)
print(a.shape)
import numpy as np
a = np.array([np.arange(0, 3)], dtype="D")
print(a)
print(a.dtype)
print(a.shape)
import numpy as np
a = np.array([np.arange(0, 3)], dtype="float") # 浮点数类型
b = np.array([np.arange(0, 3)], dtype="f") # 单精度浮点数类型
c = np.array([np.arange(0, 3)], dtype="d") # 双精度浮点数类型
# 将两个字符作为参数，第一个:数据类型，第二个:该类型在内存中占用的字节数
# 2、4、8分别代表精度为16、32、64位的浮点数
d = np.array([np.arange(0, 3)], dtype="f8")
e = np.array([np.arange(0, 3)], dtype="i8")
print(a.dtype)
print(b.dtype)
print(c.dtype)
print(d.dtype)
print(e.dtype)
# 完整的NumPy数据类型列表可以在sctypeDict.keys()中找到
print(np.sctypeDict.keys())
# dtype类的属性
import numpy as np
a = np.array([np.arange(0, 3)], dtype="int16")
print(a)
print(a.dtype.char) # 获取数据类型的字符编码
print(a.dtype.type) # 数组元素的数据类型
print(a.dtype.str) # 给出数据类型的字符串表示
自定义数据类型是一种异构数据类型，可以当做用来记录电子表格或数据库中一行数据的结构。示例：创建了一种自定义的异构数据类型，该数据类型包括一个用字符串记录的名字、一个用整数记录的数字以及一个用浮点数记录的价格。
import numpy as np
# 创建数据类型
t = np.dtype([('name', np.str_, 40), ('numitems', np.int32), ('price', np.float32)])
print(t)
# 查看数据类型(也可以查看某一字段的数据类型)
print(t['name'])
# 在用array函数创建数组时，如果没有在参数中指定数据类型，将默认为浮点数类型
# 要创建自定义数据类型的数组，就必须在参数中指定数据类型，否则将触发TypeError错误
item = np.array([('Meaning of life DVD', 42, 3.14),('Butter', 13, 2.72)], dtype=t)
print(item)
print(item[1])
4、数组的索引和切片(一维、多维)
一维数组的切片 *** 作与Python列表的切片 *** 作类似。
import numpy as np
a = np.arange(9)
print(a)
print(a[3:7])
print(a[:7:2])
print(a[::-1])
s = slice(3,7,2)
print(type(s))
print(s.start)
print(s.stop)
print(s.step)
print(a[s])
s = slice(None,None,-1)
print(a[s])
ndarray支持在多维数组上的切片 *** 作。为了方便起见，可以用一个省略号(…)来表示遍历剩下的维度。
# 先用arange函数创建一个3*3数组不改变其维度
a = np.arange(24).reshape(2, 3, 4)
print(a.shape)
print(a)
# 可以用三维坐标来选定任意一个元素，即位置、行号和列号
print(a[0, 0, 0])
# 选取所有位置的第1行、第1列的元素
print(a[:, 0, 0])
# 选取第1个位置的所有元素
print(a[0, :, :])
# 多个冒号可以用一个省略号(...)来代替，因此上面的代码等价于
print(a[0, ...])
# 选取第1个位置,第2行的所有元素
print(a[0, 1])
# 可以在数组切片中间隔地选定元素
print(a[0, 1, ::2])
# 所有位置，第2列的元素
print(a[:, :, 1])
print(a[..., 1])
# 所有位置，第2行的元素
print(a[:, 1, :])
# 第1个位置，第2列的元素
print(a[0, :, 1])
# 第1个位置，最后一列的所有元素
print(a[0, :, -1])
# 反向选取第1个位置，最后一列的所有元素
print(a[0, ::-1, -1])
# 第1个位置，在数组切片中间隔地选定元素
print(a[0, ::2, -1])
# 在多维数组中执行翻转一维数组的命令，将在最前面的维度上翻转元素的顺序
print(a[::-1])
5、改变数组的维度
ravel()方法：完成展平的 *** 作。
a = np.arange(24).reshape(2, 3, 4)
print(a)
print(a.ravel())
flatten()方法：与ravel函数的功能相同。不过，flatten函数会请求分配内存来保存结果，而ravel函数只是返回数组的一个视图。
a = np.arange(24).reshape(2, 3, 4)
print(a)
print(a.flatten())
shape属性：用元组设置维度，除了可以使用reshape函数，还可以直接用一个正整数元组来设置数组的维度。
a = np.arange(24).reshape(2, 3, 4)
print(a)
a.shape = (3, 8)
print(a)
b = a.reshape(4,2,3)
print(b)
transpose()方法：在线性代数中，转置矩阵是很常见的 *** 作。
a = np.arange(24).reshape(2, 3, 4)
a.shape = (3, 8)
print(a)
print(a.transpose())
resize()方法：resize和reshape函数的功能一样，但resize会直接修改所 *** 作的数组。
a = np.arange(24).reshape(2, 3, 4)
print(a)
a.resize((2, 12))
print(a)
6、数组的组合
NumPy数组有水平组合、垂直组合和深度组合等多种组合方式，使用vstack、 dstack、hstack、column_stack、row_stack以及concatenate函数来完成数组的组合。
import numpy as np
a = np.arange(12).reshape(3, 4)
b = a ** 3
print(a)
print(b)
# 水平组合
c1 = np.hstack((a, b))
print(c)
c2 = np.concatenate((a, b), axis=1)
print(c2)
# 垂直组合
d1 = np.vstack((a, b))
print(d1)
d2 = np.concatenate((a, b), axis=0)
print(d2)
深度组合：将相同的元组作为参数传给dstack函数，即可完成数组的深度组合。所谓深度组合，就是将一系列数组沿着纵轴(深度)方向进行层叠组合。
e = np.dstack((a, b))
print(e)
列组合：column_stack()函数
# 对于一维数组将按列方向进行组合。
a1 = np.arange(2)
a2 = a1 * 2
print(a1)
print(a2)
a3 = np.column_stack((a1, a2))
print(a3)
# 对于二维数组，column_stack与hstack的效果是相同的
a = np.arange(12).reshape(3, 4)
b = a ** 3
c1 = np.column_stack((a, b))
c2 = np.hstack((a, b))
print(c1)
print(c2)
c1 == c2
行组合：row_stack()函数
# 对于两个一维数组，将直接层叠起来组合成一个二维数组
a1 = np.arange(2)
a2 = a1 * 2
print(a1)
print(a2)
a3 = np.row_stack((a1, a2))
print(a3)
#对于二维数组，row_stack与vstack的效果是相同的
a = np.arange(12).reshape(3, 4)
b = a ** 3
c1 = np.row_stack((a, b))
c2 = np.vstack((a, b))
print(c1)
print(c2)
c1 == c2
7、数组的分割
NumPy数组可以进行水平、垂直或深度分割，相关的函数有hsplit、vsplit、dsplit和split。可以将数组分割成相同大小的子数组，也可以指定原数组中需要分割的位置。
# 水平分割
a = np.arange(12).reshape(3, 4)
print(a)
b1 = np.hsplit(a, 4) # 把数组沿着水平方向分割为3个相同大小的子数组
print(b1)
b2 = np.split(a, 4, axis=1) # 把数组沿着水平方向分割为3个相同大小的子数组
print(b2)
# 垂直分割
a = np.arange(12).reshape(3, 4)
print(a)
b1 = np.vsplit(a, 3)
print(b1)
b2 = np.split(a, 3, axis=0)
# 深度分割
a = np.arange(27).reshape(3,3,3)
print(a)
b = np.dsplit(a,3)
print(b)
8、数组的属性
除了shape和dtype属性以外，ndarray对象还有很多其他的属性。
a = np.arange(12).reshape(2, 2, 3)
print(a)
print(a.ndim) # ndim属性，给出数组的维数，或数组轴的个数
print(a.size) # size属性，给出数组元素的总个数
print(a.dtype.itemsize) # itemsize属性，给出数组中的元素在内存中所占的字节数
print(a.nbytes) # 用nbytes属性来查看整个数组所占的存储空间
print(a.size * a.dtype.itemsize)
a.resize(3, 4) # T属性的效果和transpose函数一样
print(a)
print(a.T)
a = np.array([1+1.j, 3+2.j]) # 在NumPy中，复数的虚部是用j表示的
print(a)
print(a.real) # real属性，给出复数数组的实部
print(a.imag) # imag属性，给出复数数组的虚部
print(a.dtype)
print(a.dtype.str)
a = np.array([1+1.j, 3+2.j])
print(a)
print(a.dtype)
b1 = a.tolist() # 转换成列表
print(b1)
print(type(b1))
a = np.array([1.+1.j, 3.+2.j])
print(a)
print(a.astype(int))
print(a.astype('complex'))
小结
对于数组而言， 有很多属性可以用来描述数组，数据类型就是其中之一。在NumPy中，数组的数据类型是用对象来完善表示的。类似于Python列表，NumPy数组也可以方便地进行切片和索引 *** 作。在多维数组上，NumPy有明显的优势。涉及改变数组维度的 *** 作有很多种——组合、调整、设置维度和分割等。
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）