Python3数据分析入门实战_01 写在开头 +Numpy 入门

Python3数据科学入门与实战

写在开头，关于Python，我所了解的只是基础语法和一些简单类库的使用，此次开篇教程学习目的是为了去了解关于数据分析、相关类库的学习使用。

多说一句，关于使用Python进行数据分析是不是需要对Python编程语法非常精通的问题。我想说：精通Python语法编程固然是好事，但是刚需是使用它做数据分析，而数据分析只需要对相关数据分析库上手学习即可，像Numpy、Pandas等这些库。我也知道Python可以做Web开发，轻量级的Flask、Django框架也很好用。但是现状是做数据分析，所以对Python高级编程技巧、语法底层研究等操作大可不必，基础语法上手就好，剩下的就是去主要学习这些数据分析库的灵活使用了。

Anaconda：数据科学平台(Platform)

conda：Package和Environment管理
- Environment管理：
  - 创建env：conda create --name envname python=3.4
  - 激活env：(source) activate envname
  - 退出env：(source) deactivate envname
  - 删除env：conda remove --name envname --all
- Package管理：
  - 安装package：conda install numpy
  - 查看环境中已安装package：conda list -n envname
  - 删除package：conda remove -n envname numpy

Jupyter Notebook：数据科学常用IDE

数据科学五个最佳Python库

Numpy：
- 矩阵、快速高效、矢量数学运算
- 高效索引Index，不需要循环
- 开源跨平台
Scipy：
- 依赖于Numpy
- 专为科学和工程设计
- 常用科学计算：线型代数、傅里叶变换、信号图像处理
Pandas
- 依赖于Numpy，结构化数据分析利器
- 高级数据结构：Time-Series、DataFrame、Panel
- 强大的数据索引和处理能力
Matplotlib
- Python 2D绘图领域使用最广泛的套件
- 通过mplot3d可以绘制3D图
Scikit-learn
- 机器学习Python模块，建立在Scipy之上
- 提供常用机器学习算法：聚类、回归
- 简单易学的API接口
- TensorFlow：机器学习框架，Google 开源

Numpy

关于矩阵：
- 矩形的数组，即二维数组
- 向量：指的是1xN、Nx1的矩阵
- 标量：指的是1x1的矩阵
- 数组：N维的数组，矩阵的延伸
- 特殊矩阵：
  - 全0全1矩阵
  - 单位矩阵：NxN阶矩阵，主对角线元素均为1
    - 任何矩阵与单位矩阵做相乘运算，结果均为原矩阵。(类比：任何数乘1均为任何数)
- 矩阵运算：
  - 加减法：行和列对应元素相加减
  - 乘法：
    - 数组乘法(点乘)：数组乘法(点乘)是对应元素之间做乘法
    - 矩阵乘法：
      - 设A为MxP的矩阵，B为PxN的矩阵，MxN的矩阵C为矩阵A、B的乘积，记为C=AB。

Numpy入门

数组创建和访问

import numpy as np
# create from list
list_1 = [1, 2, 3, 4]
list_2 = [5, 6, 7, 8]
# 通过列表创建数组
array_1 = np.array(list_1) // array([1, 2, 3, 4])
array_2 = np.array([list_1, list_2]) // array([[1, 2, 3, 4], [5, 6, 7, 8])
# 返回数组的shape
array_2.shape // (2, 4) 两行四列数组
# 返回数组大小
array_2.size // 8   元素大小为8
# 返回数组元素数据类型
array_2.dtype // dtype('int32') 
# 数组元素数据类型不一致时，返回数据元素类型中精确度最高的数据类型
array_3 = np.array([[1.0, 2, 3], [4.0, 5, 6]])
array_3.dtype // dtype('float64')
# 通过arange进行数组创建
array_4 = np.arange(1, 10, 2) // 添加步长为2  array([1, 3, 5, 7, 9])
# 创建一维全0矩阵
np.zeros(5) // array([0., 0., 0., 0., 0.])
# 创建2x3 全0矩阵
np.zeros([2, 3]) // array([[0., 0., 0.], [0., 0., 0.]])
# 创建2x2单位矩阵 主对角线为1 其他元素为0
np.eye(2) // array([[1., 0.], [0., 1.]])
# 访问元素
a = np.arange(1, 10) // array([1, 2, 3, 4, 5, 6, 7, 8, 9])
# 索引访问
a[0] // 1
# 子数组访问
a[1:5] // array([2, 3, 4, 5])
# 二维数组元素访问
b = np.array([[1, 2, 3], [4, 5, 6]]) // array([[1, 2, 3], [4, 5, 6]])
# 索引访问
b[1][0] // 4 (b[1, 0]也可以访问到)
# 切片操作
c = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# 行：0-2行(不含2), 列：1列开始
c[:2, 1:] //  array([[2, 3], [5, 6]])

