前言

正式开始学习Numpy，参考用书是《用Python进行数据清洗》，计划本周五之前把本书读完，关键代码全部实现一遍

NumPy基础：数组和矢量计算

按照书中所示，要搞明白具体的性能差距，考察一个包含一百万整数的数组，和一个等价的Python列表：

import numpy as np

my_arr = np.arange(1000000)

my_list = list(range(1000000))

各个序列分别乘以2：

%time for _ in range(10): my_arr2 = my_arr * 2

CPU times: user 20 ms, sys: 50 ms, total: 70 ms

Wall time: 72.4 ms

%time for _ in range(10): my_list2 = [x * 2 for x in my_list]

CPU times: user 760 ms, sys: 290 ms, total: 1.05 s

Wall time: 1.05 s

问题

此处出现报错

%time for _ in range(10): my_arr2 = my_arr * 2

    ^

SyntaxError: invalid syntax

据查阅，原来这不是python的语法，是ipython的特殊功能，用于测试语句运行的时间。于是cmd中直接启动ipython，再运行

In [4]: %time for _ in range(10): my_arr2 = my_arr * 2

Wall time: 15.7 ms

In [5]: %time for _ in range(10): my_list2 = [x * 2 for x in my_list]

Wall time: 753 ms

正如书中所说，基于NumPy的算法要比纯Python快了接近50倍

NumPy的ndarray：一种多维数组对象

创建ndarray

创建数组最简单的办法就是使用array函数。它接受一切序列型的对象（包括其他数组），然后产生一个新的含有传入数据的NumPy数组。以一个列表的转换为例：

In [19]: data1 = [6, 7.5, 8, 0, 1]

In [20]: arr1 = np.array(data1)

In [21]: arr1

Out[21]: array([ 6. ,  7.5,  8. ,  0. ,  1. ])

In [25]: arr2.ndim

Out[25]: 2

In [26]: arr2.shape

Out[26]: (2, 4)

注：这里的ndim和shape是数组的维度属性

可以看出，array函数中所有元素类型必须相同，不相同的会被强制转换，同时他还会为所建的数组中数据推断出一个合适的数据类型，除非有特殊说明

In [11]: data1 = [6, 7.5, 8, 0, 1]

In [12]: arr1 = np.array(data1)

In [13]: arr1

Out[13]: array([6. , 7.5, 8. , 0. , 1. ])

In [14]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]

In [15]: arr2 = np.array(data2)

In [16]: arr2

Out[16]:

array([[1, 2, 3, 4],

       [5, 6, 7, 8]])

In [17]: arr1.dtype

Out[17]: dtype('float64')//数组一是浮点型所以自动分配了浮点型

In [18]: arr2.dtype

Out[18]: dtype('int32')//数组二是整型所以自动分配了浮点型

此外，zeros和ones分别可以创建指定长度或形状的全0或全1数组，empty可以创建一个没有任何具体值的数组，要用这些方法创建多维数组，只需传入一个表示形状的元组即可

In [29]: np.zeros(10)

Out[29]: array([ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.])

In [30]: np.zeros((3, 6))

Out[30]:

array([[ 0.,  0.,  0.,  0.,  0.,  0.],

       [ 0.,  0.,  0.,  0.,  0.,  0.],

       [ 0.,  0.,  0.,  0.,  0.,  0.]])

In [31]: np.empty((2, 3, 2))

Out[31]:

array([[[ 0.,  0.],

        [ 0.,  0.],

        [ 0.,  0.]],

       [[ 0.,  0.],

        [ 0.,  0.],

        [ 0.,  0.]]])

而arange是Python内置函数range的数组版

由于NumPy关注的是数值计算，因此，如果没有特别指定，数据类型基本都是float64（浮点数）

NumPy数组的运算

数组很重要，因为它使你不用编写循环即可对数据执行批量运算。NumPy用户称其为矢量化（vectorization）。大小相等的数组之间的任何算术运算都会将运算应用到元素级

