我与数据科学 - [Today is Numpy] - [np随用随记]

numpy.loadtxt(fname, dtype=, comments='#', delimiter=None, converters=None, skiprows=0, usecols=None, unpack=False, ndmin=0)

data = np.loadtxt(path, dtype=float, delimiter=',', converters={4: iris_type})

skiprow表示跳过前几行，用于有文件标题和栏位说明的数据集

comment 表示跳过有符号标注的数据，默认#号

usecols 表示只使用指定的行

converters 表示预处理，可以是一个方法表示 ｛0 ： fun｝ 对第0列进行fun函数处理

numpy.split(data, (a, b), axis = 0)

x, y = np.split(data, (4,), axis=1)

将数据集分成特征和标签，第二个参数前开后闭，表示将前四列和后面的列分开

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

t2 = np.linspace(x2_min, x2_max, M)

在指定的间隔内均匀的返回等间隔的数字

start 起始位置

stop 终止位置

num 取多少个数

endpoint 是否包括终止位置

retstep 为True则返回步长

numpy.meshgrid(*xi, **kwargs)

# 画图
N, M = 50, 50  # 横纵各采样多少个值
x1_min, x1_max = x[:, 0].min(), x[:, 0].max()  # 第0列的范围
x2_min, x2_max = x[:, 1].min(), x[:, 1].max()  # 第1列的范围
t1 = np.linspace(x1_min, x1_max, N)
t2 = np.linspace(x2_min, x2_max, M)
x1, x2 = np.meshgrid(t1, t2)  # 生成网格采样点

从一个坐标向量返回一个坐标矩阵

numpy.flat

flat返回的是一个迭代器，可以使用for循环遍历所有元素

import numpy as np
a = np.arange(4).reshape(2,2)
print(a)
for i in a.flat:
    print(i)
#迭代器可以用list进行输出
print(list(a.flat))
print(type(a.flat))#返回类型为 numpy.flatiter
#可以用索引对迭代器进行引号
a.flat[3]

[[0 1]
 [2 3]]
0
1
2
3
[0, 1, 2, 3]
<class 'numpy.flatiter'>
3

np.stack(arrays,axis=0)

stack函数用于堆叠数组,其中arrays即需要进行堆叠的数组，axis是堆叠时使用的轴，比如：arrays = [[1,2,3,4], [5,6,7,8]]

这是一个二维数组，axis=0表示的是第一维，也即是arrays[0] = [1,2,3,4]或者arrays[1] = [5,6,7,8]

axis=i时，代表在堆叠时首先选取第i维进行“打包”。

当执行np.stack(arrays, axis=0)时，取出第一维的1、2、3、4，打包，[1, 2, 3, 4]，其余的类似，然后结果如下

>>> arrays = [[1,2,3,4], [5,6,7,8]]
>>> arrays=np.array(arrays)
>>> np.stack(arrays,axis=0)
array([[1, 2, 3, 4],
       [5, 6, 7, 8]])

当执行np.stack(arrays, axis=1)时，先对arrays中的第二维进行“打包”，也即是将1、5打包成[1, 5]，其余的类似，结果如下： 

>>> np.stack(arrays, axis=1)
array([[1, 5],
       [2, 6],
       [3, 7],
       [4, 8]])

我自己的理解就是 axis = 0的时候 自顶向下打包，axis = 1的时候自左向右打包

np.concatenate((a1,a2,a3,...), axis=0)

这个函数就是按照特定方向轴进行拼接，默认是第一维，在numpy官网上的示例如下： 

>>> a = np.array([[1, 2], [3, 4]])
>>> b = np.array([[5, 6]])
>>> np.concatenate((a, b), axis=0)
array([[1, 2],
       [3, 4],
       [5, 6]])
>>> np.concatenate((a, b.T), axis=1)
array([[1, 2, 5],
       [3, 4, 6]])

