console.log('*********************************************************')
        setTimeout(() => {
            console.log("主要是看宏任务什么时候执行")
        }, 0);
        var p1 = new Promise((res, rej) => {
            res('promise 1 的 then1')
        }).then(res => {
            
            console.log(res)
//  promise 1 的子promise1-2 
            new Promise((res, rej) => {
                //  setTimeout(() => {
                //     res('新的 promise')
                //  }, 1000);
                res('promise 1 的子promise1-2 的 then1')                 // 这里又给微任务队列注册了一个队列
            }).then(v => {
                console.log(v)
                return 'promise1-2 的 then2 '
            }).then(v => {
                console.log(v)
            })
            return 'prmise 1 的 then2'
        }).then(v => {
            console.log(v)
        })

        var p2 = new Promise((res, rej) => {
            res('promise 2 的 then 1')
        }).then(res => {
           
            console.log(res)
           
            return 'promise 2 的 then 2'

        }).then(v => {
            console.log(v)
        })

      

分析：

这个例子其实说明了 promise决议后 如果有then，就会把then再临时加入微任务队列末尾，继续执行

          顺序执行代码 一开始 只有promise1，promise2 完成决议判读 所以 微任务队列 只有 promise1 promise2，

执行 promise 1 的 then1 时候， 产生新的Promise1-2，并且完成决议，所以微任务队列末尾加入promise1-2 的 then1，

截至执行了 return, 此时promise1 完成决议，又把 promise 1 的 then2 加入末尾队列，

=== 》 此时只是 打印了 promise 1 的 then1，

         接着执行 微任务队列， ==》打印 promise 2 的 then 1，又把promise 2 的 then 2 加入微任务队列，

执行微任务队列里的 promise1-2 时候，==》打印 promise 1 的子promise1-2 的 then1，

又把 promise 1 的 子promise1-2 的 then2 加入微任务队列，接着打印==》 promise1的 then2 ，

       此时并不产生新的决议，所以没有新的promise加入微任务队列，接着执行 promise 2 的 then 2 打印==》promise 2 的 then 2，接着执行 promise1-2 的 then2 打印 ==》 promise1-2 的 then2

     到此时 微任务全部执行完毕i，开始执行宏认为队列，打印 ==》主要是看宏任务什么时候执行

打印顺序完整为：

       promise 1 的 then1

      promise 2 的 then 1

     promise 1 的子promise1-2 的 then1

     prmise 1 的 then2

     promise 2 的 then 2

     promise1-2 的 then2

主要是看宏任务什么时候执行

 

微任务队列 完整顺序：

promise1（promise 1 的 then1） ==》promise2（ promise 2 的 then 1） ==》 promise1-2 的 then1 ==》

promise 1 的 then2 ==》 promise 2 的 then 2 ==》 promise1-2 的 then2

数据集：Kaggle上的1908年收集的公开数据集

项目任务：

每年空难数分析
机上乘客数量
生还数、遇难数 
哪些航空公司空难数最多?
哪些机型空难数最多?
# -*-coding: utf-8 -*-
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from bokeh.io import output_notebook, output_file, show
from bokeh.charts import Bar,TimeSeries
from bokeh.layouts import column
from math import pi


- 查看数据信息








data_path = './dataset/Airplane_Crashes_and_Fatalities_Since_1908.csv'
df_data = pd.read_csv(data_path)









print u'数据集基本信息：'
print df_data.info()


    数据集基本信息：
    RangeIndex: 5268 entries, 0 to 5267
    Data columns (total 13 columns):
    Date            5268 non-null object
    Time            3049 non-null object
    Location        5248 non-null object
    Operator        5250 non-null object
    Flight #        1069 non-null object
    Route           3562 non-null object
    Type            5241 non-null object
    Registration    4933 non-null object
    cn/In           4040 non-null object
    Aboard          5246 non-null float64
    Fatalities      5256 non-null float64
    Ground          5246 non-null float64
    Summary         4878 non-null object
    dtypes: float64(3), object(10)
    memory usage: 535.1+ KB
    None









print u'数据集有%i行，%i列' %(df_data.shape[0], df_data.shape[1])


    数据集有5268行，13列









print u'数据预览：'
df_data.head()


    数据预览：







      
Date
      
Time
      
Location
      
Operator
      
Flight #
      
Route
      
Type
      
Registration
      
cn/In
      
Aboard
      
Fatalities
      
Ground
      
Summary
    
0
      
09/17/1908
      
17:18
      
Fort Myer, Virginia
      
Military - U.S. Army
      
NaN
      
Demonstration
      
Wright Flyer III
      
NaN
      
1
      
2.0
      
1.0
      
0.0
      
During a demonstration flight, a U.S. Army fly…
    
1
      
07/12/1912
      
06:30
      
AtlantiCity, New Jersey
      
Military - U.S. Navy
      
NaN
      
Test flight
      
Dirigible
      
NaN
      
NaN
      
5.0
      
5.0
      
0.0
      
First U.S. dirigible Akron exploded just offsh…
    
2
      
08/06/1913
      
NaN
      
Victoria, British Columbia, Canada
      
Private
      
-
      
NaN
      
Curtiss seaplane
      
NaN
      
NaN
      
1.0
      
1.0
      
0.0
      
The first fatal airplane accident in Canada oc…
    
3
      
09/09/1913
      
18:30
      
Over the North Sea
      
Military - German Navy
      
NaN
      
NaN
      
Zeppelin L-1 (airship)
      
NaN
      
NaN
      
20.0
      
14.0
      
0.0
      
The airship flew into a thunderstorm and encou…
    
4
      
10/17/1913
      
10:30
      
Near Johannisthal, Germany
      
Military - German Navy
      
NaN
      
NaN
      
Zeppelin L-2 (airship)
      
NaN
      
NaN
      
30.0
      
30.0
      
0.0
      
Hydrogen gas which was being vented was sucked…
    

