【大数据技术能力提升_2】numpy的学习

前言：排版有点问题，哎！

进一步学习，请参考https://www.numpy.org.cn/

数据类型

5种类型：布尔值（bool），整数（int），无符号整数（uint）、浮点（float）、复数（complex）

支持的原始类型与 C 中的原始类型紧密相关：

由于其中许多都具有依赖于平台的定义，因此提供了一组固定大小的别名：

注：类型代码一般是头一个字母+位数/8，如complex256位c32

创建、操作narray

import numpy as np

#新版本
x1 = np.int8([0,1,2,3,4,5,6,7,8,9])
x2 = np.arange(10, dtype=np.int8)
x1, x2

(array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=int8),
 array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=int8))

#老版本
y1 = np.array(np.arange(9), dtype=np.int8)
y2 = np.array(np.arange(9), dtype=‘i1‘)
y1, y2
"""
新手最容易犯的一个错误就是把数组内容直接当做参数传给array，如np.array(1,2,3)
"""

‘\n\xe6\x96\xb0\xe6\x89\x8b\xe6\x9c\x80\xe5\xae\xb9\xe6\x98\x93\xe7\x8a\xaf\xe7\x9a\x84\xe4\xb8\x80\xe4\xb8\xaa\xe9\x94\x99\xe8\xaf\xaf\xe5\xb0\xb1\xe6\x98\xaf\xe6\x8a\x8a\xe6\x95\xb0\xe7\xbb\x84\xe5\x86\x85\xe5\xae\xb9\xe7\x9b\xb4\xe6\x8e\xa5\xe5\xbd\x93\xe5\x81\x9a\xe5\x8f\x82\xe6\x95\xb0\xe4\xbc\xa0\xe7\xbb\x99array\xef\xbc\x8c\xe5\xa6\x82np.array(1,2,3)\n‘

#要转换数组的类型，请使用 .astype() 方法（首选）或类型本身作为函数
x1.astype(‘u1‘), x2.astype(int),np.int16(y1), np.uint16(y2)

(array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=uint8),
 array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]),
 array([0, 1, 2, 3, 4, 5, 6, 7, 8], dtype=int16),
 array([0, 1, 2, 3, 4, 5, 6, 7, 8], dtype=uint16))

#dtype属性，代表数组的类型；shape属性，代表数组的形状；ndim属性，代表数组有几个维度
#size属性：代表数组中元素的个数， itemsize属性：代表数组中单个元素以字节计的大小
#data属性：数组中实际的数据
z = np.arange(15).reshape((3,5))
z.shape, z.dtype, z.ndim, z.size, z.itemsize, z.data, np.issubdtype(z.dtype, np.integer), np.issubdtype(z.dtype, np.floating)

((3L, 5L),
 dtype(‘int32‘),
 2,
 15,
 4,
 <read-write buffer for 0x0000000007485580, size 60, offset 0 at 0x000000000745BC38>,
 True,
 False)

溢出错误

当值需要比数据类型中的可用内存更多的内存时，例如，numpy.power对于64位整数正确计算 100 10 8，但对于32位整数给出1874919424（不正确）。

np.power(100, 8, dtype=np.int64), np.power(100, 8, dtype=np.int32)

(10000000000000000, 1874919424)

# NumPy分别提供numpy.iinfo 并numpy.finfo 验证NumPy整数和浮点值的最小值或最大值：
np.iinfo(np.int), np.iinfo(np.int32), np.iinfo(np.int64)

(iinfo(min=-2147483648, max=2147483647, dtype=int32),
 iinfo(min=-2147483648, max=2147483647, dtype=int32),
 iinfo(min=-9223372036854775808, max=9223372036854775807, dtype=int64))

创建数组有5种常规机制：

1、从其他Python结构（例如，列表，元组）转换
2、numpy原生数组的创建（例如，arange、ones、zeros等）
3、从磁盘读取数组，无论是标准格式还是自定义格式
4、通过使用字符串或缓冲区从原始字节创建数组
5、使用特殊库函数（例如，random）

Ones 和 zeros 填充方式

注：[,]里面是可选参数，如：empty(shape[, dtype, order]) ，shape是必选参数，dtype, order是可选参数

从现有的数据创建

注：可通过np.array?来查看相关函数的说明

#zero和ones代码实现
"""
zero：创建所有元素为0的数组
ones：创建所有元素为1的数组
empty：创建所有元素为随机的数组 *****
"""
np.empty([2, 2], dtype=int), np.empty((3, 3)),np.empty_like(([1,2,3], [4,5,6])),np.eye(4)

