numpy类型入门
import numpy库后，通过numpy参数操作示例
python
import numpy as np
# 创建ndarray，通过list创建
a = np.array([1, 2, 3])
print(a)[1 2 3]
python
# 通过元组创建ndarray，并指定数据类型为float (此处是python的float类型，不是numpy的float类型)
b = np.array((2, 3, 4), dtype=float)
print("值", b, ", 类型", b.dtype)值 [2. 3. 4.] , 类型 float64
python
# 创建复数类型
c = np.array([1+2j, 3+4j, 5+6j])
print("value:", c, ", type:", c.dtype)value: [1.+2.j 3.+4.j 5.+6.j] , type: complex128
python
d = np.array(["你好", "hello", "world"])
print("value:", d, ", type:", d.dtype)value: ['你好' 'hello' 'world'] , type: <U5
python
f = np.array([b"hello", b'world'])
print("value:", f, ", type:", f.dtype)value: [b'hello' b'world'] , type: |S5数据类型分为python的类型，与numpy的类型
比如：int_, intc, int8, int16, float16...等等。是numpy的数据类型，在使用是需要有numpy前缀
python
type01 = np.array([1, 2, 3], dtype = np.int8)
type01array([1, 2, 3], dtype=int8)小端与大端：存储时数据头尾与内存前后的关系相反
python
dt = np.dtype('<u4') # uint32位，小端存储
g = np.array([1, 2, 3], dtype = dt)
print(g, g.dtype)[1 2 3] uint32通过astype()可以转换array元素的数据类型，如果转换类型不兼容会报错
python
h = np.array(["1", "2.3", "4.5"])
ht = h.astype("f4") # f4: float32
htarray([1. , 2.3, 4.5], dtype=float32)3. numpy中的几种数组函数
numpy中数组的3个基础函数
- arange 数列
- linspace 线性等分向量，等差数列
- logspace 对数等分向量，等比数列
一些基础概念：
- 标量：0维数组
- 向量（矢量）：一维数组
- 矩阵：二维数组
- 张量：三维以上数组
3.3.1 使用arange函数
arange函数创建数值范围并返回数组对象，与python中range函数类似。语法格式如下：
python
numpy.arange([start,] stop, [step,] dtype=None)- start：开始值，可以省略，默认为0， 开始值包含在数组里
- stop：结束值，不包含在数组里
- step：步长，默认值为1，步长可以是负数，表示递减
- dtype：数组元素类型
python
a = np.arange(10)
aarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
python
a = np.arange(1, 10, 2)
aarray([1, 3, 5, 7, 9])
python
a = np.arange(1, -10, -3, dtype=np.float32)
aarray([ 1., -2., -5., -8.], dtype=float32)3.3.2 等差数列与linspace函数
linsapce函数创建等差数列，语法格式如下：
python
numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)- start：开始值，包含
- stop：结束值，默认包含，通过endpoint可以调整是否包含
- num：生成元素个数
- endpoint：是否包含stop
- retstep：是否返回步长（公差），False不返回，True返回。设置为True时，函数返回值是二元数组（数组，步长）
python
a = np.linspace(0, 10, 10)
aarray([ 0. , 1.11111111, 2.22222222, 3.33333333, 4.44444444,
5.55555556, 6.66666667, 7.77777778, 8.88888889, 10. ])
python
a = np.linspace(0, 10, 10, retstep=True)
a(array([ 0. , 1.11111111, 2.22222222, 3.33333333, 4.44444444,
5.55555556, 6.66666667, 7.77777778, 8.88888889, 10. ]),
1.1111111111111112)当retstep=True时，函数返回内容为二元数组，第一个元素是等差数列，第二个元素是步长
python
a[1]1.11111111111111123.3.3 等比数列与logspace函数
python
numpy.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)- start：开始值，base ** start，base的start次幂
- stop：结束值，base ** stop， base的stop次幂
- base：底数，默认以10为底
- num：生成元素个数
- endpoint：是否包含stop
python
a = np.logspace(0, 9, 10)
aarray([1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04, 1.e+05, 1.e+06, 1.e+07,
1.e+08, 1.e+09])1e+1：1乘以10的1次方
ne+x: n乘以10的x次方
python
a = np.logspace(0, 9, 10, base=2)
aarray([ 1., 2., 4., 8., 16., 32., 64., 128., 256., 512.])3.3.4 练习
- 从给定数组里获取奇数
python
import numpy as np
arr = np.array([1, 2, 3, 4, 5])
arr2 = arr[arr % 2 == 1]
arr2array([1, 3, 5])- 创建介于2.5到6.5之间的30个均匀间隔元素的一维数组，包括6.5
python
arr = np.linspace(2.5, 6.5, num=30, endpoint=True, retstep=True)
arr(array([2.5 , 2.63793103, 2.77586207, 2.9137931 , 3.05172414,
3.18965517, 3.32758621, 3.46551724, 3.60344828, 3.74137931,
3.87931034, 4.01724138, 4.15517241, 4.29310345, 4.43103448,
4.56896552, 4.70689655, 4.84482759, 4.98275862, 5.12068966,
5.25862069, 5.39655172, 5.53448276, 5.67241379, 5.81034483,
5.94827586, 6.0862069 , 6.22413793, 6.36206897, 6.5 ]),
0.13793103448275862)4. 二维数组
4.1 创建二位数组
python
a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
aarray([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])4.2 重新设置维度
shape属性可以返回数组的形状，简单理解为：几乘几
python
a.shape(3, 3)
python
数组对象的reshape方法可以修改数组形状
python
a = np.arange(0, 10)
print("a:", a)
# 将一维数组设置成2行5列的二维数组
a = a.reshape(2, 5)
print("a reshape:", a)
b = np.arange(0, 27)
print("b:", b)
# 将一维数组b reshape成3*3*3的三维数组
b = b.reshape(3, 3, 3)
print("b reshape:", b)a: [0 1 2 3 4 5 6 7 8 9]
a reshape: [[0 1 2 3 4]
[5 6 7 8 9]]
b: [ 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]
b reshape: [[[ 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]]]4.3 更多创建二维数组的方式
- ones：创建元素都是1的数组
- zeros：创建元素都是0的数组
- empty
- full
- eye , identity
4.3.1 ones函数根据指定的形状和数据类型生成全为1的数组，语法如下：
python
numpy.ones(shape, dtype=None)dtype不指定时，float
python
a = np.ones((2, 3))
aarray([[1., 1., 1.],
[1., 1., 1.]])
python
a = np.ones((2, 3), dtype=np.int32)
aarray([[1, 1, 1],
[1, 1, 1]])4.3.2 zeros函数，与ones用法类似，区别在于元素值是0
4.3.2 empty函数，与ones用法类似，区别在于元素值是未初始化的
未初始化：内存里保存的是原始值，可能是空，也可能是上一次操作后保留在内存里的值
python
e = np.empty((2, 3))
earray([[0., 0., 0.],
[0., 0., 0.]])
python
e = np.empty((3, 7))
earray([[6.23042070e-307, 4.67296746e-307, 1.69121096e-306,
1.29061414e-306, 8.34441742e-308, 8.90104239e-307,
1.33511290e-306],
[1.42417221e-306, 1.60220393e-306, 1.02359848e-306,
3.11525958e-307, 1.69118108e-306, 8.06632139e-308,
1.20160711e-306],
[1.69119330e-306, 1.29062229e-306, 6.89804133e-307,
1.11261162e-306, 8.34443015e-308, 1.42404727e-306,
3.39986383e-317]])
python
上面e = np.empty((3, 7))执行后，e的内容不是0，而是上次内存操作后留下的值3.3.4 full函数
full函数根据指定的形状和数据类型生成数组，并用指定的数据填充，语法格式如下：
python
numpy.full(shape, fill_value, dtype=None)
python
# 创建2行4列，元素value都是10的二维数组
a = np.full((2, 4), 10)
aarray([[10, 10, 10, 10],
[10, 10, 10, 10]])
python
# 创建5个元素的一维数组，每个元素value都是3
a = np.full(5, 3, dtype=np.float32)
aarray([3., 3., 3., 3., 3.], dtype=float32)4.3.5 identity和eye函数
- identity函数用来创建单位矩阵，即：对角线元素为1，其他元素为0的正方形矩阵。
语法格式如下：
python
numpy.identity(n, dtype=None)- eye函数用来创建二维数组，对角线元素为1，其他元素为0，
语法格式如下
python
numpy.eye(N, M=None, k=0, dtype=float)- N：行数
- M：列数，如果省略，则M=N
- k：对角线开始位置的索引，默认是0，主对角线。
- dtype：元素数据类型，默认是float
python
i = np.identity(3)
iarray([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]])
python
e = np.eye(3, 4, 0, dtype=np.int32)
earray([[1, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 1, 0]])4.3.6 二维数组的轴
简单来说，二维数组的行：0轴，二维数组的列：1轴
python
x = np.array([['a', 'b', 'c', 'd', 'e'], ['h', 'i', 'j', 'k', 'l'], ['o', 'p', 'q', 'r', 's']])
xarray([['a', 'b', 'c', 'd', 'e'],
['h', 'i', 'j', 'k', 'l'],
['o', 'p', 'q', 'r', 's']], dtype='<U1')
python
# 通过轴获取二维数组中对应的元素：
x[2, 3]
# 其实就是几行几列'r'4.6 数组转置
数组的T属性可以转置数组，将数组轴的索引倒置。说人话就是行专列，列转行
- 一维数组转置无意义，转置无效果
- 形状为(n, m)，转置后形状为(m, n)
- 数组形状为(a0, a1, ..., an-1, an)，转置后形状为(an, an-1, ..., a1, a0)
python
t1 = np.array([[1, 2, 3], [4, 5, 6]])
t1array([[1, 2, 3],
[4, 5, 6]])
python
# 使用T属性转置多维数组
t1.Tarray([[1, 4],
[2, 5],
[3, 6]])