NumPy~学习总结（读书笔记作业）

什么是 NumPy?

        NumPy（Numerical Python 的缩写）是Python中科学计算的基础包。它是一个Python库，提供多维数组对象，各种派生对象（如掩码数组和矩阵），以及用于数组快速操作的各种API，有包括数学、逻辑、形状操作、排序、选择、输入输出、离散傅立叶变换、基本线性代数，基本统计运算和随机模拟等等。

                                                                                                                                                                                                                                ----NumPy官方中文文档

        应用场景：NumPy 通常与 SciPy（Python科学计算库）和 Matplotlib（Python绘图库）等软件包组合使用，这种组合方式被用来广泛地代替 MatLab 的使用。

安装和导入NumPy

使用Python包管理器pip命令安装

# windows下安装（或安装Ancaonda）
pip install numpy
#这里的NumPy需要小写为numpy，后面导入的时候也是这样！！！

使用前请先导入Numpy包！

import numpy 
#  通常起个名字：np
import numpy as np

查看你自己的NumPy版本

import numpy as np
print(np.__version__)
# 1.导包
# 2.双下划线

NumPy Ndarray 对象

Numpy提供了两种基本对象：

- ndarray：多维数组，后简称数组

- ufunc：能够对多维数组（数组）进行处理的特殊函数

        NumPy库的核心对象是n维数组对象ndarray，其中的所有函数都是对ndarray对象进行操作。（ndarray数组能对整块数据进行运算，而且其中存储的所有元素都是相同类型， 且每个元素在内存中都有相同存储大小的区域）ndarray能直接直接保存数据，而列表存储的是对象引用。

numpy.array(object, dtype = None, copy = Ture, order = None, subok = False, ndmin = 0)

参数说明：

名称	描述
object	可以是数组或者嵌套的数列
dtype	数组元素的数据类型，可选
copy	对象是否需要复制，可选
order	创建数组的样式，C为行方向，F为列方向，A为默认（任意方向）
subok	默认返回一个与基类类型一致的数组
ndmin	生成指定数组的最小维度

下面提供一些示例方便理解：

import numpy as np

# 创建一个一维数组
a = np.array([1,2,3])  
print (a)  # [1 2 3]

# 多于一个维度  
a = np.array([[1,  2],  [3,  4]])  
print (a)  
# [[1  2] 
# [3  4]]

# 最小维度  
a = np.array([1, 2, 3, 4, 5], ndmin =  2)  
print (a)  # [[1 2 3 4 5]]

# dtype 参数  
a = np.array([1,  2,  3], dtype = complex)  
print (a)  # [1.+0.j 2.+0.j 3.+0.j]

数组的基本属性：

属性	含义
ndarray.ndim	数组的维度
ndarray.shape	数组的维度大小，返回一个元组。 对于n行m列的数组维度大小为（n，m）
ndarray.size	数组中元素的总数等于行乘列
ndarray.dtype	数组的元素类型（可指定元素类型）
ndarray.itemsize	数组中每个元素的大小（以字节为单位）
ndarray.data	生成指向数组首地址的一个memoryview对象

创建一个 ndarray 只需调用 NumPy 的 array 函数即可：

import numpy as np

a = np.array([0, 1, 2, 3, 4])
# [0 1 2 3 4]
"""
使用array函数时传递一个序列生成数组，若传递多层嵌套序列则创建一个多维数组
NumPy会为新创建的数组推断一个合适的数据类型并且该参数会保存在dtype中
"""
a.ndim  # 返回数组的维度结果为1
a.shape  # 返回数组维度的大小结果为(5,)
a.size  # 返回数组中元素总数结果为5
a.dtype  # 返回数组元素类型结果为int32
a.itemsize  # 返回数组元素的大小结果为4（字节）
a.data  # 返回指向首地址的指针

a = np.array((0, 1, 2, 3, 4))
# [0 1 2 3 4]
a = np.arange(5)
# [0 1 2 3 4]
a = np.linspace(0, 2*np.pi, 5)
# [ 0.          1.57079633  3.14159265  4.71238898  6.28318531] 以均匀步长生成数字序列

# 可以通过astype()方法转换为元素类型
arr = np.array([1, 2, 3; 4, 5, 6], dtype = np.float64)  # 指定元素类型为float64型
arr.astype(np.str_)  # 转换元素类型为Unicode
# 输出为array(['1.0', '2.0', '3.0', '4.0', '5.0', '6.0'], dtype='

reshape() 函数~数组变维

imoprt numpy as np

# reshape（x,y）函数第一个参数是想要转换成的行数第二个参数是想要转换成的列数

a = np.array([[1,2],[2,3],[3,4]])  # a是一个三行两列的数组
print(a)
b = a.reshape(2,3)  # 通过reshape函数变为了两行三列的数组
print(b)
#a
#[[1 2]
#[3 4]
#[5 6]]

