结构化数据类型使用
import numpy as np
dt = np.dtype([('age', np.int8)])
# 展示结构化数据类型的使用，类型字段和对应的实际类型将被创建
a = np.array([(10,), (20,), (30,)], dtype=dt)
print(a)
# [(10,) (20,) (30,)]
print(a["age"])
# [10 20 30]
# 类型字段名可以用于存取实际的 age 列
student = np.dtype([('name', 'S20'), ('age', 'i1'), ('marks', 'f4')])
print(student)
# [('name', 'S20'), ('age', 'i1'), ('marks', '<f4')]
a = np.array([('abc', 21, 50), ('xyz', 18, 75)], dtype=student)
print(a)
#[(b'abc', 21, 50.) (b'xyz', 18, 75.)]
数组属性
a = np.arange(24)
print (a.ndim) # a 现只有一个维度
#1
# 现在调整其大小
b = a.reshape(2,4,3) # b 现在拥有三个维度
print (b.ndim)
#3
a = np.array([[1,2,3],[4,5,6]])
print (a.shape)
#(2, 3)
调整数组大小
a = np.array([[1,2,3],[4,5,6]])
a.shape = (3,2)
print (a)
# [[1 2]
# [3 4]
# [5 6]]
a = np.array([[1,2,3],[4,5,6]])
b = a.reshape(3,2)
print (b)
# [[1, 2]
# [3, 4]
# [5, 6]]
ndarray.itemsize
# ndarray.itemsize 以字节的形式返回数组中每一个元素的大小。
# 例如，一个元素类型为 float64 的数组 itemsiz 属性值为
# 8(float64 占用 64 个 bits，每个字节长度为 8，所以 64/8，占用 8 个字节），
# 又如，一个元素类型为 complex32 的数组 item 属性为 4（32/8）。
# 数组的 dtype 为 int8（一个字节）
x = np.array([1, 2, 3, 4, 5], dtype=np.int8)
print (x.itemsize)
#1
# 数组的 dtype 现在为 float64（八个字节）
y = np.array([1, 2, 3, 4, 5], dtype=np.float64)
print (y.itemsize)
#8
创建数组
x = np.empty([3, 2], dtype=int)
# 生成随机数
# 三行两列，第一维度三个元素，每一元素里又有两个元素
print(x)
# [[0 0]
# [0 0]
# [0 0]]
# 默认为浮点数
x = np.zeros(5)
print(x)
# [0. 0. 0. 0. 0.]
# 设置类型为整数
y = np.zeros((5,), dtype=np.int)
print(y)
# [0 0 0 0 0]
# 自定义类型
z = np.zeros((2, 2), dtype=[('x', 'i4'), ('y', 'i4')])
print(z)
# [[(0, 0) (0, 0)]
# [(0, 0) (0, 0)]]
print(z.dtype)
#[('x', '<i4'), ('y', '<i4')]
默认为浮点数
x = np.ones(5)
print(x)
自定义类型
x = np.ones([2, 2], dtype=int)
print(x)
# [1. 1. 1. 1. 1.]
# [[1 1]
# [1 1]]
将列表转化为ndarray
x = [1,2,3]
a = np.asarray(x)
print (a)
#[1 2 3]
将元组转换为 ndarray:
x = (1,2,3)
a = np.asarray(x)
print (a)
#[1 2 3]
设置dtype参数
x = [1,2,3]
a = np.asarray(x, dtype = float)
print (a)
#[ 1. 2. 3.]
以流的形式读入转化成 ndarray 对象
# numpy.frombuffer
# numpy.frombuffer 用于实现动态数组。
# numpy.frombuffer 接受 buffer 输入参数，以流的形式读入转化成 ndarray 对象。
# buffer 可以是任意对象，会以流的形式读入。
# dtype 返回数组的数据类型，可选
# count 读取的数据数量，默认为-1，读取所有数据。
# offset 读取的起始位置，默认为0。
s = b'Hello World'
a = np.frombuffer(s, dtype = 'S1')
print (a)
#[b'H' b'e' b'l' b'l' b'o' b' ' b'W' b'o' b'r' b'l' b'd']
NumPy 从数值范围创建数组
# numpy 包中的使用 arange 函数创建数值范围并返回 ndarray 对象，函数格式如下：
# numpy.arange(start, stop, step, dtype)
#根据 start 与 stop 指定的范围以及 step 设定的步长，生成一个 ndarray。
#生成 0 到 5 的数组:
x = np.arange(5)
print (x)
#[0 1 2 3 4]
#设置dtype
x = np.arange(5, dtype = float)
print (x)
#[0. 1. 2. 3. 4.]
构建等差数列数组
# numpy.linspace
# numpy.linspace 函数用于创建一个一维数组，数组是一个等差数列构成的，格式如下：
# np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
# 参数说明：
#
# 参数 描述
# start 序列的起始值
# stop 序列的终止值，如果endpoint为true，该值包含于数列中
# num 要生成的等步长的样本数量，默认为50
# endpoint 该值为 ture 时，数列中中包含stop值，反之不包含，默认是True。
# retstep 如果为 True 时，生成的数组中会显示间距，反之不显示。
# dtype ndarray 的数据类型
# 以下实例用到三个参数，设置起始点为 1 ，终止点为 10，数列个数为 10。
a = np.linspace(1,10,10)
print(a)
#[ 1. 2. 3. 4. 5. 6. 7. 8. 9. 10.]
a = np.linspace(1,1,10)
print(a)
#[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
a = np.linspace(10, 20, 5, endpoint = False)
print(a)
#[10. 12. 14. 16. 18.]
# numpy.logspace 函数用于创建一个于等比数列。格式如下：
# np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)
# start 序列的起始值为：base ** start
# stop 序列的终止值为：base ** stop。如果endpoint为true，该值包含于数列中
# num 要生成的等步长的样本数量，默认为50
# endpoint 该值为 ture 时，数列中中包含stop值，反之不包含，默认是True。
# base 对数 log 的底数。
# dtype ndarray 的数据类型
a = np.logspace(1.0, 2.0, num = 10)
print (a)
#
# [ 10. 12.91549665 16.68100537 21.5443469 27.82559402
# 35.93813664 46.41588834 59.94842503 77.42636827 100. ]
NumPy 切片和索引
a = np.arange(10)
s = slice(2, 7, 2) # 从索引 2 开始到索引 7 停止，间隔为2
print(a[s]) # 通过切片对象访问数组
# 或者
a = np.arange(10)
b = a[2:7:2] # 从索引 2 开始到索引 7 停止，间隔为 2
print(b)
# 输出结果为：
# [2 4 6]
# 冒号 : 的解释：如果只放置一个参数，如 [2]，将返回与该索引相对应的单个元素。
# 如果为 [2:]，表示从该索引开始以后的所有项都将被提取。如果使用了两个参数，
# 如 [2:7]，那么则提取两个索引(不包括停止索引)之间的项。
多维数组切片
a = np.array([[1, 2, 3], [3, 4, 5], [4, 5, 6]])
print(a)
# 从某个索引处开始切割
print('从数组索引 a[1:] 处开始切割')
print(a[1:])
# 输出结果为：
#
# [[1 2 3]
# [3 4 5]
# [4 5 6]]
# 从数组索引 a[1:] 处开始切割
# [[3 4 5]
# [4 5 6]]
a = np.array([[1, 2, 3], [3, 4, 5], [4, 5, 6]])
print(a[..., 1]) # 第2列元素
print(a[1, ...]) # 第2行元素
print(a[..., 1:]) # 第2列及剩下的所有元素
# 输出结果为：
#
# [2 4 5]
# [3 4 5]
# [[2 3]
# [4 5]
# [5 6]]
</font>