快速创建数组

# randn 创建长度为10的一维数组，且数组元素满足正态分布
np.random.randn(10)
-------------------------------
array([-0.33449844, -0.1490416 , -0.27399399,  1.0561671 , -0.40881947,
-1.14842854, -0.57158135, -0.02221695,  0.11761491,  0.61686979])
-------------------------------
# randint 返回元素限制10以内，大小为2x3的矩阵
np.random.randint(10, size=(2, 3))
-------------------------------
array([[0, 6, 4],
[5, 0, 8]])
-------------------------------
# 生成长度为10的数组，也可以变换为多维数组 reshape() 方法
np.random.randint(10, size=(10)) // array([3, 5, 2, 3, 0, 2, 5, 1, 8, 2])
# 变换为多维数组 reshape() 方法
np.random.randint(10, size=(10)).reshape(2, 5)
-------------------------------
array([[8, 4, 3, 1, 0],
[8, 6, 2, 2, 2]])
-------------------------------

数组运算

初始化数组

a = np.random.randint(10, size=(20)).reshape(4, 5)
-----------------------------
array([[4, 6, 9, 6, 4],
[7, 0, 7, 1, 5],
[5, 7, 5, 5, 4],
[9, 1, 7, 3, 2]])
-----------------------------
b = np.random.randint(10, size=(20)).reshape(4, 5)
-----------------------------
array([[5, 3, 6, 9, 1],
[2, 1, 9, 2, 0],
[8, 2, 5, 7, 9],
[9, 4, 0, 9, 7]])
-----------------------------

a + b

array([[ 9,  9, 15, 15,  5],
[ 9,  1, 16,  3,  5],
[13,  9, 10, 12, 13],
[18,  5,  7, 12,  9]])

a - b

array([[-1,  3,  3, -3,  3],
[ 5, -1, -2, -1,  5],
[-3,  5,  0, -2, -5],
[ 0, -3,  7, -6, -5]])

a * b

array([[20, 18, 54, 54,  4],
[14,  0, 63,  2,  0],
[40, 14, 25, 35, 36],
[81,  4,  0, 27, 14]])

a / b ：由于数组b 中存在元素0。因此，对上述结果做了INF处理，并报出警告。

RuntimeWarning: divide by zero encountered in true_divide

array([[0.8 , 2. , 1.5 , 0.66666667, 4. ],
[3.5  , 0.  , 0.77777778, 0.5 , inf],
[0.625 , 3.5 , 1. , 0.71428571, 0.44444444],
[1.   , 0.25 , inf, 0.33333333, 0.28571429]])

快速创建矩阵

mat() 进行矩阵创建

np.mat([[1, 2, 3], [4, 5, 6]])
-----------------------------
matrix([[1, 2, 3],
[4, 5, 6]])
-----------------------------

数组向矩阵转换

np.mat(a)
-----------------------------
matrix([[4, 6, 9, 6, 4],
[7, 0, 7, 1, 5],
[5, 7, 5, 5, 4],
[9, 1, 7, 3, 2]])
-----------------------------

矩阵运算

初始化矩阵

A = np.mat(a)
-----------------------------
matrix([[4, 6, 9, 6, 4],
[7, 0, 7, 1, 5],
[5, 7, 5, 5, 4],
[9, 1, 7, 3, 2]])
-----------------------------
B = np.mat(b)
-----------------------------
matrix([[5, 3, 6, 9, 1],
[2, 1, 9, 2, 0],
[8, 2, 5, 7, 9],
[9, 4, 0, 9, 7]])
-----------------------------

