数据科学原理与数据处理

数据科学原理与数据处理

1 Python行业分析

通过Stack OverFlow专业网站的大数据统计，Python相关技术模块访问量最大的簇是数据科学相关，然后才是后台开发。

1.1 数据处理流程

1.2 数据科学岗位分析

2 数据分析好助手Jupyter notebook

Jupyter Notebook（此前被称为 IPython notebook）是一个交互式笔记本，支持运行 40 多种编程语言。本质是一个 Web 应用程序，便于创建和共享文学化程序文档，支持实时代码，数学方程，可视化和 markdown。

2.1 Jupyter notebook的安装

① 使用Anaconda安装

Anaconda一个封装多种工具，库的解释器，它已经自动为你安装了Jupter Notebook及其他工具。

② 使用pip 安装

pip3 install jupyter

注意：在安装Jupyter Notebook过程中可能面临无法安装的问题(提示你要升级pip)，输入下面的命令即可

pip install --upgrade pip   升级pip
pip install juputer   安装Jupyter

2.2 Jupyter notebook 基本使用

• 在命令行处，先cd到源代码文件目录
• 然后输入 jupyter notebook 会自动打开一个jupyter web管理界面
• 点击右上角的new 下边的python3 创建一个脚本

• 点击 run进行运行会在运行完成后自动生成下一格
• 在notebook的脚本中 想将变量打印出来,不需要加print,直接输入变量名即可

• **注释：**在notebook中的单元格内添加注释，直接#+注释就可以

• 标题

• 代码单元：用于编写代码，通过按 Shift + Enter 运行代码，其结果显示在本单元下方。代码单元左边有In [1]: 这样的序列标记，方便人们查看代码的执行次序。

  • shift+enter 直接运行并在下一行插入一个单元格
  • ctrl+enter 直接运行但不插入单元格
  • alt+enter 插入一个新的单元格

• 编辑模式与命令行模式：

  • 编辑模式用来编写代码，执行文件，鼠标选中单元格，此单元格就会变为编辑模式

  

  • 命令模式用来执行快捷命令，可以通过鼠标点击两侧的空白处或者键盘上的Esc键，来使编辑模式转化命令模式。

  

  • 快捷键，只有在命令模式操作才可以修改文档，
    • Y：单元转入代码状态
    • M：单元转入markdown状态
    • A ：在上方插入新单元
    • B：在下方插入新单元
    • X：剪切选中的单元
    • Shift +V：在上方粘贴单元

• Markdown单元：用于编辑文本，采用 markdown 的语法规范，可以设置文本格式、插入链接、图片甚至数学公式。同样使用 Shift + Enter 运行 markdown 单元来显示格式化的文本(可以用来快速的生成标题)。

2.3 Jupyter notebook 内置的魔法命令

• %run + 运行python文件路径

%run D:\hello.py

• %load 将文件中的内容读出来【load回来的代码不会自动执行 ,需要手动执行一遍 】

%load D:\hello.py

• %timeit 测试代码的执行时间 【%timeit后边只能跟一行代码】

%timeit lis = [x for x in range(10000)]

• %%timeit 测试代码块的执行时间

%%timrit
lis = []
for i in range(10000):
    lis.append(1)

• %time 测试单次运行所需要的时间 【%time和%timeit都是测试时间，但是%time没有%timeit准确】

%time lis = [x for x in range(10000)]

• %%time 测试代码块的执行时间

%%time
lis = []
for i in range(10000):
	lis.append(i)

• %%html 用于在notebook中显示页面代码

%%html
<a href = 'www.baidu.com'>百度一下</a>

• %%js 用于在notebook中运行js文件的

%%html
<div class='mytest' style='color:red'>html content</div>

# 写在不同的单元格中
%%js
document.querySelector('.mytest').innerHTML='js content'

• %%writefile 将内容编写成文件

%%writefile  haha.py
    lis = [x for x in ramge(1000)]

3 数据科学模块NumPy

3.1 初级NumPy

3.1.1 NumPy基本介绍

Numpy：提供了一个在Python中做科学计算的基础库，主要用于数值计算、多维数组（矩阵）的处理。本身是由C语言开发，是个很基础的扩展，Python其余的科学计算扩展大部分都是以此为基础。

NumPy是使用Python进行科学计算的基本软件包。它包含以下内容：