我自己的理解就是 axis = 0就是竖着拼接（往下加），axis = 1就是横着拼接 （往右加），axis = 2就是往你脸上加，想象成一个三维的

np.hstack(tup)

按照列的方向堆叠， tup可以是元组，列表，或者numpy数组, 其实也就是axis=1,即

np.hstack(tup) = np.concatenate(tup, axis=1)，就是上一个api中我自己的理解，往右边加，水平方向的

按照上面对concatenate的理解则下面的示例很好理解

>>> a = np.array((1,2,3))
>>> b = np.array((2,3,4))
>>> np.hstack((a,b))
array([1, 2, 3, 2, 3, 4])
>>> a = np.array([[1],[2],[3]])
>>> b = np.array([[2],[3],[4]])
>>> np.hstack((a,b))
array([[1, 2],
       [2, 3],
       [3, 4]])

 

np.vstack(tup),

按照行的方向堆叠， tup可以是元组，列表，或者numpy数组, 理解起来与上相同

np.vstack(tup) = np.concatenate(tup, axis=0)，就是上上一个api中我自己的理解，往下边加，垂直方向的

>>> a = np.array([1, 2, 3])
>>> b = np.array([2, 3, 4])
>>> np.vstack((a,b))
array([[1, 2, 3],
       [2, 3, 4]])

>>> a = np.array([[1], [2], [3]])
>>> b = np.array([[2], [3], [4]])
>>> np.vstack((a,b))
array([[1],
       [2],
       [3],
       [2],
       [3],
       [4]])

numpy.random.randint

low、high、size三个参数。默认high是None,如果只有low，那范围就是[0,low)。如果有high，范围就是[low,high)

>>> np.random.randint(2, size=10)
array([1, 0, 0, 0, 1, 1, 0, 0, 1, 0])

>>> np.random.randint(1, size=10)
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])

>>> np.random.randint(5, size=(2, 4))
array([[4, 0, 2, 1],
       [3, 2, 2, 0]])

numpy.random.rand(d0, d1, ..., dn)

随机样本位于[0, 1)中,参数为数组的尺寸

numpy.random.randn(d0, d1, …, dn)

标准正态分布中返回一个或多个样本值

np.empty(shape[, dtype, order])

依据给定形状和类型(shape[, dtype, order])返回一个新的空数组。

shape : 整数或者整型元组，定义返回数组的形状；

dtype : 数据类型，可选，定义返回数组的类型。

order : {‘C’, ‘F’}, 可选，规定返回数组元素在内存的存储顺序：C（C语言）-row-major；F（Fortran）column-major。

>>> np.empty([2, 2])
array([[ -9.74499359e+001, 6.69583040e-309],
[ 2.13182611e-314, 3.06959433e-309]])    #random
 
>>> np.empty([2, 2], dtype=int)
array([[-1073741821, -1067949133],
[ 496041986, 19249760]])    #random

np.empty_like(a)

依据给定数组(a)的形状和类型返回一个新的空数组。

np.set_printoptions 设置当前print输出的数据的一些格式

原函数：

set_printoptions(precision=None, threshold=None, edgeitems=None, linewidth=None, suppress=None, nanstr=None, infstr=None)

precision : float输出的精度，即小数点后维数，默认8

threshold : 当数组数目过大时，设置显示几个数字，其余用省略号 。np.nan为全部显示

edgeitems : 数据边缘展示多少数据

suppress : 是否压缩由科学计数法表示的浮点数

np.logspace返回等比数列，和linespace对应 linespace返回等差数列

start，起始数字，表示base的多少次方，如0表示base的0次方

end，结束数字，表示base的多少次方，0表示base的0次方

base 底数默认为10

>>> a = np.logspace(0,9,10)
>>> a
array([  1.00000000e+00,   1.00000000e+01,   1.00000000e+02,
         1.00000000e+03,   1.00000000e+04,   1.00000000e+05,
         1.00000000e+06,   1.00000000e+07,   1.00000000e+08,
         1.00000000e+09])