numpy基础
1、数组
1)用np.ndarray类的对象表示n维数组
实际数据：数组中元素
元数据：描述数组中的元素
将实际数据与元数据分开存放，一方面提高了内存空间的使用效率，另一方面减少对实际数据的访问频率，提高性能
2)Numpy数组是同质数组，即所有元素的数据类型必须相同，类似c语言的数组
3)Numpy数组的下标从0开始，最后一个元素的下标为数组长度减1
4)np.ndarray.dtype/shape/size：类型/维度/大小
5)np.arange(起始值(0),终止值,步长(1))->等差序列
np.array(任何可被解释为Numpy数组的逻辑结构)
->任意维度和类型的数组对象
xx,shape，获取数组的维度，比如[[1,2],[3,4]]为2,2，输出为(2,2)
xx.size，占用的内存空间长度
len(xx)只会获取最外维度的元素个数
xx.type，返回数组的类型，参见下方
import numpy as np
a = np.arange(1, 10)
print(a, type(a[0]), a.dtype)
b = a.astype(float)
print(b, type(b[0]), b.dtype)
c = b.astype(str)
print(c, type(c[0]), c.dtype)
a = np.array([[10, 20, 30],
[40, 50, 60]])
print(a.shape, a.size, len(a))
b = a.reshape((6,))
print(b.shape, b.size, len(b))
c = b.reshape((3, 2))
print(c.shape, c.size, len(c))
d = np.arange(1, 25).reshape((2, 3, 4))
print(d.shape, d.size, len(d))
6)元素索引(下标)
多维数组对象：[..., 页号, 行号, 列号]
数组对象.shape->(..., 页数, 行数, 列数)
X号：[0, X数-1]
多维数组的引用可以通过a[1,2,3]方式的到数值，而不仅限于a[1][2][3]，建议使用numpy的数组的时候均使用前者，因为后面涉及到矩阵或者行列式替换的时候用后者会报错，导致学者思维混乱。
import numpy as np
a = np.array([[[1, 2],
[3, 4]],
[[5, 6],
[7, 8]]])
print(a, a.shape)
print(a[0])
print(a[0][0])
print(a[0][0][0])
print(a[0, 0, 0])
for i in range(a.shape[0]):
for j in range(a.shape[1]):
for k in range(a.shape[2]):
print(a[i, j, k])
结果：
[[[1 2]
[3 4]]
[[5 6]
[7 8]]] (2, 2, 2)
[[1 2]
[3 4]]
[1 2]
1
1
1
2
3
4
5
6
7
8
7)Numpy的内部基本数据类型
布尔型：bool_
整数型：
有符号：int8(-128~127)/int16/int32/int64
无符号：uint8(0~255)/uint16/uint32/uint64
浮点型：float16/float32/float64
复数型：complex64/complex128
字串型：str_，每个字符用32位Unicode编码表示
8)自定义复合类型（重点，在音频处理、数据传输等会使用到）
总的来说，复合类型的结构定义比较混乱。需要的时候查，可以写一个类，定义自己能理解的方法。类型字符码在下方。
import numpy as np
# 将两种不同格式数据放在一起，使用小括号括在一起表示其为一个整体，用dtype设置他们各自的所属类型
#大写U为字符串，3位三个字符，3i4为三个4字节（int32）的有符号整数
a = np.array([('123', [4, 5, 6])],
dtype='U3, 3i4')
print(a[0]['f0'], a[0]['f1'])
# 上面方法的另一种表示
b = np.array([('123', [4, 5, 6])],
dtype=[('fa', np.str_, 3),
('fb', np.int32, 3)])
print(b[0]['fa'], b[0]['fb'])
#如果不喜欢f0,也可以自定义名字，在多条数据结合的时候挺有用。
c = np.array([('123', [4, 5, 6])],
dtype={'names': ['fa', 'fb'],
'formats': ['U3', '3i4']})
print(c[0]['fa'], c[0]['fb'], c.itemsize)
#通过设置数据起点的位置，可以在数据之间插入空白，方便后期修改数据，长度不够会覆盖后面别的数据条。
d = np.array([('123', [4, 5, 6])],
dtype={'fa': ('U3', 0),
'fb': ('3i4', 16)})
print(d[0]['fa'], d[0]['fb'], d.itemsize)
#也可以有两种及以上数据的结构表述方式。
e = np.array([0x1234],
dtype=('>u2', {'lo': ('u1', 0),
'hi': ('u1', 1)}))
#我也忘记这啥输出结构了。。
print('{:x}'.format(e[0]))
print('{:x} {:x}'.format(e['lo'][0], e['hi'][0]))
结果：
123 [4 5 6]123 [4 5 6]
123 [4 5 6] 24
123 [4 5 6] 28
1234
12 34
9)类型字符码
np.bool_: ?
np.int8: b
np.uint8: B
np.int8/16/32/64: i1/2/4/8
np.uint8/16/32/64: u1/2/4/8
np.float/16/32/64: f2/4/8
np.complex64/128: c8/16
np.str_: U<字符数>
np.datetime64: M8
字节序前缀，用于多字节整数和字符串：
</>/[=]分别表示小端/大端/硬件字节序。
<字节序前缀><维度><类型><字节数或字符数>
>3i4：大端字节序，3个元素的一维数组，每个元素都是整型，每个整型元素占4个字节。
<(2,3)u8：小端字节序，6个元素2行3列的二维数组，每个元素都是无符号整型，每个无符号整型元素占8个字节。
>U7: 包含7个字符的Unicode字符串，每个字符占4个字节，采用大端字节序。
10)切片
这里就是为什么我强调习惯使用[a,b,v]的原因：使用切片的时候只能在一个括号内使用。系统自带列表则不能这么用，只能[][][]这样用，在这里切片。
系统的自带列表多维数组切片
>>> a=[[1,2,3],[4,5,6]]
>>> a[0:1][1:3]
[]
>>> a
[[1, 2, 3], [4, 5, 6]]
>>> a[0:1]
[[1, 2, 3]]
>>> a[0:1,1:3]
Traceback (most recent call last):
File "<pyshell#4>", line 1, in <module>
a[0:1,1:3]
TypeError: list indices must be integers or slices, not tuple
>>> a[0:1][1:2]
[]
>>> a[0:1][1]
Traceback (most recent call last):
File "<pyshell#6>", line 1, in <module>
a[0:1][1]
IndexError: list index out of range
>>> a[0:1]
[[1, 2, 3]] #注意这里是一个列表中的列表
>>> a[0:1][0][1:3]
[2, 3]
>>> np的数组对象[起始位置:终止位置:位置步长, ...]
缺省起始位置：(位置步长+)首/(位置步长-)尾
缺省终止位置：(位置步长+)尾后/(位置步长-)首前
缺省位置步长：1
import numpy as np
# 将一维转换为三维
b = np.arange(1, 25).reshape(2, 3, 4)
print(b)
[[[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]]
[[13 14 15 16]
[17 18 19 20]
[21 22 23 24]]]
print(b[:, 0, 0]) # 1 13
print(b[0])
print(b[0, :, :])
print(b[0, ...])
[[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]]
print(b[0, 1]) # 5 6 7 8
print(b[0, 1, ::2]) # 5 7
print(b[..., 1])
[[ 2 6 10]
[14 18 22]]
print(b[:, 1])#注意区别，上一个是切了两次，这一个只有一次，所以这个1是第二维度，上一个一时第三#维度
[[ 5 6 7 8]
[17 18 19 20]]
print(b[0, 1, 1::2]) # 6 8
print(b[0, :, -1]) # 4 8 12
print(b[0, ::-1, -1]) # 12 8 4
print(b[0, ::2, -1]) # 4 12
print(b[::-1, ::-1])#页和行反转
[[[21 22 23 24]
[17 18 19 20]
[13 14 15 16]]
[[ 9 10 11 12]
[ 5 6 7 8]
[ 1 2 3 4]]]
print(b[..., ::-1])#列翻转
[[[ 4 3 2 1]
[ 8 7 6 5]
[12 11 10 9]]
[[16 15 14 13]
[20 19 18 17]
[24 23 22 21]]]
print(b[-1, 1:, 2:])
[[19 20]
[23 24]]
11)改变维度
视图变维 \ reshape/ravel / 数据共享
> 返回一个具有新维度的新数组对象 <
复制变维 / flatten \ 数据独立
就地变维 --- 在原数组对象之上，改变其维度，不返回新数组
xxx.shape = ...
xxx.resize(...)
#此处就不分析了，唯一需要注意的就是浅拷贝和深拷贝问题复制变维是深拷贝，也可以用a.copy()深拷贝
import numpy as np
a = np.arange(1, 9)
print(a)
b = a.reshape(2, 4)
print(b)
c = b.reshape(2, 2, 2)
print(c)
d = c.ravel()
print(d)
e = c.flatten()
print(e)
a += 10
print(a, b, c, d, e, sep='\n')
a.shape = (2, 4)
print(a)
a.resize(2, 2, 2)
print(a)
f = b.transpose()
print(f)
a -= 10
print(f)
12)组合与拆分
stack结构的为组合生成新维度，如果设置维度为0，则组合物为列维度，源数组为行维度。
维度排序：（每增加一个维度，就向上加一）
0列
1行
2页
np.arange生成的一维数组。axis=0，表示上下组合。axis=1，表示左右组合，axis=2，表示前后组合。组合维度最多只能比当前维度大一。及一维只能取0,1，二维可以取0,1,2
>>> import numpy as np
>>> a=np.arange(0,3)
>>> b=np.arange(3,6)
>>> np.stack((a,b),axis=0)
array([[0, 1, 2],
[3, 4, 5]])
>>> np.stack((a,b),axis=1)
array([[0, 3],
[1, 4],
[2, 5]])
未完concatenate为组合到现有维度
垂直：
np.vstack((上, 下))->组合数组
np.concatenate((上, 下), axis=0)
/ 二维：0-行，垂直，1-列，水平
axis表示轴向 <
\ 三维：0-页，深度，1-行，垂直，2-列，水平
np.vsplit(数组, 份数)->上, ..., 下
np.split(数组, 份数, axis=0)
水平
np.hstack((左, 右))->组合数组
np.concatenate((左, 右), axis=1)
np.hsplit(数组, 份数)->左, ..., 右
np.split(数组, 份数, axis=1)
深度
np.dstack((前, 后))->组合数组
np.dsplit(数组, 份数)->前, ..., 后
行列(可以用一维数组做参数)
np.row_stack((上, 下))->组合数组
np.column_stack((左, 右))->组合数组
代码：stack.py
13)ndarray类的属性
shape - 维度
dtype - 元素类型
size - 元素数量
ndim - 维数，len(shape)
itemsize - 元素字节数
nbytes - 总字节数 = size x itemsize
real - 复数数组的实部数组
imag - 复数数组的虚部数组
T - 数组对象的转置视图
flat - 扁平迭代器
代码：attr.py
数组对象.tolist()->列表
扫一扫
807
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
