Numpy详解

最新推荐文章于 2024-08-26 19:57:40 发布

Charlie。

最新推荐文章于 2024-08-26 19:57:40 发布

阅读量2.3k

点赞数 2

分类专栏：机器学习文章标签：机器学习 python

本文链接：https://blog.csdn.net/caoyu1221/article/details/80657228

版权

机器学习专栏收录该内容

7 篇文章 13 订阅

订阅专栏

我在python机器学习入门到精通(一)里谈到里几个机器学习的几个基本包及其用法，可能有些小伙伴还是很茫然，在这里，我就对其中的numpy进行详解。
首先我们的演示都是在jupyter上面演示的，当然你得先安装jupyter，安装的步骤在这里就不讲了，我就在这里就说一些jupyter的一些简单基本的操作就足够了。Jupyter Notebook 有两种键盘输入模式。编辑模式，允许你往单元中键入代码或文本；这时的单元框线是绿色的。命令模式，键盘输入运行程序命令；这时的单元框线是灰色。

命令模式 (按键 Esc 开启)

Enter : 转入编辑模式
Shift-Enter : 运行本单元，选中下个单元
Ctrl-Enter : 运行本单元
Alt-Enter : 运行本单元，在其下插入新单元
Y : 单元转入代码状态
M :单元转入markdown状态
R : 单元转入raw状态
Shift-K : 扩大选中上方单元
Shift-J : 扩大选中下方单元
A : 在上方插入新单元
B : 在下方插入新单元
X : 剪切选中的单元
S : 文件存盘
L : 转换行号

编辑模式 ( Enter 键启动)

Tab : 代码补全或缩进
Shift-Tab : 提示
Ctrl-] : 缩进
Ctrl-A : 全选
Ctrl-Z : 复原
Ctrl-Home : 跳到单元开头
Ctrl-Up : 跳到单元开头
Ctrl-End : 跳到单元末尾
Esc : 进入命令模式
Ctrl-Backspace : 删除前面一个字
Ctrl-Delete : 删除后面一个字
Ctrl-M : 进入命令模式
Shift-Enter : 运行本单元，选中下一单元
Alt-Enter : 运行本单元，在下面插入一单元
Ctrl-S : 文件存盘
简单的魔法指令%run运行外部的python文件 %whos 查看声明了那些变量和函数 !ls 查看当前目录下的子文件和子目录 !pwd
在Numpy中， ndarray类具有六个参数，它们分别为：
shape:数组的形状。
dtype: 数据类型。
buffer：对象暴露缓冲区接口。
offset：数组数据的偏移量。
strides：数据步长。
order：{‘C’，’F’}，以行或列为主排列顺序。
下面，我们来了解创建ndarray的一些方法。在 numpy 中，我们主要通过以下 5 种途径创建数组，它们分别是：

nd1 = np.ndarray(shape=(5,4,3),dtype=np.int64)

type(nd1)
# 输出
numpy.ndarray

1.从 Python 数组结构列表，元组等转换。
2.使用 np.arange、np.ones、np.zeros 等 numpy 原生方法。
3.从存储空间读取数组。
4.通过使用字符串或缓冲区从原始字节创建数组。
5.使用特殊函数，如 random。

从列表或元组转换

在 numpy 中，我们使用 numpy.array 将列表或元组转换为 ndarray 数组。其方法为：

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

其中，参数：

object：列表、元组等。
dtype：数据类型。如果未给出，则类型为被保存对象所需的最小类型。
copy：布尔来写，默认 True，表示复制对象。

下面，通过列表创建一个 ndarray 数组：

l = list('123456')
nd2=np.array(l)
type(nd2)
# 输出
numpy.ndarray

`arange`方法创建

除了直接使用 array 方法创建 ndarray，在 numpy 中还有一些方法可以创建一些有规律性的多维数。首先，我们来看一看 arange()。arange() 的功能是在给定区间内创建一系列均匀间隔的值。方法如下：

numpy.arange(start, stop, step, dtype=None)

