数据分析常用的第三方库
numpy：数值计算
matplotlib：数据可视化
scipy：科学计算机
pandas：时间和日期序列
1 numpy的基本特点
1）矢量化运算；将包含多个数据的集合作为一个整体参与运算
2）成为几乎所有于数值分析、科学计算以及人工智能有关的功能模块的底层模块
3）性能卓越，运行速度快，绝大部分代码用标准C语言甚至有汇编语言编写
4）数据集合中的元素必须同质，牺牲灵活性换取高性能；注，列表元组里的元素可以不同，但C里面的数组元素必须同质
2 numpy数组
2.1 基本描述
numpy的数组是numpy.ndarray类型（n dimension array 意味n维数组）的对象，用于表示任意维度的数据结构，其维度信息通过shape属性访问
该对象由两部分组成
A）实际数据：数组元素本身（在内存里为一行连续的数据）
B）元数据：对实际数据类型、结构等信息的描述
比如
元素据可能是如下表示方式
base
A B
C
实际的MRO列表为：MRO = [C A B base Object]
有时会出现实际数据是一样的，但是元数据是不一样的。
注：大部分针对数组的操作实际上仅仅是针对其元数据的操作，以此提升性能。
numpy.arange(start, stop, step, dtype)，获得一个数组形式序列，注：包含起始值，但不包含终止值
numpy.array(p_object, dtype, copy, order, subok, ndim)：获得一个包含给定元素的数组对象，注：只要可迭代对象即可
p_object：Union[ndarray, lterable, int, float]
dtype：Optional[object] = None 元素类型
copy：Optional[bool] = True
order：Optional[str] = "K"
subok：Optional[object] = False
ndim：Optional[int] = 0
可简化为
numpy.array([元素1，元素2，...])：参数可以时同质的列表，元组，数组，注：元素之间的类型完全一致，但是元素内部可以由多个类型构成。
d = np.array([ [np.arange(1, 5), np.arange(5, 9), np.arange(9, 13)], [np.arange(13, 17), np.arange(17, 21), np.arange(21, 25)]]) print(d.shape, d, sep='\n')
运行
(2, 3, 4) [[[ 1 2 3 4] [ 5 6 7 8] [ 9 10 11 12]] [[13 14 15 16] [17 18 19 20] [21 22 23 24]]]
注意：
# # 一维数组 one_dim = np.arange(1,5) print(one_dim) # [1 2 3 4] 数据之间没有逗号，而数组的元素之间是用逗号隔开的 print(type(one_dim)) #<class 'numpy.ndarray'>类对象 print(one_dim.dtype) #int32元素的类型，这个数据类型在python中是没有定义的，是numpy库自己定义的 print(one_dim.shape) #(4,)表示4个元素 # 二维数组 two_dim = np.array([ [1,2,3,3], [4,5,6,6], [7,8,9,9]],dtype=float) #float64 [[1. 2. 3. 3.] print(two_dim) # print(type(two_dim)) # <class 'numpy.ndarray'>类对象 print(two_dim.dtype) # int32元素的类型，这个数据类型在python中是没有定义的，是numpy库自己定义的 print(two_dim.shape) # (3,4)表示3行4列 two1_dim = np.array([ [1], [4], [7]]) print(two1_dim) # print(two1_dim.shape) # (3,1)表示3行1列
# 三维数组 three_dim = np.array([ [ np.arange(1,5), np.arange(5,9), np.arange(9,13) ], [ np.arange(13,17), np.arange(17,21), np.arange(21,25), ], [ np.arange(14, 18), np.arange(18, 22), np.arange(22, 26), ]]) print(three_dim) # print(type(three_dim)) # <class 'numpy.ndarray'>类对象 print(three_dim.dtype) # int32元素的类型，这个数据类型在python中是没有定义的，是numpy库自己定义的 print(three_dim.shape) # (3, 3, 4),3页，3行，4列 print(three_dim[1,0,0])
2.2 数组下标
numpy中的数组也可以采用下标访问，其下标也是从0开始
import numpy as np a = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]]) print(a) print('a[0]:',a[0],sep='\n') print('a[0][0]：', a[0][0]) # a[0][0]： [1 2] print('a[0][0][0]：', a[0][0][0]) #a[0][0][0]： 1
运行
[[[1 2] [3 4]] [[5 6] [7 8]]]
a[0]: [[1 2] [3 4]]
a[0][0]： [1 2]
a[0][0][0]： 1
深刻理解shape属性
import numpy as np a = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]]) print(a.shape) #a.shape 结果为(2,2,2)的元组 for i in range(a.shape[0]): #获得a.shape[0]元组中的第1个元素 2 for j in range(a.shape[1]): #获得a.shape[1]元组中的第2个元素 2 for k in range(a.shape[2]): #获得a.shape[2]元组中的第3个元素 2 print(a[i][j][k], a[i, j, k]) #说明a[i][j][k]与a[i, j, k]等价，取出列表中的每一个元素
通过len 或 numpy.ndarray.size获取元素个数；
对于一维数组，size和len是相等的，
对于高维数组，len返回的是第一维的维数，而size返回的是所有维数的乘积。
import numpy as np a = np.array([ [ [1, 2], [3, 4] ], [ [5, 6], [7, 8] ] ]) print("a.shape:",a.shape) #(2, 2, 2) print('a.size:',a.size) #8 print('a.ndim:',a.ndim) #3 print("len(a):",len(a)) #2 b = np.array([[ [ [1, 2], [3, 4] ], [ [5, 6], [7, 8] ], [ [9, 10], [11, 12] ] ]]) print("b.shape:",b.shape) #(1, 3, 2, 2) print('b.size:',b.size) #12 元素个数，b.shape元组中所有元素的乘积 print('b.ndim:',b.ndim) #4 维度，相当于b.shape元组的长度，len(b.shape) print("len(b):",len(b)) #1 只算页数，相当于b.shape[0]
注：为了便于观察，将a b的视图写法略作调整
2.3 维度的改变
数组的维度可以在定义后再做适当调整，reshape 和 shape 。
第一种方法 reshape方法
reshape(新维度)： 不改变数据，注意，reshape()只接受一个参数，当多个参数时可以选用
import numpy as np a = np.arange(1,9) b = a.reshape((2,4)) print('a',a.shape,a,sep='\n') #(8,) [1 2 3 4 5 6 7 8] print('b',b.shape,b,sep='\n') #(2, 4) [[1 2 3 4] # [5 6 7 8]]
具体可以查看print(help(a.reshape)
第二种方法 shape属性
shape = 新维度：这种方法直接修改了所操作
import numpy as np a = np.arange(1, 9) a.shape = (2, 4) # 修改原数组本身 print('a', a.shape, a, sep='\n') #(2, 4) [[1 2 3 4] # [5 6 7 8]]
2.4 数据类型
ndarray对象的dtype属性反映了元素的数据类型，可以通过该属性读取或修改数组元素的数据类型
Object(array).astype(新数据类型) -> 新数组对象
a = np.array([1,2,3,4,5]) print(a.dtype) #int32
当赋值时不添加数据类型时，numpy会自动匹配默认值
也可以指定数据类型
a = np.array([1,2,3,4,5],dtype=np.int8) print(a.dtype) #int8
也可以通过astype对列表的数据类型进行修改
import numpy as np a = np.array([1,2,3,4,5],dtype=np.int8) b = a.astype(float) print(b.dtype) # float64 c = a.astype(str) print(c.dtype,c) #<U4 ['1' '2' '3' '4' '5'] d = b.astype(str) print(d.dtype,d) #<U32 ['1.0' '2.0' '3.0' '4.0' '5.0']
dtype表达方式的多样性
import numpy as np a = np.array([1,2,3,4],dtype=np.int32) b = np.array([1,2,3,4],"int32") c = np.array([1,2,3,4],"i4") print(a.shape,b.shape,c.shape) # (4,) (4,) (4,) 以上三个是等价的
注释：dtype=np.int32 与 ‘int32’ 表达结果相同。“int32” 与 ‘i4’ 相同，参看数据类型
2.5 数据类型
2.5.1 变长类型，长度
a = np.array(['a1b1c1'], dtype=(np.str_, 1)) print(a.dtype, a, a[0]) #<U1 ['a'] a b = np.array(['a1b1c1'], dtype=(np.str_, 2)) print(b.dtype, b, b[0]) #<U2 ['a1'] a1 c = np.array(['a1b1c1'], dtype=(np.str_, 3)) print(c.dtype, c, c[0]) #<U3 ['a1b'] a1b
实例二
a = np.array([ 'hello, word !', 'hello, python !' ], dtype=(np.str_, 14)) # <U14 unicode字符串14个，当不写14时，默认值比最长的字符数大一些的值，比如该处默认值为<U15 print(a) print(a.dtype) # >i4 dtype表示每一个最小单元的数据类型
运行
['hello, word !' 'hello, python '] <U14
2.5.2 定长类型，(维度)
a = np.array([(1, 2, 3, 4)], dtype=(np.int32, 4)) # 每个元素类型是4个int32，若维度不一致则会报错 print(a.dtype, a.shape) #int32 (1, 4)
说明：t = numpy.dtype((int,5))每个元素都是由5个int组成的一维数组，将5个int当成一个整体，实际上是二维数组
2.5.3 类型字符串1，类型字符串2，. . .
a = np.array([('1234',(1,2,3,4))],dtype='u4,4i4') print(a) #[(1234, [1, 2, 3, 4])] print(a.dtype) # [('f0', '<u4'), ('f1', '<i4', (4,))] print(a.shape) # (1,) # 一维数组，元素之间必须同质，元素内部可以由多个不同类型数据构成 print(a[0]['f0']) # 1234 print(a['f0']) # [1234] print(a[0]['f1']) # [1 2 3 4] print(a['f1']) # [[1 2 3 4]] # 备注 f0 f1是默认的，可以修改
当元素中由三个数据构成
a = np.array([('1234','abcd',(1,2,3,4))],dtype='u4,U4,4i4') print(a) # [(1234, 'abcd', [1, 2, 3, 4])] print(a.dtype) # [('f0', '<u4'), ('f1', '<U4'), ('f2', '<i4', (4,))] print(a.shape) # (1,) # 一维数组，元素之间必须同质，元素内部可以由多个不同类型数据构成 print(a[0]['f0']) # 1234 print(a['f0']) # [1234] print(a[0]['f1']) # abcd print(a['f1']) # ['abcd'] print(a[0]['f2']) # [1 2 3 4] print(a['f2']) # [[1 2 3 4]]
T：（逗号分隔的多个类型字符串）
t = numpy.dtype('U14,i4')此表示由U14和i4组成的元素，数组中的每个元素都是这个“组合类型”
T :[(子段名称，类型，维度),(子段描述),()...]
t = numpy.dtype([('name',numpy.str_,14),('age',numpy.int32)])此等价于'U14,i4'
2.5.4 元素中数据名修改
a = np.array([('1234', (1, 2, 3, 4)), ('5678', (5, 6, 7, 8))], dtype={'names': ['fa', 'fb'], 'formats': ['U4', '4i4']}) print(a.shape) #(2,) print(a.dtype) #[('fa', '<U4'), ('fb', '<i4', (4,))] print(a[0]['fa']) #1234 print(a[0]['fb']) #[1 2 3 4] print(a[1]['fa']) #5678 print(a[1]['fb']) #[5 6 7 8] print(a['fa']) #['1234' '5678'] print(a['fb']) #[[1 2 3 4] # [5 6 7 8]]
2.5.5 [(字段名称，字段类型，字段维度),...]
元素内部的数据构成
a = np.array([('1234', (1, 2, 3, 4))], dtype=[('fa', np.str_, 4), ('fb', np.int32, 4)]) print(a.dtype) #[('fa', '<U4'), ('fb', '<i4', (4,))] print(a[0]['fa']) #1234 print(a[0]['fb']) #[1 2 3 4]
与下段代码等价
b = np.array([('1234', (1, 2, 3, 4))], dtype=[('fa', 'U4'), ('fb', '4i4')]) print(b.dtype) #[('fa', '<U4'), ('fb', '<i4', (4,))] print(b[0]['fa']) #1234 print(b[0]['fb']) #[1 2 3 4]
2.5.6 (基本类型，解释类型)
实例一
a = np.array([0x1234], dtype=('>u2', {'names': ['lo', 'hi'], 'formats': ['u1', 'u1']})) print('{:x} {:x} {:x}'.format(a[0], a['lo'][0], a['hi'][0])) #1234 12 34
实例二
m = np.array(['python'], dtype=('U6', {'names': ['codes'], 'formats': ['6u4']})) print(m) #['python'] print(m[0]) #python print(m['codes'][0]) #[112 121 116 104 111 110]
a = np.array([('abc', 123), ('def', 456)], dtype='U14,i4') print(a) #[('abc', 123) ('def', 456)] print(a.dtype) #[('f0', '<U14'), ('f1', '<i4')] print(a[0][0], a[0][1]) #abc 123 b = np.array( [('abc', 123), ('def', 456)], dtype=[('name', np.str_, 14), ('age', np.int32)] ) print(b) #[('abc', 123) ('def', 456)] print(b[0]['name'], b[0]['age']) #abc 123
3 展平
将任意维度转成一维
3.1 a.ravel()
将a数组转变为一维视图（仅是转换了视图输出形式，其a数据的内部存储形式不变）
a = np.array([ [1, 2, 3], [4, 5, 6]]) b = a.ravel() print(b) #[1 2 3 4 5 6] print(a)#[[1 2 3] #[4 5 6]] a *= 10 print(a) #[[10 20 30] #[40 50 60]] print(b) #[10 20 30 40 50 60]
3.2 flatten()
将a数组转变为一维副本（将a数组复制一份并以一维数组的方式保存到内存中）
a = np.array([ [1, 2, 3], [4, 5, 6]]) b = a.flatten() # c是a的一维副本 print(b) #[1 2 3 4 5 6] print(a) #[[1 2 3] #[4 5 6]] a *= 10 print(a) #[[10 20 30] #[40 50 60]] print(b) #[1 2 3 4 5 6]
4 转置
转置视图实现方式：
Array.transpose() ：视图转置方法
Array.T：视图转置属性
无论哪种装置形式，仅改变视图形式，其内部不改变
a = np.arange(1, 9).reshape(2, 4) print(a) # [[1 2 3 4] # [5 6 7 8]] b = a.transpose() print(b) # [[1 5] # [2 6] # [3 7] # [4 8]] c = a.reshape(4, 2) print(c) # [[1 2] # [3 4] # [5 6] # [7 8]] d = a.T print(d) # [[1 5] # [2 6] # [3 7] # [4 8]] a *= 10 print(a, b, c, d, sep='\n') # 都是视图 略
注：至少是二维数组才支持转置，一维数据不支持转置，严格来讲，一维数据不存在行，只有列
将一列装置为行有两种方法，如下代码所示
a = np.arange(1,5) print(a) #[1 2 3 4] b = np.array([a]).transpose() #将其构造成二维再进行转置 print(b) # [[1] # [2] # [3] # [4]] c = a.reshape(-1,1) #这里-1行表示任意行，1，表示一列， print(c) # [[1] # [2] # [3] # [4]]
5 自定义数据类型
自定义的时候，可以先用numpy.dtype(T)创建类型
a = numpy.array([...],dtype = T)
t = numpy.dtype(T) a = numpy.array([...],dtype = t)
实例一
# python 或numpy的内置类型 t = numpy.dtype(int) t = numpy.dtype(numpy.int32)
python的数据类型会将其转化为numpy数据类型
实例二
# 实例二 类型字符串 t = numpy.dtype('int') t = numpy.dtype('int32')
5.1 类型字符编码
t = numpy.dtype('>(2,3)4i4')
这个表示为：
> 大端字节序
（2，3） 维度，2行3列
4：分量数，也就是说2行3列数组中又存在一个一维数组，每个数组中又4个元素，这4个元素中每个元素为4字节整型i，i4相当于int32
i 分量类型 ，每个分量是一个整型，
4 分量字节数，每个整型占据4个字节，每个类型的字长
实例一：
b = np.array([ (((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,35,36)), ((37,38,39,40), (41,42,43,44), (45,46,47,48))) ],dtype = '>(2,3)4i4') # dtype = '>(2,3,4)i4'与dtype = '>(2,3)4i4'等价 print(b) print(b.dtype) #>i4 dtype表示每一个最小单元的数据类型
运行
[[[[ 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 35 36]] [[37 38 39 40] [41 42 43 44] [45 46 47 48]]]] >i4
6 改变维度的4种方式
1）视图变维、2）复制变维、3）就地变维、4）视图转置
6.1 视图变维
import numpy a = numpy.arange(1,7) b = a.reshape(2,3) #[[1 2 3] # [4 5 6]] # 可以变回来 c = b.reshape(6) #[1,2,3,4,5,6] d = b.ravel() #扁平化 [1,2,3,4,5,6]
6.2 复制变维
e = b.flatten() #扁平化数据,e复制了b数据，e 独立于b存在
6.3 就地变维
a.shape = (2,3) #把已有的数组更变为新的数组类型
shape为a的属性，此时a的数据结构形式就发生了变化
数据是共享的，元数据是独立的，元数据包含了数据，还包括有对数据的描述（数据结构）
元数据，可以简单理解为描述为语言
a.resize((3,2))#就地变维，形参只有一个，(2,3)是以元组形式传参的，
6.4 视图转置
略
7 组合与拆分
垂直组合：vstack((上，下))
垂直分割：vsplit(数组，分割数)->子数组元组
水平组合：hstack((左，右))
水平分割：hsplit(数组，分割数)->子数组元组
深度组合：dstack((前，后))
深度分割：dsplit(数组，分割数)->子数组元组
行组合：row_stack((上，下))
列组合：column_stack((左，右))
7.1 垂直、水平、深度组合方式
垂直：v = numpy.vstack((u,d))
水平：h = numpy.hstack((l,r))
深度：d = numpy.dstack((a,b)) 可以理解为沿垂直纸面的组合方式
import numpy as np a = np.arange(1,10).reshape(3,3) b = a * 10 print(a, b, sep='\n') # a # [[1 2 3] # [4 5 6] # [7 8 9]] # b # [[10 20 30] # [40 50 60] # [70 80 90]] c = np.vstack((a,b)) print(c) # [[ 1 2 3] # [ 4 5 6] # [ 7 8 9] # [10 20 30] # [40 50 60] # [70 80 90]] d = np.hstack((a,b)) print(d) # [[ 1 2 3 10 20 30] # [ 4 5 6 40 50 60] # [ 7 8 9 70 80 90]] e = np.dstack((a,b)) print(e) # [[[ 1 10] # [ 2 20] # [ 3 30]] # # [[ 4 40] # [ 5 50] # [ 6 60]] # # [[ 7 70] # [ 8 80] # [ 9 90]]]
7.2 行组合、列组合
行组合：r = np.row_stack((u,d))
列组合：c = np.column_stack((l,r))
行、列组合一般针对一维数组，
对于二维及二维以上数组，行组合和垂直组合效果一样，列组合和水平组合效果一样
# 行组合 r = np.row_stack((u,d)) # u [1 2 3] # d [4 5 6] # r [ # [1 2 3] # [4 5 6] # ] # 列组合 c = np.column_stack((l,r)) # l [1 2 3] # r [4 5 6] # c [ # [1 4] # [2 5] # [3 6] # ]
7.3 垂直分割、水平分割、深度分割
1）垂直分割
u,d = numpy.vsplit(v,2)
u,m,d = numpy.vsplit(v,3)#分割的份数
2）水平分割
垂直分割、水平分割和垂直合并、水平合并是可逆的
l,m,r = numpy.hsplit(h,3)
3）深度分割
q,r = np.dsplit(e,2)
print(q,r,sep='\n')
备注：深度分割和深度合并是不可逆操作；
可以通过下段代码将其还原
q = q.transpose()[0].transpose()
r = r.transpose()[0].transpose()
print(q,r,sep='\n')
学习代码
import numpy as np a = np.arange(11, 20).reshape(3, 3) print('a') print(a) b = np.arange(21, 30).reshape(3, 3) print(b) c = np.arange(31, 40).reshape(3, 3) print(c) d = np.vstack((a, b, c)) print('d') print(d) # concatenate()方法可以选择方向进行合并 e = np.concatenate((a, b, c), axis=0) # 沿(行轴)合并 print('e') print(e) f, g, h = np.vsplit(e, 3) print('f,g,h') print(f, g, h, sep='\n') i = np.hstack((a, b, c)) # 水平组合 print('i') print(i) j = np.concatenate((a, b, c), axis=1) print('j') print(j) k, l, m = np.hsplit(j, 3) print('k') print(k) print('l') print(l) print('m') print(m) n = np.dstack((a, b)) print('n') print(n) o, p = np.dsplit(n, 2) print('o') print(o) print('p') print(p) print('o.T[0].T, p.T[0].T') print(o.T) print(o.T[0].T, p.T[0].T, sep='\n') q = np.arange(1, 4) r = np.arange(4, 7) s = np.arange(7, 10) print('q, r, s') print(q, r, s, sep='\n') t = np.row_stack((q, r, s)) #t = np.vstack((q, r, s)) print('t') print(t) u = np.column_stack((q, r, s)) #u = np.hstack((q, r, s)) print('u') print(u)
8 复数
import numpy as np a = np.array([ [1 + 1j, 2 + 4j, 3 + 7j], [11 + 11j, 12 + 14j, 13 + 17j], [21 + 21j, 22 + 24j, 23 + 27j], ]) print(a.dtype) # complex128 print(a.dtype.char) # D print(a.dtype.str) # <c16 print(a.imag) #虚部数组 # [[ 1. 4. 7.] # [11. 14. 17.] # [21. 24. 27.]] # 数字后面的点，表示浮点数 print('-----') print(a.real) # 实部数组 # [[ 1. 2. 3.] # [11. 12. 13.] # [21. 22. 23.]] print(a.T) #转置 # [[ 1. +1.j 11.+11.j 21.+21.j] # [ 2. +4.j 12.+14.j 22.+24.j] # [ 3. +7.j 13.+17.j 23.+27.j]]
9 numpy.ndarray 类的属性
1）dtype 元素类型
2）shape 维度 几行几列
3）ndim 数组维数，也可以理解为最外层的维度
4）size 元素个数，元素数len，如果一维size与len是相等的，当二维及以上时，则size仅表示列数，size行列式乘积
a [1 2 3] len(a) -> 3 a.sise -> 3 b [ [1 2 3]， [4 5 6] ] len(b) ->2 b.size ->6
5）itemsize 每个元素的字节数
6）nbytes 数组的总字节数 = size * itemsize
7）T 转置视图
8）real 复数数组的实部视图
9）image 复数数组的虚部视图
10）flat 扁平迭代器
flat属性将返回一个numpy.flatiter对象。扁平迭代器可以让我们像遍历一维数组一样去遍历任意的多维数组。（迭代器的计算是惰性的，节约内存）
11）tolist 转化为python列表 ，转换之后可以明显看到其是用逗号分隔的
numpy.ndarray.tolist()-> 列表对象
import numpy as np a = np.array( [ (1 + 1j, 2 + 2j, 3 + 7j), (1 + 1j, 2 + 2j, 3 + 7j), (1 + 1j, 2 + 2j, 3 + 7j) ] ) print(a) # [[1.+1.j 2.+2.j 3.+7.j] # [1.+1.j 2.+2.j 3.+7.j] # [1.+1.j 2.+2.j 3.+7.j]] print(type(a)) # <class 'numpy.ndarray'> print(type(a[0])) # <class 'numpy.ndarray'> print(type(a[0][0])) # <class 'numpy.complex128'> print(a.dtype) # complex128 print(a.dtype.type) # <class 'numpy.complex128'> print(a.dtype.str) #<c16 16 * 8 类型的字符串 print(a.dtype.char) # D <c16 16 * 8 类型的字符码，类型的字符编码 print(a.dtype.itemsize) # 16 表示dtype所描述的数据占用多少字节 这里面的16 与上一个16 以及128 都是一致的 print(a.ndim) #2 print(len(a),a.size) #3 9 # 若为三位数组，则len（）表示页数，a.size则是页数*行*列 print(a.itemsize) #16 print(a.nbytes) #144 print(a.T) # [[1.+1.j 1.+1.j 1.+1.j] # [2.+2.j 2.+2.j 2.+2.j] # [3.+7.j 3.+7.j 3.+7.j]] print(a.real, a.imag, sep='\n') #略 print(a.flat) # <numpy.flatiter object at 0x000001ED511EA310> for item in a.flat: print(item) # (1+1j) # (2+2j) # (3+7j) # (1+1j) # (2+2j) # (3+7j) # (1+1j) # (2+2j) # (3+7j) print('*'*6) # ****** print(a.flat[4]) #(2+2j) print(a.flat[[1,3,5]]) # [2.+2.j 1.+1.j 3.+7.j] a.flat[[2,4,6]] = 0 # 赋值 print(a) # [[1.+1.j 2.+2.j 0.+0.j] # [1.+1.j 0.+0.j 3.+7.j] # [0.+0.j 2.+2.j 3.+7.j]] b = a.tolist() print(b) # [[(1+1j), (2+2j), 0j], [(1+1j), 0j, (3+7j)], [0j, (2+2j), (3+7j)]]
print('flat') for elem in a.flat: # 性能最优 print(elem) print('ravel') for elem in a.ravel(): # 性能居中 print(elem) print('flatten') for elem in a.flatten(): # 性能最差 print(elem)
类似的代码
import numpy as np a = np.array([ [1 + 1j, 2 + 4j, 3 + 7j], [4 + 2j, 5 + 5j, 6 + 8j], [7 + 3j, 8 + 6j, 9 + 9j]]) print('a.dtype') print(a.dtype) print('a.dtype.char') print(a.dtype.char) print('a.dtype.str') print(a.dtype.str) print('a.dtype.name') print(a.dtype.name) print('a.shape') print(a.shape) print('a.ndim') print(a.ndim) print('a.size') print(a.size) print('a.itemsize') print(a.itemsize) print('a.nbytes') print(a.nbytes) print('a.real') print(a.real) print('a.imag') print(a.imag) print('a.T') print(a.T) print('flat') for elem in a.flat: # 性能最优 print(elem) print('ravel') for elem in a.ravel(): # 性能居中 print(elem) print('flatten') for elem in a.flatten(): # 性能最差 print(elem) b = a.tolist() print('b') print(b) c = np.array(b) print('c') print(c) d = [] for i in range(10): d.append(i) print('d') print(d) e = np.array([], dtype=int) for i in range(10): e = np.append(e, i) print('e') print(e)
a.append(i)
a = np.append(a,i)
链表是指针形式，在内存中的空间可以不连续，通过指针形式进行联系
数组，必须是一个整块的空间，数组中的元素需要的是连续内存，如果内存不足，则会开辟或寻找一个新的空间，将原内容拷贝到新的空间，
3242
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