• 强大的N维数组对象
• 复杂的（广播）功能
• 集成C / C ++和Fortran代码的工具
• 有用的线性代数，傅立叶变换和随机数功能
• Nmupy本质就是ndarray
• 多维矩阵
  • 1维数组看做向量vector–点和直线
  • 2维数组看做2维矩阵–表和平面
  • 3维数组看做3维矩阵–空间

除了其明显的科学用途外，NumPy还可以用作通用数据的高效多维容器。可以定义任意数据类型。这使NumPy可以无缝，快速地与各种数据库集成。官方学习资料https://numpy.org/。

3.1.2 NumPy的安装与导入

# 安装  
pip install numpy

# 导入 
import numpy as np

3.1.3 NumPy中的数组创建

NumPy提供的最重要的数据结构是一个称为NumPy数组的强大对象。NumPy数组是通常的Python数组的扩展。NumPy数组配备了大量的函数和运算符，可以帮助我们快速编写各种类型计算的高性能代码。

arange	生成遍历得到的数的数组
array	生成列表元素的数组
linspace	生成元素之间’等差关系‘的数组
logspace	生成元素之间’等比关系‘的数组
ones	生成所有元素都为 1 的数组
zeros	生成所有元素都为 0 的数组
eye	生成一种类似单位矩阵的数组
diag	生成一个对角矩阵数组
random.random	生成 (0,1)的随机数据的随机数组
random.rand	生成随机数据的均匀分布的数组
random.randn	生成一个符合正态分布的数组
random.randint	生成固定范围内的，固定形状的数组

import numpy as np

# 使用arange创建数组
arr = np.arange(0, 6, 2) # 一维数组
arr = np.arange(0, 6, 2).reshape(1, 3) # 二维数组
print(arr)

print('--------------------------------------------------------------------')
# 使用linspace创建数组——元素之间’等差‘
# 参数1 开始位置
# 参数2 结束位置
# 参数3 创建数组元素的个数
arr= np.linspace(0, 6, 7)
print(arr)

print('------------------------------------------------------------------')
# 使用logspace创建函数--元素之间’等比‘
# 参数1 开始位置 10^0
# 参数2 结束位置 10^2
# 参数3 创建数组元素的个数
arr = np.logspace(0, 2, 5)
print(arr)

print('------------------------------------------------------------------')
# ones --生成所有元素都为 1 的数组
arr = np.ones(shape = (2, 3))
print(arr)

print('------------------------------------------------------------------')
# zeros --生成所有元素都为 0 的数组
arr = np.zeros(shape=(2, 3))
print(arr)

print('------------------------------------------------------------------')
# eye--生成一种类似单位矩阵的数组
# 参数k 决定对角线的位置
# 参数k<0 ,对角线上移k个位置
# 参数k>0 ,对角线下移k个位置
# 参数k超出范围，是个（3,3）都为0的数组
arr = np.eye(3, 3, k = 0)
print(arr)

print('------------------------------------------------------------------')
# diag 生成一个对角矩阵数组，参数为对角线上的值
# k 上移，下移 和eye 一样
arr = np.diag([1, 3, 5, 7], k = 0)
arr1 = np.diag([[1, 3, 5, 7], [2, 4, 6, 8]])
print(arr, '\n', arr1)

print('------------------------------------------------------------------')
# 生成 (0,1)的随机数据的随机数组
arr = np.random.random(5)
arr1 = np.random.random((2, 3))
print(arr, '\n', arr1)

print('------------------------------------------------------------------')
# 生成随机数据的均匀分布的数组【需要数据量比较大】
arr = np.random.rand(5)
arr1 = np.random.rand(2, 3)
print(arr,'\n',arr1)

print('------------------------------------------------------------------')
# 生成一个符合正态分布的数组
# 参数为 元素个数 或者 行列数
arr = np.random.randn(2, 3)
print(arr)

print('------------------------------------------------------------------')
# 生成固定范围内的，固定形状的数组
#如果不传size ，那么生成一个随机整数
arr = n.random.randint(0, 5, size = [2, 3])
arr1 = np.random.randint(0, 5)
print(arr, '\n', arr1)

print('------------------------------------------------------------------')
# 获得一个均值为0 标准差为1 的矩阵数组
# 第一个参数是均值 第二个参数是标准差,第三个参数是元素的个数
arr = np.random.normal(0, 1, size = 1000000)
print(arr)

3.1.4 NumPy的数组属性

ndim	输出数组的维度
shape	输出数组的形状
size	输出数组的元素个数
dtype	输出数组的数据类型
itemsize	输出数组的大小

import numpy as np
arr = np.array([[[1,2,3],[4,5,6],[7,8,9]],[[2,3,4],[9,8,7],[5,6,4]]])