#b
#[[1 2 3]
#[4 5 6]]

NumPy数据类型

        NumPy 作为 Python 的扩展包，它提供了比 Python 更加丰富的数据类型。

NumPy数据类型

数据类型表

名称	描述
bool_	布尔型数据类型（True 或者 False）
int_	默认的整数类型（类似于 C 语言中的 long，int32 或 int64）
intc	与 C 的 int 类型一样，一般是 int32 或 int 64
intp	用于索引的整数类型（类似于 C 的 ssize_t，一般情况下仍然是 int32 或 int64）
int8	字节（-128 to 127）
int16	整数（-32768 to 32767）
int32	整数（-2147483648 to 2147483647）
int64	整数（-9223372036854775808 to 9223372036854775807）
uint8	无符号整数（0 to 255）
uint16	无符号整数（0 to 65535）
uint32	无符号整数（0 to 4294967295）
uint64	无符号整数（0 to 18446744073709551615）
float_	float64 类型的简写
float16	半精度浮点数，包括：1 个符号位，5 个指数位，10 个尾数位
float32	单精度浮点数，包括：1 个符号位，8 个指数位，23 个尾数位
float64	双精度浮点数，包括：1 个符号位，11 个指数位，52 个尾数位
complex_	complex128 类型的简写，即 128 位复数
complex64	复数，表示双 32 位浮点数（实数部分和虚数部分）
complex128	复数，表示双 64 位浮点数（实数部分和虚数部分）
str_	表示字符串类型
string_	表示字节串类型

数据类型对象（dtype）

        数据类型对象又称为dtype对象，主要用来描述数组元素的数据类型、大小以及字节顺序。同时，它也可以用来创建结构化数据。比如常见的 int64、float32 都是 dtype 对象的实例。

- 数据的类型（整数，浮点数或者 Python 对象）

- 数据的大小（例如， 整数使用多少个字节存储）

- 数据的字节顺序（小端法或大端法）

- 在结构化类型的情况下，字段的名称、每个字段的数据类型和每个字段所取的内存块的部分

- 如果数据类型是子数组，那么它的形状和数据类型是什么。

        字节顺序是通过对数据类型预先设定 < 或 > 来决定的。 < 意味着小端法(最小值存储在最小的地址，即低位组放在最前面)。> 意味着大端法(最重要的字节存储在最小的地址，即高位组放在最前面)。

dtype语法

numpy.dtype(object, align, copy)

- object - 要转换为的数据类型对象

- align - 如果为True，填充字段使其类似C的结构体

- copy - 复制dtype对象，如果为False，则是对内饰数据类型对象的引用

import numpy as np
# 使用标量类型
a1 = np.dtype(np.int32)
print(a1)  # int32

# int8, int16, int32, int64 四种数据类型可以使用字符串 'i1', 'i2','i4','i8' 代替
a2 = np.dtype('i4')
print(a2)  # int32

# 将数据类型应用于 ndarray 对象
a3 = np.dtype([('age',np.int8)]) 
a4 = np.array([(10,),(20,),(30,)], dtype = a3) 
print(a)  # [(10,) (20,) (30,)]

# 类型字段名可以用于存取实际的 age 列
a5 = np.dtype([('age',np.int8)]) 
a6 = np.array([(10,),(20,),(30,)], dtype = a5) 
print(a['age'])  # [10 20 30]

# 定义一个结构化数据类型 student，包含字符串字段 name，整数字段 age，及浮点字段 marks，并将这个 # dtype 应用到 ndarray 对象。
student = np.dtype([('name','S20'), ('age', 'i1'), ('marks', 'f4')]) 
a = np.array([('abc', 21, 50),('xyz', 18, 75)], dtype = student) 
print(a)  # [('abc', 21, 50.0), ('xyz', 18, 75.0)]


# 数组的 dtype 为 int8（一个字节）(ndarray.itemsize 以字节的形式返回数组中每一个元素的大小。)
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

数据类型标识码

NumPy中每种数据类型都有一个唯一标识的字符码，如下图所示：

标识码表

字符	对应类型
b	代表布尔型
i	带符号整型
u	无符号整型
f	浮点型
c	复数浮点型
m	时间间隔（timedelta）
M	datatime（日期时间）
O	Python对象
S,a	字节串（S）与字符串（a）
U	Unicode
V	原始数据（void）

创建ndarray数组

创建 ndarray 数组的方法

        除了使用 array() 方法外，NumPy 还提供了其他创建 ndarray 数组的方法。

numpy.empty

numpy.empty 方法用来创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组：

numpy.empty(shape, dtype = float, order = 'C')

参数	描述
shape	数组形状
dtype	数据类型，可选
order	有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。

import numpy as np 
arr = np.empty((2.3), dtype = int, order = 'F') 
print(arr) 
"""
输出结果为：
[[1740919781 1699243488]
 [     12290          0]
 [         0          0]]
数组元素是内存随机给的值，因为未被初始化
"""