数组与标量的算术运算会将标量值传播到各个元素

大小相同的数组之间的比较会生成布尔值数组

基本的索引和切片

当你将一个标量值赋值给一个切片时（如arr[5:8]=12），该值会自动传播（也就说后面将会讲到的“广播”）到整个选区。跟列表最重要的区别在于，数组切片是原始数组的视图。这意味着数据不会被复制，视图上的任何修改都会直接反映到源数组上

In [60]: arr = np.arange(10)

In [61]: arr

Out[61]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

In [64]: arr[5:8] = 12

In [65]: arr

Out[65]: array([ 0,  1,  2,  3,  4, 12, 12, 12,  8,  9])

由于numpy处理数据时并不会随意复制数据，所以性能和优化都得以大大的提升

同时在访问多维数组的时候，可以传入一个以逗号隔开的索引列表来选取单个元素，也可以用传统的C中数组读取方式，这两者等价

切片索引

对于二维数组其切片方式稍显不同，它是沿着第0轴（即第一个轴）切片的。也就是说，切片是沿着一个轴向选取元素的。表达式arr2d[:2]可以被认为是“选取arr2d的前两行”。

花式索引

花式索引（Fancy indexing）是一个NumPy术语，它指的是利用整数数组进行索引。假设我们有一个8×4数组

In [117]: arr = np.empty((8, 4))

In [118]: for i in range(8):

   .....:     arr[i] = i

In [119]: arr

Out[119]:

array([[ 0.,  0.,  0.,  0.],

       [ 1.,  1.,  1.,  1.],

       [ 2.,  2.,  2.,  2.],

       [ 3.,  3.,  3.,  3.],

       [ 4.,  4.,  4.,  4.],

       [ 5.,  5.,  5.,  5.],

       [ 6.,  6.,  6.,  6.],

       [ 7.,  7.,  7.,  7.]])

为了以特定顺序选取行子集，只需传入一个用于指定顺序的整数列表或ndarray即可：

In [120]: arr[[4, 3, 0, 6]]

Out[120]:

array([[ 4.,  4.,  4.,  4.],

       [ 3.,  3.,  3.,  3.],

       [ 0.,  0.,  0.,  0.],

       [ 6.,  6.,  6.,  6.]])

数组转置和轴对换

转置是重塑的一种特殊形式，它返回的是源数据的视图（不会进行任何复制操作）。数组不仅有transpose方法，还有一个特殊的T属性：

In [126]: arr = np.arange(15).reshape((3, 5))

In [127]: arr

Out[127]:

array([[ 0,  1,  2,  3,  4],

       [ 5,  6,  7,  8,  9],

       [10, 11, 12, 13, 14]])

In [128]: arr.T

Out[128]:

array([[ 0,  5, 10],

       [ 1,  6, 11],

       [ 2,  7, 12],

       [ 3,  8, 13],

       [ 4,  9, 14]])

通用函数：快速的元素级数组函数

（总算看到这里）

利用数组进行数据处理

该函数的求值运算就好办了，把这两个数组当做两个浮点数那样编写表达式即可

其中meshgrid函数将两个输入的数组x和y进行扩展，前一个的扩展与后一个有关，后一个的扩展与前一个有关，前一个是竖向扩展，后一个是横向扩展。因为，y的大小为2，所以x竖向扩展为原来的两倍，而x的大小为3，所以y横向扩展为原来的3倍。通过meshgrid函数之后，输入由原来的数组变成了一个矩阵

将条件逻辑表述为数组运算

numpy.where函数是三元表达式x if condition else y的矢量化版本

解释:比如我有三个数组，数组一数组二，外加一个布尔类型数组，我希望如果布尔数组是ture就选数组一否则选数组二，如果用纯python写，则是

x if c else y

这样处理大数据时会及慢，若使用np.where，则只需要

np.where(c, x, y)

