前言

正式开始学习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 ...

随机推荐

Pytorch从0开始实现YOLO V3指南 part3——实现网络前向传播
本节翻译自:https://blog.paperspace.com/how-to-implement-a-yolo-v3-object-detector-from-scratch-in-pytorch ...
初始化二维列表时使用[ [0]* N ] * K会出现的问题
声明二维列表使用[ [0]* N ] * K会出现的问题初始化二维列表时使用[ [0]* N ] * K创建,外层列表的每一个元素地址相同: 创造了一个二维列表: 修改其中的一个元素a[1][1], ...
DNS 系列（二）：DNS 记录及工作方式，你了解吗？
在上一篇<DNS 系列(一):为什么更新了 DNS 记录不生效?>中,我们主要讲解了 DNS 和 DNS 传播,知道了网络通信主要通过 IP 地址来进行,而域名系统(DNS)则是保证用户在 ...
《吐血整理》保姆级系列教程-玩转Fiddler抓包教程(5)-Fiddler监控面板详解
1.简介按照从上往下,从左往右的计划,今天就轮到介绍和分享Fiddler的监控面板了.监控面板主要是一些辅助标签工具栏.有了这些就会让你的会话请求和响应时刻处监控中毫无隐私可言.监控面板是fiddl ...
丽泽普及2022交流赛day22 无社论
开始掉分模式 . T3 有人上费用流了???(id) 不用 TOC 了 . T1 暴力 T2 没看见任意两圆不相交,gg 包含关系容易维护,特判相切 . 单调栈即可 T3 贪心 T4 神秘题
Nginx 平滑升级、Nginx的一些基础配置
# Nginx 平滑升级 # 方案一:使用Nginx服务信号进行升级 # 1.将就版本的sbin目录下可执行nginx进行备份(mv nginx nginxold) # 2.将新版本 configur ...
5.26 NOI 模拟
\(T1\)石子与HH与HHの取博弈是不可能会的 \(c_i\)相等,比较显然的\(Nim,\)直接前缀异或求一下 \(a_i=1,\)区间长度对\(2\)取模结论\(:\)黑色石子严格大于白色个 ...
Chapter 02 - Let's Get Started(C#篇)
详细解释,书上有哈.直接上代码和结果. Xcode下的自定义类 (通过new file-> cocoa class创建,保持和书中名字一样RandomController),自定义的fields ...
活动报名｜对话贡献者：DolphinScheduler x Pulsar 在线 Meetup
各位 DolphinScheduler 和 Pulsar 社区的小伙伴们,Apache DolphinScheduler x Pulsar 在线 Meetup 来啦! 导语大数据任务调度.消息流的订 ...
Luogu1919 【模板】A*B Problem升级版（FFT）
简单的\(A*B\) \(Problem\),卡精度卡到想女装 #include <iostream> #include <cstdio> #include <cstri ...

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

前言