Numpy基础数据结构python Numpy基础数据结构
NumPy数组是⼀个多维数组对象，称为ndarray。其由两部分组成：
实际的数据
描述这些数据的元数据
1.⼀维数组
import numpy as np
ar = np.array([1,2,3,4,5,6,7])
print(ar)          # 输出数组，注意数组的格式：中括号，元素之间没有逗号（和列表区分）
print(ar.ndim)    # 输出数组维度的个数（轴数），或者说“秩”，维度的数量也称rank
print(ar.shape)    # 数组的维度，对于n⾏m列的数组，shape为（n，m）
print(ar.size)    # 数组的元素总数，对于n⾏m列的数组，元素总数为n*m
print(ar.dtype)    # 数组中元素的类型，类似type()（注意了，type()是函数，.dtype是⽅法）
print(ar.itemsize) # 数组中每个元素的字节⼤⼩，int32类型字节为4，float64的字节为8
print(ar.data)    # 包含实际数组元素的缓冲区，由于⼀般通过数组的索引获取元素，所以通常不需要使⽤这个属性。
ar  # 交互⽅式下输出，会有array(数组)
# 数组的基本属性
# ①数组的维数称为秩（rank），⼀维数组的秩为1，⼆维数组的秩为2，以此类推
# ②在NumPy中，每⼀个线性的数组称为是⼀个轴（axes），秩其实是描述轴的数量：
# ⽐如说，⼆维数组相当于是两个⼀维数组，其中第⼀个⼀维数组中每个元素⼜是⼀个⼀维数组
# 所以⼀维数组就是NumPy中的轴（axes），第⼀个轴相当于是底层数组，第⼆个轴是底层数组⾥的数组。
# ⽽轴的数量——秩，就是数组的维数。
输出结果：
[1 2 3 4 5 6 7]
1
(7,)
7
int32
4
<memory at 0x0000027EA4F80F48>
array([1, 2, 3, 4, 5, 6, 7])
2.⼆维数组
import numpy as np
ar2 = np.array([[1,2,3],[2,3,4]])
print(ar2)
print(ar2.ndim)
print(ar2.shape)
print(ar2.dtype)
ar2
输出结果：
[[1 2 3]
[2 3 4]]
2
(2, 3)
int32
array([[1, 2, 3],
[2, 3, 4]])
3.有字符串的混合数组
import numpy as np
lst = [[1,2,3],['a','b','c']]
print(type(lst))
ar2 = np.array([['a','b','c'],[1,2,3]])
print(ar2)
print(ar2.dtype)    #有字符串组成的类型⼀定为字符串型号
输出结果：
<class'list'>
[['a''b''c']
['1''2''3']]
<U1
4.三维数组
import numpy as np          #三维数组，由两个⼆维数组构成，⽽每个⼆维数组由2个⼀维数组构成
ar2 = np.array([[[1,2,3],[2,3,4]],
[[4,5,6],[7,8,9]]
])
print(ar2)
print(ar2.shape)
print(ar2.ndim)
输出结果：
[[[1 2 3]
[2 3 4]]
[[4 5 6]
[7 8 9]]]
(2, 2, 3)
3
5. 创建数组_1 array()
# 创建数组：array()函数，括号内可以是列表、元祖、数组、⽣成器等
ar1 = np.array(range(10))  # 整型
ar2 = np.array([1,2,3.14,4,5])  # 浮点型由列表组成
ar3 = np.array([[1,2,3],('a','b','c')])  # ⼆维数组：嵌套序列（列表，元祖均可）
ar4 = np.array([[1,2,3],('a','b','c','d')])  # 注意嵌套序列数量不⼀会怎么样？
print(ar1,type(ar1),ar1.dtype)
print(ar2,type(ar2),ar2.dtype)
print(ar3,ar3.shape,ar3.ndim,ar3.size)    # ⼆维数组，共6个元素
print(ar4,ar4.shape,ar4.ndim,ar4.size)    # ⼀维数组，共2个元素
输出结果：
[0 1 2 3 4 5 6 7 8 9] <class'numpy.ndarray'> int32
[1.  2.  3.14 4.  5.  ] <class'numpy.ndarray'> float64
[['1''2''3']
['a''b''c']] (2, 3) 2 6
[list([1, 2, 3]) ('a', 'b', 'c', 'd')] (2,) 1 2
6.⽤数组构建数组
a1 = np.array([1,2,3])    #⽤数组构建数组
a2 = np.array([3,4,5])
a3 = np.array([a1,a2])
a3.shape
输出结果：
(2, 3)
7.创建数组_2 arange()
# 创建数组：arange()，类似range()，在给定间隔内返回均匀间隔的值。
print(np.arange(10))    # 返回0-9，整型
print(np.arange(10.0))  # 返回0.0-9.0，浮点型
print(np.arange(5,12))  # 返回5-11
print(np.arange(5.0,12,2))  # 返回5.0-12.0，步长为2
print(np.arange(10000))  # 如果数组太⼤⽽⽆法打印，NumPy会⾃动跳过数组的中⼼部分，并只打印边⾓：
输出结果：
[0 1 2 3 4 5 6 7 8 9]
[0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]
[ 5  6  7  8  9 10 11]
[ 5.  7.  9. 11.]
[  0    1    2 ... 9997 9998 9999]
8.创建数组_3 linspace()函数
# 创建数组：linspace()：返回在间隔[开始，停⽌]上计算的num个均匀间隔的样本。
ar1 = np.linspace(2.0, 3.0, num=5)  #输出两端都是闭合的，包括3
ar2 = np.linspace(2.0, 3.0, num=5, endpoint=False)  #输出右端不闭合，不包括3
ar3 = np.linspace(2.0, 3.0, num=5, retstep=True)
print(ar1,type(ar1))
python安装numpy教程print(ar2)
print(ar3,type(ar3))
# numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
# start：起始值，stop：结束值
# num：⽣成样本数，默认为50
# endpoint：如果为真，则停⽌是最后⼀个样本。否则，不包括在内。默认值为True。
# retstep：如果为真，返回（样本，步骤），其中步长是样本之间的间距，输出为⼀个包含2个元素的元祖，第⼀个元素为array，第⼆个为步长实际值
[2.  2.25 2.5  2.75 3.  ] <class'numpy.ndarray'>
[2.  2.2 2.4 2.6 2.8]
(array([2.  , 2.25, 2.5 , 2.75, 3.  ]), 0.25) <class'tuple'>
9.
ar3 = np.linspace(2.0, 3.0, num=5, retstep=True)
ar = ar3 [0]
bc = ar3 [1]
print("创建的数组为:",ar)
print("创建的数组的步长为：",bc)
输出结果：
创建的数组为: [2.  2.25 2.5  2.75 3.  ]
创建的数组的步长为： 0.25
10.创建数组_3  zeros()/zeros_like()/ones()/ones_like()
ar1 = np.zeros(5)
ar2 = np.zeros((2,2), dtype = np.int)
ar = np.zeros((3,3,3))
print(ar) #三维数组
print(ar1,ar1.dtype)
print(ar2,ar2.dtype)
print('------')
# s(shape, dtype=float, order='C')：返回给定形状和类型的新数组，⽤零填充。
# shape：数组纬度，⼆维以上需要⽤()，且输⼊参数为整数
# dtype：数据类型，默认numpy.float64
# order：是否在存储器中以C或Fortran连续（按⾏或列⽅式）存储多维数据。
ar3 = np.array([list(range(5)),list(range(5,10))])
ar4 = np.zeros_like(ar3)
print(ar3)
print(ar4)
print('------')
# 返回具有与给定数组相同的形状和类型的零数组，这⾥ar4根据ar3的形状和dtype创建⼀个全0的数组ar5 = np.ones(9)
ar6 = np.ones((2,3,4))
ar7 = np.ones_like(ar3)
print(ar5)
print(ar6)
print(ar7)
# ones()/ones_like()和zeros()/zeros_like()⼀样，只是填充为1
输出结果：
[[[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.] float64
[[0 0]
[0 0]] int32
------
[[0 1 2 3 4]
[5 6 7 8 9]]
[[0 0 0 0 0]
[0 0 0 0 0]]
------
[1. 1. 1. 1. 1. 1. 1. 1. 1.]
[[[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]]
[[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]]]
[[1 1 1 1 1]
[1 1 1 1 1]]
11. 创建数组_4 eye()
(5))
# 创建⼀个正⽅的N*N的单位矩阵，对⾓线值为1，其余为0
输出结果：
[[1. 0. 0. 0. 0.]
[0. 1. 0. 0. 0.]
[0. 0. 1. 0. 0.]
[0. 0. 0. 1. 0.]
[0. 0. 0. 0. 1.]]
ndarray的数据类型
bool ⽤⼀个字节存储的布尔类型（True或False）
inti 由所在平台决定其⼤⼩的整数（⼀般为int32或int64）
int8 ⼀个字节⼤⼩，-128 ⾄ 127
int16 整数，-32768 ⾄ 32767
int32 整数，-2 31 ⾄ 2 32 -1
int64 整数，-2 63 ⾄ 2 63 - 1
uint8 ⽆符号整数，0 ⾄ 255
uint16 ⽆符号整数，0 ⾄ 65535
uint32 ⽆符号整数，0 ⾄ 2 ** 32 - 1
uint64 ⽆符号整数，0 ⾄ 2 ** 64 - 1
float16 半精度浮点数：16位，正负号1位，指数5位，精度10位
float32 单精度浮点数：32位，正负号1位，指数8位，精度23位
float64或float 双精度浮点数：64位，正负号1位，指数11位，精度52位complex64 复数，分别⽤两个32位浮点数表⽰实部和虚部
complex128或complex 复数，分别⽤两个64位浮点数表⽰实部和虚部

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。