numpy.zeros

创建指定大小的数组，数组元素以 0 来填充：

numpy.zeros(shape, dtype = float, order = 'C')
# 参数说明同上

import numpy as np
 
# 默认为浮点数
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)]]
"""

numpy.ones

创建指定形状的数组，数组元素以 1 来填充：

numpy.ones(shape, dtype = None, order = 'C')

import numpy as np
 
# 默认为浮点数
x = np.ones(5) 
print(x)  # [1. 1. 1. 1. 1.]

 
# 自定义类型
x = np.ones([2,2], dtype = int)
print(x)
"""
[[1 1]
 [1 1]]
"""

numpy.full

返回给定维度和类型的新数组，填充 fill_value。

numpy.full(shape, fill_value, dtype=None, order='C')

参数	描述
shape	返回数组为度
fill_value	填充值
dtype	返回数组的数据类型，默认值 None 指：np.array(fill_value).dtype
order	有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。

import numpy as np
a = np.full((2, 3), 7)
print(a)
"""
[[7 7 7]
 [7 7 7]]
"""

NumPy 从已有的数组创建数组

numpy.asarray

        numpy.asarray 类似 numpy.array，但 numpy.asarray 参数只有三个，比 numpy.array 少两个。

numpy.asarray(a, dtype = None, order = None)
numpy.array(object, dtype = None, copy = Ture, order = None, subok = False, ndmin = 0)

import numpy as np 
 
x =  [1,2,3]  # 或者是一个元组 x =  (1,2,3)  # 也可以是一个元组列表 x =  [(1,2,3),(4,5)]  
a = np.asarray(x)  # 或者你可以加dtype参数:a = np.asarray(x, dtype =  float)  
print (a)

numpy.frombuffer

numpy.frombuffer 用于实现动态数组。numpy.frombuffer 接受 buffer 输入参数，以流的形式读入转化成 ndarray 对象。

numpy.frombuffer(buffer, dtype = float, count = -1, offset = 0)

注意：buffer 是字符串的时候，Python3 默认 str 是 Unicode 类型，所以要转成 bytestring 在原 str 前加上 b。

参数	描述
buffer	可以是任意对象，会以流的形式读入。
dtype	返回数组的数据类型，可选
count	读取的数据数量，默认为-1，读取所有数据。
offset	读取的起始位置，默认为0。

import numpy as np

a = np.frombuffer(b'Hello World', 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']

import numpy as np
import array

a = array.array('i', [1, 2, 3, 4])
print(a)

na = np.frombuffer(a, dtype=np.int_)  # 数据值会动态改变
print(na)

a[0] = 10
print(a)
print(na)

"""四个输出
array('i', [1, 2, 3, 4])
[1 2 3 4]
array('i', [10, 2, 3, 4])
[10  2  3  4]
"""

array.array 创建的数组对象内存是连续的（这里不能用 list，会报：AttributeError: 'list' object has no attribute 'buffer'），numpy.frombuffer 从 array.array 的内存中创建数组，从上例中可以看出，改变 array.array 的值，numpy.frombuffer 的值也会跟着改变。array.array 数组中的值改变是可以的，但是如果是添加值，那就不行了。

import numpy as np
import array

a = array.array("i", [1, 2, 3, 4])
na = np.frombuffer(a, dtype=int)
print(na)

a.append(5)
print(na)

"""
输出为
[1 2 3 4]
[140896288       381         3         4]  # 出错啦！
"""

numpy.fromiter

numpy.fromiter 方法从可迭代对象中建立 ndarray 对象，返回一维数组。

numpy.fromiter(iterable, dtype, count=-1)

参数	描述
iterable	可迭代对象
dtype	返回数组的数据类型
count	读取的数据数量，默认为-1，读取所有数据

import numpy as np 
 
# 使用 range 函数创建列表对象  
list=range(5)
it=iter(list)
 
# 使用迭代器创建 ndarray 
x=np.fromiter(it, dtype=float)
print(x)  # 结果是 [0. 1. 2. 3. 4.]

看起来有点像 numpy.array，array 方法需要传入的是一个 list，而 fromiter 可以传入可迭代对象。

import numpy as np

iterable = (x * x for x in range(5))
a = np.array(iterable)
print(a)  # 结果是  at 0x000000001442DD00>

下面的例子需要下载seaborn的基础数据包（在我的资源里面可以下这个数据包的 .zip文件）讲下载的文件解压后放在c盘user目录下（例如：C:\Users\ASUS）即可

 

 

参考文献：

NumPy官方中文文档https://www.numpy.org.cn/https://www.numpy.org.cn/

菜鸟教程https://www.runoob.com/https://www.runoob.com/

c语言中文网http://c.biancheng.net/http://c.biancheng.net/