数据类型
1.数据类型之间的转换
- 5种基本类型：bool、int、uint、float、复数。
- int32代表32位整型
- 在创建时指定类型的两种方式，直接类型 or 类型字符。
astype 改变数组的类型
直接a.dtype获取数组类型
>>> import numpy as np
>>> a=np.arange(12,dtype=float)
>>> a
array([ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11.])
>>> a=np.arange(12,dtype='i')
>>> a
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], dtype=int32)
>>> a.dtype
dtype('int32')
>>> a.astype('float')
array([ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11.])
2.数组标量
- NumPy通常将数组元素作为数组标量返回（带有关联dtype的标量
3.溢出错误
- 当值需要比数据类型中的可用内存更多的内存时，NumPy数值类型的固定大小可能会导致溢出错误
#100的8次方超出32位存储空间
>>> np.power(100, 8, dtype=np.int64)
10000000000000000
>>> np.power(100, 8, dtype=np.int32)
1874919424
- Python中的int大小是灵活的，不会溢出。
- Numpy提供numpy.iinfo和numpy.finfo验证NumPy整数和浮点值的最小值或最大值
>>> np.finfo(float)
finfo(resolution=1e-15, min=-1.7976931348623157e+308, max=1.7976931348623157e+308, dtype=float64)
>>> np.iinfo(int)
iinfo(min=-2147483648, max=2147483647, dtype=int32)
>>> np.iinfo(np.int64)
iinfo(min=-9223372036854775808, max=9223372036854775807, dtype=int64)
如果64位整数仍然太小，则结果可能会转换为浮点数。浮点数提供了更大但不精确的可能值范围。
np.power(100,100,dtype=np.float64)
扩展精度
- 为了有效地进行内存的校准，np.longdouble通常以零位进行填充，即96或者128位， 哪个更有效率取决于硬件和开发环境；通常在32位系统上它们被填充到96位，而在64位系统上它们通常被填充到128位。
- 尽管它们的名称是这样叫的, 但是np.float96和np.float128只提供与np.longdouble一样的精度, 即大多数x86机器上的80位和标准Windows版本中的64位。
创建数组
1. 从其他Python结构（例如，列表，元组）转换
>>> a=np.array((1,2,3,4))
>>> a
array([1, 2, 3, 4])
>>> b=np.array([5,6,2])
>>> b
array([5, 6, 2])
>>> c = np.array([[1,2],(3,4)])
>>> c
array([[1, 2],
[3, 4]])
2. numpy原生数组的创建（例如，arange、ones、zeros等）
np.zeros((n,m)) 填充0
np.ones((n,m)) 填充1
#n,m代表数组的形状
np.linspace(n,m,p)
n为开始，p为结束，m为个数
3. 从磁盘读取数组，无论是标准格式还是自定义格式
- 使用 numpy.fromfile() 函数和 .tofile() 方法直接读取和写入numpy数组
4. 通过使用字符串或缓冲区从原始字节创建数组
5. 使用特殊库函数（例如，random）
Numpy输入与输出
使用genfromtxt导入数据
- genfromtxt执行两个主要的循环。第一个循环以字符串序列转换文件的每一行。第二个循环将每个字符串转换为适当的数据类型
定义输入
- 唯一强制参数是数据的来源
将行拆分为列
delimiter为None的时候，按制表符分割
>>> from io import BytesIO
>>> data = b"1,2,3\n4,5,6"
>>> np.genfromtxt(BytesIO(data),delimiter=",")
array([[1., 2., 3.],
[4., 5., 6.]])
>>> data=b" 1 2 2"
>>> np.genfromtxt(BytesIO(data),delimiter=None)
array([1., 2., 2.])
- delimiter为整数或数组时，可以规定输出的数组中每个列的宽度
>>> data=b"12345\n 3 4\n56 7"
>>> np.genfromtxt(BytesIO(data),delimiter=(3,2))
array([[123., 45.],
[ 3., 4.],
[ 56., 7.]])
#数组第一列宽为3，第二列宽为2
- autostrip参数，为True时可消除每个元素的前导空白和尾随空白
- comments可用于定义标记注释开始的字符串。默认情况下为#
>>> data=b"""#
... #comment
... #comment
... 1.2
... 3.4
... 5.6
... #commeng
... """
>>> np.genfromtxt(BytesIO(data),delimiter='.',comments="#")
array([[1., 2.],
[3., 4.],
[5., 6.]])
- skip_header(n)和skip_footer(n)分别代表从头部和尾部跳过n个行
>>> data = "\n".join(str(i) for i in range(10))
>>> np.genfromtxt(BytesIO(data),)
array([ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])
>>> np.genfromtxt(BytesIO(data),
... skip_header=3, skip_footer=5)
array([ 3., 4.])
- usecols参数，截取部分列
>>> data = "1 2 3\n4 5 6"
>>> np.genfromtxt(BytesIO(data), usecols=(0, -1))
array([[ 1., 3.],
[ 4., 6.]])
#获取第一列和最后一列
设置名称
- names参数，给列指定名称，可以用对应的列名来用usecols选出列。
>>> data=b"1 2 3\n4 5 6"
>>> np.genfromtxt(BytesIO(data),names="a,b,c",usecols=("a","c"))
array([(1., 3.), (4., 6.)], dtype=[('a', '>> np.genfromtxt(BytesIO(data),usecols=(0,-1))
array([[1., 3.],
[4., 6.]])
- 从数据本身定义列名，使用names关键字的值为True。这些名字将从第一行（在skip_header之后）被读取。
- 在函数中names参数具有最高优先级，优于其他方式定义的名称
- defaultfmt参数
当names为None，默认为f0，f1等等。或names不够时，也是如此。
defaultfmt覆盖默认值
例：defaultfmt=“var_%i” - deletechars 删除列表
- excludelist 排除列表
- case_sensitive 大小写
选择数据的类型
接受一个dtype参数设置数据类型
- 一个包含两个键'names'和'formats'的字典。
- 现有的numpy.dtype对象。
- 特殊值None。在这种情况下，列的类型将根据数据本身确定（见下文）。
- 以下四点见代码
>>> np.genfromtxt(BytesIO(data),usecols=(0,-1),dtype=int)
array([[1, 3],
[4, 6]])
>>> np.genfromtxt(BytesIO(data),usecols=(0,-1),dtype='i4')
array([[1, 3],
[4, 6]])
>>> np.genfromtxt(BytesIO(data),names="a,b,c",dtype=[('a',int),('b',float)])
array([(1, 2.), (4, 5.)], dtype=[('a', '>> np.genfromtxt(BytesIO(data),names="a,b,c",dtype=(int,float,float))
array([(1, 2., 3.), (4, 5., 6.)],
dtype=[('a', ' 除直接的dtype=int之外，其他的返回的都是一个带有结构化dtype的一维数组。
调整转换
- converters定义转换函数。
converters参数必须是一个字典。
>>> data=b"1,2,3\n4,5,6\n"
>>> names="a,b,c"
>>> np.genfromtxt(BytesIO(data))
array([nan, nan])
>>> np.genfromtxt(BytesIO(data),delimiter=',')
array([[1., 2., 3.],
[4., 5., 6.]])
>>> np.genfromtxt(BytesIO(data),delimiter=',',names=names)
array([(1., 2., 3.), (4., 5., 6.)],
dtype=[('a', '>> def func(x):
... return '0'
...
>>>
np.genfromtxt(BytesIO(data),delimiter=',',dtype=int,names=names,converters={'b':func})
array([(1, 0, 3), (4, 0, 6)],
dtype=[('a', ' - missing_values 和filling_values分别代表丢失值和为丢失值设定的值
- usemask，布尔掩码，True为缺失
索引
切片索引
>>> y = np.arange(35).reshape(5,7)
>>> y
array([[ 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, 27],
[28, 29, 30, 31, 32, 33, 34]])
>>> y[1:5:2,::3]
array([[ 7, 10, 13],
[21, 24, 27]])
索引数组
>>> x = np.arange(10,1,-1)
>>> x
array([10, 9, 8, 7, 6, 5, 4, 3, 2])
>>> x[np.array([3, 3, 1, 8])]
array([7, 7, 9, 2])
索引多维数组
>>> y[np.array([0,2,4]), np.array([0,1,2])]
array([ 0, 15, 30])
在这种情况下，如果索引数组具有匹配的形状，并且索引数组的每个维度都有一个索引数组，则结果数组具有与索引数组相同的形状
>>> y[np.array([0,2,4]), np.array([0,1])]
: shape mismatch: objects cannot be
broadcast to a single shape
如果索引数组的形状不同，则尝试将它们广播为相同的形状。如果它们无法广播到相同的形状，则会引发异常
>>> y[np.array([0,2,4]), 1]
array([ 1, 15, 29])
广播机制允许索引数组与其他索引的标量组合
- 可以仅使用索引数组对数组进行部分索引
>>> y[np.array([0,2,4])]
array([[ 0, 1, 2, 3, 4, 5, 6],
[14, 15, 16, 17, 18, 19, 20],
[28, 29, 30, 31, 32, 33, 34]])
布尔或掩码索引数组
- 布尔数组做索引返回的是一维数组
>>> b = y>20
>>> y[b]
array([21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34])
>>> b[:,5]
array([False, False, False, True, True])
>>> y[b[:,5]]
array([[21, 22, 23, 24, 25, 26, 27],
[28, 29, 30, 31, 32, 33, 34]])
#此时的b[:,5]相当于【3，4】
- 布尔索引要和被索引数组的形状完全相同才能索引到每一个元素。
如果布尔索引少一个维度，那么对数组进行索引时的最小单位就上升一个维度。
>>> x
array([[[ 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, 27, 28, 29]]])
>>> a=np.array([True,True,False,True,False])
>>> a
array([ True, True, False, True, False])
>>> b=np.array([[a,a,a],[a,a,a]])
>>> b
array([[[ True, True, False, True, False],
[ True, True, False, True, False],
[ True, True, False, True, False]],
[[ True, True, False, True, False],
[ True, True, False, True, False],
[ True, True, False, True, False]]])
>>> x[b]
array([ 0, 1, 3, 5, 6, 8, 10, 11, 13, 15, 16, 18, 20, 21, 23, 25, 26,
28])
在程序中使用索引
- slice 切片
- Ellipsis 省略号
>>> indices = (1,1,1,1)
>>> z[indices]
40
>>> indices = (1,1,1,slice(0,2)) # same as [1,1,1,0:2]
>>> z[indices]
array([39, 40])
>>> indices = (1, Ellipsis, 1) # same as [1,...,1]
>>> z[indices]
array([[28, 31, 34],
[37, 40, 43],
[46, 49, 52]])
广播
术语广播（Broadcasting）描述了 numpy 如何在算术运算期间处理具有不同形状的数组
- 当一个数组和一个标量值在一个操作中组合时，会发生最简单的广播
>>> a = np.array([1.0, 2.0, 3.0])
>>> b = 2.0
>>> a * b
array([ 2., 4., 6.])
一般广播规则
在两个数组上运行时，NumPy会逐元素地比较它们的形状。它从尾随尺寸开始，并向前发展。两个尺寸兼容时
1.他们是平等的，或者
2.其中一个是1
- 平等的意味着
1.有相同的形状
2.最外围的元素个数相同
例：a和b最外围都是3个
>>> import numpy as np
>>> a=np.array([[1,2,3],[3,4,5],[5,6,7]])
>>> b=np.array([1,2,3]),
>>> a*b
array([[ 1, 4, 9],
[ 3, 8, 15],
[ 5, 12, 21]])
- 各种情况
A (2d array): 5 x 4
B (1d array): 1
Result (2d array): 5 x 4
A (2d array): 5 x 4
B (1d array): 4
Result (2d array): 5 x 4
A (3d array): 15 x 3 x 5
B (3d array): 15 x 1 x 5
Result (3d array): 15 x 3 x 5
A (3d array): 15 x 3 x 5
B (2d array): 3 x 5
Result (3d array): 15 x 3 x 5
A (3d array): 15 x 3 x 5
B (2d array): 3 x 1
Result (3d array): 15 x 3 x 5
>>> x = np.arange(4)
>>> xx = x.reshape(4,1)
>>> y = np.ones(5)
>>> z = np.ones((3,4))
>>> x.shape
(4,)
>>> y.shape
(5,)
>>> x + y
ValueError: operands could not be broadcast together with shapes (4,) (5,)
>>> xx.shape
(4, 1)
>>> y.shape
(5,)
>>> (xx + y).shape
(4, 5)
>>> xx + y
array([[ 1., 1., 1., 1., 1.],
[ 2., 2., 2., 2., 2.],
[ 3., 3., 3., 3., 3.],
[ 4., 4., 4., 4., 4.]])
>>> x.shape
(4,)
>>> z.shape
(3, 4)
>>> (x + z).shape
(3, 4)
>>> x + z
array([[ 1., 2., 3., 4.],
[ 1., 2., 3., 4.],
[ 1., 2., 3., 4.]])
>>> a = np.array([0.0, 10.0, 20.0, 30.0])
>>> b = np.array([1.0, 2.0, 3.0])
>>> a[:, np.newaxis] + b
array([[ 1., 2., 3.],
[ 11., 12., 13.],
[ 21., 22., 23.],
[ 31., 32., 33.]])
字节交换
字节排序和ndarrays
ndarray是一个为内存中的数据提供python数组接口的对象
- 关于一些2字节整数与4字节整数之间的转换之类的。
- 更改数组dtype中的字节顺序信息，以便将基础数据解释为不同的字节顺序。这是作用 arr.newbyteorder()
- 更改基础数据的字节顺序，保留dtype解释。这是做什么的 arr.byteswap()
- dtype参数很重要
结构化数组
- 结构化数组，ndarray。包含dtype，一个一维数组，元素是元组。
>>> import numpy as np
>>> x = np.array([('李栋良',22,84),('Daenerys',22,55)],
... dtype=[('name','U10'),('age','i4'),('weight','f4')]
...
...
... )
>>> x
array([('李栋良', 22, 84.), ('Daenerys', 22, 55.)],
dtype=[('name', '>> x[name]
Traceback (most recent call last):
File "", line 1, in
NameError: name 'name' is not defined
>>> x['name']
array(['李栋良', 'Daenerys'], dtype='>> x['age']=23
>>> x
array([('李栋良', 23, 84.), ('Daenerys', 23, 55.)],
dtype=[('name', '>> x['weight'][1]=54
>>> x
array([('李栋良', 23, 84.), ('Daenerys', 23, 54.)],
dtype=[('name', ' 结构化数据类型创建
- 元组列表的形式，shape是可选的
np.dtype([('x', 'f4'), ('y', np.float32), ('z', 'f4', (2, 2))]) - 逗号分隔，字段名称被赋予默认名称 f0、f1等
np.dtype('i8, f4, S3')
dtype([('f0', '- 字段参数组字典
字典有两个必需键 “names” 和 “format”，以及四个可选键 “offsets”、“itemsize”、“Aligned” 和 “title”。 - 字段参数组字典
>>> np.dtype({'names':['A','B'],'formats':['i4','f4']})
dtype([('A', '可以通过names使用相同长度的字符串序列分配属性来修改字段名称。
dtype对象还具有类似字典的属性，fields其键是字段名称， 其值是包含每个字段的dtype和字节偏移量的元组。
>>> d.fields
mappingproxy({'x': (dtype('int64'), 0), 'y': (dtype('float32'), 8)})
- 偏移量指的是内存中的偏移，可以认为指定，也可以自动偏移和对齐。
默认情况下（align=False），numpy将字段打包在一起，使得每个字段从前一个字段结束的字节偏移开始，并且字段在内存中是连续的
>>> d=np.dtype('u1,i8,f4,u2,u1,i4')
>>> d.fields
mappingproxy({'f0': (dtype('uint8'), 0), 'f1': (dtype('int64'), 1), 'f2': (dtype('float32'), 9), 'f3': (dtype('uint16'), 13), 'f4': (dtype('uint8'), 15), 'f5': (dtype('int32'), 16)})
>>> [d.fields[name][1] for name in d.names]
[0, 1, 9, 13, 15, 16]
- 如果align=True设置了，numpy将以与许多C编译器填充C结构相同的方式填充结构
>>> d=np.dtype('u1,i8,f4,u2,u1,i4',align=True)
>>> [d.fields[name][1] for name in d.names]
[0, 8, 16, 20, 22, 24]
索引和分配给结构化数组
- 使用元组赋值
- 使用标量赋值，会将标量分配给所有字段
>>> x=np.array(2,dtype='i4,u1')
>>> x
array((2, 2), dtype=[('f0', '- 来自其他结构化数组的赋值是可以的。但是具有不同数量的字段的结构化数组不能彼此分配
索引
- 使用名称索引和修改
- 访问的字段是子数组，则子数组的维度将附加到结果的形状
>>> x = np.zeros((2, 2), dtype=[('a', np.int32), ('b', np.float64, (3, 3))])
>>> x
array([[(0, [[0., 0., 0.], [0., 0., 0.], [0., 0., 0.]]),
(0, [[0., 0., 0.], [0., 0., 0.], [0., 0., 0.]])],
[(0, [[0., 0., 0.], [0., 0., 0.], [0., 0., 0.]]),
(0, [[0., 0., 0.], [0., 0., 0.], [0., 0., 0.]])]],
dtype=[('a', '>> x['a'].shape
(2, 2)
>>> x['b'].shape
(2, 2, 3, 3)
- 结构化数组中的名称可看作列名
>>> a=np.zeros(3)
>>> a
array([0., 0., 0.])
>>> a=np.zeros(3, dtype=[('a', 'i4'), ('b', 'i4'), ('c', 'f4')])
>>> a
array([(0, 0, 0.), (0, 0, 0.), (0, 0, 0.)],
dtype=[('a', '>> a[['a','c']]
array([(0, 0.), (0, 0.), (0, 0.)],
dtype={'names':['a','c'], 'formats':[' - 使用整数进行索引获得结构化标量，获得的结构化标量也像视图一样，进行修改会修改原数组
结构比较
>>> a=np.ones(2,dtype='i4,u1')
>>> a
array([(1, 1), (1, 1)], dtype=[('f0', '>> b=np.ones(2,dtype='i4,u1')
>>> a==b
array([ True, True])
记录数组
- 记录数组允许暗属性访问结构化数组的字段