处理缺失数据
# def process_missing_data(df_data):
#     """
#             处理缺失数据
#     """
#     if df_data.isnull().values.any():
#         # 存在缺失数据
#         print '存在缺失数据！'
#         df_data = df_data.fillna(0.)    # 填充nan
#         # df_data = df_data.dropna()    # 过滤nan
#     return df_data.reset_index()


-  数据转换








df_data['Date'] = pd.to_datetime(df_data['Date'])
# df_data['Date']









df_data['Year'] = df_data['Date'].map(lambda x: x.year)
df_data.head()







      
Date
      
Time
      
Location
      
Operator
      
Flight #
      
Route
      
Type
      
Registration
      
cn/In
      
Aboard
      
Fatalities
      
Ground
      
Summary
      
Year
    
0
      
1908-09-17
      
17:18
      
Fort Myer, Virginia
      
Military - U.S. Army
      
NaN
      
Demonstration
      
Wright Flyer III
      
NaN
      
1
      
2.0
      
1.0
      
0.0
      
During a demonstration flight, a U.S. Army fly…
      
1908
    
1
      
1912-07-12
      
06:30
      
AtlantiCity, New Jersey
      
Military - U.S. Navy
      
NaN
      
Test flight
      
Dirigible
      
NaN
      
NaN
      
5.0
      
5.0
      
0.0
      
First U.S. dirigible Akron exploded just offsh…
      
1912
    
2
      
1913-08-06
      
NaN
      
Victoria, British Columbia, Canada
      
Private
      
-
      
NaN
      
Curtiss seaplane
      
NaN
      
NaN
      
1.0
      
1.0
      
0.0
      
The first fatal airplane accident in Canada oc…
      
1913
    
3
      
1913-09-09
      
18:30
      
Over the North Sea
      
Military - German Navy
      
NaN
      
NaN
      
Zeppelin L-1 (airship)
      
NaN
      
NaN
      
20.0
      
14.0
      
0.0
      
The airship flew into a thunderstorm and encou…
      
1913
    
4
      
1913-10-17
      
10:30
      
Near Johannisthal, Germany
      
Military - German Navy
      
NaN
      
NaN
      
Zeppelin L-2 (airship)
      
NaN
      
NaN
      
30.0
      
30.0
      
0.0
      
Hydrogen gas which was being vented was sucked…
      
1913
    

数据分析与可视化——空难数vs年份
a)  seaborn



plt.figure(figsize=(15.0,10.0))
sns.countplot(x='Year', data=df_data)

<matplotlib.axes._subplots.AxesSubplot at 0x1158ce610>




plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams['axes.unicode_minus']=False



plt.title(u'空难次数VS年份')
plt.xlabel(u'年份')
plt.ylabel(u'空难次数')
plt.xticks(rotation=90)
plt.show()



b) bokeh



p = Bar(df_data,'Year',title=u'空难次数 VS 年份',plot_width=1000,legend=False,xlabel=u'年份',ylabel=u'空难次数')
p.xaxis.major_label_orientation = pi/2
output_notebook()
show(p)



数据分析与可视化——乘客数量vs遇难数vs年份
grouped_year_sum_data = df_data.groupby('Year',as_index=False).sum()
grouped_year_sum_data.head()


  
Year
  
Aboard
  
Fatalities
  
Ground
0
  
1908
  
2.0
  
1.0
  
0.0
1
  
1912
  
5.0
  
5.0
  
0.0
2
  
1913
  
51.0
  
45.0
  
0.0
3
  
1915
  
60.0
  
40.0
  
0.0
4
  
1916
  
109.0
  
108.0
  
0.0
a) seaborn



grouped_year_sum_data = df_data.groupby('Year',as_index=False).sum()
grouped_year_sum_data.head()



plt.title(u'乘客数量vs遇难数vs年份')
plt.xlabel(u'年份')
plt.ylabel(u'乘客数量vs遇难数')
plt.xticks(rotation=90)
plt.show()



b) bokeh



tsline = TimeSeries(data=grouped_year_sum_data, x='Year',y=['Aboard','Fatalities'],color=['Aboard', 'Fatalities'],
                    dash=['Aboard', 'Fatalities'],title=u'乘客数量vs遇难数vs年份',xlabel=u'年份',ylabel=u'乘客数vs遇难数',
                    legend=True)
tspoint = TimeSeries(data=grouped_year_sum_data,x='Year',y=['Aboard','Fatalities'],color=['Aboard', 'Fatalities'],
                    dash=['Aboard', 'Fatalities'],builder_type='point',title=u'乘客数量vs遇难数vs年份',xlabel=u'年份',
                    ylabel=u'乘客数vs遇难数',legend=True)
output_notebook()
show(column(tsline,tspoint))




top n 分析
grouped_data = df_data.groupby(by='Type',as_index=False)['Date'].count()
grouped_data.rename(columns={'Date':'Count'},inplace=True)
top_n = 10
top_n_grouped_data = grouped_data.sort_values('Count',ascending=False).iloc[:top_n, :]
top_n_grouped_data


  
Type
  
Count
1178
  
Douglas DC-3
  
334
2388
  
de Havilland Canada DHC-6 Twin Otter 300
  
81
1097
  
Douglas C-47A
  
74
1089
  
Douglas C-47
  
62
1230
  
Douglas DC-4
  
40
2340
  
Yakovlev YAK-40
  
37
125
  
Antonov AN-26
  
36
1598
  
Junkers JU-52/3m
  
32
1119
  
Douglas C-47B
  
29
1045
  
De Havilland DH-4
  
28
- 可视化结果



plt.figure(figsize=(15.0,10.0))
sns.barplot(x='Count',y='Type',data=top_n_grouped_data)



plt.title('Count vs Type',fontsize=20)
plt.xlabel('Type')
plt.ylabel('Count')
plt.show()

