Numpy基础

数据分析

 Numpy+Scipy+Matplotlib+Pandas
基础数值算法
科学计算
数据可视化
序列高级函数

一、numpy是什么？

1.Numerical Python，数值的Python，补充了Python语言所欠缺的数值计算能力。
2.Numpy是其它数据分析及机器学习库的底层库。
3.Numpy完全标准C语言实现，运行效率充分优化。
4.Numpy开源免费。

二、Numpy的历史

1.1995年，Numeric，Python语言数值计算扩充。
2.2001年，Scipy->Numarray，多维数组运算。
3.2005年，Numeric+Numarray->Numpy。
4.2006年，Numpy脱离Scipy成为独立的项目。

三、Numpy的核心：多维数组

1.代码简洁：减少Python代码中的循环。
	2.底层实现：厚内核(C)+薄接口(Python)，保证性能。

# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import datetime as dt#处理系统时间
import numpy as np
n = 100000
start = dt.datetime.now()#取系统此刻时间
A, B = [], []
for i in range(n):
    A.append(i ** 2)
    B.append(i ** 3)
C = []
for a, b in zip(A, B):
    C.append(a + b)
print((dt.datetime.now() - start).microseconds)#microseconds是微秒
#下面是用Numpy运行的，不用循环，循环出现在Numpy的底层实现
start = dt.datetime.now()
A, B = np.arange(n) ** 2, np.arange(n) ** 3
C = A + B
print((dt.datetime.now() - start).microseconds)

jupyter上运行的结果：
133958
8393

四、Numpy基础

1.数组对象

1)用np.ndarray类的对象表示n维数组
实际数据：数组中元素
元数据：描述数组中的元素（相当于档案，到哪去档案也跟着走）
将实际数据与元数据分开存放，一方面提高了内存空间的使用效率，另一方面减少对实际数据的访问频率，提高性能
2)Numpy数组是同质数组，即所有元素的数据类型必须相同（只用用这种方式才能保证它的性能；用C语言来实现，C语言的数据类型就必须相同）
3)Numpy数组的下标从0开始，最后一个元素的下标为数组长度减1
4)np.ndarray.dtype/shape/size：类型/维度/大小
5)产生数组的方法：
（1）np.arange(起始值(默认0),终止值,步长(默认1))->返回值：等差序列
（2）np.array(任何可被解释为Numpy数组的逻辑结构)
    ->返回值：任意维度和类型的数组对象

代码：shape.py

# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import numpy as np
a = np.arange(1, 3)
print(a, a.shape)
b = np.array([[1, 2., '3'],
              [4, 5, 6]])
print(b, b.shape)
c = np.array([np.arange(1, 4),
              np.arange(4, 7),
              np.arange(7, 10)])
print(c, c.shape)

type.py

# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import numpy as np
a = np.arange(1, 10)
print(a, type(a[0]), a.dtype)
b = a.astype(float)
print(b, type(b[0]), b.dtype)
c = b.astype(str)
print(c, type(c[0]), c.dtype)

size.py

# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import numpy as np
a = np.array([[10, 20, 30],
              [40, 50, 60]])
print(a.shape, a.size, len(a))
b = a.reshape((6,))
print(b.shape, b.size, len(b))
c = b.reshape((3, 2))
print(c.shape, c.size, len(c))
d = np.arange(1, 25).reshape((2, 3, 4))
print(d.shape, d.size, len(d))

6)元素索引(下标)
数组对象[..., 页号, 行号, 列号]
数组对象.shape->(..., 页数, 行数, 列数)
X号：[0, X数-1]

代码：index.py

# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import numpy as np
a = np.array([[[1, 2],
               [3, 4]],
              [[5, 6],
               [7, 8]]])
print(a, a.shape)
print(a[0])#第0页
print(a[0][0])#第0页里面的第0行
print(a[0][0][0])#第0页里面的第0行的第0列
print(a[0, 0, 0])#和上面是等价的
for i in range(a.shape[0]):#通过循环遍历数组中的数
    for j in range(a.shape[1]):#行数
        for k in range(a.shape[2]):#列数
            print(a[i, j, k])

7)Numpy的内部基本数据类型
布尔型：bool_（python里面占一个字节）
整数型：
	有符号：int8(-128~127)/int16/int32/int64
	无符号：uint8(0~255)/uint16/uint32/uint64
