1.数据类型及数组创建
1.1常量
numpy.nan(numpy.NaN,numpy.NAN) | not a number,表示非数值、空值nan。
|
numpy.inf(Inf = inf = infty = Infinity = PINF) | 正无穷大inf |
numpy.pi | π,3.1415926535897932384... |
numpy.e | 自然常数e,2,718281828.... |
1.2数据类型
1.2.1数据类型对象(numpy.dtype类的实例)
dtype对象的构造:
class dtype(object):
def __init__(self, obj, align=False, copy=False):
pass
使用时:numpy.dtype(object,align,copy)
- object:要转换成为的数据类型
- align:如果为True,填充字段使其类似C的结构体
- copy:复制dtype对象,如果为false,则是对内置数据类型对象的引用
下表列举了常用 numpy 基本类型。
类型 | 备注 | 说明 |
bool_ = bool8 | 8位 | 布尔类型 |
int8 = byte | 8位 | 整型 |
int16 = short | 16位 | 整型 |
int32 = intc | 32位 | 整型 |
int_ = int64 = long = int0 = intp | 64位 | 整型 |
uint8 = ubyte | 8位 | 无符号整型 |
uint16 = ushort | 16位 | 无符号整型 |
uint32 = uintc | 32位 | 无符号整型 |
uint64 = uintp = uint0 = uint | 64位 | 无符号整型 |
float16 = half | 16位 | 浮点型 |
float32 = single | 32位 | 浮点型 |
float_ = float64 = double | 64位 | 浮点型 |
str_ = unicode_ = str0 = unicode | Unicode 字符串 | |
datetime64 | 日期时间类型 | |
timedelta64 | 表示两个时间之间的间隔 |
每个内建类型都有一个唯一定义它的字符代码,如“i4”简写可用来代替numpy.int32,如下:
字符 | 对应类型 | 备注 |
b | boolean | 'b1' |
i | signed integer | 'i1', 'i2', 'i4', 'i8' |
u | unsigned integer | 'u1', 'u2' ,'u4' ,'u8' |
f | floating-point | 'f2', 'f4', 'f8' |
c | complex floating-point | |
m | timedelta64 | 表示两个时间之间的间隔 |
M | datetime64 | 日期时间类型 |
O | object | |
S | (byte-)string | S3表示长度为3的字符串 |
U | Unicode | Unicode 字符串 |
V | void |
numpy.dtype(): 返回数据结构中数据元素的类型,其中的元素类型必须统一,因此list、dict没有dtype,np.array有。
numpy.dtype.itemsize():此类数据类型对象的元素大小(字节)
numpy.array.astype():改变array中数据元素的类型
import numpy as np
a = np.dtype('b1')
print(a.type) # <class 'numpy.bool_'>
print(a.itemsize) # 1
a = np.dtype('i1')
print(a.type) # <class 'numpy.int8'>
print(a.itemsize) # 1
a = np.dtype('i2')
print(a.type) # <class 'numpy.int16'>
print(a.itemsize) # 2
a = np.dtype('i4')
print(a.type) # <class 'numpy.int32'>
print(a.itemsize) # 4
a = np.dtype('i8')
print(a.type) # <class 'numpy.int64'>
print(a.itemsize) # 8
a = np.dtype('u1')
print(a.type) # <class 'numpy.uint8'>
print(a.itemsize) # 1
a = np.dtype('u2')
print(a.type) # <class 'numpy.uint16'>
print(a.itemsize) # 2
a = np.dtype('u4')
print(a.type) # <class 'numpy.uint32'>
print(a.itemsize) # 4
a = np.dtype('u8')
print(a.type) # <class 'numpy.uint64'>
print(a.itemsize) # 8
a = np.dtype('f2')
print(a.type) # <class 'numpy.float16'>
print(a.itemsize) # 2
a = np.dtype('f4')
print(a.type) # <class 'numpy.float32'>
print(a.itemsize) # 4
a = np.dtype('f8')
print(a.type) # <class 'numpy.float64'>
print(a.itemsize) # 8
a = np.dtype('S')
print(a.type) # <class 'numpy.bytes_'>
print(a.itemsize) # 0
a = np.dtype('S3')
print(a.type) # <class 'numpy.bytes_'>
print(a.itemsize) # 3
a = np.dtype('U3')
print(a.type) # <class 'numpy.str_'>
print(a.itemsize) # 12
1.2.2结构化数据类型(详见1.4.4利用数据结构来创建数组)
类型字段和对应实际类型将被创建。
import numpy as np
#创建结构化数据类型
dt = np.dtype([('age',np.int8)])
print(dt) #[('age','i1')]
#将数据类型应用于ndarray对象
a = np.array([(10,),(20,),(30,)],dtype=dt)
print(a) #[(10,) (20,) (30,)]
#类型字段名可以用于存取实际的age列
print(a['age']) #[10 20 30]
#定义一个结构化数据类型student,并将这个dtype应用到ndarray
student = np.dtype([('name','S20'),('age','i1'),('mark','f4')])
b = np.array([('leah',21,90),('mike',18,75)],dtype=student)
print(b) #[(b'leah', 21, 90.) (b'mike', 18, 75.)]
print(b['name']) #[b'leah' b'mike']
print(b['age']) #[21 18]
print(b['mark']) #[90. 75.]
问题1:为什么将数据类型改成‘S3’后,字符串前面加了个b?
import numpy as np
dt = np.dtype('S3')
a = np.array([('asd',)],dt)
print(a)
result:[[b'asd']]
1.3时间日期和时间增量
1.3.1 datetime64基础
在 numpy 中,我们很方便地将字符串转换成时间日期类型datetime64,datetime64是带单位的日期时间类型,其单位如下:
日期单位 | 代码含义 | 时间单位 | 代码含义 |
Y | 年 | h | 小时 |
M | 月 | m | 分钟 |
W | 周 | s | 秒 |
D | 天 | ms | 毫秒 |
- | - | us | 微秒 |
- | - | ns | 纳秒 |
- | - | ps | 皮秒 |
- | - | fs | 飞秒 |
- | - | as | 阿托秒 |
注意:
- 1秒 = 1000 毫秒(milliseconds)
- 1毫秒 = 1000 微秒(microseconds)
【例1】从字符串创建 datetime64 类型时(格式为‘year-month-day time’),默认情况下,numpy 会根据字符串自动选择对应的单位。
import numpy as np
a = np.datetime64('2020-03-01')
print(a, a.dtype) # 2020-03-01 datetime64[D]
a = np.datetime64('2020-03')
print(a, a.dtype) # 2020-03 datetime64[M]
a = np.datetime64('2020-03-08 20:00:05')
print(a, a.dtype) # 2020-03-08T20:00:05 datetime64[s]
a = np.datetime64('2020-03-08 20:00')
print(a, a.dtype) # 2020-03-08T20:00 datetime64[m]
a = np.datetime64('2020-03-08 20')
print(a, a.dtype) # 2020-03-08T20 datetime64[h]
【例2】从字符串创建 datetime64 类型时,可以强制指定使用的单位。
import numpy as np
a = np.datetime64('2020-03', 'D')
print(a, a.dtype) # 2020-03-01 datetime64[D]
a = np.datetime64('2020-03', 'Y')
print(a, a.dtype) # 2020 datetime64[Y]
print(np.datetime64('2020-03') == np.datetime64('2020-03-01')) # True
print(np.datetime64('2020-03') == np.datetime64('2020-03-02')) #False
由上例可以看出,2019-03 和 2019-03-01所表示的其实是同一个时间,年-月-日-时-分-秒默认为第一个月第一天00:00:00。 事实上,如果两个 datetime64 对象具有不同的单位,它们可能仍然代表相同的时刻。并且从较大的单位(如月份)转换为较小的单位(如天数)是安全的。
【例3】从字符串创建 datetime64 数组时,如果单位不统一,则一律转化成其中最小的单位。
import numpy as np
a = np.array(['2020-03', '2020-03-08', '2020-03-08 20:00'], dtype='datetime64')
print(a, a.dtype)
# ['2020-03-01T00:00' '2020-03-08T00:00' '2020-03-08T20:00'] datetime64[m]
【例4】使用arange()
创建 datetime64 数组,用于生成日期范围,精确至最小单位。
import numpy as np
a = np.arange('2020-08-01', '2020-08-10', dtype=np.datetime64) #精确到天
print(a)
# ['2020-08-01' '2020-08-02' '2020-08-03' '2020-08-04' '2020-08-05'
# '2020-08-06' '2020-08-07' '2020-08-08' '2020-08-09'] #左闭右开
print(a.dtype) # datetime64[D]
a = np.arange('2020-08-01 20:00', '2020-08-10', dtype=np.datetime64) #精确到分钟
print(a)
# ['2020-08-01T20:00' '2020-08-01T20:01' '2020-08-01T20:02' ...
# '2020-08-09T23:57' '2020-08-09T23:58' '2020-08-09T23:59']
print(a.dtype) # datetime64[m]
a = np.arange('2020-05', '2020-12', dtype=np.datetime64) #精确到月
print(a)
# ['2020-05' '2020-06' '2020-07' '2020-08' '2020-09' '2020-10' '2020-11']
print(a.dtype) # datetime64[M]
1.3.2datetime64 和 timedelta64 运算
【例1】日期时间和时间增量的加减法。timedelta64 表示两个 datetime64 之间的差。datetime64可做减法,减完后的数据类型为timedelta64形式。timedelta64 也是带单位的,并且和相减运算中的两个 datetime64 中的较小的单位保持一致。datetime64也可以与timedelta64相加。
import numpy as np
a = np.datetime64('2020-03-08') - np.datetime64('2020-03-07')
b = np.datetime64('2020-03-08') - np.datetime64('2020-03-07 08:00')
c = np.datetime64('2020-03-08') - np.datetime64('2020-03-07 23:00', 'D')
#c强制转换单位为Day,不足一天按一天算,(向上取整)
print(a, a.dtype) # 1 days timedelta64[D]
print(b, b.dtype) # 960 minutes timedelta64[m]
print(c, c.dtype) # 1 days timedelta64[D]
#加法是datetime64+timedelta64,需要标明时间增量的单位
a = np.datetime64('2020-03') + np.timedelta64(20, 'D')
b = np.datetime64('2020-06-15 00:00') + np.timedelta64(12, 'h')
print(a, a.dtype) # 2020-03-21 datetime64[D]
print(b, b.dtype) # 2020-06-15T12:00 datetime64[m]
【例2】时间增量的单位转换。生成 timedelta64时,要注意年('Y')和月('M')这两个单位无法和其它单位进行运算(一年有几天?一个月有几天、几个小时?这些都是不确定的,只有如一天有24小时这样固定的才能转换)。
import numpy as np
a = np.timedelta64(1, 'Y')
b = np.timedelta64(a, 'M')
print(a) # 1 years
print(b) # 12 months #year和month能转换
c = np.timedelta64(1, 'h')
d = np.timedelta64(c, 'm') #hour和minutes能转换
print(c) # 1 hours
print(d) # 60 minutes
print(np.timedelta64(a, 'D'))
# TypeError: Cannot cast NumPy timedelta64 scalar from metadata [Y] to [D] according to the rule 'same_kind'
print(np.timedelta64(b, 'D'))
# TypeError: Cannot cast NumPy timedelta64 scalar from metadata [M] to [D] according to the rule 'same_kind'
【例3】timedelta64 的运算,timedelta间可进行转换量固定的单位间的运算,精确到最小单位。
import numpy as np
a = np.timedelta64(1, 'Y')
b = np.timedelta64(6, 'M')
c = np.timedelta64(1, 'W')
d = np.timedelta64(1, 'D')
e = np.timedelta64(5, 'D')
print(a) # 1 years
print(b) # 6 months
print(a + b) # 18 months
print(a - b) # 6 months
print(2 * a) # 2 years
print(a / b) # 2.0
print(c / d) # 7.0
print(c % e) # 2 days
【例4】numpy.datetime64 与 datetime.datetime 可以相互转换
import numpy as np
import datetime
dt = datetime.datetime(year=2020, month=6, day=1, hour=20, minute=5, second=30)
dt64 = np.datetime64(dt, 's')
print(dt64, dt64.dtype)
# 2020-06-01T20:05:30 datetime64[s]
dt2 = dt64.astype(datetime.datetime)
print(dt2, type(dt2))
# 2020-06-01 20:05:30 <class 'datetime.datetime'>
1.3.3工作日功能
numpy.busday_offset(dates, offsets, roll='raise', weekmask='1111100', holidays=None, busdaycal=None, out=None)
- dates,日期,格式为‘year-month-day’
- offsets,偏移量,滚动到下一个工作日。问题2:偏移量是如何作用的?先roll后offsets
- roll:{'raise', 'nat', 'forward', 'following', 'backward', 'preceding', 'modifiedfollowing', 'modifiedpreceding'},默认为raise,forward与backward常用。
- weekmask:七个布尔值,用来定义哪些天是工作日。
【例1】如果当前是工作日,计算后面第offsets个工作日,如果当前日期为非工作日,默认报错。可以指定forward或backward规则来避免报错。(一个是向以后取第一个有效的工作日,一个是向以前取第一个有效的工作日)。可以指定偏移量为 0 来获取当前日期向前或向后最近的工作日,当然,如果当前日期本身就是工作日,则直接返回当前日期。如果offsets和forward/backward都存在,则先进行forward/backward,然后偏移到后面第offsets个工作日。
import numpy as np
# 2020-07-10 星期五
a = np.busday_offset('2020-07-10', offsets=1)
print(a) # 2020-07-13
a = np.busday_offset('2020-07-11', offsets=1)
print(a)
# ValueError: Non-business day date in busday_offset
a = np.busday_offset('2020-07-11', offsets=0, roll='forward')
b = np.busday_offset('2020-07-11', offsets=0, roll='backward')
print(a) # 2020-07-13
print(b) # 2020-07-10
a = np.busday_offset('2020-07-11', offsets=1, roll='forward')
b = np.busday_offset('2020-07-11', offsets=1, roll='backward')
print(a) # 2020-07-14
print(b) # 2020-07-13
该功能能判断某天是否是工作日。
numpy.is_busday(dates, weekmask='1111100', holidays=None, busdaycal=None, out=None)
【例2】返回指定日期是否是工作日。
import numpy as np
# 2020-07-10 星期五
a = np.is_busday('2020-07-10')
b = np.is_busday('2020-07-11')
print(a) # True
print(b) # False
【例3】统计一个datetime64[D]
中的工作日天数。
import numpy as np
# 2020-07-10 星期五
begindates = np.datetime64('2020-07-10')
enddates = np.datetime64('2020-07-20')
a = np.arange(begindates, enddates, dtype='datetime64')
b = np.count_nonzero(np.is_busday(a))
print(a)
# ['2020-07-10' '2020-07-11' '2020-07-12' '2020-07-13' '2020-07-14'
# '2020-07-15' '2020-07-16' '2020-07-17' '2020-07-18' '2020-07-19']
print(b) # 6
1.4数组的创建
1.4.1根据已有数据创建数组
【array()方法】
import numpy as np
# 创建一维数组
a = np.array([0, 1, 2, 3, 4])
#第一层()代表函数引用,[]代表第一行,逗号分隔代表不同列
b = np.array((0, 1, 2, 3, 4)) 最内层()或[]都可
print(a, type(a))
print(b, type(b))
# 创建二维数组
#第一层()代表函数引用,第二层[]代表一整个数组,第三层[]表示一行,逗号分隔表示不同列
c = np.array([[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]])
print(c, type(c))
# 创建三维数组
#第一层()代表函数引用,第二层[]代表整个数组,第三层[]代表一层,第四层()代表一行,逗号分隔代表不同列
d = np.array([[(1.5, 2, 3), (4, 5, 6)],
[(3, 2, 1), (4, 5, 6)]])
print(d, type(d))
【asarray()方法】
array()和asarray()都可以将结构数据转化为 ndarray,但是array()和asarray()主要区别就是当数据源是ndarray
import numpy as np
x = [[1, 1, 1], [1, 1, 1], [1, 1, 1]] #数据源是list
y = np.array(x)
z = np.asarray(x)
x[1][2] = 2 #列表在引用后改变
print(x)
# [[1, 1, 1], [1, 1, 2], [1, 1, 1]]
print(y)
# [[1 1 1]
# [1 1 1]
# [1 1 1]]
print(z)
# [[1 1 1]
# [1 1 1]
# [1 1 1]] #array和asarray都改变
x = np.array([[1, 1, 1], [1, 1, 1], [1, 1, 1]]) #数据源是ndarray
y = np.array(x)
z = np.asarray(x)
x[1][2] = 2 #x在引用后改变
print(x,x.dtype)
# [[1 1 1]
# [1 1 2]
# [1 1 1]] int32
print(y,y.dtype) #array是副本,不改变
# [[1 1 1]
# [1 1 1]
# [1 1 1]] int32
print(z,z.dtype) #未改变dtype的asarray直接引用ndarray,改变
# [[1 1 1]
# [1 1 2]
# [1 1 1]] int32
【fromfunction()方法】
def fromfunction(function, shape, **kwargs):
【例】通过在每个坐标上执行一个函数来构造数组。
import numpy as np
def f(x, y):
return 10 * x + y
#填充与行列坐标相关的矩阵。(5,4)为矩阵形状,限制迭代次数
x = np.fromfunction(f, (5, 4), dtype=int)
print(x)
# [[ 0 1 2 3]
# [10 11 12 13]
# [20 21 22 23]
# [30 31 32 33]
# [40 41 42 43]]
#lambda i,j: ..... 定义关于坐标(i,j)的函数
x = np.fromfunction(lambda i, j: i == j, (3, 3), dtype=int)
print(x)
# [[ True False False]
# [False True False]
# [False False True]]
x = np.fromfunction(lambda i, j: i + j, (3, 3), dtype=int)
print(x)
# [[0 1 2]
# [1 2 3]
# [2 3 4]]
1.4.2特定值和结构的填充方法
【零数组】
zeros()函数:返回给定形状和类型的零数组。
zeros_like()函数:返回与给定数组形状和类型相同的零数组。
【例】
import numpy as np
x = np.zeros(5)
print(x) # [0. 0. 0. 0. 0.]
x = np.zeros([2, 3])
print(x)
# [[0. 0. 0.]
# [0. 0. 0.]]
x = np.array([[1, 2, 3], [4, 5, 6]])
y = np.zeros_like(x)
print(y)
# [[0 0 0]
# [0 0 0]]
【1数组】
ones()函数:返回给定形状和类型的1数组。
ones_like()函数:返回与给定数组形状和类型相同的1数组。
【例】
import numpy as np
x = np.ones(5)
print(x) # [1. 1. 1. 1. 1.]
x = np.ones([2, 3])
print(x)
# [[1. 1. 1.]
# [1. 1. 1.]]
x = np.array([[1, 2, 3], [4, 5, 6]])
y = np.ones_like(x)
print(y)
# [[1 1 1]
# [1 1 1]]
【空数组】
empty()函数:返回给定形状和类型的空数组。
empty_like()函数:返回与给定数组形状和类型相同的空数组。
【例】
import numpy as np
x = np.empty(5)
print(x)
# [1.95821574e-306 1.60219035e-306 1.37961506e-306
# 9.34609790e-307 1.24610383e-306]
x = np.empty((3, 2))
print(x)
# [[1.60220393e-306 9.34587382e-307]
# [8.45599367e-307 7.56598449e-307]
# [1.33509389e-306 3.59412896e-317]]
x = np.array([[1, 2, 3], [4, 5, 6]])
y = np.empty_like(x)
print(y)
# [[ 7209029 6422625 6619244]
# [ 100 707539280 504]]
【单位数组】
eye()函数:返回一个对角线上为1,其它地方为零的单位数组,可以不“方”。
identity()函数:返回一个方的单位数组。
【例】
import numpy as np
x = np.eye(4)
print(x)
# [[1. 0. 0. 0.]
# [0. 1. 0. 0.]
# [0. 0. 1. 0.]
# [0. 0. 0. 1.]]
x = np.eye(2, 3)
print(x)
# [[1. 0. 0.]
# [0. 1. 0.]]
x = np.identity(4)
print(x)
# [[1. 0. 0. 0.]
# [0. 1. 0. 0.]
# [0. 0. 1. 0.]
# [0. 0. 0. 1.]]
【对角数组】
diag()函数:提取对角线或构造对角数组。
【例】
import numpy as np
x = np.arange(9).reshape((3, 3))
print(x)
# [[0 1 2]
# [3 4 5]
# [6 7 8]]
print(np.diag(x)) # [0 4 8]
print(np.diag(x, k=1)) # [1 5]
print(np.diag(x, k=-1)) # [3 7]
v = [1, 3, 5, 7]
x = np.diag(v)
print(x)
# [[1 0 0 0]
# [0 3 0 0]
# [0 0 5 0]
# [0 0 0 7]]
【常数数组】
full()
函数:返回一个常数数组。(亦可返回所有常量)
full_like()
函数:返回与给定数组具有相同形状和类型的常数数组。
【例】
import numpy as np
x = np.full((2,), 7)
print(x)
# [7 7]
x = np.full(2, 7)
print(x)
# [7 7]
x = np.full((2, 7), 7)
print(x)
# [[7 7 7 7 7 7 7]
# [7 7 7 7 7 7 7]]
x = np.array([[1, 2, 3], [4, 5, 6]])
y = np.full_like(x, 7)
print(y)
# [[7 7 7]
# [7 7 7]]
1.4.3利用数值范围创建
arange(start,stop,step)函数:返回给定间隔内的均匀间隔的值,给定间隔(默认1),数量自适应。
linspace()函数:返回给定间隔内的等间隔数字,给定数字数量,间隔自适应。
logspace()函数:返回数以对数刻度均匀分布。
numpy.random.rand() 返回一个由[0,1)内的随机数组成的数组。
(random系列函数)
【例】
import numpy as np
x = np.arange(5) #默认为[0,5),间隔为1
print(x) # [0 1 2 3 4]
x = np.arange(3, 7, 2) #指定间隔
print(x) # [3 5]
x = np.linspace(start=0, stop=2, num=9) #指定间隔和数字数量n,输出等间隔的n个数
print(x)
# [0. 0.25 0.5 0.75 1. 1.25 1.5 1.75 2. ]
x = np.logspace(0, 1, 5)
print(np.around(x, 2))
# [ 1. 1.78 3.16 5.62 10. ]
#np.around 返回四舍五入后的值,可指定精度。
# around(a, decimals=0, out=None)
# a 输入数组
# decimals 要舍入的小数位数。 默认值为0。 如果为负,整数将四舍五入到小数点左侧的位置
x = np.linspace(start=0, stop=1, num=5)
#logspace的同等意义
x = [10 ** i for i in x]
print(np.around(x, 2))
# [ 1. 1.78 3.16 5.62 10. ]
x = np.random.random(5)
print(x)
# [0.41768753 0.16315577 0.80167915 0.99690199 0.11812291]
x = np.random.random([2, 3])
print(x)
# [[0.41151858 0.93785153 0.57031309]
# [0.13482333 0.20583516 0.45429181]]
1.4.4利用数据结构来创建 ()
结构数组,先定义结构,后利用np.array()创建数组。参数dtype为定义的结构。
【利用字典定义结构】
【例】
import numpy as np
personType = np.dtype({
'names': ['name', 'age', 'weight'],
'formats': ['U30', 'i8', 'f8']})
a = np.array([('Liming', 24, 63.9), ('Mike', 15, 67.), ('Jan', 34, 45.8)],
dtype=personType)
print(a, type(a))
# [('Liming', 24, 63.9) ('Mike', 15, 67. ) ('Jan', 34, 45.8)]
# <class 'numpy.ndarray'>
【利用包含多个元组的列表来定义结构】
【例】
import numpy as np
personType = np.dtype([('name', 'U30'), ('age', 'i8'), ('weight', 'f8')])
a = np.array([('Liming', 24, 63.9), ('Mike', 15, 67.), ('Jan', 34, 45.8)],
dtype=personType)
print(a, type(a))
# [('Liming', 24, 63.9) ('Mike', 15, 67. ) ('Jan', 34, 45.8)]
# <class 'numpy.ndarray'>
# 结构数组的取值方式和一般数组差不多,可以通过下标取得元素:
print(a[0])
# ('Liming', 24, 63.9)
print(a[-2:])
# [('Mike', 15, 67. ) ('Jan', 34, 45.8)]
# 我们可以使用字段名作为下标获取对应的值
print(a['name'])
# ['Liming' 'Mike' 'Jan']
print(a['age'])
# [24 15 34]
print(a['weight'])
# [63.9 67. 45.8]
1.5数组的属性
numpy.ndarray.ndim:返回数组的维数(轴的个数)也称为秩,一维数组的秩为 1,二维数组的秩为 2,以此类推。
numpy.ndarray.shape:数组的维度,返回一个元组代表维度。这个元组的长度就是维度的数目,即 ndim 属性(秩)。
numpy.ndarray.size:数组中所有元素的总量,相当于数组的shape中所有元素的乘积,例如矩阵的元素总量为行与列的乘积。
numpy.ndarray.dtype ndarray :对象的元素类型。
numpy.ndarray.itemsize:以字节的形式返回数组中每一个元素的大小。
【例】
import numpy as np
a = np.array([1, 2, 3, 4, 5])
print(a.ndim) # 1
print(a.shape) # (5,) 一维数组的维度
print(a.dtype) # int32
print(a.size) # 5
print(a.itemsize) # 4
b = np.array([[1, 2, 3], [4, 5, 6.0]])
print(b.shape) # (2, 3) 分别为二维数组的两个维度
print(b.dtype) # float64
print(b.size) # 6
print(b.ndim) # 2
print(b.itemsize) # 8
在ndarray
中所有元素必须是同一类型,否则会自动向下转换,int->float->str。
【例】
import numpy as np
a = np.array([1, 2, 3, 4, 5])
print(a) # [1 2 3 4 5]
b = np.array([1, 2, 3, 4, '5'])
print(b) # ['1' '2' '3' '4' '5']
c = np.array([1, 2, 3, 4, 5.0])
print(c) # [1. 2. 3. 4. 5.]