javascript是一门单线程语言，所有任务需要排队，前一个任务结束，才会执行后一个任务。如果上一个任务的执行过程耗时很长，下一个任务就不得不等待很长的时间，这时设计者就把任务设成了同步任务和异步任务。同步任务在主线程上是一个个执行，而异步任务则会进入任务队列（task queue），只有在所有同步任务执行完，异步任务才会被执行。
异步任务有：setTimeout、setlnterval、DOM事件、Promise、Ajax；
任务队列
根据规范，事件循环是通过任务队列的机制来进行协调的。一个 Event Loop 中，可以有一个或者多个任务队列(task queue)，一个任务队列便是一系列有序任务(task)的集合；每个任务都有一个任务源(task source)，源自同一个任务源的 task 必须放到同一个任务队列，从不同源来的则被添加到不同队列。setTimeout/Promise 等API便是任务源，而进入任务队列的是他们指定的具体执行任务。
在事件循环中，每进行一次循环操作称为 tick，每一次 tick 的任务处理模型是比较复杂的，但关键步骤如下：

在此次 tick 中选择最先进入队列的任务(oldest task)，如果有则执行(一次)
检查是否存在 Microtasks，如果存在则不停地执行，直至清空 Microtasks Queue
更新 render
主线程重复执行上述步骤

在上诉tick的基础上需要了解几点：

JS分为同步任务和异步任务
同步任务都在主线程上执行，形成一个执行栈
主线程之外，事件触发线程管理着一个任务队列，只要异步任务有了运行结果，就在任务队列之中放置一个事件。
一旦执行栈中的所有同步任务执行完毕（此时JS引擎空闲），系统就会读取任务队列，将可运行的异步任务添加到可执行栈中，开始执行。



宏任务
(macro)task，可以理解是每次执行栈执行的代码就是一个宏任务（包括每次从事件队列中获取一个事件回调并放到执行栈中执行）。
浏览器为了能够使得JS内部(macro)task与DOM任务能够有序的执行，会在一个(macro)task执行结束后，在下一个(macro)task 执行开始前，对页面进行重新渲染，流程如下：
(macro)task->渲染->(macro)task->…
宏任务包含：
script(整体代码)

setTimeout

setInterval

I/O

UI交互事件

postMessage

MessageChannel

setImmediate(Node.js 环境)
微任务
microtask,可以理解是在当前 task 执行结束后立即执行的任务。也就是说，在当前task任务后，下一个task之前，在渲染之前。
所以它的响应速度相比setTimeout（setTimeout是task）会更快，因为无需等渲染。也就是说，在某一个macrotask执行完后，就会将在它执行期间产生的所有microtask都执行完毕（在渲染前）。

微任务包含：
Promise.then

Object.observe

MutaionObserver

process.nextTick(Node.js 环境)
运行机制
在事件循环中，每进行一次循环操作称为 tick，每一次 tick 的任务处理模型是比较复杂的，但关键步骤如下：

执行一个宏任务（栈中没有就从事件队列中获取）
执行过程中如果遇到微任务，就将它添加到微任务的任务队列中
宏任务执行完毕后，立即执行当前微任务队列中的所有微任务（依次执行）
当前宏任务执行完毕，开始检查渲染，然后GUI线程接管渲染
渲染完毕后，JS线程继续接管，开始下一个宏任务（从事件队列中获取）

如图：

即宏任务->微任务->页面渲染->宏任务
简单实例分析
例子1：
<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
</head>

<body>
    <script>
        setTimeout(function () {
            new Promise(function (resolve, reject) {
                console.log('异步宏任务promise');
                resolve();
            }).then(function () {
                console.log('异步微任务then')
            })
            console.log('异步宏任务');
        }, 0)
        new Promise(function (resolve, reject) {
            console.log('同步宏任务promise');
            resolve();
        }).then(function () {
            console.log('同步微任务then')
        })
        console.log('同步宏任务')
    </script>
</body>

</html>

输出结果：
同步宏任务promise
同步宏任务
同步微任务then
异步宏任务promise
异步宏任务
异步微任务then

分析：setTimeout是异步任务，虽然他在0秒后执行但仍排在队列的后面，因此其中的代码全部靠后执行；new Promise是同步任务同时也是主任务，因此第一行先打印’同步宏任务promise’，then是微任务所以靠后执行，先执行第28行代码，之后再执行第26行的then语句，因此第二行输出为’同步宏任务’，第三行为’同步微任务then’；接下来执行setTimeout中的语句，then因为是微任务所以在第20行执行完成后再执行。
例子2：
<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
</head>

<body>
    <script>
        console.log('1');//
        setTimeout(function () {
            console.log('2');//
            new Promise(function (resolve) {
                console.log('3');//
                resolve();
            }).then(function () {
                console.log('4');//
            })
        }, 0);
        new Promise(function (resolve) {
            console.log('5');//
            resolve();
        }).then(function () {
            console.log('6');//
        });
        setTimeout(function () {
            console.log('7');//
            new Promise(function (resolve) {
                console.log('8');//
                resolve();
            }).then(function () {
                console.log('9');//
            });
        })
        console.log('10');//
        // 1 5 10 6 2 3 4 7 8 9
    </script>
</body>

</html>

输出结果：1 5 10 6 2 3 4 7 8 9
例子3（async、await、promise）：
<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
</head>

<body>
    <script>
        console.log('1');
        async function async1() {
            console.log('2');
            await async2();
            console.log('3');
        }
        async function async2() {
            console.log('4');
        }
        //调用async1
        async1();
        setTimeout(function () {
            console.log('5');
            new Promise(function (resolve) {
                console.log('6');
                resolve();
            }).then(function () {
                console.log('7');
            });
        }, 0);
        new Promise(function (resolve, reject) {
            console.log('8');
            resolve();
        }).then(function () {
            console.log('9');
        })
        setTimeout(function () {
            console.log('10');
            new Promise(function (resolve) {
                console.log('11');
                resolve();
            }).then(function () {
                console.log('12');
            });
        }, 0);
        console.log('13');
        //1 2 4 8 13 3 9 5 6 7 10 11 12
    </script>
</body>

</html>

输出结果：1 2 4 8 13 3 9 5 6 7 10 11 12
如果本文对你有帮助，请点个赞吧！