即可

np.where的第二个和第三个参数不必是数组，它们都可以是标量值。在数据分析工作中，where通常用于根据另一个数组而产生一个新的数组。假设有一个由随机数据组成的矩阵，你希望将所有正值替换为2，将所有负值替换为－2。若利用np.where，则会非常简单：

In [172]: arr = np.random.randn(4, 4)

In [173]: arr

Out[173]:

array([[-0.5031, -0.6223, -0.9212, -0.7262],

       [ 0.2229,  0.0513, -1.1577,  0.8167],

       [ 0.4336,  1.0107,  1.8249, -0.9975],

       [ 0.8506, -0.1316,  0.9124,  0.1882]])

In [174]: arr > 0

Out[174]:

array([[False, False, False, False],

       [ True,  True, False,  True],

       [ True,  True,  True, False],

       [ True, False,  True,  True]], dtype=bool)

In [175]: np.where(arr > 0, 2, -2)

Out[175]:

array([[-2, -2, -2, -2],

       [ 2,  2, -2,  2],

       [ 2,  2,  2, -2],

       [ 2, -2,  2,  2]])

数学和统计方法

可以通过数组上的一组数学函数对整个数组或某个轴向的数据进行统计计算。sum、mean以及标准差std等聚合计算（aggregation，通常叫做约简（reduction））既可以当做数组的实例方法调用，也可以当做顶级NumPy函数使用。

（这里mean是计算平均数）

排序

跟Python内置的列表类型一样，NumPy数组也可以通过sort方法就地排序

唯一化以及其它的集合逻辑

NumPy提供了一些针对一维ndarray的基本集合运算。最常用的可能要数np.unique了，它用于找出数组中的唯一值并返回已排序的结果

线性代数

伪随机数生成

numpy.random模块对Python内置的random进行了补充，增加了一些用于高效生成多种概率分布的样本值的函数。

可以用normal来得到一个标准正态分布的4×4样本数组

In [238]: samples = np.random.normal(size=(4, 4))

In [239]: samples

Out[239]:

array([[ 0.5732,  0.1933,  0.4429,  1.2796],

       [ 0.575 ,  0.4339, -0.7658, -1.237 ],

       [-0.5367,  1.8545, -0.92  , -0.1082],

       [ 0.1525,  0.9435, -1.0953, -0.144 ]])

我们说这些都是伪随机数，是因为它们都是通过算法基于随机数生成器种子，在确定性的条件下生成的。你可以用NumPy的np.random.seed更改随机数生成种子

numpy.random的数据生成函数使用了全局的随机种子。要避免全局状态，你可以使用numpy.random.RandomState，创建一个与其它隔离的随机数生成器：

In [245]: rng = np.random.RandomState(1234)

In [246]: rng.randn(10)

Out[246]:

array([ 0.4714, -1.191 ,  1.4327, -0.3127, -0.7206,  0.8872,  0.8596,

       -0.6365,  0.0157, -2.2427])

示例：随机漫步

书中使用纯python实现1000步的随机漫步（从0开始，步长1和－1出现的概率相等）

In [247]: import random

   .....: position = 0

   .....: walk = [position]

   .....: steps = 1000

   .....: for i in range(steps):

   .....:     step = 1 if random.randint(0, 1) else -1

   //对于random.randint,作用是参数1、参数2必须是整数，函数返回参数1和参数2之间的任意整数， 闭区间

   .....:     position += step

   .....:     walk.append(position)

   .....:

这里我的理解是random.randint在0，1之间挑一个，如果是1就输出1，是0就输出-1

然后如果用numpy里面的random，代码如下

In [251]: nsteps = 1000

In [252]: draws = np.random.randint(0, 2, size=nsteps)

In [253]: steps = np.where(draws > 0, 1, -1)

In [254]: walk = steps.cumsum()

这里一开始我很不理解，np.random.randint(0, 2, size=nsteps)中我以为是0，1，2选择，结果我尝试输出

