精华内容
下载资源
问答
  • 如何查询同一个时间段内但不同日期的数据,例如:2017年3月1日到2017年6月1日中每天早上8到9点的数据
  • 获取Kafka topic指定时间段数据

    千次阅读 2020-11-23 11:16:15
    需求:给定topic,获取某个时间段某些过滤条件下的数据。 思路:1)获取分区和offset,通过命令查询,类似kafka-console-consumer --bootstrap-server 127.0.0.1:9092 --topic test_topic --partition 1 --offset ...

    需求:给定topic,获取某个时间段某些过滤条件下的数据。

    思路:1)获取分区和offset,通过命令查询,类似kafka-console-consumer --bootstrap-server 127.0.0.1:9092 --topic test_topic --partition 1 --offset 255129 | grep "test";
               2)将topic接入elk,通过kibana可视化查询或es接口调用查询;
               3)代码实现。
               我这里通过方式3实现的,输入topic、起止时间、过滤内容,将查询的数据写入文件中,便于后续分析。如果有更好的办法,欢迎留言交流。

    代码实现:
    1)pom.xml

      <properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
            <maven.compiler.source>1.8</maven.compiler.source>
            <maven.compiler.target>1.8</maven.compiler.target>
            <kafka.version>1.0.1</kafka.version>
            <main.class>com.example.KafkaConsumerByTime</main.class>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>org.apache.kafka</groupId>
                <artifactId>kafka_2.11</artifactId>
                <version>${kafka.version}</version>
            </dependency>
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-shade-plugin</artifactId>
                    <version>2.4.1</version>
                    <configuration>
                        <createDependencyReducedPom>true</createDependencyReducedPom>
                    </configuration>
                    <executions>
                        <execution>
                            <phase>package</phase>
                            <goals>
                                <goal>shade</goal>
                            </goals>
                            <configuration>
                                <transformers>
                                    <transformer
                                            implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer"/>
                                    <transformer
                                            implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    </transformer>
                                </transformers>
                            </configuration>
                        </execution>
                    </executions>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-jar-plugin</artifactId>
                    <version>3.0.2</version>
                    <configuration>
                        <archive>
                            <manifest>
                                <addClasspath>true</addClasspath>
                                <mainClass>${main.class}</mainClass>
                            </manifest>
                        </archive>
                    </configuration>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>2.3.2</version>
                    <configuration>
                        <source>${maven.compiler.source}</source>
                        <target>${maven.compiler.target}</target>
                    </configuration>
                </plugin>
            </plugins>
        </build>

    2)主要实现,为了便于非开发人员使用,main函数会有输入参数处理,非开发人员可以通过jar包运行,得到需要的结果

    package com.example;
    
    import org.apache.kafka.clients.consumer.ConsumerRecord;
    import org.apache.kafka.clients.consumer.ConsumerRecords;
    import org.apache.kafka.clients.consumer.KafkaConsumer;
    import org.apache.kafka.clients.consumer.OffsetAndTimestamp;
    import org.apache.kafka.common.PartitionInfo;
    import org.apache.kafka.common.TopicPartition;
    
    import java.io.File;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.*;
    
    public class KafkaConsumerByTime{
        static KafkaConsumer<String, String> consumer;
        public static void main(String[] args) throws Exception {
            //传入参数判断
            if(args.length<3){
                throw new Exception("parameter args exception!");
            }
            String filterValue = "";
            if(args.length>3){
                filterValue=args[3];
            }
            long fetchStartTime = 0;
            long fetchEndTime = 0;
            try{
                fetchStartTime = dateToStamp(args[1]);
                fetchEndTime=dateToStamp(args[2]);
            }catch(ParseException e){
                throw new Exception(e.toString());
            }
            if(fetchStartTime==0||fetchEndTime==0){
                throw new Exception("startTime|endTime error!");
            }
    
            //kafkaConsumer
            Properties props = new Properties();
            props.put("bootstrap.servers", "127.0.0.1:9092");  //连接地址
            props.put("group.id", "test15");
            props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
            props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
            consumer = new KafkaConsumer(props);
    
            //根据时间段及过滤条件获取指定数据
            getMsgByTime(args[0],fetchStartTime,fetchEndTime,filterValue);
            System.out.println("finish!");
        }
    
        private static void getMsgByTime(String topic,long fetchStartTime,long fetchEndTime,String filterValue){
            //根据起始时间获取每个分区的起始offset
            Map<TopicPartition, Long> map = new HashMap();
            List<PartitionInfo> partitions = consumer.partitionsFor(topic);
            for (PartitionInfo par : partitions) {
                map.put(new TopicPartition(topic, par.partition()), fetchStartTime);
            }
            Map<TopicPartition, OffsetAndTimestamp> parMap = consumer.offsetsForTimes(map);
    
            //遍历每个分区,将不同分区的数据写入不同文件中
            boolean filterCondition1 = filterValue.trim().length()==0;
            boolean filterCondition = true,isBreak = false;
            for (Map.Entry<TopicPartition, OffsetAndTimestamp> entry : parMap.entrySet()) {
                TopicPartition key = entry.getKey();
                OffsetAndTimestamp value = entry.getValue();
    //            System.out.println(key);//topic-partition,eg:testTopic-0
    //            System.out.println(value);//eg:(timestamp=1584684100465, offset=32382989)
                //根据消费里的timestamp确定offset
                if (value != null) {
                    long offset = value.offset();
                    consumer.assign(Arrays.asList(key));//订阅主题中指定的分区key.partition()
                    consumer.seek(key, offset);
                }
    
                //拉取消息
                isBreak = false;
                FileWriter fw = null;
                try {
                    fw = new FileWriter(new File("./"+key.toString()+".txt"),true);
                } catch (IOException e) {
                    e.printStackTrace();
                }
                while (true) {
                    ConsumerRecords<String, String> poll = consumer.poll(1000);
                    StringBuffer stringBuffer =  new StringBuffer(20000);
                    for (ConsumerRecord<String, String> record : poll) {
                        filterCondition=filterCondition1||(filterValue.trim().length()>0&&record.value().contains(filterValue));
                        if (record.timestamp() <= fetchEndTime&&filterCondition){
                            stringBuffer.append(record.value()+"\r\n");
                        }else if(record.timestamp()>fetchEndTime){
                            isBreak=true;
                        }
                    }
                    try {
                        fw.write(stringBuffer.toString());
                        stringBuffer.setLength(0);
                        fw.flush();
                    }catch (IOException e){
                        e.printStackTrace();
                    }
                    if(isBreak){
                        break;
                    }
                }
                try {
                    fw.close();
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
        }
    
        //将时间转换为时间戳
        private static Long dateToStamp(String s) throws ParseException {
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            Date date = simpleDateFormat.parse(s);
            return date.getTime();
        }
    }

    3)maven打包
    mvn package
    上述命令执行后会生成jar包KafkaByTimeTool-1.0-SNAPSHOT.jar
    4)使用
    java  -jar  KafkaByTimeTool-1.0-SNAPSHOT.jar  ${参数1}  ${参数2}  ${参数3}  ${参数4}
    参数1:topic,比如"testTopic"
    参数2:起始时间,比如"2020-11-16 23:59:59"
    参数3:截止时间,比如"2020-11-17 23:59:59"
    参数4:过滤内容,比如"response",如果没有则不填

    展开全文
  • SPSS(十九)SPSS之时间序列模型(图文+数据集)

    万次阅读 多人点赞 2019-06-17 22:32:38
    SPSS(十九)SPSS之时间序列模型(图文+数据集) 时间序列是指将同一统计指标的数值按其发生的时间先后顺序排列而成的数列。正如人们常说,人生的出场顺序很重要,时间序列中隐藏着一些过去与未来的关系。时间序列...

    SPSS(十九)SPSS之时间序列模型(图文+数据集)

    时间序列是指将同一统计指标的数值按其发生的时间先后顺序排列而成的数列。正如人们常说,人生的出场顺序很重要,时间序列中隐藏着一些过去与未来的关系。时间序列分析试图通过研究过去来预测未来。

    时间序列分析在工程、金融、科技等众多领域有着广泛的应用。在大数据时代,时间序列分析已经成为 AI 技术的一个分支,通过将时间序列分析与分类模型相结合,更好的应用于数据检测、预测等场景。

    时间序列模型简介

    • 依时间顺序排列起来的一系列观测值(观测值之间不独立)
    • 它考虑的不是变量间的因果关系,而是重点考察变量在时间方面的发展变化规律,并为之建立数学模型
    • 使用时间序列模型的前提:有足够长的数据序列;数据序列的变动是稳定而规律的

    另外一种理解方式:假如我们对一件事情研究其背后规律很久的话,可以收集到很多的自变量/影响因素去研究与因变量之间的关系,但是由于各种原因我们做不到,我们只能用一个t(时间)来替代所有的影响因素来研究自变量是如何变化的

     

    时间序列分析面临的问题

    时序应该在现实生活中应用的很广,但是为什么不常用这个模型呢?

    • 基础统计数据原因(数据收集)

    报表系统——质量问题
    统计口径——不统一
    范围变化、区域划分——变化

    • 理论和技术培训原因 

    之前没有好的工具来实现时间序列模型

     

    时间序列的方法分类

    • Time domain(最为常见的方法):将时间序列看成是过去一些点的函数,或者认为序列具有随时间系统变化的趋势,它可以用不多的参数来加以描述,或者说可以通过差分、周期等还原成随机序列。
    • Frequency domain:认为时间序列是由数个正弦波成份叠加而成,当序列的确来自一些周期函数集合时,该方法特别有用。 比如心电图
       

    时间序列的构成

    并不是每个序列都包含所有4种成分。比如以年为时间单位的序列就不会有季节变化;
    一些较短的序列也看不出循环变化。所以在分析的时候得具体情况具体分析。 

    • 长期趋势

    指一种长期的变化趋势。它采取一种全局的视角,不考虑序列局部的波动

    下图,整体呈下降趋势

    • 季节变化(Season)

    反映一种周期性的变化一般在一年中完成
    虽然称作“季节”,但是周期并不一定是季度,也可以是月、周等其它能在一年内完成的周期。因为,大多数的周期都以季节的形式出现,所以称作季节变化

    比较典型的季节变化例子:圣诞节效应;冷饮的销售情况

    • 循环变化(Cyclic)

    循环跨度超年

    指一种较长时间的周期变化。一般来说循环时间为2-15年。循环变化一般会出现波峰和波谷,呈现一种循环往复的现象。 
    比如:经济危机 

    • 不规则变化(error) 

    指时间序列中无法预计的部分,也可以理解为误差
    序列的随机波动 
    突发事件引起的 
    它是无法预测的 
    在分析中往往又将其称为白噪声

    它是时间序列中除去趋势、季节变化和自相关性之后的剩余随机扰动。由于时间序列存在不确定性,随机噪声总是夹杂在时间序列中,致使时间序列表现出某种震荡式的无规律运动。
    比如:911事件

     

    时间序列分析对长度的要求

    • 不同的序列分析方法对时间序列分析对长度不一样,建模过程一般都会做差分,差分会损失信息,差分得越多,相应要求的时间序列越长
    • 如果是稳定序列的话,历史数据越多,对预测的帮助越大
    • 如果存在周期,一般需要4个周期以上数理上认为应当在20个周期以上

           假如只有两三个周期,那周期性的分析就没有太大作用了

     

    对于时间序列问题有哪些基本分析思路

    看到数据其实不一定要上最复杂的方法

    • 平滑与季节分解(遇到比较简单的序列)

    用移动平均的方式消除波动,反映出主要的趋势

    • 回归模型

    如果在序列分析中我们考虑到自变量的话,根据历史数据建立相应的回归模型用于预测。甚至来说可以直接把时间当做自变量用于预测,当然我们知道回归时候要求残差是独立的,假如检验出来是非独立的话,我们可以去建一个自回归模型

    • ARIMA

    如果时间序列变化太复杂,我们可以采用ARIMA建模,现在最强大的时序建模方法。真正的时间序列模型建模分析方法
     

    平滑与季节分解

    • 是利用时间序列资料进行短期预测的一种方法。它的基本思想是:除去一些不规则变化后,时间序列将剩下一些基本的变化模式,而这种变化模式将延续到将来。
    • 描述时间序列数据的变化规律和行为,不去试图解释和理解这种变化的原因。例如:您可能发现在过去的一年里,三月和九月都会出现销售的高峰,您可能希望继续保持这样,尽管您不知道为什么。
    • 平滑的主要目的就是除去时间序列的不规则变化,把时间序列的基本变化模式突现出来,作为短期预测的基础。因此也有人把平滑称作“修匀”。
    • 平滑的方法很多。广义上说,可以认为回归也是一种平滑。因为拟合回归曲线可以把杂乱的观测数据修匀得到连续而光滑的曲线。
    • 移动平均和移动中位数等这些不同的平滑技术又被称为平滑器。平滑处理后,可以得到一些新的序列。不同的平滑器得到的新序列是不同的。选择合适的平滑器,寻求最佳的预测效果是平滑处理的关键。

     

    案例:NRC数据的建模预测

    美国1947年1月到1969年12月住宅建筑的数据,分析目的是希望能过通过历史数据来预测1970年全年的情况。

    数据集

    nrc是我们准备用于分析的变量

    nrc2又新增了12个月的数据,可以用来评价我们的预测效果

    556	556
    528	528
    545	545
    607	607
    701	701
    785	785
    874	874
    950	950
    1006	1006
    1093	1093
    1135	1135
    1070	1070
    891	891
    757	757
    874	874
    1028	1028
    1168	1168
    1257	1257
    1294	1294
    1305	1305
    1273	1273
    1203	1203
    1100	1100
    978	978
    846	846
    731	731
    763	763
    844	844
    981	981
    1086	1086
    1147	1147
    1171	1171
    1207	1207
    1238	1238
    1241	1241
    1171	1171
    1077	1077
    1031	1031
    1089	1089
    1276	1276
    1499	1499
    1703	1703
    1827	1827
    1898	1898
    1900	1900
    1785	1785
    1614	1614
    1427	1427
    1289	1289
    1188	1188
    1229	1229
    1288	1288
    1324	1324
    1399	1399
    1428	1428
    1409	1409
    1400	1400
    1397	1397
    1330	1330
    1200	1200
    1015	1015
    963	963
    1149	1149
    1234	1234
    1346	1346
    1437	1437
    1472	1472
    1486	1486
    1473	1473
    1481	1481
    1438	1438
    1309	1309
    1131	1131
    1057	1057
    1206	1206
    1363	1363
    1431	1431
    1570	1570
    1577	1577
    1550	1550
    1514	1514
    1481	1481
    1420	1420
    1294	1294
    1104	1104
    1029	1029
    1167	1167
    1347	1347
    1517	1517
    1627	1627
    1717	1717
    1770	1770
    1783	1783
    1759	1759
    1717	1717
    1650	1650
    1473	1473
    1379	1379
    1562	1562
    1753	1753
    1925	1925
    2064	2064
    2098	2098
    2082	2082
    2051	2051
    1983	1983
    1851	1851
    1656	1656
    1392	1392
    1305	1305
    1457	1457
    1618	1618
    1753	1753
    1884	1884
    1908	1908
    1895	1895
    1860	1860
    1798	1798
    1741	1741
    1567	1567
    1324	1324
    1206	1206
    1350	1350
    1486	1486
    1604	1604
    1718	1718
    1767	1767
    1796	1796
    1787	1787
    1761	1761
    1694	1694
    1513	1513
    1292	1292
    1192	1192
    1302	1302
    1421	1421
    1550	1550
    1702	1702
    1804	1804
    1876	1876
    1907	1907
    1954	1954
    1957	1957
    1832	1832
    1606	1606
    1493	1493
    1676	1676
    1907	1907
    2091	2091
    2253	2253
    2350	2350
    2358	2358
    2310	2310
    2232	2232
    2092	2092
    1883	1883
    1588	1588
    1408	1408
    1613	1613
    1804	1804
    1935	1935
    2112	2112
    2039	2039
    1982	1982
    1931	1931
    1860	1860
    1790	1790
    1644	1644
    1378	1378
    1221	1221
    1459	1459
    1720	1720
    1860	1860
    2059	2059
    2053	2053
    2053	2053
    2055	2055
    2041	2041
    1974	1974
    1807	1807
    1543	1543
    1368	1368
    1605	1605
    1906	1906
    2141	2141
    2377	2377
    2357	2357
    2377	2377
    2330	2330
    2210	2210
    2113	2113
    1965	1965
    1686	1686
    1492	1492
    1666	1666
    1950	1950
    2206	2206
    2421	2421
    2517	2517
    2553	2553
    2516	2516
    2500	2500
    2450	2450
    2230	2230
    1867	1867
    1678	1678
    1866	1866
    2068	2068
    2191	2191
    2385	2385
    2518	2518
    2541	2541
    2439	2439
    2327	2327
    2260	2260
    2118	2118
    1834	1834
    1639	1639
    1782	1782
    2000	2000
    2203	2203
    2429	2429
    2550	2550
    2561	2561
    2473	2473
    2377	2377
    2284	2284
    2136	2136
    1848	1848
    1644	1644
    1781	1781
    1979	1979
    2124	2124
    2287	2287
    2387	2387
    2351	2351
    2202	2202
    1978	1978
    1785	1785
    1614	1614
    1368	1368
    1248	1248
    1405	1405
    1613	1613
    1836	1836
    2107	2107
    2336	2336
    2471	2471
    2446	2446
    2375	2375
    2310	2310
    2191	2191
    1859	1859
    1655	1655
    1885	1885
    2262	2262
    2518	2518
    2628	2628
    2721	2721
    2790	2790
    2780	2780
    2678	2678
    2593	2593
    2454	2454
    2133	2133
    1940	1940
    2195	2195
    2540	2540
    2810	2810
    2962	2962
    2974	2974
    2880	2880
    2763	2763
    2648	2648
    2482	2482
    2288	2288
    	1961
    	1765
    	1986
    	2297
    	2485
    	2592
    	2650
    	2707
    	2721
    	2747
    	2735
    	2627


    时间序列操作的基本步骤

    • 预处理过程

    缺失值的填补 

    一般这两种方法我们比较常用


    时间变量的定义(spss对数据集进行了特殊标记,让spss知道其为序列数据,并非新增三个变量那么简单,必须是刚才进行下面的操作)


    时间序列的平稳化

    观测原始序列是什么分布,时间刻度这一块随便选一个时间自变量

    发现其有长期趋势及季节变化(大概一年)


    一次差分(假如序列匀速上升的话,一次差分序列后应该是平的)

    继续查看其变化(一次差分作为变量)

    确实序列变平了,但是随着时间增加季节变换还是存在的


    季节差分(把周期性也干掉),一阶:相邻的两个季节做相减

    看季节差分分布分布状况

    看到下面的序列,无长期趋势、无季节变换,可认为是一个比较平稳的序列了

    但是刚才上面在做一次差分后的序列,可以看出其序列随着时间增长离散程度会慢慢变大,后续分析可以考虑这一点,可以做变量变换。

    其实刚才上面的步骤不用那么麻烦,在序列图中即可观察

    当前周期:12在哪里设置呢?(在我们刚才定义日期选取的)

     

    关于数据平稳化问题:(非常详细的理论基础)

    大家可以参考

    https://zhuanlan.zhihu.com/p/60023855

    https://zhuanlan.zhihu.com/p/60648709

     

    时间序列趋势的图形化观察

    • Sequence Chart:序列图

    实际上就是一种特殊的线图

    • Autocorrelation Chart:做单个序列,任意滞后(包括负的滞后,也就是超前)的自相关和偏相关图

    对序列图的初步观察结果作进一步确认(检验其是不是白噪声序列)
    重点关心主要的相关趋势,然后再对模型进一步修正

    刚才我们认为做了一次差分和季节差分真的为平稳序列了吗?

    滞后n阶:隔了n个数据的自相关性

    Sig.<0.05,证明存在自相关的,不都是白噪声

    为了方便查看,给出了图,1到5阶都是存在统计学意义的

    自相关系数是有传递性的问题在里面的,spss就会计算偏自相关系数,屏蔽传递的效应后,看剩余的关联是否还存在

    自相关拖尾,偏自相关也拖尾,这两个是为了知道我们进行建模的

    自相关图:自回归系数的变化
    偏相关图:偏回归系数的变化

    假如他是以下模型,应满足下面的特征

    实际用起来,spss会提供一个自动分析的方法

    模型拟合
    几乎均可包含在ARIMA模型族中
    寻找适当的参数是一个反复尝试的过程

    生成 ARIMA 模型的基本步骤:

    1. 对序列绘图,进行 ADF 检验,观察序列是否平稳;对于非平稳时间序列要先进行 d 阶差分,转化为平稳时间序列;
    2. 经过第一步处理,已经得到平稳时间序列。要对平稳时间序列分别求得其自相关系数(ACF)和偏自相关系数(PACF),通过对自相关图和偏自相关图的分析,得到最佳的阶数p、q;
    3. 由以上得到的d、q、p ,得到 ARIMA 模型。然后开始对得到的模型进行模型检验。

    专家建模器:会在指数平滑模型和ARIMA模型里面选取

     

    R方相对于平稳的R方来说,是比较过于乐观的,假如数据是有波动趋势的,我们将趋势解释掉之后,占相当大的变异解释度进去了,平稳的R方比较客观

    RMSE(残差均方)

    MAPE(相对误差)

    MAXAPE(最大值相对误差)

    MAE(绝对误差)

    MAXAE(最大值绝对误差)

    正态化BIC(比较专业化的指标)

     

    当前模型剩下来的这块能否当成白噪声?

    H0:白噪声序列

    Sig.>0.05,剩下来的确实是白噪声序列

     

     

    如何让其做预测?怎么用时间序列?

    由于SPSS的一个小BUG,变量名前缀要修改一下,不能是中文

    对比一下原始序列和预测值效果

    我们想预测到久一点呢?

    假如我们有1970年的真实数据了,对比一下模型预测及真实数据差别

    展开全文
  • 一个简单的定义是时间序列数据包括附加到顺序时间点数据点。 ​ 时间序列数据的来源是周期性的测量或观测。许多行业都存在时间序列数据。举几个例子: 一时间内的股票价格 每天,每周,每月的销售额 流程中的...

    ​ 时间序列数据有许多定义,它们以不同的方式表示相同的含义。一个简单的定义是时间序列数据包括附加到顺序时间点的数据点。

    ​ 时间序列数据的来源是周期性的测量或观测。许多行业都存在时间序列数据。举几个例子:

    • 一段时间内的股票价格
    • 每天,每周,每月的销售额
    • 流程中的周期性度量
    • 一段时间内的电力或天然气消耗率

    ​ 在这篇文章中,我将列出20个要点,帮助你全面理解如何用Pandas处理时间序列数据。

    1.不同形式的时间序列数据

    ​ 时间序列数据可以是特定日期、持续时间或固定的自定义间隔的形式。

    ​ 时间戳可以是给定日期的一天或一秒,具体取决于精度。例如,’ 2020-01-01 14:59:30 '是基于秒的时间戳。

    2.时间序列数据结构

    ​ Pandas提供灵活和高效的数据结构来处理各种时间序列数据。

    ​ 除了这3个结构之外,Pandas还支持日期偏移概念,这是一个与日历算法相关的相对时间持续时间。

    3.创建一个时间戳

    ​ 最基本的时间序列数据结构是时间戳,可以使用to_datetimeTimestamp函数创建

    import pandas as pdpd.to_datetime('2020-9-13')
    Timestamp('2020-09-13 00:00:00')pd.Timestamp('2020-9-13')
    Timestamp('2020-09-13 00:00:00')
    

    4.访问按时间戳保存的信息

    ​ 我们可以获得存储在时间戳中的关于日、月和年的信息。

    a = pd.Timestamp('2020-9-13')a.day_name()
    'Sunday'
    a.month_name()
    'September'
    a.day
    13
    a.month
    9
    a.year
    2020
    

    5. 隐藏信息访问

    ​ 时间戳对象还保存有关日期算法的信息。例如,我们可以问这一年是不是闰年。以下是我们可以获得的一些更具体的信息:

    b = pd.Timestamp('2020-9-30')b.is_month_end
    Trueb.is_leap_year
    Trueb.is_quarter_start
    Falseb.weekofyear
    40
    

    6. 欧洲风格的日期

    ​ 我们可以使用to_datetime函数处理欧洲风格的日期(即日期在先)。dayfirst参数被设置为True。

    pd.to_datetime('10-9-2020', dayfirst=True)
    Timestamp('2020-09-10 00:00:00')pd.to_datetime('10-9-2020')
    Timestamp('2020-10-09 00:00:00')
    

    ​ 注意:如果第一项大于12,Pandas会知道它不能是月。

    pd.to_datetime('13-9-2020')
    Timestamp('2020-09-13 00:00:00')
    

    7. 将数据格式转换为时间序列数据

    ​ to_datetime函数可以将具有适当列的数据名称转换为时间序列。考虑以下数据格式:

    pd.to_datetime(df)0   2020-04-13 
    1   2020-05-16 
    2   2019-04-11 
    dtype: datetime64[ns]
    

    7.时间戳之外的时间表示

    ​ 在现实生活中,我们几乎总是使用连续的时间序列数据,而不是单独的日期。而且,Pandas处理顺序时间序列数据非常简单。

    ​ 我们可以将日期列表传递给to_datetime函数。

    pd.to_datetime(['2020-09-13', '2020-08-12', '2020-08-04', '2020-09-05'])
    DatetimeIndex(['2020-09-13', '2020-08-12', '2020-08-04', '2020-09-05'], dtype='datetime64[ns]', freq=None)
    

    ​ 返回的对象是一个DatetimeIndex。

    ​ 还有一些更实用的方法来创造一系列的时间数据。

    9. 用to_datetime和to_timedelta创建时间序列

    ​ 可以通过将TimedeltaIndex添加到时间戳中来创建DatetimeIndex。

    pd.to_datetime('10-9-2020') + pd.to_timedelta(np.arange(5), 'D')
    

    ​ “D”用来表示“day”,但是也有很多其他的选择。

    10. date_range函数

    ​ 它提供了一种更灵活的创建DatetimeIndex的方法。

    pd.date_range(start='2020-01-10', periods=10, freq='M')
    

    ​ 参数的作用是:指定索引中的项数。freq 是频率,“M”表示一个月的最后一天。

    ​ 就freq参数而言,date_range非常灵活。

    pd.date_range(start='2020-01-10', periods=10, freq='6D')
    

    ​ 我们创建了一个频率为6天的数据。

    11. period_range函数

    ​ 它返回一个PeriodIndex。语法类似于date_range函数。

    pd.period_range('2018', periods=10, freq='M')
    

    12. timedelta_range函数

    ​ 它返回一个TimedeltaIndex。

    pd.timedelta_range(start='0', periods=24, freq='H')
    

    13.时区

    ​ 默认情况下,Panda的时间序列对象没有指定的时区。

    dates = pd.date_range('2019-01-01','2019-01-10')
    dates.tz is None
    True
    

    ​ 我们可以使用tz_localize方法为这些对象分配时区。

    dates_lcz = dates.tz_localize('Europe/Berlin')
    dates_lcz.tz
    <DstTzInfo 'Europe/Berlin' LMT+0:53:00 STD>
    

    14. 创建一个具有指定时区的时间序列

    ​ 我们还可以使用tz关键字参数创建带有时区的时间序列对象。

    pd.date_range('2020-01-01', periods = 5, freq = 'D', tz='US/Eastern')
    

    15. 偏移量

    ​ 假设我们有一个时间序列索引,并且想为所有的日期偏移一个特定的时间。

    A = pd.date_range('2020-01-01', periods=10, freq='D')
    A
    

    ​ 让我们给这个数据加上一周的偏移。

    A + pd.offsets.Week()
    

    16. 移动时间序列数据

    ​ 时间序列数据分析可能需要移数据点进行比较。移位函数可以移位数据。

    A.shift(10, freq='M')
    

    17. Shift vs tshift

    • 移动:移动数据
    • tshift:移动时间索引

    ​ 让我们创建一个带有时间序列索引的dataframe,并绘制它以查看shift和tshift之间的区别。

    dates = pd.date_range('2020-03-01', periods=30, freq='D')
    values = np.random.randint(10, size=30)
    df = pd.DataFrame({'values':values}, index=dates)df.head()
    

    ​ 让我们把原始的时间序列和移位的时间序列一起画出来。

    import matplotlib.pyplot as pltfig, axs = plt.subplots(nrows=3, figsize=(10,6), sharey=True)
    plt.tight_layout(pad=4)
    df.plot(ax=axs[0], legend=None)
    df.shift(10).plot(ax=axs[1], legend=None)
    df.tshift(10).plot(ax=axs[2], legend=None)
    

    18. 用取样函数重新采样

    ​ 时间序列数据的另一个常见操作是重采样。根据任务的不同,我们可能需要以更高或更低的频率重新采样数据。

    ​ Resample创建指定内部的组(或容器),并允许您对组进行合并。

    ​ 让我们创建一个包含30个值和一个时间序列索引的Panda系列。

    A = pd.date_range('2020-01-01', periods=30, freq='D')
    values = np.random.randint(10, size=30)
    S = pd.Series(values, index=A)
    

    ​ 以下将返回3天时间内的平均值。

    S.resample('3D').mean()
    

    ​ 在某些情况下,我们可能对特定频率的值感兴趣。函数返回指定间隔结束时的值。例如,在上一步创建的系列中,我们可能只需要每3天(而不是平均3天)一次的值。

    S.asfreq('3D')
    

    20.滚动

    ​ 滚动对于时间序列数据是一种非常有用的操作。滚动意味着创建一个具有指定大小的滚动窗口,并对该窗口中的数据执行计算,当然,该窗口将滚动数据。下图解释了滚动的概念。

    ​ 值得注意的是,计算开始时整个窗口都在数据中。换句话说,如果窗口的大小为3,那么第一次合并将在第三行进行。

    ​ 让我们为我们的数据应用一个3天的滚动窗口。

    S.rolling(3).mean()[:10]
    

    结论

    ​ 我们已经全面介绍了用Pandas进行时间序列分析。值得注意的是,Pandas提供了更多的时间序列分析。

    ​ 感谢您的阅读。如果你有任何反馈,请告诉我。

    作者:Soner Yıldırım

    deephub翻译组:孟翔杰

    展开全文
  • 早高峰时间段查询 SELECT * FROM table WHERE hour(时间字段) BETWEEN 07 and 09 但是遇到一个问题就是要查凌晨的数据就不行了 因为凌晨是当天到第二天 所以: 凌晨数据查询 SELECT * FROM table WHERE (hour...

    一 、 查某个时间段的数据

    早高峰时间段查询(早上7点到九点)

    SELECT * FROM table WHERE  hour(时间字段) BETWEEN 07 and 09 
    

    但是遇到一个问题就是要查凌晨的数据就不行了
    因为凌晨是当天到第二天 所以:

    凌晨数据查询(晚上10点到次日凌晨6点)

    SELECT * FROM table WHERE (hour(时间字段)>=22 or 6 >=hour(时间字段))

    二、 查最接近的记录

    查询场景:现在的需求是查询年龄最接近20岁的用户,获取前5个

    我现在的数据库记录用户年龄的字段记录格式是"1995-05-20",字段名称birthday

    解决思路:

    1.首先查询时转换成用户年龄

    日期格式转年龄的方法:

    (1)当前年份 - 日期格式中的年份

    date_format(now(), '%Y') - from_unixtime(unix_timestamp(birthday), '%Y')

    (2)当前年份 - 日期格式中的年份(获取方法不同)

    date_format(now(), '%Y') - year(birthday)

    2.通过order by asb() 排序获取最接近的数据

    完整的语句:

    SELECT
      (date_format(now(), '%Y') - year(birthday)) as age
    FROM  user
    WHERE
      is_anchor = 1
    ORDER BY abs(20 - age)
    limit 0,5

     

    三、查某个时间段的且最接近的记录数据

    查询场景:现在的需求是查询某个用户在2020年中最早出单时间(凌晨5点-9点,且最接近5点的数据)和2020年中最晚出单时间(晚上10点-次日凌晨4点,取最靠近凌晨4点的出单时间)

    我现在的数据库记录出单时间的字段记录格式是"yyyy-MM-dd HH:mm:ss",字段名称GMT_MODIFIED

    解决思路:

    最早出单时间:

    1. 首先查询凌晨5-9点(小时 5-8)的数据, hour(p.GMT_MODIFIED) BETWEEN 05 and 08

    2.再查最接近5点的数据 select   hour(p.GMT_MODIFIED) as hourss from  hip_sal_policy p  where   ORDER BY abs(5 - hourss)

    最晚出单时间:

    1. 首先查询晚上10点-次日凌晨4点(小时 22-4)的数据, hour(p.GMT_MODIFIED) >= 22 or 04 >= hour(p.GMT_MODIFIED)

    2.再查最接近4点的数据 select   hour(p.GMT_MODIFIED) as hourss from  hip_sal_policy p  where   ORDER BY abs(4 - hourss)

    完整sql 

    最早出单时间(凌晨5-9点)
    select
      DATE_FORMAT(p.GMT_MODIFIED,'%H:%i') policyTime,
      hour(p.GMT_MODIFIED) as hourss
    from  hip_sal_policy p
    where
        p.status ='1' and p.creator = #{userId}
        and p.GMT_MODIFIED BETWEEN '2020-01-01 00:00:00' and '2020-12-31 23:59:59'
       and hour(p.GMT_MODIFIED) BETWEEN 05 and 08
       ORDER BY abs(5 - hourss)
        limit 1
    最晚出单时间(晚上10点-次日凌晨4点)
    
    select
       DATE_FORMAT(p.GMT_MODIFIED,'%H:%i') policyTime,
       hour(p.GMT_MODIFIED) as hourss
    from  hip_sal_policy p
    where
       p.status ='1' and p.creator = '675609'
       and p.GMT_MODIFIED BETWEEN '2020-01-01 00:00:00' and '2020-12-31 23:59:59'
        and    (hour(p.GMT_MODIFIED) >= 22 or 04 >= hour(p.GMT_MODIFIED))
        ORDER BY abs(4 - hourss)
        limit 1

     

     

    展开全文
  • hive中任意相邻时间段数据获取

    千次阅读 2018-03-02 19:52:44
    通过sql语句获取相邻时段数据不比通过其它编程语言,因为sql里面没有for循环...获取这些用户的全部定位数据,并根据定位时间进行排序如上,从左到右以此分别为用户id,定位时间,定位省份id,排序编号,是否定位在贵...
  • 横截面数据时间序列数据、面板数据

    万次阅读 多人点赞 2018-03-20 15:12:40
    具有“横截面”和“时间序列”两个维度,当这类数据按两个维度进行排列时,数据都排在一个平面上,与排在一条线上的一维数据有着明显的不同,整个表格像是一个面板,所以称为面板数据(Panel Data)。 实际上如果从...
  • 在前几次分享中我们知道,很多时序算法都依赖完整的时序数据进行建模,许多业务也需要数据保持完整性,以更好地进行可视化与分析。然而在真实场景中,由于采集能力或网络传输的原因,时序数据常常会有缺...
  • 查询数据库当天某时间段数据

    万次阅读 2017-10-24 16:15:35
    1、SQL在查询当天记录时要注意是从当天的00分0秒0毫秒开始,到次日00分0秒0毫秒截止,但不包含次日的00分0秒0毫秒。 2、注意:在不同数据库产品中,获得当天日期的函数不一样。 MSSQL获得当前日期:convert...
  • 我有一张表,一个是我前一段时间用的数据,一个是我现在用的数据,我想比较一下,这两张数据不同。(表结构相同) 谢谢各位大神指导~谢谢、
  • Oracle查询一段时间内的数据

    千次阅读 2019-09-12 10:35:22
    本以为很简单的问题,今天做了一下还是感觉得多练习才可以各个数据库的写法可能不同 Oracle 方法如下: 1、select xmdadocdt from dsdata.xmda_t where xmdadocdt between to_date('2019-08-01','yyyy-mm-dd') ...
  • 要实现的效果:对excel表中的数据,如果某个公司三个月内出现的次数超过3次,则将基筛选出来,注意三个月是指任何时间起点的三个月,而不是某月某日到某月某日的三个月。 原始表如下, ...
  • 数据结构之时间复杂度

    千次阅读 2019-05-29 23:34:47
    算法(Algorithm)是指用来操作数据、解决程序问题的一组方法。对于同一个问题,使用不同的算法,也许最终得到的结果是一样的,但在过程中消耗的资源和时间却会有很大的区别。 那么我们应该如何去衡量不同算法之间...
  • 横截面数据是在同一时间不同统计单位相同统计指标组成的数据列。横截面数据不要求统计对象及其范围相同,但要求统计的时间相同。也就是说必须是同一时间截面上的数据。例如,为了研究某一行业各个企业的产出与投入...
  • 0900-1200 1200-1600 1600-2100 2100-0900 这四个时间段 意思就是相当于一天的开始是9点,然后最后的时间段是晚上9点到第二天早上9点 ,查询的数据都是9点到第二天9点的数据,求大神给思路
  • 做项目的时候需要统对项目日志做分析,其中有一个需求是获取某个给定的时间段内,每一天的日志数据,比如说要获取从2018-02-02 09:18:36到2018-03-05 23:18:36这个时间段内,统计出每一天的日志数据,一般情况下,...
  • 在本文中,我们将研究时间序列数据并探索一种生成合成时间序列数据的方法...主要的区别是时间序列数据与表格数据相比有更多的数据点实例。 能源数据集的案例研究 如果我们看一下能源数据集,它实际上看起来只是一个常规
  • Python Dataframe pandas 将数据分割成时间跨度相等的数据块 有如下dataframe格式的数据,列名分别为date、ip,我需要统计每5s内出现的ip,以及这些ip出现的频数。
  • 什么是时间序列数据

    万次阅读 2018-10-24 16:47:00
    用描述性的语言来解释什么是时序数据,简单的说,就是这类数据描述了某个被测量的主体在一个时间范围内的每个时间点上的测量值。   对时序数据进行建模的话,会包含三个重要部分,分别是:主体,时间点和测量值。....
  • 例如:以下是一个全球范围的NC数据,有1512个时间波段 但这些数据都是全球范围数据,而且包含数据信息类型有的有几千种,对于局部和特定数据使用和分析很不方便,我们需要将这些数据进行范围和类型提取。 ...
  • 不同Oracle数据库之间的数据同步

    万次阅读 2017-04-19 15:09:02
    对于中大型数据库,业务数据库里所有的数据同步到另外一个处理服务器上最佳的选择还是使用SnapShot方式,即快照的方式。 Oracle数据库的快照是一个表,它包含有对一个本地或远程数据库上一个或
  • 时间序列数据挖掘

    千次阅读 2018-11-14 12:40:44
    时间序列是一种重要的高维数据类型,它是由客观对象的某个物理量在不同时间点的采样值按照时间先后次序排列而组成的序列,在经济管理以及工程领域具有广泛应用。例如证券市场中股票的交易价格与交易量、外汇市场上的...
  • 时间序列数据的处理

    万次阅读 2018-05-30 16:11:15
    摘要: 随着云计算和IoT的发展,时间序列数据数据量急剧膨胀,高效的分析时间序列数据,使之产生业务价值成为一个热门话题。阿里巴巴数据库事业部的HiTSDB团队为您分享时间序列数据的计算分析的一般方法以及优化...
  • 不同数据库表之间的数据同步

    万次阅读 2019-06-05 16:35:06
    不同数据库表之间的数据同步 场景还原: 现在需要对正式环境做升级,需要从实施环境往正式环境导入部分数据,现在需要比对两个数据库之间某个表的数据差异,并将正式环境缺少的部分,从实施环境同步到正式环境。...
  • 时间序列数据:在不同时间点搜集到的数据,这些数据通常会随时间的变化而变化。比如股票价格、每日温度等 横截面数据:在相同或近似相同时间点搜集到的数据。比如绝大多数通过问卷调查搜集到的数据、人口普查数据 ...
  • SQL按时间分段分组统计数据

    万次阅读 2018-07-19 14:22:36
    下面sql条件中48表示时间段数(一天48个0.5小时即半小时分段统计,以此类推修改);--注释了查询条件即只统计错误或统计时间限制(hh24miss)内的数据;最后0和500分别为分页起止数。 查询行数据 select * from ...
  • 项目中经常会对两张数据库表的数据进行比较,选出相同的数据或者不同数据。在SQL SERVER 2000中只能用Exists来判断,到了SQL SERVER 2005以后可以采用EXCEPT和INTERSECT运算符比较两张表的数据。 EXCEPT运算符...
  • 线性表:线性表是一种线性结构,它是一个含有n≥0个结点的有限序列,同一个线性表中的数据元素数据类型相同并且满足“一对一”的逻辑关系。“一对一”的逻辑关系指的是对于其中的结点,有且仅有一个开始结点没有前驱...
  • 参考文章:x轴数据不同 数据连续 前两天要画一个echarts图,用两条曲线来分别展示修改前和修改后的高度和体积的对应关系,形成对比。 H作为x轴,V作为y轴。H和V都是可变的。 封装数据:series中的data项[[H,V],[H,v]...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,089,688
精华内容 835,875
关键字:

不同时间点数据的比较