数据挖掘是一种技术，它将传统的数据分析方法与处理大量数据的复杂算法相结合。

数据挖掘是在大型数据存储库中，自动地发现有用信息的过程。数据挖掘技术用来探查大型数据库，发现先前未知的有用模式。

数据挖掘（Data mining）是一个跨学科的计算机科学分支。它是用人工智能、机器学习、统计学和数据库的交叉方法在相对较大型的数据集中发现模式的计算过程。

数据挖掘的基本任务


利用分类与预测、聚类分析、关联规则、时序模式、偏差检测、智能推荐等方法，帮助企业提取数据中蕴含的商业价值，提高企业的竞争力。


数据挖掘建模过程


定义挖掘目标、数据取样 、数据探索 、数据预处理、挖掘建模、模型评价


Python 数据挖掘相关扩展库


Numpy   提供数组支持，以及相应的高效的处理函数
Scipy   提供矩阵支持，以及矩阵相关
Matplotlib 强大的数据可视化工具，作图库
Pandas   强大、灵活的数据分析和探索工具
StatsModels 统计建模和计量经济学，包括描述统计，统计模型估计和推断
Scikit-Learn 支持回归、分类、聚类等强大的机器学习库
Keras      深度学习库，用于建立神经网络以及深度学习模型（Anaconda Navigator）
Gensim     用来做文本主题模型的库，文本挖掘可能用到

Numpy 基本操作 (数组的操作）


import numpy as np
a= np.array([2,0,1,5])
print a,type(a)
print (a[:3])
print (a.min())
a.sort()
print (a)
b=np.array([[1,2,3],[4,5,6]])
print b
print (b*b)
print (b**2)


[2 0 1 5] <type 'numpy.ndarray'>
[2 0 1]
0
[0 1 2 5]
[[1 2 3]
 [4 5 6]]
[[ 1  4  9]
 [16 25 36]]
[[ 1  4  9]
 [16 25 36]]



Scipy （矩阵预算，线性代数、积分、插值、FFT、信号处理、图像处理等的计算）


求解线性方程组和数值积分

from scipy.optimize import fsolve # 导入求解方程组的函数
def f(x):
    x1=x[0]
    x2=x[1]
    return [2*x1-x2**2-1,x1**2-x2-2]
result=fsolve(f,[1,1])
print (result)

from scipy import integrate #导入积分函数
def g(x):
    return (1-x**2)**0.5
pi_2,err=integrate.quad(g,-1,1)
print (pi_2*2),err

[ 1.91963957  1.68501606]
 3.14159265359 1.00023567207e-09



Matplotlib 作图的基本代码


import numpy as np
import matplotlib.pyplot as plt

x=np.linspace(0,10,1000) #作图的变量自变量
y=np.sin(x)+1
z=np.cos(x**2)+1

plt.figure(figsize=(8,4)) #设置图像大小
plt.plot(x,y,label='$ sin x+1 $',color='red',linewidth=2) #作图，设置标签、线条颜色，宽度
plt.plot(x,z,'b--',label='$cos x^2+1$')
plt.xlabel('Time(s) ')
plt.ylabel('Volt')
plt.title('A Simple Example')
plt.ylim(0,2.2)
plt.legend() #显示图例
plt.show()




np.random.seed(1000)
y=np.random.standard_normal(20)
print y
x=range(len(y))
print x
plt.plot(x,y)
plt.plot(y.cumsum(),'b',lw=1.5)
plt.plot(y.cumsum(),'ro',lw=1.5)
plt.show()

[-0.8044583   0.32093155 -0.02548288  0.64432383 -0.30079667  0.38947455
 -0.1074373  -0.47998308  0.5950355  -0.46466753  0.66728131 -0.80611561
 -1.19606983 -0.40596016 -0.18237734  0.10319289 -0.13842199  0.70569237
  1.27179528 -0.98674733]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]




np.random.seed(2000)
#y1=np.random.standard_normal((20,2))
y=np.random.standard_normal((20,2)).cumsum(axis=0)
print y
plt.figure(figsize=(9,4))
plt.subplot(121)
plt.plot(y[:,0],lw=1.5,label='1st')
plt.plot(y[:,0],'ro')
plt.grid(True)
plt.legend(loc=0)
plt.axis('tight')
plt.xlabel('index')
plt.ylabel('value')
plt.title('1st Data Set')
plt.subplot(122)
plt.bar(np.arange(len(y)),y[:,1],width=0.5,color='g',label='2nd')
plt.grid(True)
plt.legend(loc=0)
plt.axis('tight')
plt.xlabel('index')
plt.ylabel('value')
plt.title('2st Data Set')

[[ 1.73673761  1.89791391]
 [-0.37003581  1.74900181]
 [ 0.21302575 -0.51023122]
 [ 0.35026529 -1.21144444]
 [-0.27051479 -1.6910642 ]
 [ 0.93922398 -2.76624806]
 [ 1.74614319 -3.05703153]
 [ 1.52519555 -3.22618757]
 [ 2.62602999 -3.14367705]
 [ 2.6216544  -4.8662353 ]
 [ 3.67921082 -7.38414811]
 [ 1.7685707  -6.07769276]
 [ 2.19296834 -6.54686084]
 [ 1.18689581 -7.46878388]
 [ 1.81330034 -7.11160718]
 [ 1.79458178 -6.89043591]
 [ 2.49318589 -6.05592589]
 [ 0.82754806 -8.95736573]
 [ 0.77890953 -9.00274406]
 [ 2.25424343 -9.51643749]]





Text(0.5,1,u'2st Data Set')