In [53]: nsteps = 1000

In [54]: draws = np.random.randint(0, 2, size=nsteps)

In [55]: draws

Out[55]:

array([0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1,

       0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1,

       0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 0,

       0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,

       1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1,

       1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1,

       1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0,

       0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0,

       1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0,

       1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1,

       1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1,

       1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1,

       1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1,

       0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0,

       0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0,

       0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,

       0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0,

       1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1,

       1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1,

       0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1,

       1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1,

       0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1,

       1, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0,

       0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0,

       0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1,

       0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0,

       1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0,

       1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1,

       0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0,

       1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1,

       0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0,

       0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0,

       1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1,

       1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0,

       1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1,

       0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1,

       0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0,

       1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1,

       0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1,

       1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0,

       0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,

       1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0,

       0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1,

       1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0,

       0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1,

       0, 0, 0, 0, 0, 1, 1, 1, 1, 1])

In [56]:

发现其实np.random.randint(0, 2, size=nsteps)只产生了0，1

经过查阅才知道np.random.randint是返回一个随机整型数，范围从低（包括）到高（不包括），即[low, high)。而python里面的random是直接闭区间，上下都有包含

一次模拟多个随机漫步

如果希望模拟多个随机漫步过程（比如5000个），只需对上面的代码做一点点修改即可生成所有的随机漫步过程。只要给numpy.random的函数传入一个二元元组就可以产生一个二维数组，然后我们就可以一次性计算5000个随机漫步过程（一行一个）的累计和了：

In [258]: nwalks = 5000

In [259]: nsteps = 1000

In [260]: draws = np.random.randint(0, 2, size=(nwalks, nsteps)) # 0 or 1

In [261]: steps = np.where(draws > 0, 1, -1)

In [262]: walks = steps.cumsum(1)

In [263]: walks

Out[263]:

array([[  1,   0,   1, ...,   8,   7,   8],

       [  1,   0,  -1, ...,  34,  33,  32],

       [  1,   0,  -1, ...,   4,   5,   4],

       ...,

       [  1,   2,   1, ...,  24,  25,  26],

       [  1,   2,   3, ...,  14,  13,  14],

       [ -1,  -2,  -3, ..., -24, -23, -22]])

小结

NumPy基础：数组和矢量计算基本结束，争取晚上把第五章拿下！

【学习笔记】第04章 NumPy基础：数组和矢量计算的更多相关文章

python numpy基础数组和矢量计算
在python 中有时候我们用数组操作数据可以极大的提升数据的处理效率, 类似于R的向量化操作,是的数据的操作趋于简单化,在python 中是使用numpy模块可以进行数组和矢量计算. 下面来看下简单 ...
python数据分析 Numpy基础数组和矢量计算
NumPy(Numerical Python的简称)是Python数值计算最重要的基础包.大多数提供科学计算的包都是用NumPy的数组作为构建基础. NumPy的部分功能如下: ndarray,一个具 ...
利用Python进行数据分析第4章 NumPy基础-数组与向量化计算（3）
4.2 通用函数:快速的元素级数组函数通用函数(即ufunc)是一种对ndarray中的数据执行元素级运算的函数. 1)一元(unary)ufunc,如,sqrt和exp函数 2)二元(unary) ...
《利用python进行数据分析》读书笔记--第四章 numpy基础：数组和矢量计算
http://www.cnblogs.com/batteryhp/p/5000104.html 第四章 Numpy基础:数组和矢量计算第一部分:numpy的ndarray:一种多维数组对象实话说, ...
python数据分析---第04章 NumPy基础：数组和矢量计算
NumPy(Numerical Python的简称)是Python数值计算最重要的基础包.大多数提供科学计算的包都是用NumPy的数组作为构建基础. NumPy的部分功能如下: ndarray,一个具 ...
<<Python基础教程>>学习笔记 | 第04章 | 字典
第04章:字典当索引不好用时 Python唯一的内建的映射类型,无序,但都存储在一个特定的键中.键能够使字符.数字.或者是元祖. ------ 字典使用: 表征游戏棋盘的状态,每一个键都是由坐标值组 ...
《利用Python进行数据分析》笔记---第4章NumPy基础：数组和矢量计算
写在前面的话: 实例中的所有数据都是在GitHub上下载的,打包下载即可. 地址是:http://github.com/pydata/pydata-book 还有一定要说明的: 我使用的是Python ...
apue学习笔记（第一章UNIX基础知识）
总所周知,UNIX环境高级编程是一本很经典的书,之前我粗略的看了一遍,感觉理解得不够深入. 听说写博客可以提高自己的水平,因此趁着这个机会我想把它重新看一遍,并把每一章的笔记写在博客里面. 我学习的时 ...
The C++ Programming Language 学习笔记第5章指针、数组和结构
1.关于输出指向字符的指针的值. 现在定义,char c='a',char* pc=&c.在C中,输出该值只需要printf("%p\n",pc);而在C++中,如果cou ...