浮点型：float16/float32/float64
复数型：complex64/complex128
字串型：str_，每个字符用32位Unicode编码表示（当作编码来看）
8)自定义复合类型

代码：dtype.py

# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import numpy as np
a = np.array([('123', [4, 5, 6])],#一个域是字符串，一个域是数组
             dtype='U3, 3i4')#在这dtype是一个关键字参数
print(a[0]['f0'], a[0]['f1'])#访问元素
b = np.array([('123', [4, 5, 6])],
             dtype=[('fa', np.str_, 3),#“fa是自己定的”
                    ('fb', np.int32, 3)])#用元组来描述
print(b[0]['fa'], b[0]['fb'])
c = np.array([('123', [4, 5, 6])],#结合上面的两个方法
             dtype={'names': ['fa', 'fb'],#字段的名字
                    'formats': ['U3', '3i4']})#字段的格式
print(c[0]['fa'], c[0]['fb'], c.itemsize)#每个元素的字节数
d = np.array([('123', [4, 5, 6])],
             dtype={'fa': ('U3', 0),#类型和偏移，从0开始
                    'fb': ('3i4', 16)})#从16开始
print(d[0]['fa'], d[0]['fb'], d.itemsize)
e = np.array([0x1234],#代表16进制
             dtype=('>u2', {'lo': ('u1', 0),#u2表示两字节的无符号整数
                            'hi': ('u1', 1)}))
print('{:x}'.format(e[0]))#以16进制形式输出的结果
print('{:x} {:x}'.format(e['lo'][0], e['hi'][0]))

9)类型字符码
np.bool_: ?
np.int8: b
np.uint8: B
np.int8/16/32/64: i1/2/4/8
np.uint8/16/32/64: u1/2/4/8
np.float/16/32/64: f2/4/8
np.complex64/128: c8/16
np.str_: U<字符数>
np.datetime64: M8
字节序前缀，用于多字节整数和字符串：
</>/[=]分别表示小端/大端/硬件字节序。
<字节序前缀><维度><类型><字节数或字符数>
>3i4：大端字节序，3个元素的一维数组，每个元素都是整型，每个整型元素占4个字节。
<(2,3)u8：小端字节序，6个元素2行3列的二维数组，每个元素都是无符号整型，每个无符号整型元素占8个字节。
>U7: 包含7个字符的Unicode字符串，每个字符占4个字节，采用大端字节序。


10)切片
数组对象[起始位置:终止位置:位置步长, ...]
缺省起始位置：(位置步长+)首（0）/(位置步长-)尾（-1）
缺省终止位置：(位置步长+)尾后/(位置步长-)首前
缺省位置步长：1

代码：slice.py

# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import numpy as np
a = np.arange(1, 10)
print(a)  # 1 2 3 4 5 6 7 8 9
print(a[:3])  # 1 2 3
print(a[3:6])   # 4 5 6
print(a[6:])  # 7 8 9
print(a[::-1])  # 9 8 7 6 5 4 3 2 1
print(a[:-4:-1])  # 9 8 7
print(a[-4:-7:-1])  # 6 5 4
print(a[-7::-1])  # 3 2 1
print(a[::])  # 1 2 3 4 5 6 7 8 9
print(a[:])  # 1 2 3 4 5 6 7 8 9
print(a[...])  # 1 2 3 4 5 6 7 8 9
print(a[::3])  # 1 4 7
print(a[1::3])  # 2 5 8
print(a[2::3])  # 3 6 9
b = np.arange(1, 25).reshape(2, 3, 4)
print(b)
print(b[:, 0, 0])  # 1 13#第0行第0列
print(b[0])#指第0列
print(b[0, :, :])#第0页的所有行所有列
print(b[0, ...])#缺省，表示除了最高维指定后，其他都缺省
print(b[0, 1])  # 5  6  7  8#第0页的第1行
print(b[0, 1, ::2])  # 5 7#在列上单独应用切片
print(b[..., 1])#页全要，行全要，列只要第1列
print(b[:, 1])#冒号表示页，拿每一页的第一行
print(b[0, 1, 1::2])  # 6 8#第0页，第一行，从1开始，以2为步长
print(b[0, :, -1])  # 4 8 12#第0页，所有行的最后一列，把列倒着来
print(b[0, ::-1, -1])  # 12 8 4#倒着取所有行的最后一列
print(b[0, ::2, -1])  # 4 12#第0页
print(b[::-1, ::-1])#对页所有的，逆序，所有行，逆序，所有列，正序
print(b[..., ::-1])#和上面相反
print(b[-1, 1:, 2:])#拿最后一页的右下角，行从第一行以后，列从第2列以后