print('数组的维度 : ',arr.ndim)
print('数组的形状 : ',arr.shape) # 2块 3行3列
print('数组的元素个数 : ',arr.size)
print('数组的数据类型 : ',arr.dtype)
print('数组的大小 : ',arr.itemsize)
print('数组转置 : ',arr.T)

3.1.5 数组的索引

# # 普通取值
# 一维数组

import numpy as np 
my_array = np.array([1, 2, 3, 4, 5]) 

print(my_array[0])  # 取一维数组的第一个
print(my_array[-1]) # 取一维数组的最后一个

# 二维数组
import numpy as np 
my_array = np.arange(15).reshape(3, 5)

print(my_array[0])  # 取二维数组的第一行
print(my_array[-1])  # 取二维数组的最后一行


# # 切片取值
# 一维数组
import numpy as np 
my_array = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) 

print(my_array[0: 5])
print(my_array[: 5])
print(my_array[0: 8: 2])
print(my_array[::-1])

# 二维数组
import numpy as np 
my_array = np.arange(15).reshape(3, 5)

print(my_array[0:5])
print(my_array[:5])
# 注:python生成的普通数组中,切片切出来的值和原来的数据没有任何关系,一个改变 ,另一个不发生改变
# 注:numpy生成的数组,切片切出来的值和原来的数据有引用关系,一个改变,另一个也发生改变

# bool取值
import numpy as np

a = np.array([[1,2], [3, 4], [5, 6]])
bool_idx = (a > 2)              
print(bool_idx)                          
print(a[bool_idx])  

# 或者
print(a[a > 2])   

3.1.6 ndarray 中的合并与分割

concatenate	进行数组的合并 参数：axis = 0与vstack一致，axis = 1与hstack一致
vstack	垂直方向上进行拼接 【行】
hstack	水平方向上进行拼接 【列】
split	进行数组的分割 参数：axis = 0与vstack一致，axis = 1与hstack一致
vsplit	垂直方向上进行分割 【行】
hsplit	水平方向上进行分割 【列】

import numpy as np
# # 合并

# 一维数组的合并
arr_1 = np.array([1, 2, 3])
arr_2 = np.array([4, 5, 6])
arr = np.concatenate([arr_1, arr_2])

print(arr)

# 二维数组的合并
import numpy as np

arr_1 = np.arange(4).reshape((2, 2))
arr_2 = np.arange(4, 8).reshape((2, 2))

#数组组合
# 按行的方向【垂直】，进行拼接,参数是一个对象
new_arr = np.vstack((arr_1, arr_2))
print(new_arr)

# 按列的方向【水平】，进行拼接,参数是一个对象
new_arr = np.hstack((arr_1, arr_2))
print(new_arr)

# 和vstack一样
new_arr = np.concatenate((arr_1, arr_2), axis=0)
print(new_arr)

# 和hstack一样
new_arr = np.concatenate((arr_1, arr_2), axis=1)
print(new_arr)

# # 分割
# 一维数组
arr = np.arange(10)
print(arr.split(arr, 2))
print(arr.split(arr, 5))
# 第二个参数是指分割成几份 ,要传入正确的分割值,因为平均拆分，必须可以被数组位数整除

# 二维数组
arr = np.arange(16).reshape(4, 4)

# 在列的方向上进行分割数组
new_arr = np.hsplit(arr, 4)
new_arr1 = np.split(arr, 4, axis = 1)
print(new_arr)
print('-----------------------------------------------')
print(new_arr1)
print('-----------------------------------------------')

# 在行的方向上进行分割数组
new_arr = np.vsplit(arr, 4)
new_arr1 = np.split(arr, 4, axis = 0)
print(new_arr)
print('-----------------------------------------------')
print(new_arr1)

3.1.7 NumPy中的矩阵创建

mat	创建矩阵
matrix	创建矩阵，会占用更多的内存
asmatrix	创建矩阵，三个都是矩阵的创建，创建方式上并没差别，但是推荐使用mat，asmatrix
bmat	进行堆积组合矩阵

import numpy as np

# 创建矩阵，---【必须是二维的】

## mat
m11 = np.mat('1 2 3;4 5 6;7 8 9')
print(m11)
print('--------------------------mat1-----------------------')
#可以将列表转化为矩阵
m12 = np.mat([[1,2,3],[4,5,6],[7,8,9]])
print(m12)
print('--------------------------mat2-----------------------')
# 可以将数组转化为矩阵
m13 = np.mat(np.array([[1,2,3],[4,5,6],[7,8,9]]))
print(m13)
print('--------------------------mat3-----------------------')