pandas 的简单例子  (数据的读取、处理和探索)  series(类似一维数组） dataFrame（相当于一张二维的表格，每一列都是一个Series）


import numpy as np
import pandas as pd
df=pd.DataFrame([10,20,30,40],columns=['numbers'],index=['a','b','c','d'])
df





   


  

    

      

      
numbers
    
  
  

    

      
a
      
10
    
    

      
b
      
20
    
    

      
c
      
30
    
    

      
d
      
40
    
  



df.index

Index([u'a', u'b', u'c', u'd'], dtype='object')


df.columns

Index([u'numbers'], dtype='object')


print df.ix['c']
print df.ix[['a','d']]
print df.ix[df.index[1:3]]
print df.sum()
print df.apply(lambda x:x**2)

numbers    30
Name: c, dtype: int64
   numbers
a       10
d       40
   numbers
b       20
c       30
numbers    100
dtype: int64
   numbers
a      100
b      400
c      900
d     1600


df['floats']=(1.5,2.5,3.5,4.5)
df





  

    

      

      
numbers
      
floats
    
  
  

    

      
a
      
10
      
1.5
    
    

      
b
      
20
      
2.5
    
    

      
c
      
30
      
3.5
    
    

      
d
      
40
      
4.5
    
  



df['names']=pd.DataFrame(['Yves','Guido','Feild','Fance'],index=['a','b','c','d'])
print df
df=df.append(pd.DataFrame({'numbers':100,'floats':5.75,'names':'Henry'},index=['Z']))
print df

   numbers  floats  names
a       10     1.5   Yves
b       20     2.5  Guido
c       30     3.5  Feild
d       40     4.5  Fance
   floats  names  numbers
a    1.50   Yves       10
b    2.50  Guido       20
c    3.50  Feild       30
d    4.50  Fance       40
Z    5.75  Henry      100


df['floats']['a']

1.5


type(df)

pandas.core.frame.DataFrame


df['numbers']

a     10
b     20
c     30
d     40
Z    100
Name: numbers, dtype: int64


type(df['numbers'])

pandas.core.series.Series


import matplotlib.pyplot as plt
df['numbers'].cumsum().plot(style='r',lw=2.) #画numbers这列的累加图形
plt.xlabel('date')
plt.ylabel('value')
plt.show()



import pandas as pd     #Series和DataFrame数据结构
s=pd.Series([1,2,3],index=['a','b','c'])
print s
d=pd.DataFrame([[1,2,3],[4,5,6]],columns=['a','b','c'])
print d
d2=pd.DataFrame(s)
print d2
print d.head()

a    1
b    2
c    3
dtype: int64
   a  b  c
0  1  2  3
1  4  5  6
   0
a  1
b  2
c  3
   a  b  c
0  1  2  3
1  4  5  6



StatsModels 注重数据的统计建模分析，使pytohn有R语言的味道， StatsModels支持与pandas进行数据交互，强大的数据挖掘组合


from statsmodels.tsa.stattools import adfuller as ADF
from pandas.core import datetools
import numpy as np
ADF(np.random.rand(100)) #返回的结果是ADF值和p值  单位根和概率值


(-11.253758305760554,
 1.6868652157937374e-20,
 0L,
 99L,
 {'1%': -3.4981980821890981,
  '10%': -2.5825959973472097,
  '5%': -2.8912082118604681},
 31.149412019471782)



Scilit-Learn包括数据预处理、分类与预测、回归、聚类和模型分析


from sklearn import datasets #导入数据集
iris=datasets.load_iris()  #加载数据集
print(iris.data.shape)

from sklearn import svm #建立线性SVM分类器
clf=svm.LinearSVC()#建立线性SVM分类器
clf.fit(iris.data,iris.target)# 用数据训练模型
clf.predict([[5.0,3.6,1.5,0.25]])#训练好模型之后，输入新的数据进行预测
clf.coef_  #训练好模型的参数



(150L, 4L)

array([[ 0.18424073,  0.451224  , -0.80793865, -0.45071743],
       [ 0.0533189 , -0.89005676,  0.40352144, -0.93828342],
       [-0.85072726, -0.98671105,  1.38088737,  1.86538905]])



Keras 搭建神经网络 自编码器、循环神经网络、递归神经网络、卷积神经网络
Gensim 处理语言方面的任务，如文本相似度计算、word2Vec等


数据探索

通过检验数据集的数据质量、绘制图表、计算某些特征量等手段，对样本数据集的结构和规律进行分析的过程。 

有助于选择合适的数据预处理和建模方法。

数据质量分析

缺失值、异常值、不一致的值、重复数据及含有特殊符号的数据（#、￥、*）

缺失值的处理


缺失值产生的原因

1、信息暂时无法获取，或者信息获取代价太大

2、信息被遗漏

3、属性值不存在
缺失值的影响

数据挖掘建模将丢失大量有用信息； 数据挖掘模型表现出的不确定性更加显著，规律难把握；包含空值的数据建模，导致不可靠的输出。
缺失值分析

统计分析的方法，可以得到含有缺失值属性的个数。 删除记录、插补、不处理


异常值分析

简单统计量分析（最大值，最小值）、箱形图分析

import pandas as pd
catering_sale='data3/catering_sale.xls'  #餐饮数据
data=pd.read_excel(catering_sale,index_col=u'日期') #日期列为索引列
data.head()







  

    

      

      
销量
    
    

      
日期
      

    
  
  

    

      
2015-03-01
      
51.0
    
    

      
2015-02-28
      
2618.2
    
    

      
2015-02-27
      
2608.4
    
    

      
2015-02-26
      
2651.9
    
    

      
2015-02-25
      
3442.1
    
  



data.describe()







  

    

      

      
销量
    
  
  

    

      
count
      
200.000000
    
    

      
mean
      
2755.214700
    
    

      
std
      
751.029772
    
    

      
min
      
22.000000
    
    

      
25%
      
2451.975000
    
    

      
50%
      
2655.850000
    
    

      
75%
      
3026.125000
    
    

      
max
      
9106.440000
    
  



import pandas as pd

catering_sale = 'data3/catering_sale.xls' #餐饮数据
data = pd.read_excel(catering_sale, index_col = u'日期') #读取数据，指定“日期”列为索引列

import matplotlib.pyplot as plt #导入图像库
plt.figure() #建立图像
p = data.boxplot(return_type='dict') #画箱线图，直接使用DataFrame的方法
x = p['fliers'][0].get_xdata() # 'flies'即为异常值的标签
y = p['fliers'][0].get_ydata()
y.sort() #从小到大排序，该方法直接改变原对象

#用annotate添加注释
#其中有些相近的点，注解会出现重叠，难以看清，需要一些技巧来控制。
for i in range(len(x)): 
  if i>0:
    plt.annotate(y[i], xy = (x[i],y[i]), xytext=(x[i]+0.05 -0.8/(y[i]-y[i-1]),y[i]))
  else:
    plt.annotate(y[i], xy = (x[i],y[i]), xytext=(x[i]+0.08,y[i]))

plt.show() #展示箱线图



数据特征分析

分布分析（定量数据的分布分析,定性数据的分布分析）、对比分析、统计量分析、周期性分析、贡献度分析、相关性分析，了解数据的规律和趋势，为数据挖掘的后续环节提供支持。

统计量分析：集中趋势度量（均值、中位数、众数）；离中趋势度量（极差、标准差、变异系数、四分位间距）；

# 统计量分析
import pandas as pd

catering_sale = 'data3/catering_sale.xls' #餐饮数据
data = pd.read_excel(catering_sale, index_col = u'日期') #读取数据，指定“日期”列为索引列
data = data[(data[u'销量'] > 400)&(data[u'销量'] < 5000)] #过滤异常数据
statistics = data.describe() #保存基本统计量

statistics.loc['range'] = statistics.loc['max']-statistics.loc['min'] #极差 最大值减最小值
statistics.loc['var'] = statistics.loc['std']/statistics.loc['mean'] #变异系数    比较两个或多个具有不同单位或波动幅度的数据集的离中趋势
statistics.loc['dis'] = statistics.loc['75%']-statistics.loc['25%'] #四分位数间距 值越大说明变异程度越大

print(statistics)

                销量
count   195.000000
mean   2744.595385
std     424.739407
min     865.000000
25%    2460.600000
50%    2655.900000
75%    3023.200000
max    4065.200000
range  3200.200000
var       0.154755
dis     562.600000


贡献度分析：A1-A7总盈利占85%

import pandas as pd

#初始化参数
dish_profit = 'data3/catering_dish_profit.xls' #餐饮菜品盈利数据
data = pd.read_excel(dish_profit, index_col = u'菜品名')
data = data[u'盈利'].copy()
data.sort_values(ascending = False)

import matplotlib.pyplot as plt #导入图像库
plt.figure()
data.plot(kind='bar')
plt.ylabel(u'盈利（元）')
p = 1.0*data.cumsum()/data.sum()
p.plot(color = 'r', secondary_y = True, style = '-o',linewidth = 2)
plt.annotate(format(p[6], '.4%'), xy = (6, p[6]), xytext=(6*0.9, p[6]*0.9), arrowprops=dict(arrowstyle="->", connectionstyle="arc3,rad=.2")) #添加注释，即85%处的标记。这里包括了指定箭头样式。
plt.ylabel(u'盈利（比例）')
plt.show()



相关性分析：相关系数 

 $$r=\frac{\sum_{i=1}^n {(x_i-\bar x)(y_i-\bar y)}}{\sqrt{{\sum_{i=1}^n (x_i-\bar x)^2}{\sum_{i=1}^n(y_i-\bar y)^2}}}$$ 


import pandas as pd

catering_sale = 'data3/catering_sale_all.xls' #餐饮数据，含有其他属性
data = pd.read_excel(catering_sale, index_col = u'日期') 
print data.head()

data.corr() #相关系数矩阵，即给出了任意两款菜式之间的相关系数
print data.corr()[u'百合酱蒸凤爪'] #只显示“百合酱蒸凤爪”与其他菜式的相关系数
print data[u'百合酱蒸凤爪'].corr(data[u'翡翠蒸香茜饺']) #计算“百合酱蒸凤爪”与“翡翠蒸香茜饺”的相关系数

            百合酱蒸凤爪  翡翠蒸香茜饺  金银蒜汁蒸排骨  乐膳真味鸡  蜜汁焗餐包  生炒菜心  铁板酸菜豆腐  香煎韭菜饺  香煎罗卜糕  \
日期                                                                              
2015-01-01      17       6        8     24   13.0    13      18     10     10   
2015-01-02      11      15       14     13    9.0    10      19     13     14   
2015-01-03      10       8       12     13    8.0     3       7     11     10   
2015-01-04       9       6        6      3   10.0     9       9     13     14   
2015-01-05       4      10       13      8   12.0    10      17     11     13   

            原汁原味菜心  
日期                  
2015-01-01      27  
2015-01-02      13  
2015-01-03       9  
2015-01-04      13  
2015-01-05      14  
百合酱蒸凤爪     1.000000
翡翠蒸香茜饺     0.009206
金银蒜汁蒸排骨    0.016799
乐膳真味鸡      0.455638
蜜汁焗餐包      0.098085
生炒菜心       0.308496
铁板酸菜豆腐     0.204898
香煎韭菜饺      0.127448
香煎罗卜糕     -0.090276
原汁原味菜心     0.428316
Name: 百合酱蒸凤爪, dtype: float64
0.00920580305184


数据预处理

数据预处理占到60%， 数据清洗、数据集成（属性冗余问题），数据变换、数据规约。

数据清洗主要包括：缺失值处理（均值、中位数、众数插补，最近临插补、回归方法、插值法）、异常值处理（删除、视为缺失值、平均值修正）。


 $$y= a_0+a_1x+a_2x^2+...+a_{n-1}x^{n-1}$$ 

lagrange插值法：








#拉格朗日插值代码
#拉格朗日插值代码  
import pandas as pd #导入数据分析库Pandas  
from scipy.interpolate import lagrange #导入拉格朗日插值函数  

inputfile = 'data4/catering_sale.xls' #销量数据路径  
outputfile = './sales.xls' #输出数据路径  

data = pd.read_excel(inputfile) #读入数据  
#data[u'销量'][(data[u'销量'] < 400) | (data[u'销量'] > 5000)] = None #过滤异常值，将其变为空值  
row_indexs = (data[u'销量'] < 400) | (data[u'销量'] > 5000)  #得到过滤数据的索引  
data.loc[row_indexs,u'销量'] = None  #过滤数据  

#自定义列向量插值函数  
#s为列向量，n为被插值的位置，k为取前后的数据个数，默认为5  
def ployinterp_column(s, n, k=5):  
    y = s[list(range(n-k, n)) + list(range(n+1, n+1+k))] #取数  
    y = y[y.notnull()] #剔除空值  
    return lagrange(y.index, list(y))(n) #插值并返回拉格朗日插值结果  

#逐个元素判断是否需要插值  
for i in data.columns:  
    for j in range(len(data)):  
        if (data[i].isnull())[j]: #如果为空即插值。  
#       data[i][j] = ployinterp_column(data[i], j)  
            data.loc[j,i] = ployinterp_column(data[i], j)  
data.to_excel(outputfile) #输出结果，写入文件  



数据归一化：

#数据规范化
import pandas as pd
import numpy as np

datafile = 'data4/normalization_data.xls' #参数初始化
data = pd.read_excel(datafile, header = None) #读取数据

(data - data.min())/(data.max() - data.min()) #最小-最大规范化
(data - data.mean())/data.std() #零-均值规范化
data/10**np.ceil(np.log10(data.abs().max())) #小数定标规范化








  

    

      

      
0
      
1
      
2
      
3
    
  
  

    

      
0
      
0.078
      
0.521
      
0.602
      
0.2863
    
    

      
1
      
0.144
      
-0.600
      
-0.521
      
0.2245
    
    

      
2
      
0.095
      
-0.457
      
0.468
      
-0.1283
    
    

      
3
      
0.069
      
0.596
      
0.695
      
0.1054
    
    

      
4
      
0.190
      
0.527
      
0.691
      
0.2051
    
    

      
5
      
0.101
      
0.403
      
0.470
      
0.2487
    
    

      
6
      
0.146
      
0.413
      
0.435
      
0.2571
    
  



连续属性离散化： 

等宽离散化: 将属性的值域分成相同宽度的区间

等频离散化：间相同数量的记录放进每个区间

基于聚类

#-*- coding: utf-8 -*-

import pandas as pd

datafile = 'data4/discretization_data.xls' #参数初始化
data = pd.read_excel(datafile) #读取数据
data = data[u'肝气郁结证型系数'].copy()
print data.head(10)

k = 4
#等宽离散化
d1 = pd.cut(data, k, labels = range(k)) #等宽离散化，各个类比依次命名为0,1,2,3

#等频率离散化
w = [1.0*i/k for i in range(k+1)]  #[0.0, 0.25, 0.5, 0.75, 1.0]
w = data.describe(percentiles = w)[4:4+k+1] #使用describe函数自动计算分位数
w[0] = w[0]*(1-1e-10)
d2 = pd.cut(data, w, labels = range(k))

from sklearn.cluster import KMeans #引入KMeans
kmodel = KMeans(n_clusters = k, n_jobs = 4) #建立模型，n_jobs是并行数，一般等于CPU数较好
kmodel.fit(data.values.reshape((len(data), 1))) #训练模型
c = pd.DataFrame(kmodel.cluster_centers_).sort_values(0) #输出聚类中心，并且排序（默认是随机序的）
w = c.rolling(window=2,center=False).mean().iloc[1:] #相邻两项求中点，作为边界点
#w = pd.DataFrame.rolling(window=2,center=False).mean()
w = [0] + list(w[0]) + [data.max()] #把首末边界点加上
d3 = pd.cut(data, w, labels = range(k))

def cluster_plot(d, k): #自定义作图函数来显示聚类结果
  import matplotlib.pyplot as plt

  plt.figure(figsize = (8, 3))
  for j in range(0, k):
    plt.plot(data[d==j], [j for i in d[d==j]], 'o')

  plt.ylim(-0.5, k-0.5)
  return plt

cluster_plot(d1, k).show()

cluster_plot(d2, k).show()
cluster_plot(d3, k).show()

0    0.056
1    0.488
2    0.107
3    0.322
4    0.242
5    0.389
6    0.246
7    0.330
8    0.257
9    0.205
Name: 肝气郁结证型系数, dtype: float64








#主成分分析 降维
import pandas as pd

#参数初始化
inputfile = 'data4/principal_component.xls'
outputfile = './dimention_reducted.xls' #降维后的数据

data = pd.read_excel(inputfile, header = None) #读入数据

from sklearn.decomposition import PCA

pca = PCA()
pca.fit(data)
print pca.components_ #返回模型的各个特征向量
print pca.explained_variance_ratio_ #返回各个成分各自的方差百分比

[[ 0.56788461  0.2280431   0.23281436  0.22427336  0.3358618   0.43679539
   0.03861081  0.46466998]
 [ 0.64801531  0.24732373 -0.17085432 -0.2089819  -0.36050922 -0.55908747
   0.00186891  0.05910423]
 [-0.45139763  0.23802089 -0.17685792 -0.11843804 -0.05173347 -0.20091919
  -0.00124421  0.80699041]
 [-0.19404741  0.9021939  -0.00730164 -0.01424541  0.03106289  0.12563004
   0.11152105 -0.3448924 ]
 [-0.06133747 -0.03383817  0.12652433  0.64325682 -0.3896425  -0.10681901
   0.63233277  0.04720838]
 [ 0.02579655 -0.06678747  0.12816343 -0.57023937 -0.52642373  0.52280144
   0.31167833  0.0754221 ]
 [-0.03800378  0.09520111  0.15593386  0.34300352 -0.56640021  0.18985251
  -0.69902952  0.04505823]
 [-0.10147399  0.03937889  0.91023327 -0.18760016  0.06193777 -0.34598258
  -0.02090066  0.02137393]]
[  7.74011263e-01   1.56949443e-01   4.27594216e-02   2.40659228e-02
   1.50278048e-03   4.10990447e-04   2.07718405e-04   9.24594471e-05]


pca=PCA(3)
pca.fit(data)
low_d=pca.transform(data)
low_d

array([[  8.19133694,  16.90402785,   3.90991029],
       [  0.28527403,  -6.48074989,  -4.62870368],
       [-23.70739074,  -2.85245701,  -0.4965231 ],
       [-14.43202637,   2.29917325,  -1.50272151],
       [  5.4304568 ,  10.00704077,   9.52086923],
       [ 24.15955898,  -9.36428589,   0.72657857],
       [ -3.66134607,  -7.60198615,  -2.36439873],
       [ 13.96761214,  13.89123979,  -6.44917778],
       [ 40.88093588, -13.25685287,   4.16539368],
       [ -1.74887665,  -4.23112299,  -0.58980995],
       [-21.94321959,  -2.36645883,   1.33203832],
       [-36.70868069,  -6.00536554,   3.97183515],
       [  3.28750663,   4.86380886,   1.00424688],
       [  5.99885871,   4.19398863,  -8.59953736]])




挖掘建模

分类与预测（回归分析、决策树（ID3）、神经网络、贝叶斯网络、支持向量机） 

聚类分析 

关联规则（Apriori） 

时序模式 

偏差检测

ID3算法核心是在决策树的各级节点上，使用信息增益方法作为属性的选择标准，来帮助确定生成每个节点时所采用的合适属性。



 $$I(s_1,s_2,...,s_m)=-\sum_{i=1}^m P_ilog_2(P_i)$$ 


m表示属性值的个数，$s_i$ 是某个属性值的样本个数, $P_i$ 可以用 $\frac{s_i}S$,S是s样本数据的集合。

总信息熵：销售数量高的数据18，低的数据16, $I(18,16)=- \frac{18}{34} log_2 \frac{18}{34}- \frac{16}{34} log_2 \frac{16}{34}$

是否周末属性：是的条件下，销售高的记录11，低为3，表示（11，3）；不是的条件下，销售高记录7，低为13，表示（7，13）；

是否周末的属性的信息熵增益：$I(18,16)-(\frac{14}{34}I(11,3)+\frac{20}{34}I(7,13))$




#使用ID3决策树算法预测销量高低
import pandas as pd

#参数初始化
inputfile = 'data5/sales_data.xls'
data = pd.read_excel(inputfile, index_col = u'序号') #导入数据
print data.head()

#数据是类别标签，要将它转换为数据
#用1来表示“好”、“是”、“高”这三个属性，用-1来表示“坏”、“否”、“低”
data[data == u'好'] = 1
data[data == u'是'] = 1
data[data == u'高'] = 1
data[data != 1] = -1
print data.head()
x = data.iloc[:,:3].as_matrix().astype(int) #前三个属性的矩阵
y = data.iloc[:,3].as_matrix().astype(int) #销量的矩阵

from sklearn.tree import DecisionTreeClassifier as DTC
dtc = DTC(criterion='entropy') #建立决策树模型，基于信息熵
dtc.fit(x, y) #训练模型

#导入相关函数，可视化决策树。
#导出的结果是一个dot文件，需要安装Graphviz才能将它转换为pdf或png等格式。
from sklearn.tree import export_graphviz
x = pd.DataFrame(x)
from sklearn.externals.six import StringIO
x = pd.DataFrame(x)
with open("tree.dot", 'w') as f:
  f = export_graphviz(dtc, feature_names = x.columns, out_file = f)


   天气 是否周末 是否有促销 销量
序号                 
1   坏    是     是  高
2   坏    是     是  高
3   坏    是     是  高
4   坏    否     是  高
5   坏    是     是  高
    天气 是否周末 是否有促销 销量
序号                  
1   -1    1     1  1
2   -1    1     1  1
3   -1    1     1  1
4   -1   -1     1  1
5   -1    1     1  1




value=[0,6]代表0个低，6个高

Apriori算法： 找最大K项频繁集  没一项的支持度 p（a）=7/10, 支持度为0.2（支持度计数为2） 



#使用Apriori算法挖掘菜品订单关联规则
import pandas as pd
from apriori import * #apriori函数

inputfile = 'data5/menu_orders.xls'
outputfile = './apriori_rules.xls' #结果文件
data = pd.read_excel(inputfile, header = None)
print data.head(11)

print(u'\n转换原始数据至0-1矩阵...')
ct = lambda x : pd.Series(1, index = x[pd.notnull(x)]) #转换0-1矩阵的过渡函数
b = map(ct, data.as_matrix()) #用map方式执行
data = pd.DataFrame(list(b)).fillna(0) #实现矩阵转换，空值用0填充
print(u'\n转换完毕。')
del b #删除中间变量b，节省内存

support = 0.2 #最小支持度 同时发生的概率
confidence = 0.5 #最小置信度  A发生则B发生的概率
ms = '---' #连接符，默认'--'，用来区分不同元素，如A--B。需要保证原始表格中不含有该字符

find_rule(data, support, confidence, ms).to_excel(outputfile) #保存结果

   0  1    2    3
0  a  c    e  NaN
1  b  d  NaN  NaN
2  b  c  NaN  NaN
3  a  b    c    d
4  a  b  NaN  NaN
5  b  c  NaN  NaN
6  a  b  NaN  NaN
7  a  b    c    e
8  a  b    c  NaN
9  a  c    e  NaN

转换原始数据至0-1矩阵...

转换完毕。

正在进行第1次搜索...
数目：6...

正在进行第2次搜索...
数目：3...

正在进行第3次搜索...
数目：0...

结果为：
           support  confidence
e---a          0.3    1.000000
e---c          0.3    1.000000
c---e---a      0.3    1.000000
a---e---c      0.3    1.000000
a---b          0.5    0.714286
c---a          0.5    0.714286
a---c          0.5    0.714286
c---b          0.5    0.714286
b---a          0.5    0.625000
b---c          0.5    0.625000
b---c---a      0.3    0.600000
a---c---b      0.3    0.600000
a---b---c      0.3    0.600000
a---c---e      0.3    0.600000