11)改变维度
视图变维（浅拷贝） \    reshape/ravel（做扁平化，鸡蛋灌饼——>油条）                                / 数据共享
                 > 返回一个具有新维度的新数组对象 <
复制变维（深拷贝） /    flatten （）                                           \ 数据独立
就地变维 --- 在原数组对象之上，改变其维度，不返回新数组
xxx.shape = ...
xxx.resize(...)

代码：reshape.py

# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import numpy as np
a = np.arange(1, 9)
print(a)
b = a.reshape(2, 4)#两行4列
print(b)
c = b.reshape(2, 2, 2)#2页2行2列
print(c)
d = c.ravel()#压回一维
print(d)
e = c.flatten()#
print(e)
a += 10
print(a, b, c, d, e, sep='\n')#分隔符为换行符
a.shape = (2, 4)
print(a)
a.resize(2, 2, 2)
print(a)
f = b.transpose()#转值运算
print(f)
a -= 10
print(f)

12)组合与拆分
垂直：
np.vstack((上, 下))->组合数组
np.concatenate((上, 下), axis=0)
                        / 二维：0-行，垂直，1-列，水平
axis表示轴向 <
                        \ 三维：0-页，深度，1-行，垂直，2-列，水平
np.vsplit(数组, 份数)->上, ..., 下
np.split(数组, 份数, axis=0)
水平
np.hstack((左, 右))->组合数组
np.concatenate((左, 右), axis=1)
np.hsplit(数组, 份数)->左, ..., 右
np.split(数组, 份数, axis=1)
深度
np.dstack((前, 后))->组合数组
np.dsplit(数组, 份数)->前, ..., 后
行列(可以用一维数组做参数)
np.row_stack((上, 下))->组合数组（行）
np.column_stack((左, 右))->组合数组（列）

代码：stack.py

# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import numpy as np
a = np.arange(11, 20).reshape(3, 3)
print(a)
b = a + 10
print(b)
c = np.vstack((a, b))（a在上，b在下）
print(c)
d = np.concatenate((a, b), axis=0)
print(d)
e, f = np.vsplit(c, 2)
print(e, f, sep='\n')
g, h = np.split(d, 2, axis=0)#沿着垂直方向拆分
print(g, h, sep='\n')
i = np.hstack((a, b))#沿着水平拆分
print(i)
j = np.concatenate((a, b), axis=1)
print(j)
k, l = np.hsplit(i, 2)
print(k, l, sep='\n')
m, n = np.split(i, 2, axis=1)
print(m, n, sep='\n')
o = np.dstack((a, b))
print(o)#三维数组
p, q = np.dsplit(o, 2)#深度的拆分
print(p.T[0].T, q.T[0].T, sep='\n')#T 为Transport
#针对一维数组
a, b = a.ravel(), b.ravel()
print(a, b)
#r = np.vstack((a, b))
r = np.row_stack((a, b))#行组合
print(r)
#s = np.hstack((a, b))
s = np.column_stack((a, b))#列组合
print(s)

13)ndarray类的属性
shape - 维度
dtype - 元素类型
size - 元素数量
ndim - 维数，len(shape)
itemsize - 元素字节数
nbytes - 总字节数 = size x itemsize
real - 复数数组的实部数组
imag - 复数数组的虚部数组
T - 数组对象的转置视图
flat - 扁平迭代器（相当于一个一维数组）
代码：attr.py
数组对象.tolist()->列表

代码

# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import numpy as np
a = np.array([[1 + 1j, 2 + 4j, 3 + 7j],
              [4 + 2j, 5 + 5j, 6 + 8j],
              [7 + 3j, 8 + 6j, 9 + 9j]])
print(a.shape)#（3，3）
print(a.dtype)#元素类型
print(a.size)#元素个数
print(a.ndim)#维数属性
print(a.size)
print(a.itemsize)#每一项的字节数
print(a.nbytes)#总字节
print(a.real, a.imag, sep='\n')#找实部和虚部
print(a.T)#转置
print([elem for elem in a.flat])#当作一维数组遍历
b = a.tolist()#数组变列表
print(b)