A + B

matrix([[ 9,  9, 15, 15,  5],
[ 9,  1, 16,  3,  5],
[13,  9, 10, 12, 13],
[18,  5,  7, 12,  9]])

A - B

matrix([[-1,  3,  3, -3,  3],
[ 5, -1, -2, -1,  5],
[-3,  5,  0, -2, -5],
[ 0, -3,  7, -6, -5]])

A * B ：矩阵乘法(满足：mp – pn 相乘为 m*n矩阵)

AA = np.mat(np.random.randint(10, size=(20)).reshape(4, 5))
-----------------------------------------------------------
matrix([[1, 4, 3, 6, 5],
[7, 6, 4, 9, 0],
[4, 4, 2, 1, 8],
[0, 1, 6, 6, 2]])
-----------------------------------------------------------
BB = np.mat(np.random.randint(10, size=(20)).reshape(5, 4))
-----------------------------------------------------------
matrix([[6, 8, 2, 2],
[0, 7, 4, 8],
[7, 1, 6, 5],
[9, 9, 6, 3],
[2, 4, 8, 9]])
-----------------------------------------------------------

AA * BB

matrix([[ 91, 113, 112, 112],
[151, 183, 116, 109],
[ 63, 103, 106, 125],
[100,  75,  92,  74]])

数组常用函数

数组初始化

a = np.random.randint(10, size=(20)).reshape(4, 5)
--------------------------------------------------
array([[2, 2, 1, 2, 4],
[9, 0, 7, 9, 8],
[6, 7, 6, 8, 6],
[2, 8, 1, 4, 8]])
--------------------------------------------------

元素去重保留唯一值

np.unique(a)
--------------------------------------------------
array([0, 1, 2, 4, 6, 7, 8, 9])
--------------------------------------------------

数组求和(以列为单位)

sum(a)
--------------------------------------------------
array([19, 17, 15, 23, 26])
--------------------------------------------------

具体行的和

sum(a[0])
--------------------------------------------------
11
--------------------------------------------------

具体列的和

sum(a[:,0])
--------------------------------------------------
19
--------------------------------------------------

最值

a.max() # 数组最值
max(a[0]) # 具体行最值
...

数组的input和output

Python的pickle模块实现了基本的数据序列和反序列化。
通过pickle模块的序列化操作能够将程序中运行的对象信息保存到文件中去，永久存储。
通过pickle模块的反序列化操作，能够从文件中创建上一次程序保存的对象。
基本接口：
- pickle.dump(obj, file, [,protocol]) 将对象obj保存到文件file中去。
- pickle.load(file) 从file中读取一个字符串，并将它重构为原来的Python对象。

举个栗子：

导入需要的库
```
import pickle
import numpy as np
```

数组初始化

x = np.arange(10)
----------------------
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
----------------------

输出文件

# 创建文件对象，文件名为：x.pkl，读写方式为：只写
f = open('x.pkl', 'wb')
# 将数组对象保存到文件对象中
pickle.dump(x, f)
# 查看文件, Linux、Mac系统下命令为 !ls
!dir

输入文件

# 创建文件对象，文件名为：x.pkl，读写方式为：只读
f = open('x.pkl', 'rb')
# 从文件对象中读取字符串，并将其转换为数组对象
pickle.load(f)

Numpy 中的 save 方法

# 将数组对象保存成文件，后缀名为 .npy
np.save('one_array', x)

Numpy 中的 load 方法

# 读取文件
np.load('one_array.npy')

Numpy 中的 savez 方法：压缩文件

# 初始化数组y
y = np.arange(20)
----------------------------------
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 
15, 16,17, 18, 19])
----------------------------------
# 压缩文件
np.savez('two_array.npz', a=x,b=y)
# 读取压缩文件
np.load('two_array.npz')
# 按索引读取数组内容
c['a']
----------------------------------
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
----------------------------------
c['b']
----------------------------------
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 
15, 16,17, 18, 19])
----------------------------------