精华内容
下载资源
问答
  • console.log('*********************************************************') setTimeout(() => { console.log("主要是看宏任务什么时候执行") }, 0); var p1 = new Promise((res, rej)...
     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

    展开全文
  • 空难数据分析例子

    千次阅读 2017-03-20 11:24:19
    数据集:Kaggle上的1908年收集的公开数据集项目任务: 每年空难数分析 机上乘客数量 生还数、遇难数 哪些航空公司空难数最多? 哪些机型空难数最多? # -*-coding: utf-8 -*- import pandas as pd import seaborn as ...

    数据集: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()

    这里写图片描述

    展开全文
  • #微任务 和 宏任务的执行分析 #简单实例分析 例子1: <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width, ...

    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

    如果本文对你有帮助,请点个赞吧!

    展开全文
  • 数据分析简单例子

    万次阅读 多人点赞 2018-01-31 16:43:51
    数据挖掘是一种技术,它将传统的数据分析方法与处理大量数据的复杂算法相结合。 数据挖掘是在大型数据存储库中,自动地发现有用信息的过程。数据挖掘技术用来探查大型数据库,发现先前未知的有用模式。 数据挖掘...

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

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

    数据挖掘(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=i=1n(xix¯)(yiy¯)i=1n(xix¯)2i=1n(yiy¯)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=a0+a1x+a2x2+...+an1xn1
    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(s1,s2,...,sm)=i=1mPilog2(Pi)

    m表示属性值的个数,si 是某个属性值的样本个数, Pi 可以用 siS,S是s样本数据的集合。

    总信息熵:销售数量高的数据18,低的数据16, I(18,16)=1834log218341634log21634

    是否周末属性:是的条件下,销售高的记录11,低为3,表示(11,3);不是的条件下,销售高记录7,低为13,表示(7,13);

    是否周末的属性的信息熵增益:I(18,16)(1434I(11,3)+2034I(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
    
    展开全文
  • 词法分析——词法分析任务

    千次阅读 2018-10-30 13:02:25
    词法分析器的任务是读入源程序,对其进行一定的切分,得到记号流 对于字符流和记号流之间的区别,下面给出一个例子来说明 if (x &gt; 5) y = "hello"; else z = 1; 对面上面这段程序,在词法分析器...
  • RDD使用例子 本节介绍一个RDD使用例子,将数据文件读入为RDD,并作相应的转化、行动操作,在过程中展示RDD的知识点,例子来自于《Spark快速大数据分析》第八章。 创建数据文件,如下: ## input.txt ## INFO This ...
  • 在其中,词法分析器的任务就是读入源程序,对其进行一定的切分,得到记号流。对于字符流和记号流之间的区别,下面给出一个例子来说明。if (x > 5) y = "hello"; else z = 1;对面上面这段程序,在词法分析器的...
  • 如果你了解gulp的使用方法,那么你需要一个实战的例子来帮你加深理解。 这里将会手把手教你如何搭建一个工作流,类似yo angular这样的gulpfile.js ---------------------------------------------------分析需求...
  • MapReduce 运行的时候,会通过 Mapper 运行的任务读取 HDFS 中的数据文件,然后调用自己的方法,处理数据,最后输出。Reducer 任务会接收 Mapper 任务输出的数据,作为自己的输入数据,调用自己的方法,最后输出到 ...
  • 介绍当我开始我的数据科学之旅时,我探索的第一个算法是线性回归。...毋庸置疑,模型评价是一项关键性的任务,它凸显了模型的不足。选择最合适的评价指标是一个关键的任务。而且,我遇到了两个重...
  • 接下来就为大家描述一个基于ThinkPHP框架定时执行任务例子,具体的方法会在下面进行详细的描述。 关于定时执行任务在这里需要提醒的是, 这里描述的方法是被动执行的,也就是说当系统网站产生访问的时候,程序会...
  • 我打算以 flink 官方的 例子 <<Monitoring the Wikipedia Edit Stream>> 作为示例,进行 flink 流...后续我会对这个拓扑任务代码进行逐行的深入分析,以达到深入了解flink代码运行机制的目的. pub...
  • 作者 | 高光轩 编辑 |高卫华 出品 | CSDN(ID:CSDNnews) 背景 ...airflow作为apache基金会的一款开源的优秀调度系统,目前被国内外很多大...举个例子说明下,假设你设置了一个任务是每天8:00跑,但是你发现到了...
  • 官方大牛写的关于MVP的例子,应用名称叫做todoapp(大牛不喜欢驼峰 0、作者是大牛,包名是按照页面名字(比如添加任务页)去命名的(没有用那种按照组件去分package),厉害,谁让我比较烂,所以大家都很牛,这也...
  • 接下继续执行的就是Worker上的Executor进程了,本文继续分析整个Executor的启动与任务提交流程 Spark-submit 提交一个任务到集群通过的是Spark-submit通过启动脚本的方式启动它的主类,这里以WordCount为例子spark-...
  • LoadRunner 解的地方--測试结果的分析.其余的录制和加压測试等设置对于我们来讲通过几次操作就能够轻松掌握了.针对 Results Analysis 我用图片加文字做了一个样例,希望通过样例能给大家很多其它的帮助.这个样例主要...
  • 用卷积神经网络对句子分类  ...针对句子级别的分类任务,我们使用卷积神经网络(CNN)结合预训练的词向量做了一系列的实验。我们证明一个少量调节超参数的简单CNN模型结合静态词向量可以在很多基准上取
  • 作者丨邴立东、李昕、李正、彭海韵、许璐单位丨阿里巴巴达摩院等任务简介我们略过关于 sentiment analysis 重要性的铺陈,直接进入本文涉及的任务。先上例子,对于一句餐馆评论:...
  • 利用Future模式来解决高并发的问题是相当常见的,举几个例子:1.Guava中的SettableFuture,Spring中的ListenableFuture(Guava中也有),我们可以实现自动监控异步任务的运行结果并异步处理结果。从而提高CPU的利用率...
  • 前面几篇文章整体分析了Netty应用启动过程,但是留了一些细节情况并没有深入研究,本文主要围绕 reactor线程对任务执行。EventLoopEventLoop可以理解为一个单线程多任务的线程池,netty中所有内部任务事件都是由...
  • Phaser是jdk1.7才出现的,可以实现分阶段实现任务,多个线程执行第一个阶段任务,等待所有线程第一阶段执行完了才开始执行第二阶段,如此类推。其实就是多个栅栏CyclicBarrier,只不过这个Phaser比较灵活。 先看下...
  • ucos-II并不像linux等操作系统一样提供中断程序处理的框架,更合理的说法是用户必须在自己的中断服务程序中适配ucos的任务调度机制。这个适配就是在OSIntEnter和OSIntExit。...ucos-II中中断的例子(...
  • 首先通过两个图来引入什么是决策树。...一般情况下,一棵决策树包含一个根节点,若干内部节点和若干叶节点,如下图所示,那么与是否学习的决策过程对应起来,‘女票’为根节点,'陪女友'和‘任务’‘...
  • 一 ,SparkPi 源码分析 : 1 ,在 linux 中把例子整出来 : 2 ,得到 jar 包 : 3 ,把他整到 idea 中 : 4 ,看这个类 : SparkPi 5 ,源码查看 : 读懂它,老师已经添加详细注释 思路 : 代码 : package ...
  • spark任务中基于rdd的执行流程分析

    千次阅读 2015-11-12 17:36:18
    下面是rdd的论文中,从hdfs读取日志数据的一个例子: lines = spark.textFile("hdfs://...")  // lines is a org.apache.spark.rdd.MappedRDD errors = lines.filter(_.starts...
  • 目的: 1.arcgis server9.2 ADF自定义一个简单的Task控件。 准备工作: 1.找到DeveloperKit\SamplesNET\Server\Web_...0.自定义任务控件一般是从任务抽象类(Task或者FloatingPanelTask)继承而来。FloatingPan...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,052
精华内容 420
关键字:

任务分析例子