(array([[43998544,        0],
        [62099504,        0]]), array([[0.22222222, 0.44444444, 0.66666667],
        [0.88888889, 1.11111111, 1.33333333],
        [1.55555556, 1.77777778, 2.        ]]), array([[         0, 1073741824,          0],
        [1074790400,          0, 1075314688]]), array([[1., 0., 0., 0.],
        [0., 1., 0., 0.],
        [0., 0., 1., 0.],
        [0., 0., 0., 1.]]))

#因为浮点数的有限精度问题，array返回的数组可能无法预知，因此出现浮点数时，最好用linspace
np.arange(10,100,10),np.linspace(0,2,10)

(array([10, 20, 30, 40, 50, 60, 70, 80, 90]),
 array([0.        , 0.22222222, 0.44444444, 0.66666667, 0.88888889,
        1.11111111, 1.33333333, 1.55555556, 1.77777778, 2.        ]))

打印数组

打印出来非常类似嵌套列表
如果数组太长，则会自动忽略部数据，只打印首位

print np.arange(24).reshape(2,3,4),np.arange(1000000)

[[[ 0  1  2  3]
  [ 4  5  6  7]
  [ 8  9 10 11]]

 [[12 13 14 15]
  [16 17 18 19]
  [20 21 22 23]]] [     0      1      2 ... 999997 999998 999999]

基本操作

在数组上进行算术操作都是元素级别的(elementwise)。

注：在线性代数中，乘号*代表的矩阵乘法,但在numpy中代表元素级别乘法，矩阵乘法用np.dot(a,b)或a.dot(b)

若a+=b，a是int，b是float，则会报错，因为b比a更精错，但b+=a则不会报错

a = np.array([1,2,3,4])
b = np.arange(4)
a-b, a+b, a*b, a*2, a/3,a.dot(b) #全部新增的一个数组

(array([1, 1, 1, 1]),
 array([1, 3, 5, 7]),
 array([ 0,  2,  6, 12]),
 array([2, 4, 6, 8]),
 array([0, 0, 1, 1]),
 20)

ndarray内置函数：sum,min,max,comsum，并且可以通过制定axis=0或1来指定对行或者列操作

通用函数

一元ufunc

二元ufunc

索引、切片以及遍历

一维数组非常类似与python的list和tuple，它们可以被index、slice、iterate copy方法可以复制数组和标量值

c = np.arange(10)
c,c[0],c[1:3],c[:5],c[5:],c[:-1],c[:]

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

跟列表最重要的区别在于，数组的切片的数据不会复制，任何修改都会反馈到元数据上

c1 = c[4:6]
c1[:] = 111
c

array([  0,   1,   2,   3, 111, 111,   6,   7,   8,   9])

#二维数组的索引和切片
d = np.arange(16).reshape((4,4))
d[1][0],d[0,1]

(4, 1)

#布尔型索引
#布尔型索引在多维数组里面经常会跟上面的数字索引方法混用
e = np.array([‘a‘,‘b‘,‘c‘,‘e‘,‘f‘,‘g‘,‘h‘,‘i‘,‘j‘,‘k‘])
e == ‘e‘,c[e == ‘f‘],c[e != ‘e‘],c[(e == ‘f‘)|(e != ‘f‘)]

(array([False, False, False,  True, False, False, False, False, False,
        False]),
 array([111]),
 array([  0,   1,   2, 111, 111,   6,   7,   8,   9]),
 array([  0,   1,   2,   3, 111, 111,   6,   7,   8,   9]))

元素的形状

可以通过reshape（创建新数组）、resize（改变原数组）、ravel（使数组变扁平）

将不同的数组堆叠（stacking）起来

多个数组可以沿着不同的额轴堆叠起来，用vstack（竖向）、hstack（横向）

将一个数组切分成多个

使用hsplit或vsplit将一个数组沿制定方向切分split(array,(x,y))切分为x列和y列，split(array,n)切分为n个数组

拷贝与视图

1、简单的赋值不发生拷贝；函数调用也不会产生拷贝 2、不同数据对象可以共享相同的数据，view方法新建一个数组，但是仍使用相同的数据 3、深拷贝：copy

广播

在NumPy中如果遇到大小不一致的数组运算，就会触发广播机制。满足一定的条件才能触发广播，不然也会报错。

形状相同

形状相同的数组之间的运算就是在对应位做运算。

形状不同

当数组大小不一致时，就会触发广播机制。广播机制的规则：

1.让所有输入数组都向其中shape最长的数组看齐，shape中不足的部分都通过在前面加1补齐；

2.输出数组的shape是输入数组shape的各个轴上的最大值；

3.如果输入数组的某个轴和输出数组的对应轴的长度相同或者其长度为1时，这个数组能够用来计算，否则出错；

4.当输入数组的某个轴的长度为1时，沿着此轴运算时都用此轴上的第一组值。

原文地址：https://www.cnblogs.com/CQ-LQJ/p/11823959.html