你需要先设置值所在的区间，这里为 [开始，停止），你应该能发现这是一个半开半闭区间。然后，在设置step步长用于设置值之间的间隔。最后的可选参数dtype可以设置返回ndarray` 的值类型。
比如：

nd3=np.arange(0,150,step=5,dtype=np.float32)
display(nd3.shape,nd3.dtype)
# 输出：
(30,)
dtype('float32')

nd3
#输出：
array([  0.,   5.,  10.,  15.,  20.,  25.,  30.,  35.,  40.,  45.,  50.,
        55.,  60.,  65.,  70.,  75.,  80.,  85.,  90.,  95., 100., 105.,
       110., 115., 120., 125., 130., 135., 140., 145.], dtype=float32)

`linspace` 方法创建

linspace方法也可以像arange方法一样，创建数值有规律的数组。inspace用于在指定的区间内返回间隔均匀的值。其方法如下：

numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

start：序列的起始值。
stop：序列的结束值。
num：生成的样本数。默认值为50。
endpoint：布尔值，如果为真，则最后一个样本包含在序列内。
retstep：布尔值，如果为真，返回间距。
dtype：数组的类型。
比如：

#全闭区间
nd4=np.linspace(0,150,num=151)
nd4.shape
# 输出：
(150,)

#不适用dtype属性改变默认的数据类型
#使用numpyd.astype(np.float32)
nd4.astype(np.int)
#输出：
array([  0,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  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,  36,  37,  38,
        39,  40,  41,  42,  43,  44,  45,  46,  47,  48,  49,  50,  51,
        52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  62,  63,  64,
        65,  66,  67,  68,  69,  70,  71,  72,  73,  74,  75,  76,  77,
        78,  79,  80,  81,  82,  83,  84,  85,  86,  87,  88,  89,  90,
        91,  92,  93,  94,  95,  96,  97,  98,  99, 100, 101, 102, 103,
       104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
       117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129,
       130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,
       143, 144, 145, 146, 147, 148, 149, 150])

`ones` 方法创建

numpy.ones 用于快速创建数值全部为 1 的多维数组。其方法如下：

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

其中：
shape:用于指定数组形状，例如（1， 2）或 3。
dtype:数据类型。
order：{ ‘C’, ‘F’}
例如：

nd5=np.ones(shape=(456,730,3))
nd5.dtype # 输出为：dtype('float64')
plt.imshow(nd5)
# 输出及图片
<matplotlib.image.AxesImage at 0xc6d9be0>

这里写图片描述

`zeros` 方法创建

zeros 方法和上面的 ones 方法非常相似，不同的地方在于，这里全部填充为 0。zeros 方法和 ones 是一致的。

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

其中：
shape：用于指定数组形状，例如（1， 2）或3。
dtype：数据类型。
order：{‘C’，’F’}，按行或列方式储存数组。
例如：

nd6 = np.zeros(shape=(456,730,3))
nd6.dtype #输出：dtype('float64')
#jpg  rgb   (0-255)
#png   rgb  (0-1)
plt.imshow(nd6)
# 输出及图片：
<matplotlib.image.AxesImage at 0xd72b668>

这里写图片描述

`full`方法创建

numpy.full用于创建一个自定义形状的数组，可以自己指定一个值，该值填满整个矩阵。

numpy.full(shape,fill_value=num)

例如：

nd7 = np.full(shape=(456,730,3),fill_value=125.0)
nd7.dtype # 输出：dtype('float64')
plt.imshow(nd7)
# 输出及图片：
<matplotlib.image.AxesImage at 0xc67db38>

这里写图片描述

`eye` 方法创建

numpy.eye 用于创建一个二维数组，其特点是k 对角线上的值为 1，其余值全部为0。方法如下：

numpy.eye(N, M=None, k=0, dtype=<type 'float'>)  
#k表示从下标第几个开始

其中：

N：输出数组的行数。
M：输出数组的列数。
k：对角线索引：0（默认）是指主对角线，正值是指上对角线，负值是指下对角线。

例如：

nd8 = np.eye(5,5)
nd8
# 输出：
array([[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.]])

从一张图去认识Numpy

下面我将用一个完整的例子及输出来串联这些知识点，用一张图片来认识numpy。

import numpy as np
# matplotlib画图，也可以读取图片
import matplotlib.pyplot as plt

# 图片，音频都叫流（数据流）
# 读取图片
cat = plt.imread('cat.png')
display(cat.shape)

# display(cat.shape)的输出结果
(864, 864, 4)

# 随机生成的rgb
im = np.random.randint(0, 255, size=(456,730,3))
# im = im.astype(np.float64)
plt.imshow(im)

这里写图片描述

# 显示图片
plt.imshow(cat)

这里写图片描述

display(cat,cat.shape)

# 输出结果
array([[[0.7529412 , 0.7529412 , 0.8       , 1.        ],
        [0.7529412 , 0.7529412 , 0.8       , 1.        ],
        [0.7529412 , 0.7529412 , 0.8       , 1.        ],
        ...,
        [0.14901961, 0.1254902 , 0.0627451 , 1.        ],
        [0.14901961, 0.1254902 , 0.0627451 , 1.        ],
        [0.14901961, 0.1254902 , 0.0627451 , 1.        ]],

       [[0.7529412 , 0.7529412 , 0.8       , 1.        ],
        [0.7529412 , 0.7529412 , 0.8       , 1.        ],
        [0.7529412 , 0.7529412 , 0.8       , 1.        ],
        ...,
        [0.14901961, 0.1254902 , 0.0627451 , 1.        ],
        [0.14901961, 0.1254902 , 0.0627451 , 1.        ],
        [0.14901961, 0.1254902 , 0.0627451 , 1.        ]],

       [[0.7490196 , 0.75686276, 0.8039216 , 1.        ],
        [0.7490196 , 0.75686276, 0.8039216 , 1.        ],
        [0.7490196 , 0.75686276, 0.8039216 , 1.        ],
        ...,
        [0.14901961, 0.1254902 , 0.0627451 , 1.        ],
        [0.14901961, 0.1254902 , 0.0627451 , 1.        ],
        [0.14901961, 0.1254902 , 0.0627451 , 1.        ]],

       ...,

       [[0.8862745 , 0.8117647 , 0.827451  , 1.        ],
        [0.8862745 , 0.8117647 , 0.827451  , 1.        ],
        [0.8862745 , 0.8117647 , 0.827451  , 1.        ],
        ...,
        [0.9098039 , 0.85490197, 0.85490197, 1.        ],
        [0.9098039 , 0.85490197, 0.85490197, 1.        ],
        [0.9098039 , 0.85490197, 0.85490197, 1.        ]],

       [[0.8862745 , 0.8117647 , 0.827451  , 1.        ],
        [0.8862745 , 0.8117647 , 0.827451  , 1.        ],
        [0.8862745 , 0.8117647 , 0.827451  , 1.        ],
        ...,
        [0.9098039 , 0.85490197, 0.85490197, 1.        ],
        [0.9098039 , 0.85490197, 0.85490197, 1.        ],
        [0.9098039 , 0.85490197, 0.85490197, 1.        ]],

       [[0.8862745 , 0.8117647 , 0.827451  , 1.        ],
        [0.8862745 , 0.8117647 , 0.827451  , 1.        ],
        [0.8862745 , 0.8117647 , 0.827451  , 1.        ],
        ...,
        [0.9098039 , 0.85490197, 0.85490197, 1.        ],
        [0.9098039 , 0.85490197, 0.85490197, 1.        ],
        [0.9098039 , 0.85490197, 0.85490197, 1.        ]]], dtype=float32)
(864, 864, 4)

# 全闭区间
nd4=np.linspace(0, 150, num=150)
nd4.shape
nd4

# 输出结果
array([  0.        ,   1.00671141,   2.01342282,   3.02013423,
         4.02684564,   5.03355705,   6.04026846,   7.04697987,
         8.05369128,   9.06040268,  10.06711409,  11.0738255 ,
        12.08053691,  13.08724832,  14.09395973,  15.10067114,
        16.10738255,  17.11409396,  18.12080537,  19.12751678,
        20.13422819,  21.1409396 ,  22.14765101,  23.15436242,
        24.16107383,  25.16778523,  26.17449664,  27.18120805,
        28.18791946,  29.19463087,  30.20134228,  31.20805369,
        32.2147651 ,  33.22147651,  34.22818792,  35.23489933,
        36.24161074,  37.24832215,  38.25503356,  39.26174497,
        40.26845638,  41.27516779,  42.28187919,  43.2885906 ,
        44.29530201,  45.30201342,  46.30872483,  47.31543624,
        48.32214765,  49.32885906,  50.33557047,  51.34228188,
        52.34899329,  53.3557047 ,  54.36241611,  55.36912752,
        56.37583893,  57.38255034,  58.38926174,  59.39597315,
        60.40268456,  61.40939597,  62.41610738,  63.42281879,
        64.4295302 ,  65.43624161,  66.44295302,  67.44966443,
        68.45637584,  69.46308725,  70.46979866,  71.47651007,
        72.48322148,  73.48993289,  74.4966443 ,  75.5033557 ,
        76.51006711,  77.51677852,  78.52348993,  79.53020134,
        80.53691275,  81.54362416,  82.55033557,  83.55704698,
        84.56375839,  85.5704698 ,  86.57718121,  87.58389262,
        88.59060403,  89.59731544,  90.60402685,  91.61073826,
        92.61744966,  93.62416107,  94.63087248,  95.63758389,
        96.6442953 ,  97.65100671,  98.65771812,  99.66442953,
       100.67114094, 101.67785235, 102.68456376, 103.69127517,
       104.69798658, 105.70469799, 106.7114094 , 107.71812081,
       108.72483221, 109.73154362, 110.73825503, 111.74496644,
       112.75167785, 113.75838926, 114.76510067, 115.77181208,
       116.77852349, 117.7852349 , 118.79194631, 119.79865772,
       120.80536913, 121.81208054, 122.81879195, 123.82550336,
       124.83221477, 125.83892617, 126.84563758, 127.85234899,
       128.8590604 , 129.86577181, 130.87248322, 131.87919463,
       132.88590604, 133.89261745, 134.89932886, 135.90604027,
       136.91275168, 137.91946309, 138.9261745 , 139.93288591,
       140.93959732, 141.94630872, 142.95302013, 143.95973154,
       144.96644295, 145.97315436, 146.97986577, 147.98657718,
       148.99328859, 150.        ])

# 不使用dtype属性改变默认的数据类型
# 使用numpyd.astype(np.float32)
nd4.astype(np.int)

# 输出结果
array([  0,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  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,  36,  37,  38,
        39,  40,  41,  42,  43,  44,  45,  46,  47,  48,  49,  50,  51,
        52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  62,  63,  64,
        65,  66,  67,  68,  69,  70,  71,  72,  73,  74,  75,  76,  77,
        78,  79,  80,  81,  82,  83,  84,  85,  86,  87,  88,  89,  90,
        91,  92,  93,  94,  95,  96,  97,  98,  99, 100, 101, 102, 103,
       104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
       117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129,
       130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,
       143, 144, 145, 146, 147, 148, 150])