随机推荐

meet in the middle 复习笔记
前言若干年前看过现在又忘了.这么简单都忘所以今天来重新复习一下. 正题考虑这样的问题: 给定 $n$ 个物品的价格,你有 $m$ 块钱,每件物品限买一次,求买东西的方案数. \(n\le ...
Windows对拍系统
有个东西可以帮助对拍,告诉你两个程序的输出哪不一样(但是无法得知错误位置,聊胜于无吧) 一.打开计算机二.在上方输入$cmd$,摁下回车三.弹出对话窗如下,输入$fc +$空格,输入两个需要比较 ...
from Crypto.Cipher import AES报错
python 在 Windows下使用AES时要安装的是pycryptodome 模块 pip install pycryptodome python 在 Linux下使用AES时要安装的是pyc ...
Trie 树总结
Trie,又经常叫前缀树,字典树等等.它有很多变种,如后缀树,Radix Tree/Trie,PATRICIA tree,以及bitwise版本的crit-bit tree.当然很多名字的意义其实有交 ...
小白之Python基础（二）
一.字符串 1.字符串编码发展: 1)ASCII码: 一个字节去表示 (8个比特(bit)作为一个字节(byte),因此,一个字节能表示的最大的整数就是255(二进制11111111 = 十进制255 ...
Badusb 资料整理
Badusb常用代码整理一.小马下载执行适用于常见可执行文件 #include <Keyboard.h> void setup() { //初始化,这里的代码只执行一次 delay(5 ...
多云部署多主模式的MGR集群，每个云一个MGR 节点,满足业务单元化改造的需求
欢迎来到 GreatSQL社区分享的MySQL技术文章,如有疑问或想学习的内容,可以在下方评论区留言,看到后会进行解答 GreatSQL社区原创内容未经授权不得随意使用,转载请联系小编并注明来源. 本 ...
技术分享 | 浅谈mysql语法解析调试方法
欢迎来到 GreatSQL社区分享的MySQL技术文章,如有疑问或想学习的内容,可以在下方评论区留言,看到后会进行解答本文向您介绍一种利用mysql解析器和bison的调试选项进行sql语法解析跟踪 ...
Linux—权限管理
Linux 权限管理 1.权限简介 Linux权限是操作系统用来限制对资源访问的机制,权限一般分为读.写.执行.系统中每个文件都拥有特定的权限:属主.属组以及其他人,通过这样的机制来限制哪些用户或用户 ...
JS判断两个数组的元素是否完全相等
1.使用ES6 新增的扩展运算符和Set新数据类型判断两个数组是否包含有相同的元素 var arr1 = ['green' , 'yellow' ,'blue' ,'red']; var arr2 = ...

【学习笔记】 第04章 NumPy基础：数组和矢量计算

前言