标签：type dtype 学习 np 数组 numpy print NumPy
继续学习NumPy
numpy_test2.py ：
import numpy
import numpy as np
'''
4, Numpy创建数组
除了使用 array() 方法外，NumPy 还提供了其他创建 ndarray 数组的方法。
1) numpy.empty()
numpy.empty() 创建未初始化的数组，可以指定创建数组的形状（shape）和数据类型（dtype），语法格式如下：
numpy.empty(shape, dtype = float, order = 'C')
它接受以下参数：
shape：指定数组的形状；如 (3,3) : 三行三列数组
dtype：数组元素的数据类型，默认值是值 float；
order：指数组元素在计算机内存中的储存顺序，默认顺序是“C”(行优先顺序)。
“C”代表以行顺序存储，“F”则表示以列顺序存储
'''
print("-----------numpy.empty()-------------")
arr1 = np.empty((3,3), dtype=int)
print('arr1 :', arr1)
'''
arr1 : [[1064435968 -637534208 1836412421]
[ 19495280 1869416154 1701606756]
[ 867 0 768]]
可以看到，numpy.empty() 返回的数组带有随机值，但这些数值并没有实际意义。
切记 empty 并非创建空数组。
'''
'''
2) numpy.zeros()
该函数用来创建元素均为 0 的数组，同时还可以指定被数组的形状，语法格式如下：
numpy.zeros(shape,dtype=float,order="C")
参数说明
参数名称 说明描述
shape：指定数组的形状大小。
dtype：可选项，数组的数据类型，默认值是值 float。
order：指数组元素在计算机内存中的储存顺序，默认顺序是“C”(行优先顺序)。
“C”代表以行顺序存储，“F”则表示以列顺序存储
'''
print("-----------numpy.zeros()-------------")
#默认数据类型为浮点数
arr2 = np.zeros(6)
print('arr2 :', arr2)
arr3 = np.zeros((3,3), dtype=int)
print('arr3 :', arr3)
'''
arr2 : [0. 0. 0. 0. 0. 0.]
arr3 : [[0 0 0]
[0 0 0]
[0 0 0]]
numpy.zeros() 跟 numpy.empty() 类似，只是创建的数组初始值为0.
'''
'''
3) numpy.ones()
返回指定形状大小与数据类型的新数组，并且新数组中每项元素均用 1 填充，语法格式如下：
numpy.ones(shape, dtype = None, order = 'C')
参数说明
参数名称 说明描述
shape：指定数组的形状大小。
dtype：可选项，数组的数据类型，默认值是值 float。
order：指数组元素在计算机内存中的储存顺序，默认顺序是“C”(行优先顺序)。
“C”代表以行顺序存储，“F”则表示以列顺序存储
'''
print("-----------numpy.ones()-------------")
arr4 = np.ones((3, 3), dtype=int)
print('arr4 :', arr4)
'''
arr4 : [[1 1 1]
[1 1 1]
[1 1 1]]
numpy.ones() 跟 numpy.zeros() 类似，只是创建的数组初始值为1.
'''
'''
4) numpy.asarray()
asarray() 与 array() 类似，但是它比 array() 更为简单。
asarray() 能够将一个 Python 序列转化为 ndarray 对象，语法格式如下：
numpy.asarray(sequence，dtype = None ，order = None)
参数说明
参数名称 说明描述
sequence：接受一个 Python 序列，可以是列表或者元组；
dtype：可选项，数组的数据类型，默认值是Python原序列的数据类型。
order：指数组元素在计算机内存中的储存顺序，默认顺序是“C”(行优先顺序)。
“C”代表以行顺序存储，“F”则表示以列顺序存储
'''
print("-----------numpy.asarray()-------------")
# 将列表转化为 numpy 数组：
pyList = [1, 2, 4, 6, 7, 9]
arr5 = np.asarray(pyList)
print('type(arr5) :', type(arr5))
print('arr5 :', arr5)
'''
type(arr5) : <class 'numpy.ndarray'>
arr5 : [1 2 4 6 7 9]
'''
# 使用元组创建 numpy 数组：
pyTuple = (1.1, 2.3, 4.3, 6.2, 7.8, 9.0)
arr6 = np.asarray(pyTuple)
print('type(arr6) :', type(arr6))
print('arr6 :', arr6)
'''
type(arr6) : <class 'numpy.ndarray'>
arr6 : [1.1 2.3 4.3 6.2 7.8 9. ]
'''
# 使用嵌套列表创建多维数组：
pyListArray = [[1, 2, 3], [6, 5, 4], [3, 6, 9]]
arr7 = np.asarray(pyListArray)
print('type(arr7) :', type(arr7))
print('arr7 :', arr7)
'''
type(arr7) : <class 'numpy.ndarray'>
arr7 : [[1 2 3]
[6 5 4]
[3 6 9]]
'''
'''
5) numpy.frombuffer()
表示使用指定的缓冲区创建数组。下面给出了该函数的语法格式：
numpy.frombuffer(buffer, dtype = float, count = -1, offset = 0)
参数说明
参数名称 说明描述
buffer：将任意对象转换为流的形式读入缓冲区；
dtype：返回数组的数据类型，默认是 float32；
count：要读取的数据数量，默认为 -1 表示读取所有数据；
offset：读取数据的起始位置，默认为 0。
'''
print("-----------numpy.frombuffer()-------------")
#字节串类型
strList = b'PandaCode'
print('type(strList) :', type(strList))
print('strList :', strList)
arr8 = np.frombuffer(strList, dtype = "S1")
print('type(arr8) :', type(arr8))
print('arr8 :', arr8)
'''
type(strList) : <class 'bytes'>
strList : b'PandaCode'
type(arr8) : <class 'numpy.ndarray'>
arr8 : [b'P' b'a' b'n' b'd' b'a' b'C' b'o' b'd' b'e']
'''
'''
6) numpy.fromiter()
该方法可以把迭代对象转换为 ndarray 数组，其返回值是一个一维数组。
numpy.fromiter(iterable, dtype, count = -1)
参数说明
参数名称 说明描述
iterable: 可迭代对象。
dtype: 返回数组的数据类型。
count: 读取的数据数量，默认为 -1，读取所有数据。
'''
print("-----------numpy.fromiter()-------------")
# 使用 range 函数创建列表对象
list1 = range(8)
#print('list1 :',list1)
#生成可迭代对象i
iter1 = iter(list1)
#print('iter1 :',iter1)
#使用i迭代器，通过fromiter方法创建ndarray
arr9 = np.fromiter(iter1, dtype=float)
print('type(arr9) :', type(arr9))
print('arr9 :', arr9)
'''
type(arr9) : <class 'numpy.ndarray'>
arr9 : [0. 1. 2. 3. 4. 5. 6. 7.]
'''
'''
5, NumPy创建区间数组
所谓区间数组，是指数组元素的取值位于某个范围内，并且数组元素之间可能会呈现某种规律，比如等比数列、递增、递减等。
为了方便科学计算，Python NumPy 支持创建区间数组。
1) numpy.arange()
在 NumPy 中，您可以使用 arange() 来创建给定数值范围的数组，语法格式如下：
numpy.arange(start, stop, step, dtype)
参数说明
参数名称 说明描述
start 起始值，默认是 0。
stop 终止值，注意生成的数组元素值不包含终止值。
step 步长，默认为 1。
dtype 可选参数，指定 ndarray 数组的数据类型。
根据start与stop指定的范围以及step步长值，生成一个 ndarray 数组，示例如下。
'''
print("-----------numpy.arange()-------------")
arr10 = np.arange(10)
print('arr10 :', arr10)
# 设置 start 、stop 值以及步长，最终输出 0-10 中的奇数：
arr11 = np.arange(1,10,2)
print('arr11 :', arr11)
'''
arr10 : [0 1 2 3 4 5 6 7 8 9]
arr11 : [1 3 5 7 9]
'''
'''
2) numpy.linspace()
表示在指定的数值区间内，返回均匀间隔的一维【等差数组】，默认均分 50 份，语法格式如下：
np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
参数说明
参数名称 说明描述
start：代表数值区间的起始值；
stop：代表数值区间的终止值；
num：表示数值区间内要生成多少个均匀的样本。默认值为 50；
endpoint：默认为 True，表示数列包含 stop 终止值，反之不包含；
retstep：默认为 False，表示生成的数组中会不显示公差项，反之显示；
dtype：代表数组元素值的数据类型。
'''
print("-----------numpy.linspace()-------------")
# 1-10之间，生成4个样本
arr12 = np.linspace(1, 10, 4)
print('arr12 :', arr12)
# endpoint 为 Fasle 时，此时不包含终止值：
arr13 = np.linspace(1, 10, 4, endpoint=False)
print('arr13 :', arr13)
# retstep 为 True 时，显示公差项：
arr14 = np.linspace(1, 10, 4, retstep=True)
print('arr14 :', arr14)
'''
arr12 : [ 1. 4. 7. 10.]
arr13 : [1. 3.25 5.5 7.75]
arr14 : (array([ 1., 4., 7., 10.]), 3.0)
'''
'''
3) numpy.logspace()
该函数同样返回一个 ndarray 数组，它用于创建【等比数组】，语法格式如下：
np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)
参数说明
参数名称 说明描述
start 序列的起始值：base**start。
stop 序列的终止值：base**stop。
num 数值范围区间内样本数量，默认为 50。
endpoint 默认为 True 包含终止值，反之不包含。
base 对数函数的 log 底数，默认为10。
dtype 可选参数，指定 ndarray 数组的数据类型。
'''
print("-----------numpy.logspace()-------------")
# 10的1次方和2次方即 10-100之间，生成5个样本
arr15 = np.logspace(1, 2, num=5)
print('arr15 :', arr15)
# base = 2 的对数函数
arr16 = np.logspace(1, 9, num=9, base=2)
print('arr16 :', arr16)
'''
arr15 : [ 10. 17.7827941 31.6227766 56.23413252 100. ]
arr16 : [ 2. 4. 8. 16. 32. 64. 128. 256. 512.]
'''
'''
6， Numpy索引和切片
在 NumPy 中，如果想要访问，或修改数组中的元素，您可以采用索引或切片的方式，
比如使用从 0 开始的索引依次访问数组中的元素，这与 Python 的 list 列表是相同的。
NumPy 提供了多种类型的索引方式，常用方式有两种：基本切片与高级索引。这里重点讲解基本切片。
1） 基本切片
NumPy 内置函数 slice() 可以用来构造切片对象，
slice(start, stop, step)
该函数需要传递三个参数值分别是 start（起始索引）、stop（终止索引） 和 step（步长） ，
通过它可以实现从原数组的上切割出一个新数组。
'''
print("-----------基本切片，slice()-------------")
arr17 = np.arange(10)
print('arr17 :', arr17)
#生成切片对象，生成一个(从索引2开始，到索引8停止，间隔步长为2)的切片对象
slc = slice(2,8,2)
arr18 = arr17[slc]
print('arr18 = arr17[slice(2,8,2)]切片对象切片 :',arr18)
#也可以通过冒号来分割切片参数，最终也能获得相同结果
arr19 = arr17[2:8:2]
print('arr19 = arr17[2:8:2]冒号来分割切片 :',arr19)
'''
arr17 : [0 1 2 3 4 5 6 7 8 9]
arr18 = arr17[slice(2,8,2)]切片对象切片 : [2 4 6]
arr19 = arr17[2:8:2]冒号来分割切片 : [2 4 6]
对冒号切片做简单地说明：
如果仅输入一个参数，则将返回与索引相对应的元素。 对于上述示例来说[3] 就会返回 3。
如果在其前面插入“:”如[:8]，则会返回 0-7 的所有数字（不包含8）。
如是 [3:] 则会返回 3-9 之间的数字。
如果在两个参数之间，如[4:8]，则对两个索引值之间的所有元素进行切片（不包括停止索引）。
如果在三个参数之间，如[2:8:2]，则对两个索引值之间的所有元素（不包括停止索引）2-7，步长为2，进行切片。
'''
'''
2) 多维数组切片
'''
print("-----------基本切片，多维数组切片-------------")
arr20 = np.array([[1, 2, 3], [6, 4, 3], [7, 8, 9]])
print('arr20 :', arr20)
# 从[1:]索引处开始切割
arr21 = arr20[1:]
print('arr21 :', arr21)
'''
arr20 : [[1 2 3]
[6 4 3]
[7 8 9]]
arr21 : [[6 4 3]
[7 8 9]]
'''
'''
注意：切片还可以使用省略号“…”，如果在行位置使用省略号，那么返回值将包含所有行元素，反之，则包含所有列元素。
'''
arr22 = arr20[...,1]
#返回数组的第二列
print('arr22,返回数组的第二列 :', arr22)
#返回数组的第二行
arr23 = arr20[1,...]
print('arr23,返回数组的第二行 :', arr23)
#返回第二列后的所有项
arr24 = arr20[...,1:]
print('arr24,返回第二列后的所有项 :', arr24)
'''
arr22,返回数组的第二列 : [2 4 8]
arr23,返回数组的第二行 : [6 4 3]
arr24,返回第二列后的所有项 : [[2 3]
[4 3]
[8 9]]
'''
标签：type,
dtype,
学习,
np,
数组,
numpy,
print,
NumPy
From： https://www.cnblogs.com/xh2023/p/17429336.html