## matrix
#m11 = np.matrix('1 2 3;4 5 6;7 8 9')
m11 = np.asmatrix('1 2 3;4 5 6;7 8 9')
print(m11)
print('--------------------------matrix1-----------------------')
#m12 = np.matrix([[1,2,3],[4,5,6],[7,8,9]])
m12 = np.asmatrix([[1,2,3],[4,5,6],[7,8,9]])
print(m12)
print('--------------------------matrix2-----------------------')
#m13 = np.matrix(np.array([[1,2,3],[4,5,6],[7,8,9]]))
m13 = np.asmatrix(np.array([[1,2,3],[4,5,6],[7,8,9]]))
print(m13)
print('--------------------------matrix3-----------------------')

# 推荐使用mat 或者 asmatrix【matrix，会复制一份，占用更多的内存空间】

## bmat 进行堆积组合矩阵

arr1 = list(np.arange(4).reshape(2,2))
arr2 = list(np.arange(4,8).reshape(2,2))
print(arr1,type(arr1))
new_arr = np.bmat([[arr1,arr2],[arr2,arr1]])
print(new_arr)
print('--------------------------bmat1-------------------------')
# 数组组合矩阵
arr1 = np.arange(4).reshape(2,2)
arr2 = np.arange(4,8).reshape(2,2)
print(arr1,type(arr1))

new_arr = np.bmat([[arr1,arr2],[arr2,arr1]])
print(new_arr)
print('--------------------------bmat2-------------------------')
#列表组合矩阵
arr1 = [[1,2,3],[4,5,6]]
arr2 = [[5,6,7],[7,8,9]]
print(arr1,type(arr1))

new_arr = np.bmat([[arr1,arr2],[arr2,arr1]])
print(new_arr)
print('--------------------------bmat3-------------------------')
# 矩阵组合矩阵
arr1 = np.mat('1 2;3 4')
arr2 = np.mat('5 6;7 8')
print(arr1,type(arr1))

new_arr = np.bmat([[arr1,arr2],[arr2,arr1]])
print(new_arr)
print('--------------------------bmat4-------------------------')

3.1.8 NumPy数组中矩阵的运算

import numpy as np

# Basic Operators
a = np.arange(25).reshape((5, 5))

b = np.array([10, 62, 1, 14, 2, 56, 79, 2, 1, 45,
              4, 92, 5, 55, 63, 43, 35, 6, 53, 24,
              56, 3, 56, 44, 78]).reshape((5,5))

print(a + b)
print(a - b)
print(a * b)
print(a / b)
print(a ** 2)
print(a < b) 
print(a > b)
# 这些操作符都是对数组进行逐元素运算。比如 (a, b, c) + (d, e, f) 的结果就是 (a+d, b+e, c+f)。它将分别对每一个元素进行配对，然后对它们进行运算。它返回的结果是一个数组。

print(a.dot(b))
# dot() 函数计算两个数组的点积。它返回的是一个标量（只有大小没有方向的一个值）而不是数组。



import numpy as np

jz1 = np.mat(np.arange(9).reshape(3,3))
jz2 = np.mat(np.arange(9,18).reshape(3,3))
jz3 = np.mat(np.arange(6).reshape(2,3))
jz4 = np.mat(np.arange(9,15).reshape(2,3))

#矩阵与数相乘
result = 3*jz1
print(result)
print('---------------------矩阵运算 1----------------------')

#矩阵与同形矩阵相加
result = jz1+jz2
print(result)
print('---------------------矩阵运算 2----------------------')

#矩阵与同形矩阵相减
result = jz1-jz2
print(result)
print('---------------------矩阵运算 3----------------------')

#矩阵与矩阵相乘【左矩阵列数 == 右矩阵行数(必须满足!)】
# result = jz3*jz1
# result = np.matmul(jz3,jz1) #在某些情况下 matmul 会比dot严格一点
result = np.dot(jz3,jz1) #
print(result)
print('---------------------矩阵运算 4----------------------')

#矩阵对应元素相乘 ---需要满足广播机制 ---数组的广播机制
result = np.multiply(jz1,jz2) #【必须同形】
print(result)
print('---------------------矩阵运算 5----------------------')

print(jz1,'\n',type(jz1))
print('矩阵的转置 : \n',jz1.T)
print('矩阵的逆矩阵 : \n',jz4.I) ## A * A.I = E
print(