精华内容
下载资源
问答
  • 今天遇到的问题是日期控件,在js中监听当前input的change事件时无效,其实很简单就解决了 只需要在input输入框中加上箭头所指东西,至此,问题解决

    今天遇到的问题是日期控件,在js中监听当前input的change事件时无效,其实很简单就解决了

    只需要在input输入框中加上箭头所指东西,至此,问题解决

    展开全文
  • use-color-change React挂钩...指定要闪烁的颜色以及动画需要多长时间。 挂钩的返回值类型为{animation:string},您可以将其作为任何元素的样式进行传递,还可以使用例如animation-timing-func对其进行进一步的自定义
  • 改进型人工势场法

    万次阅读 多人点赞 2019-06-14 09:39:34
    改进型人工势场法 首先介绍了人工势场法基本原理,其次分析了人工势场法的缺陷,最后针对这些缺陷给出改进算法。文末还贴出代码链接。

    1、人工势场法基本原理

    人工势场法的基本原理就是将无人车假设成一个点,该点在一个虚拟力场中运动,虚拟力场是由目标点对无人车的引力场和障碍物对无人车的斥力场组成。引力场由目标点产生,斥力场是由所有的障碍物产生的和力场组成。因此,人工势场法的势场函数定义为引力场与斥力场的和,如下面的式子所示。无人车的移动方向为势场函数下降的方向。这样,无人车就可以找到一条无碰撞的路径。
    U ( q ) = U a t t ( q ) + U r e p ( q ) U(q)=U_{att}(q)+U_{rep}(q) U(q)=Uatt(q)+Urep(q)
    在上式中,q是无人车的坐标点, U a t t ( q ) U_{att}(q) Uatt(q)是引力场, U r e p ( q ) U_{rep}(q) Urep(q)是斥力场,U(q)是势场和。
    势场函数的负梯度定义为人工力,人工力由引力和斥力组成。引力为引力场的负梯度,斥力为斥力场的负梯度。因此,无人车在势场中所受力为:
    F ( q ) = − ∇ U a t t ( q ) − ∇ U r e p ( q ) = F a t t ( q ) + F r e p ( q ) F(q)=-\nabla U_{att}(q)-\nabla U_{rep}(q)=F_{att}(q)+F_{rep}(q) F(q)=Uatt(q)Urep(q)=Fatt(q)+Frep(q)
    上式中,F(q)为无人车所受合力, F a t t F_{att} Fatt为引力,引导无人车走向目标点, F r e p F_{rep} Frep为斥力,使无人车远离障碍物点。
    引力场的计算公式如下:
    U a t t = 1 2 K a t t ( q − q g ) 2 U_{att}=\frac {1}{2}K_{att}(q-q_g)^2 Uatt=21Katt(qqg)2
    上式中, K a t t K_{att} Katt为引力增益常数, q g q_g qg为目标点的位置。根据上式可以计算出引力的大小为:
    F a t t = − ∇ U a t t ( q ) = − K a t t ( q − q g ) F_{att}=-\nabla U_{att}(q)=-K_{att}(q-q_g) Fatt=Uatt(q)=Katt(qqg)
    F a t t F_{att} Fatt的方向指向目标点,与无人车当前位置到目标点位置的距离成线性关系。 F a t t F_{att} Fatt可以分解为x轴方向的力与y轴方向的力:
    F a t t x = − K a t t ( x − x g ) F_{attx}=-K_{att}(x-x_g) Fattx=Katt(xxg)
    F a t t y = − K a t t ( y − y g ) F_{atty}=-K_{att}(y-y_g) Fatty=Katt(yyg)
    斥力场的计算公式如下:
    U r e p = { 0 , if  ρ o b s ( q ) ≥ ρ 0 1 2 K r e p ( 1 ρ o b s ( q ) − 1 ρ 0 ) 2 , if  ρ o b s ( q ) < ρ 0 U_{rep}=\begin {cases} 0, & \text {if $ \rho_{obs}(q)\geq\rho_{0}$} \\ \frac {1}{2}K_{rep}(\frac {1}{\rho_{obs}(q)}-\frac {1}{\rho_{0}})^2, & \text{if $ \rho_{obs}(q)<\rho_{0}$} \end{cases} Urep={0,21Krep(ρobs(q)1ρ01)2,if ρobs(q)ρ0if ρobs(q)<ρ0
    其中 K r e p K_{rep} Krep为斥力增益常数, ρ o b s ( q ) = ∣ ∣ q − q o b s ∣ ∣ \rho_{obs}(q)=||q-q_{obs}|| ρobs(q)=qqobs q o b s q_{obs} qobs为障碍物坐标。 ρ 0 \rho_0 ρ0为最大影响距离,若障碍物与无人车距离大于 ρ 0 \rho_0 ρ0,则将斥力场视为0。设置 ρ 0 \rho_0 ρ0可以消除离无人车较远的障碍物对无人车轨迹的影响, ρ 0 \rho_0 ρ0的值取决于无人车速度与加速度大小。与引力计算相似,斥力的计算公式为:
    F r e p = − ∇ U r e p ( q ) = { 0 , if  ρ o b s ( q ) ≥ ρ 0 K r e p ( 1 ρ o b s ( q ) − 1 ρ 0 ) ( 1 ρ o b s 2 ( q ) ) q − q o b s ∣ ∣ q − q o b s ∣ ∣ , if  ρ o b s ( q ) < ρ 0 F_{rep}=-\nabla U_{rep}(q)=\begin {cases} 0, & \text {if $ \rho_{obs}(q)\geq\rho_{0}$} \\ K_{rep}(\frac {1}{\rho_{obs}(q)}-\frac {1}{\rho_{0}})(\frac{1}{\rho_{obs}^2(q)})\frac{q-q_{obs}}{||q-q_{obs}||}, & \text{if $ \rho_{obs}(q)<\rho_{0}$} \end{cases} Frep=Urep(q)={0,Krep(ρobs(q)1ρ01)(ρobs2(q)1)qqobsqqobs,if ρobs(q)ρ0if ρobs(q)<ρ0
    F r e p F_{rep} Frep的方向指向障碍物点的反方向, F r e p F_{rep} Frep可以分解为x轴方向的力与y轴方向的力,如下所示:
    F r e p x = { 0 , if  ρ o b s ( q ) ≥ ρ 0 K r e p ( 1 ρ o b s ( q ) − 1 ρ 0 ) ( 1 ρ o b s 2 ( q ) ) x − x o b s ∣ ∣ q − q o b s ∣ ∣ , if  ρ o b s ( q ) < ρ 0 F_{repx}=\begin {cases} 0, & \text {if $ \rho_{obs}(q)\geq\rho_{0}$} \\ K_{rep}(\frac {1}{\rho_{obs}(q)}-\frac {1}{\rho_{0}})(\frac{1}{\rho_{obs}^2(q)})\frac{x-x_{obs}}{||q-q_{obs}||}, & \text{if $ \rho_{obs}(q)<\rho_{0}$} \end{cases} Frepx={0,Krep(ρobs(q)1ρ01)(ρobs2(q)1)qqobsxxobs,if ρobs(q)ρ0if ρobs(q)<ρ0
    F r e p y = { 0 , if  ρ o b s ( q ) ≥ ρ 0 K r e p ( 1 ρ o b s ( q ) − 1 ρ 0 ) ( 1 ρ o b s 2 ( q ) ) y − y o b s ∣ ∣ q − q o b s ∣ ∣ , if  ρ o b s ( q ) < ρ 0 F_{repy}=\begin {cases} 0, & \text {if $ \rho_{obs}(q)\geq\rho_{0}$} \\ K_{rep}(\frac {1}{\rho_{obs}(q)}-\frac {1}{\rho_{0}})(\frac{1}{\rho_{obs}^2(q)})\frac{y-y_{obs}}{||q-q_{obs}||}, & \text{if $ \rho_{obs}(q)<\rho_{0}$} \end{cases} Frepy={0,Krep(ρobs(q)1ρ01)(ρobs2(q)1)qqobsyyobs,if ρobs(q)ρ0if ρobs(q)<ρ0
    以上的斥力计算是针对单个障碍物而言,但是环境中往往有多个障碍物,所以斥力场与斥力应该是多个障碍物对无人车的斥力场和与斥力和,则:
    U ( q ) = U a t t ( q ) + ∑ i = 1 n U r e p ( q ) U(q)=U_{att}(q)+\sum_{i=1}^n U_{rep}(q) U(q)=Uatt(q)+i=1nUrep(q)
    F ( q ) = F a t t ( q ) + ∑ i = 1 n F r e p ( q ) F(q)=F_{att}(q)+\sum_{i=1}^n F_{rep}(q) F(q)=Fatt(q)+i=1nFrep(q)
    其中n为障碍物个数。无人车受力情况如下图所示,其中F为无人车所受合力。

    无人车受力分析

    2、人工势场法缺陷

    (1)容易陷入局部极小值。当无人车所受引力与斥力大小相等、方向相反时,无人车所受合力为0,此时无人车陷入了局部极小值点。在局部极小值点周围的各个位置的合力都指向局部极小值,导致无人车在局部极小值点周围振荡,无法自行走出该区域。
    (2)统人工势场法引力部分与无人车和目标点位置距离成正比,当无人车距离目标点较远时,引力部分过大,可能导致无人车与障碍物相撞。
    (3)目标点附近有障碍物时,无人车可能无法到达目标点。

    3、人工势场法改进方法

    3.1、人工势场法引力场改进

    传统人工势场法引力部分与无人车和目标点位置距离成正比,当无人车距离目标点较远时,引力部分过大,可能导致无人车与障碍物相撞。针对这一问题,对引力场公式进行改进,具体如下。
    引力场的大小由无人车与目标点的距离决定,当值非常大时,引力将会变得非常大,则斥力相对于引力而言就会变得非常小,这就会导致无人车与障碍物相撞。因此,有必要对引力场加以改进,公式如下:
    U r e p = { 1 2 K a t t ( q − q g ) 2 , if  ( q − q g ) ≤ d d K a t t ( q − q g ) , if  ( q − q g ) > d U_{rep}=\begin {cases} \frac{1}{2}K_{att}(q-q_g)^2, & \text {if $(q-q_g)\leq d$} \\ dK_{att}(q-q_g), & \text{if $ (q-q_g)> d$} \end{cases} Urep={21Katt(qqg)2,dKatt(qqg),if (qqg)dif (qqg)>d
    U r e p = { − K a t t ( q − q g ) , if  ( q − q g ) ≤ d − d K a t t q − q g ∣ ∣ q − q g ∣ ∣ , if  ( q − q g ) > d U_{rep}=\begin {cases} -K_{att}(q-q_g), & \text {if $(q-q_g)\leq d$} \\ -dK_{att}\frac {q-q_g}{||q-q_g||}, & \text{if $ (q-q_g)> d$} \end{cases} Urep={Katt(qqg),dKattqqgqqg,if (qqg)dif (qqg)>d
    其中,d为阈值,当无人车与目标点距离小于等于d时,引力与距离成正比;当无人车与目标点距离大于d时,将引力视为常数;
    在这里插入图片描述

    3.2、模拟退火法

    3.2.1、模拟退火法原理

    当人工势场法陷入局部极小值时,在当前点 x x x处选择一个随机点 x 1 x_1 x1,然后根据上面计算势场函数的公式,分别计算出点 x x x与点 x 1 x_1 x1处的势场 U ( x ) U(x) U(x) U ( x 1 ) U(x_1) U(x1),如果满足 U ( x 1 ) ≤ U ( x ) U(x_1)\leq U(x) U(x1)U(x),则接受点 x 1 x_1 x1作为下一个点;如果满足 U ( x 1 ) > U ( x ) U(x_1)>U(x) U(x1)>U(x),则计算概率 P = e − Δ T , Δ = U ( x 1 ) − U ( x ) P=e^{-\frac{\Delta}{T}},\Delta=U(x_1)-U(x) P=eTΔ,Δ=U(x1)U(x),并以概率 P P P接受该点作为下一个点。同时 T T T以一定的方式减小,一般 T ( t ) = α T ( t − 1 ) , 0.85 < α < 1 T(t)=\alpha T(t-1),0.85<\alpha<1 T(t)=αT(t1),0.85<α<1。重复以上步骤直到逃离局部极小值。
    模拟退火法的算法步骤如下:
    1、设置 x = S x=S x=S( S S S局部极小值或者起点)。
    2、选择退火策略,设置 T = T 0 T=T_0 T=T0
    3、While( T ≥ T f T\geq T_f TTf并且没有逃离局部极小值)

    3.1、产生一个随机点 x 1 = x + Δ x x_1=x+\Delta x x1=x+Δx( Δ x \Delta x Δx为点 x x x附近一个随机点,距离点 x x x一个步长)。
    3.2、计算 U ( x 1 ) U(x_1) U(x1),即点 x 1 x_1 x1处的势能。
    3.3、设置 Δ = U ( x 1 ) − U ( x ) \Delta=U(x_1)-U(x) Δ=U(x1)U(x)
    3.4、如果 Δ ≤ 0 \Delta \leq 0 Δ0,设置 x = x 1 x=x_1 x=x1
    3.5、如果 Δ > 0 \Delta>0 Δ>0,以概率P设置 x = x 1 x=x_1 x=x1,其中 P = e − Δ T , Δ = U ( x 1 ) − U ( x ) P=e^{-\frac{\Delta}{T}},\Delta=U(x_1)-U(x) P=eTΔ,Δ=U(x1)U(x)(具体为: 设置一个随机概率a,当P>a时,设置 x = x 1 x=x_1 x=x1,反之,这个随机点为失败的随机点,再重新设置随机点)
    3.6、如果 U ( x 1 ) ≤ U ( S ) U(x_1)\leq U(S) U(x1)U(S),成功逃离局部极小值。
    4、如果没有逃离局部极小值,返回失败;否则,返回成功。

    在实际的编程过程中,不是以 U ( x 1 ) ≤ U ( S ) U(x_1)\leq U(S) U(x1)U(S)为标志判断是否程序逃离局部极小值,而是计算当前点与进入局部极小值时的点之间的距离,若该距离大于设定值,则认为逃离局部极小值。通常设定值为步长的5-10倍,本程序设定值为步长的5倍。当无人车陷入局部极小值时启用模拟退火法。而判断无人车是否陷入局部极小值是根据无人车是否陷入振荡或者所受合力是否为0,判断是否陷入振荡则是根据第j次与第j-2次小车的位置判断,若这两个点距离小于步长的0.1倍,则认为小车陷入振荡。
    基于模拟退火法的人工势场法算法流程图如下:

    在这里插入图片描述

    3.2.2、仿真结果

    在仿真实验中,将障碍物看成半径为0.5的圆,其他参数的设置如下表所示:
    在这里插入图片描述
    下图为没有改进前的人工势场法:
    在这里插入图片描述
    下图为改进后的人工势场法,其中蓝色部分为传统人工势场法规划出的路径,绿色部分为基于模拟退火法的人工势场法:
    在这里插入图片描述

    4、代码解释与链接

    1、运行main.m即可,代码里面有详细的备注,大家应该都可以看得懂,欢迎大家一起交流。
    2、在main.m最下面部分有对路径的优化算法,路径优化有两个算法,分别check_lineA.m和check_lineB.m。为由于楼主最近比较忙,所以没有时间更新对优化路径算法的解释,有兴趣的小伙伴可以自己先看看。
    3、没有改进前的人工势场法:https://download.csdn.net/download/chengchang1234/11139704
    基于模拟退火法的人工势场法:https://download.csdn.net/download/chengchang1234/11239864

    展开全文
  • 问题:排序条件只有时间,如果时间的值很多都是一样的,那么在分页的时候上一页下一页可能查询数据相同,例如写入了200条数据,每页显示10条,在一个分页区间内,可能返回的查询数据是一样的 解决办法:加入多个...

    问题:排序条件只有时间,如果时间的值很多都是一样的,那么在分页的时候上一页下一页可能查询数据相同,例如写入了200条数据,每页显示10条,在一个分页区间内,可能返回的查询数据是一样的

    解决办法:加入多个排序字段。

    select  t.WQR as WQR40_43_ from T_EXPERTIFO t where 1=1 order by t.CREATETIME , t.ID desc
    

    这种排序,用逗号隔开 ,现根据createtime升序排序,如果createtime相同再根据id降序排序;没有写是否生序降序默认升序。

    注意:这里不是根据createtime降序,ID降序。

    展开全文
  • 本文详解pd.Timestamp方法创建日期时间对象、pd.Timestamp、pd.DatetimeIndex方法创建时间序列及pd.date_range创建连续时间序列、 pd.to_datetime、str和parse方法用于字符串与时间格式的相互转换、truncate方法截取...

    Pandas基于时间应用

    1 时间处理基础

    Pandas提供了四种类型的生成日期时间的对象:日期时间、时间增量、时间跨度、日期偏移量

    (1)日期时间(Date Times):具有时区支持的特定日期和时间。与Python标准库中的datetime.datetime类似。如2020年12月6日13点37分50秒;

    (2)时间增量(Time Deltas):绝对持续时间,用于在指定时间点基础上增加指定的增量,如在某年月日的基础上增加2天、增加2个月、减少4小时等,最后产生一个新的时间点;

    (3)时间跨度(Time Span):由时间点及其相关周期定义的时间跨度,如连续产生一年四个季度的时间序列;

    (4)日期偏移(Date Offsets):以日历计算的相对持续时间,表示时间间隔,两个时间点之间的长度,如日、周、月、季度、年。

    日期时间对象

    1.1 获取当前时刻的时间

    获取当前时刻的时间就是获取此时此刻与时间相关的数据,除了具体的年、月、日、时、分、秒,还会单独看年、月、周、日等指标。

    1.1.1 返回当前时刻的日期和时间

    返回当前时刻的日期和时间在Python中借助函数 now() 实现。

    from datetime import datetime
    
    datetime.now()
    
    datetime.datetime(2020, 12, 6, 14, 9, 55, 720085)
    
    datetime.date(datetime.now())   # 获取当前日期
    
    datetime.date(2020, 12, 6)
    
    datetime.time(datetime.now())   # 获取当前时间
    
    datetime.time(14, 11, 51, 776782)
    

    1.1.2 分别返回当前时刻的年、月、日

    返回当前时刻的年份在Python中借助函数 year 实现

    datetime.now().year
    
    2020
    

    返回当前时刻的月份在Python中借助函数 month 实现

    datetime.now().month
    
    11
    

    返回当前时刻的日在Excel和Python中都借助函数 day 实现

    datetime.now().day
    
    19
    

    1.1.3 返回当前时刻的周数

    与当前时刻的周相关的数据有两个,一个是当前时刻是一周中的周几,另一个是返回当前时刻所在的周在全年的周里面是第几周。

    返回当前时刻是周几在Python中借助 weekday() 函数实现。

    datetime.now().weekday()+1
    
    4
    

    Attention :Python中周几是从0开始数的,所以在后面加1

    返回当前时刻所在周的周数,在Python中使用的是 isocalendar() 函数。

    datetime.now().isocalendar()
    
    (2020, 47, 4)
    

    2020年的第47周的第4天

    datetime.now().isocalendar()[1]
    
    47
    

    1.2 pd.Timestamp创建日期时间对象

    Pandas库也提供了类似的日期时间对象 pd.Timestamp

    import pandas as pd
    pd.Timestamp("2020-12-06")
    
    Timestamp('2020-12-06 00:00:00')
    
    pd.Timestamp(2020,12,6,13,19,52)
    
    Timestamp('2020-12-06 13:19:52')
    
    pd.Timestamp(year=2020,month=12,day=6,hour=14,minute=19,second=52)  # 键值对形式指定年月日时分秒
    
    Timestamp('2020-12-06 14:19:52')
    
    pd.Timestamp(2020,12,6,13,19,52).year   # 通过year、month、day属性获取年月日
    
    2020
    

    1.4 指定日期和时间的格式

    借助 date() 函数将日期和时间设置成只展示日期。

    datetime.now().date()
    
    datetime.date(2020, 11, 19)
    

    借助 time() 函数将日期和时间设置成只展示时间。

    datetime.now().time()
    
    datetime.time(15, 1, 27, 19303)
    

    借助 strftime() 函数可以自定义时间和日期的格式,strftime() 函数是将日期和时间的格式转化为某些自定义的格式,具体的格式有以下几种

    日期转换格式

    datetime.now().strftime("%F")
    
    '2020-11-19'
    
    datetime.now().strftime("%F %H:%M:%S")
    
    '2020-11-19 15:04:31'
    

    2 时间序列

    基于时间序列的数据记录,可以通过Series、DataFrame的索引值来记录时间点,可以同步记录对应时间点的数据元素。

    2.1 指定时间点建立时间序列的Series对象

    通过 pd.Timestamp 与 pd.DatetimeIndex 方法建立指定时间序列的Series对象

    import pandas as pd
    import numpy as np
    T1 = pd.Series(np.arange(4),index=[pd.Timestamp("2020-12-6"),pd.Timestamp("2020-12-7"),pd.Timestamp("2020-12-8"),pd.Timestamp("2020-12-9")])
    print(T1)   # 指定4个时间点为索引值
    print("="*30)
    T1.index    # pandas 自动把索引归类为日期时间索引
    
    2020-12-06    0
    2020-12-07    1
    2020-12-08    2
    2020-12-09    3
    dtype: int32
    
    ==============================
    
    DatetimeIndex(['2020-12-06', '2020-12-07', '2020-12-08', '2020-12-09'], dtype='datetime64[ns]', freq=None)
    
    T1 = pd.Series(np.arange(4),index=pd.DatetimeIndex(["2020-12-6","2020-12-7","2020-12-8","2020-12-9"]))
    print(T1)   
    print("="*30)
    T1.index                                                  
    
    2020-12-06    0
    2020-12-07    1
    2020-12-08    2
    2020-12-09    3
    dtype: int32
    
    ==============================
    
    
    DatetimeIndex(['2020-12-06', '2020-12-07', '2020-12-08', '2020-12-09'], dtype='datetime64[ns]', freq=None)
    

    2.2 时间范围函数建立时间序列

    pd.date_range()函数用于产生连续的时间序列

    pd.date_range(start=None,end=None,periods=None,freq=None,tz=None,normalize=False,name=None,close=None,**kwargs)

    start :字符串或者类似datetime类型的值,可选,设置开始日期,必须与end参数搭配使用
    
    end :字符串或者类似datetime类型的值,可选,设置结束日期
    
    periods :整数,可选,设置要生成的日期周期数(也叫绝对增量),或者说在start指定开始日期的基础上,按照指定频率(freq)需要连续生成的日期数量,结合freq参数一起使用
    
    freq :字符串或者DateOffest类型值设置需要生成的日期间隔频率,默认值为"D","D"代表以Day(天)为频率,可以用数值加频率扩展频率范围,如"2D"代表以2天为一个周期频率    Attention:在以周为频率的情况下,都是从周日开始,不一定是指定的开始时间开始
    
    tz :字符串或者tzinfor值,可选,用于指定本地时区的名称
    
    normalize :默认值为False,为True时则设置开始、结束日期的时间为午夜,即零点
    
    name :字符串,默认值为None,可以设置生成DatetimeIndex对象的名称
    
    closed :可选,可选项为{None,"left","right"}可以理解为时间范围,左右边界可以设置为开闭区间,"left"表示左闭区间,"right"表示右闭区间,None表示两边都为闭区间
    
    pd.date_range(start="2020-12-6 15:02:30",end="2020-12-9 15:02:30")  # 生成2020-12-06 15:02:30至2020-12-09 15:02:30按天为间隔的连续时间序列
    
    DatetimeIndex(['2020-12-06 15:02:30', '2020-12-07 15:02:30',
                   '2020-12-08 15:02:30', '2020-12-09 15:02:30'],
                  dtype='datetime64[ns]', freq='D')
    
    pd.date_range(start="2020-12-6 15:02:30",periods=4,freq="2D",name="时间索引")  # 生成以2020-12-06 15:02:30为始的按2天为间隔的连续4个时间序列
    
    DatetimeIndex(['2020-12-06 15:02:30', '2020-12-08 15:02:30',
                   '2020-12-10 15:02:30', '2020-12-12 15:02:30'],
                  dtype='datetime64[ns]', name='时间索引', freq='2D')
    
    pd.date_range(start="2020-12-6 15:02:30",end="2020-12-9 15:02:30",closed="left")  # 生成2020-12-06 15:02:30至2020-12-09 15:02:30按天为间隔左闭右开的连续时间序列
    
    DatetimeIndex(['2020-12-06 15:02:30', '2020-12-07 15:02:30',
                   '2020-12-08 15:02:30'],
                  dtype='datetime64[ns]', freq='D')
    

    2.3 时间转换

    在不同时间场合,时间使用的要求也不一样,有需要字符串形式的,有需要datetime形式的,有日期、时间的不同组合的,因此需要灵活转换

    2.3.1 pd.to_datetime方法将字符串转为datetime型

    pd.to_datetime(arg,errors=“raise”,dayfirst=False,yearfirst=False,utc=None,box=True,format=None,exact=True,unit=None,infer_datetime_format=False,origin=“unix”,cache=False)

    arg :指定转换的数据对象,可以是整型、浮点型、字符串、列表、元组、一维数组、Serise、DataFrame和字典
    
    errors :设置出错提示方式,可选{"ignore","raise","coercec"},默认值为"raise",如果转换失败,则给出出错提示信息;"ignore"则不出发出错提示信息;"coercec"在转换过程存在无效时间值时,自动转为NaT值
    
    dayfirst :指定arg参数转换时的顺序,设置为True时,则先转换日期,再转换时间,默认值为False
    
    yearfirst :值为True时则先转换日期,默认值为False
    
    utc :值为True返回UTC DatetimeIndex,默认值为None
    
    box :默认值为True返回DatetimeIndex或相关索引对象;值为False则返回多维数组
    
    format :字符串,默认值为None,指定字符串时间转化为时间时的strftime的格式,类似strftime方法转化为时间的使用方法
    
    exact :默认值为True表示精确匹配格式,值为False则允许匹配目标字符串中的任何位置
    
    unit :字符串,默认值为"ns",对转换对象指定时间单位(D天、s秒、ma毫秒、ns纳秒)
    
    infer_datetime_format :默认值为False,如果为True,且没有给出转换固定格式(format参数),且字符串日期时间格式确定,则可以提高转换速度
    
    origin :确定日期的开始点,默认值为"unix",则日期的开始点为1970-01-01,若提供值为Timestamp日期,则以Timestamp的起点日期作为开始点日期
    
    cache :默认值为False,如果为True,则是用唯一的转换日期缓存来应用日期时间转换,解析重复的日期字符串时可以提高转换速度
    
    import pandas as pd
    from datetime import datetime
    filename = r"D:\data_test.xlsx" 
    df = pd.read_excel(filename)
    
    print(df.head())
    print("="*30)
    print(df.info())
    
      name gender   birthday start_work  income          tel            email  \
    0   赵一      男  1989/8/10 2012-09-08   15000  13611011234    zhaoyi@qq.com   
    1   王二      男  1990/10/2 2014-03-06   12500  13500012234   wanger@163.com   
    2   张三      女  1987/3/12 2009-01-08   18500  13515273330  zhangsan@qq.com   
    3   李四      女  1991/8/16 2014-06-04   13000  13923673388   lisi@gmail.com   
    4   刘五      女  1992/5/24 2014-08-10    8500  17823117890     liuwu@qq.com   
    
                       other  
    0  {教育:本科,专业:电子商务,爱好:运动}  
    1      {教育:大专,专业:汽修,爱好:}  
    2   {教育:本科,专业:数学,爱好:打篮球}  
    3   {教育:硕士,专业:统计学,爱好:唱歌}  
    4      {教育:本科,专业:美术,爱好:}  
    ==============================
    <class 'pandas.core.frame.DataFrame'>
    RangeIndex: 8 entries, 0 to 7
    Data columns (total 8 columns):
     #   Column      Non-Null Count  Dtype         
    ---  ------      --------------  -----         
     0   name        8 non-null      object        
     1   gender      8 non-null      object        
     2   birthday    8 non-null      object        
     3   start_work  8 non-null      datetime64[ns]
     4   income      8 non-null      int64         
     5   tel         8 non-null      int64         
     6   email       8 non-null      object        
     7   other       8 non-null      object        
    dtypes: datetime64[ns](1), int64(2), object(5)
    memory usage: 640.0+ bytes
    None
    
    df.birthday=pd.to_datetime(df.birthday,format="%Y-%m-%d")
    df.info()
    
    <class 'pandas.core.frame.DataFrame'>
    RangeIndex: 8 entries, 0 to 7
    Data columns (total 8 columns):
     #   Column      Non-Null Count  Dtype         
    ---  ------      --------------  -----         
     0   name        8 non-null      object        
     1   gender      8 non-null      object        
     2   birthday    8 non-null      datetime64[ns]
     3   start_work  8 non-null      datetime64[ns]
     4   income      8 non-null      int64         
     5   tel         8 non-null      int64         
     6   email       8 non-null      object        
     7   other       8 non-null      object        
    dtypes: datetime64[ns](2), int64(2), object(4)
    memory usage: 640.0+ bytes
    
    data = pd.DataFrame({"客户":["李","张","刘","宋"],"工资":[3500,2500,1500,500],"日期":["2020-11-19","2020-11-20","2020-12-19","2020-12-20"]},index = ["A","B","C","D"])
    print(data.info)
    
    <bound method DataFrame.info of   客户    工资          日期
    A  李  3500  2020-11-19
    B  张  2500  2020-11-20
    C  刘  1500  2020-12-19
    D  宋   500  2020-12-20>
    

    2.3.2 parse()函数将字符串格式转换为时间格式

    使用 parse() 函数将字符串格式转换为时间格式

    from dateutil.parser import parse
    time ="2020-12-06"
    print(type(time))
    print("="*30)
    print(parse(time))
    print("="*30)
    print(type(parse(time)))
    
    <class 'str'>
    ==============================
    2020-12-06 00:00:00
    ==============================
    <class 'datetime.datetime'>
    

    2.3.3 str方法将时间格式转换为字符串格式

    使用 str() 函数将时间格式转换为字符串格式

    now = str(datetime.now())
    type(now)
    
    str
    

    2.4 时间索引

    2.4.1 关键字检索

    import numpy as np 
    import pandas as pd
    index = pd.DatetimeIndex(["2020-11-19","2020-11-20","2020-12-19","2020-12-20"])
    data = pd.DataFrame(np.arange(1,5),columns= ["num"],index = index)
    data
    
    num
    2020-11-191
    2020-11-202
    2020-12-193
    2020-12-204
    data["2020"]   # 年索引
    
    num
    2020-11-191
    2020-11-202
    2020-12-193
    2020-12-204
    data["2020-11"]  # 年月索引
    
    num
    2020-11-191
    2020-11-202
    data["2020-11-19":"2020-12-20"]  # 指定时间范围索引
    
    num
    2020-11-191
    2020-11-202
    2020-12-193
    2020-12-204

    上面的索引方法适用于索引是时间的情况下,但是并不是在所有情况下,时间都可以做索引,比如说时间只是一个普通列

    from datetime import datetime
    from dateutil.parser import parse 
    index =["A","B","C","D"]
    data = pd.DataFrame({"客户":["李","张","刘","宋"],"成交时间":[parse("2020-11-19"),parse("2020-11-20"),parse("2020-12-19"),parse("2020-12-20")]},index = index)
    data
    
    客户成交时间
    A2020-11-19
    B2020-11-20
    C2020-12-19
    D2020-12-20
    data[data["成交时间"] ==  datetime(2020,11,20)]  # 选择成交时间是2020-11-20的行
    
    客户成交时间
    B2020-11-20
    data[(data["成交时间"] > datetime(2020,11,19)) & (data["成交时间"] < datetime(2020,12,21))]   # 选择成交时间大于2020-11-19和成交时间小于2020-11-21的所有行
    
    客户成交时间
    B2020-11-20
    C2020-12-19
    D2020-12-20

    2.4.2 truncate方法截取时间

    通过 truncate 方法实现对Series或DataFrame对象日期的截取

    truncate(before=None,after=None,axis=None,copy=True)

    before :指定行索引值或列索引值,用于截取前面的值
    
    after :指定行索引值或列索引值,用于截取后面的值
    
    axis :0为行索引,1为列索引
    
    copy :复制数据
    
    T = pd.date_range("2020-12-6",periods=5,freq="2D")
    df1 = pd.DataFrame(("a","b","c","d","e"),index=T)
    print(df1)
    print("="*30)
    df1.truncate(before = pd.Timestamp("2020-12-07"),after= pd.Timestamp("2020-12-13"))   # 截取2020-12-07到2020-12-13这个时间段的数据
    
                0
    2020-12-06  a
    2020-12-08  b
    2020-12-10  c
    2020-12-12  d
    2020-12-14  e
    ==============================
    
    0
    2020-12-08b
    2020-12-10c
    2020-12-12d

    2.5 时间增量处理

    时间增量是相对时间点上的绝对时间差异,用不同的单位表示,如天、小时、分钟、秒。可以是正数也可以是负数

    2.5.1 Timedelta()增量函数

    Timedelta 是 datetime 的一个子类,用于提供时间增量计算功能

    pd.Timedelta(value,unit,days,seconds,microseconds,milliseconds,minutes,hours,weeks)

    value :字符串、整型、Timedelta、timedelta、np.timedelta64,指定时间增量
    
    unit :字符串,可选,时间增量单位,默认值为"ns",可选值为{"Y","M","W","D","days","day","hours","hour",.....}
    
    days,seconds,microseconds,milliseconds,minutes,hours,weeks :用键值对形式显示指定增量数值
    

    (1)字符串形式增减日期、小时

    import pandas as pd
    import datetime as dt
    import numpy as np
    today = dt.datetime.now()
    print(today)
    print("="*30)
    today.date() + pd.Timedelta("2 day")   # 提供增量为两天的时间增量
    
    2020-12-08 10:24:15.549743
    ==============================
    
    datetime.date(2020, 12, 10)
    
    today + pd.Timedelta("2 hours")   # 提供增量为两小时的时间增量
    
    datetime.datetime(2020, 12, 8, 12, 24, 15, 549743)
    
    today + pd.Timedelta("-2 hours")   # 提供两小时的时间减量
    
    datetime.datetime(2020, 12, 8, 8, 24, 15, 549743)
    

    (2)以整数和时间形式提供增减量

    today + pd.Timedelta(2 ,unit="hours")   # 提供增量为两小时的时间增量
    
    datetime.datetime(2020, 12, 8, 12, 24, 15, 549743)
    
    today + pd.Timedelta(2 ,unit="W")   # 提供增量为两周的时间增量
    
    datetime.datetime(2020, 12, 22, 10, 24, 15, 549743)
    

    (3)以datetime.datetime、np.timedelta64形式提供增减量

    today + pd.Timedelta(weeks=2)    #提供增量为两周的时间增量
    
    datetime.datetime(2020, 12, 22, 10, 24, 15, 549743)
    
    today + pd.Timedelta(np.timedelta64(2,"W"))
    
    datetime.datetime(2020, 12, 22, 10, 24, 15, 549743)
    

    2.5.2 to_timedelta()转为增量函数

    pd.to_timedelta(arg,unit=“ns”,box=True,errors=“raise”)

    arg :字符串、timedelta、类似列表、Series,指定需要转换为增量的数据对象
    
    unit :增量时间单位,同pd.Timedelta的unit
    
    box :默认值为True返回Timedelta\TimedeltaIndex结果,值为False则返回timedelta64类型数据
    
    pd.to_timedelta(np.arange(5),unit="s")  # 返回连续5个秒值的时间增量
    
    TimedeltaIndex(['00:00:00', '00:00:01', '00:00:02', '00:00:03', '00:00:04'], dtype='timedelta64[ns]', freq=None)
    

    2.5.3 timedelta_range()产生连续增量函数

    timedelta_range(start=None,end=None,periods=None,freq=None,name==None,closed=None)

    start :字符串、类似timedelta对象,默认值为None,指定时间增量左边边界
    
    end :字符串、类似timedelta对象,默认值为None,指定时间增量右边边界
    
    periods :整型,默认值为None,指定周期数,即增量个数
    
    freq :字符串、DateOffest,默认值为"D",指定增量频率,可以使用倍数方式指定,如"5D"
    
    name :字符串,默认值为None,指定生成TimedeltaIndex的名称
    
    closed :字符串,默认值为None,限制左右区间值得范围,可选项为{"right","left",None}
    
    pd.timedelta_range(start="1 day",end="10 day",periods=5,name="索引")
    
    TimedeltaIndex([ '1 days 00:00:00',  '3 days 06:00:00',  '5 days 12:00:00',
                     '7 days 18:00:00', '10 days 00:00:00'],
                   dtype='timedelta64[ns]', name='索引', freq=None)
    
    pd.timedelta_range(start="1 day", periods=5,freq= "2D",name="索引")
    
    TimedeltaIndex(['1 days', '3 days', '5 days', '7 days', '9 days'], dtype='timedelta64[ns]', name='索引', freq='2D')
    

    2.5.4 时间增量属性、增量索引

    Timedelta、TimedeltaIndex对象提供了增量相关的属性,用于增量不同单位的数值的获取。当想单独获取增量的天(days)、秒(seconds)、毫秒(milliseconds)、微妙(microseconds)、纳秒(nanoseconds)值时,可以通过上述两对象所提供的属性对象进行获取。

    1、Timedelta对象

    import pandas as pd
    d1 = pd.Timedelta("31 days 10 min 20 sec")   # 建立一个Timedelta对象
    d1
    
    Timedelta('31 days 00:10:20')
    

    (1) components属性,以获取增量的所有值

    d1.components   # 显示增量的所有内容
    
    Components(days=31, hours=0, minutes=10, seconds=20, milliseconds=0, microseconds=0, nanoseconds=0)
    
    d1.components[2]  # 通过下标值,获取增量的分钟值
    
    10
    

    (2) days属性

    d1.days  # 从增量中获取天的数值
    
    31
    

    (3) seconds属性

    d1.seconds  # 从增量中获取秒的数值(分钟+秒)
    
    620
    

    (3) microseconds属性

    d1.microseconds  # 从增量中获取微秒的数值(分钟+秒)
    
    0
    

    Attention:Timedelta并没有提供hours、week等类似的其他属性,而TimedeltaIndex提供的属性也略有差异

    2、TimedeltaIndex 时间增量索引对象

    TimedeltaIndex(data,unit,freq,copy,start,periods,end,closed,name)

    data :一维数组、一维列表,可选,用于建立timedelta类似数据的索引值
    
    unit :整数、浮点数,可选,指定增量时间单位(D、h、m、s、ms、ns)
    
    freq :字符串、偏移对象,可选,指定时间频率,可以传递字符串"infer",以便在创建时将索引的频率设置为推断频率
    
    copy :可选,默认值True为复制数据,值为False为数据视图
    
    start :可选, timedelta类似类型,指定增量开始值,如果data参数为None,则用该参数指定timedelta数据的起点
    
    periods :整数,可选,指定值要求大于0,指定增量数,优先end参数设置
    
    end : timedelta类似类型,指定结東时间,可选,如果 periods为None,则生效
    
    closed :字符串或默认值None,可选,指定生成值的开闭区间范围,可选择值{"left","right", None}
    
    name :可选,指定时间增量索引的名称
    

    用 Timedeltalndex建立时间增量索引对象

    import numpy as np
    import datetime as dt
    t = pd.TimedeltaIndex(["1 days","10 days","10:20:05",np.timedelta64(10,"D"),dt.timedelta(days=10,seconds=2)])
    t
    
    TimedeltaIndex([ '1 days 00:00:00', '10 days 00:00:00',  '0 days 10:20:05',
                    '10 days 00:00:00', '10 days 00:00:02'],
                   dtype='timedelta64[ns]', freq=None)
    
    t.days
    
    Int64Index([1, 10, 0, 10, 10], dtype='int64')
    

    生成连续时间增量还可以使用 pd.timedelta_range(),方法类似 pd.date_range()

    2.6 时间周期处理

    周期表示一段范围的时间,如一天、一月、一季度、一年等,规则的时间周期用pandas中的pd Period对象表示,pd Period_range()产生连续的时间周期序列对象PeriodsIndex

    2.6.1 时间周期建立

    通过时间周期的建立,可以更加灵活地控制年、月等时间周期的变化。

    pd Period(value, freq, year,month,quarter,day,hour,minute,second)

    value : Period或 compat.string_types类型,默认值None表示时间段,如4Q2005代表2005年第四季度
    
    freq : 字符串,默认值None,指定字符串型的 Pandas时间周期。
    
    year : 整数,默认值None,指定年数
    
    month : 整数,默认值1,指定月数
    
    quarter : 整数,默认值None,指定季度数
    
    day : 整数,默认值1,指定天数。
    
    hour : 整数,默认值0,指定小时数。
    
    minute : 整数,默认值0,指定分钟数
    
    second:整数,默认值0,指定秒数。
    
    M = pd.Period("2020-12",freq="M")
    M
    
    Period('2020-12', 'M')
    
    M+2
    
    Period('2021-02', 'M')
    

    2.6.2 时间周期序列

    在需要固定时间序列的地方,可以通过 pd.period_range() 函数产生

    period_range(start=None,end= None, periods= None, freq=None,name=None)
    start : 字符串或 period对象,指定周期序列的开始时间点,默认值为None

    end : 字符串或 period对象,指定周期序列的结東时间点,默认值为None
    
    periods : 整数,指定周期个数,默认值None
    
    freq : 字符串或 Dateoffset,指定周期名称,如Y、MI、D、h、m、、ms、ns,默认值D(天)
    
    name : 字符串,默认值None,指定 Periodindex名称
    

    (1) 以月为周期产生连续的时间序列

    M = pd.period_range("2020-12-12","2021-12-12",freq="M")
    M
    
    PeriodIndex(['2020-12', '2021-01', '2021-02', '2021-03', '2021-04', '2021-05',
                 '2021-06', '2021-07', '2021-08', '2021-09', '2021-10', '2021-11',
                 '2021-12'],
                dtype='period[M]', freq='M')
    

    (2) 以季度为周期产生连续的时间序列

    Q = pd.period_range("12/12/2020","12/12/2021",freq="Q")
    Q
    
    PeriodIndex(['2020Q4', '2021Q1', '2021Q2', '2021Q3', '2021Q4'], dtype='period[Q-DEC]', freq='Q-DEC')
    
    (3)以PeriodIndex对象为基础建立二维表
    
    a=pd.DataFrame({"韦德":[25,28,23,27,26]},index=Q)
    a
    
    韦德
    2020Q425
    2021Q128
    2021Q223
    2021Q327
    2021Q426

    2.7 日期偏移处理

    类似时间增量,只存在细微的区别

    2.7.1 时间偏移量建立

    日期偏移量更加遵循日历持续时间规则,如 Dateoffset在增加日时总是增加到指定日的同时间,而忽略夏令时等所带来的时间差异:而 Timedelta()在增加日时,每天增加24小时

    pd.DateOffset(n,normalize,**kwds)

    n : 整数,默认值为1,指定产生偏移量数
    
    normalize : 默认值为 False,当值为True时将DateOffset添加的时间结果含入到半夜0点。
    
    kwds : 以键值对形式指定偏移量周期
    
    import pandas as pd
    t1 = pd.Timestamp("2020-12-14")
    print(t1)
    t1 + pd.DateOffset(n=2,months=3) # 增加2*3=6个月
    
    2020-12-14 00:00:00
    
    Timestamp('2021-06-14 00:00:00')
    

    2.7.2 用offsets对象附带的方法调整日期

    t2 = pd.Timestamp(2020,12,14,13,19,52)
    print(t2)
    t2 + pd.offsets.YearEnd()   # 增加到年度结束日期
    
    2020-12-14 13:19:52
    
    Timestamp('2020-12-31 13:19:52')
    
    t2 + pd.offsets.MonthBegin(n=2)  # 增加到2个月后的月初
    
    Timestamp('2021-02-01 13:19:52')
    

    2.7.3 用pd.DateOffset()函数调整日期

    t1 + pd.DateOffset(n=2,months=3)
    
    Timestamp('2021-06-14 00:00:00')
    

    2.8 时间运算

    2.8.1 计算时间差

    在Python中两个时间做差会返回一个timedelta对象,该对象中包含天数、秒、微秒三个等级,如果要获取小时、分钟,则需要进行换算。

    time_cha = datetime(2020,11,19,18,5,50)-datetime(2020,11,18,17,5,50)
    time_cha
    
    datetime.timedelta(days=1, seconds=3600)
    

    差值为1天3600秒

    time_cha.days
    
    1
    
    time_cha.seconds
    
    3600
    
    import pandas as pd
    from datetime import datetime
    filename = r"D:\data_test.xlsx" 
    df = pd.read_excel(filename)
    
    print(df.head())
    print("="*30)
    df.birthday=pd.to_datetime(df.birthday,format="%Y-%m-%d")
    df["年龄"]= datetime.now().year-df.birthday.dt.year
    print(df.head())
    
      name gender   birthday start_work  income          tel            email  \
    0   赵一      男  1989/8/10 2012-09-08   15000  13611011234    zhaoyi@qq.com   
    1   王二      男  1990/10/2 2014-03-06   12500  13500012234   wanger@163.com   
    2   张三      女  1987/3/12 2009-01-08   18500  13515273330  zhangsan@qq.com   
    3   李四      女  1991/8/16 2014-06-04   13000  13923673388   lisi@gmail.com   
    4   刘五      女  1992/5/24 2014-08-10    8500  17823117890     liuwu@qq.com   
    
                       other  
    0  {教育:本科,专业:电子商务,爱好:运动}  
    1      {教育:大专,专业:汽修,爱好:}  
    2   {教育:本科,专业:数学,爱好:打篮球}  
    3   {教育:硕士,专业:统计学,爱好:唱歌}  
    4      {教育:本科,专业:美术,爱好:}  
    ==============================
      name gender   birthday start_work  income          tel            email  \
    0   赵一      男 1989-08-10 2012-09-08   15000  13611011234    zhaoyi@qq.com   
    1   王二      男 1990-10-02 2014-03-06   12500  13500012234   wanger@163.com   
    2   张三      女 1987-03-12 2009-01-08   18500  13515273330  zhangsan@qq.com   
    3   李四      女 1991-08-16 2014-06-04   13000  13923673388   lisi@gmail.com   
    4   刘五      女 1992-05-24 2014-08-10    8500  17823117890     liuwu@qq.com   
    
                       other  年龄  
    0  {教育:本科,专业:电子商务,爱好:运动}  31  
    1      {教育:大专,专业:汽修,爱好:}  30  
    2   {教育:本科,专业:数学,爱好:打篮球}  33  
    3   {教育:硕士,专业:统计学,爱好:唱歌}  29  
    4      {教育:本科,专业:美术,爱好:}  28  
    

    2.8.2 时间偏移

    时间偏移是指给时间往前推或往后推一段时间,即加或减一段时间

    在Python中实现时间偏移的方式有两种:第一种是借助timedelta,但是它只能偏移天、秒、微秒单位的时间;第二种是用Pandas中的日期偏移量(date offset)。

    ● timedelta

    由于timedelta只支持天、秒、微秒单位的时间运算,如果是其他单位的时间运算,则需要换算成以上三种单位中的一种方可进行偏移。

    from datetime import timedelta
    data = datetime(2020,11,19,18,5,50)
    
    data + timedelta(days=1)
    
    datetime.datetime(2020, 11, 20, 18, 5, 50)
    
    data + timedelta(seconds=1)
    
    datetime.datetime(2020, 11, 19, 18, 5, 51)
    
    data - timedelta(days=1)
    
    datetime.datetime(2020, 11, 18, 18, 5, 50)
    
    data - timedelta(seconds=1)
    
    datetime.datetime(2020, 11, 19, 18, 5, 49)
    

    ● date offset

    date offset 可以直接实现天、小时、分钟单位的时间偏移,不需要换算,相比timedelta要方便一些。

    from pandas.tseries.offsets import Day,Hour,Minute
    data = datetime.now()
    data
    
    datetime.datetime(2020, 11, 19, 18, 21, 20, 937641)
    
    data + Day(1)
    
    Timestamp('2020-11-20 18:21:20.937641')
    
    data + Hour(1)
    
    Timestamp('2020-11-19 19:21:20.937641')
    
    data + Minute(10)
    
    Timestamp('2020-11-19 18:31:20.937641')
    
    data - Day(1)
    
    Timestamp('2020-11-18 18:21:20.937641')
    
    data - Hour(1)
    
    Timestamp('2020-11-19 17:21:20.937641')
    
    data - Minute(10)
    
    Timestamp('2020-11-19 18:11:20.937641')
    
    展开全文
  • 前言:这段时间一直没有写博客,首先是我正在实现权限系列的绝色和操作的实现,因为这些东西在前面我们都已经说过了,所以我们就不重复的说...第一种解决方案就是我们使用Jquery来解决,我们知道,当值从Json传递到前台
  • 时间序列预测中,脏乱数据的存在会影响最终的预测结果。这是肯定的,尤其是在这个领域,因为时间依赖性在处理时间序列时起着至关重要的作用。 噪音或异常值必须按照特别的解决方案小心处理。在这种情况下,...
  • python格式化输出之format用法

    千次阅读 2019-10-01 12:58:19
    当值为整数时和’d’相同,值为浮点数时和’g’相同。不同的是它会根据区域设置插入数字分隔符。 ‘%’ - 百分数。将数值乘以100然后以fixed-point(‘f’)格式打印,值后面会有一个百分号。 1 >> > print ...
  • IDL 运算时间比较

    2019-06-12 11:09:06
    当值等于142时,半径5内的元素赋值为0  eqValue =  142  repValue =  0  ;符合要求的坐标  suitIdx =  calIdxInDistance ([ 0 , 0 ], 5 )  ;新数据  nData = data  idxs =  where ...
  • 2.Oracle的系统参数RESOURCE_LIMIT是一个用来监控用户对于数据库资源使用的参数,当值为true的时候即为启用,否则禁用(默认是禁用的)。该参数结合profile来控制多种资源的使用,如CPU_PER_SESSION,CONNECT_TIME...
  • 为了在线性时间与空间内归并,它不能在线性时间内实现就地排序,原地排序对它来说并不足够。而快速排序的优点就在于它是原地的,也就是说,它很 节省内存 。 引用一张来自维基百科的能够非常清晰表示快速排序的...
  • 当值为个位数时,前面加0; function zeroPadding(num, digit) { let zero = ""; for (var i = 0; i ; i++) { zero += "0"; } return (zero + num).slice(-digit); } // PS:微信小程序时间转时间戳时 ...
  • AUTOSAR 网络管理NM

    千次阅读 2019-11-12 22:06:54
    当值V更新为b时(此时TMS判断为假),进行直接/N次传输模式,传输三次。由图3可知,随着V值的更新该I-PDU的传输模式在这两种传输模式之间切换。 信号发送的实现 首先根据该信号的相关配置,判定其是内部消息...
  • 作者简介 作者名:编程界明世隐 ...3. 老Java程序员花一天时间写了个飞机大战 4. Java植物大战僵尸 5. 老Java程序员花2天写了个连连看 6. Java消消乐(天天爱消除) 7. Java贪吃蛇小游戏 8. Java扫雷小
  • sql注入基于布尔/时间的盲注详解

    千次阅读 2017-10-07 14:55:19
    其实基于布尔盲注和基于时间的盲注都是需要编写大量的代码,就像本篇的文章一样。之前在简单的SQL注入中,一句SQL注入代码就可以解决的问题在这里就需要编写Python代码来进行大量的注入测试才能够得到内容。其实之前...
  • ${a.datetime} 当输出datetime数据时,如果datetime为null系统将报异常;...当进行时间格式化处理时 ${a.datetime?string('yyyy')}  需要将前面的内容用() 括起来才可以使用! 如 ${(a.datetime?s
  • 引入 time 模块 import time 获取当前时间戳 unix_timestamp_current = time....unix_timestamp = None # 这是你要转换的时间戳,当值为 None 时,函数 localtime 自动获取当前戳,localtime(None) 等价于 localtim
  • 在每次采样时间命中时,该块都会在状态寄存器中的“t”时刻不断累积输入的值,并在“t-1”时刻之前发出值累积值。 如果高于上限或低于下限,则会裁剪输出值。 当值被裁剪时会引发一个标志。 可以通过嵌入式 MATLAB ...
  • 当值接近零时,没有线性关系。关系。 随着相关性接近正负1,关系更强。 值+1表示两个变量之间的正线性关系完美,-1表示两个变量之间的负线性关系完美。¹ The correlation squared (R²) has special meaning in ...
  • 【算法】6 比较排序之外学习新的线性时间排序

    千次阅读 多人点赞 2015-06-11 12:36:30
    它的运行时间是线性的且取决于最大值和最小值之间的差异,当值的变化明显大于数目时就不太适用了。而它也可以作为基排序的子程序。 COUNTING-SORT(A,B,k) 1 let C[ 0. ..k] be a new array 2 for i= ...
  • 会话的状态: 1.active 处于此状态的会话,...还有一点就是,killed的状态一般会持续较长时间,而且用windows下的工具pl/sql developer来kill掉,是不管用的,要用命令:alter system kill session 'sid,serial#' ...
  • React 小键盘 数字、日期和时间的小键盘,使用 React 构建并为 React 构建。 它的编写考虑了可扩展性。 这个项目的想法是在一个表单中覆盖大多数输入类型。 演示/示例 现场演示:gpietro.github.io/react-numpad-...
  • 关注微信公共号:小程在线 关注CSDN博客:程志伟的博客 ... 第十四天41、回归分析1、简单的线性回归模型2、其他的几种回归分析模型:1、对数模型2、指数模型3、幂模型4、多项式模型42、时间序列分析1、创建人工...
  • mybatis 日期时间格式化的问题

    千次阅读 2019-03-11 20:24:57
    mysql 数据库 datetime类型字段 ...数据库中时间是对的 pojo: 第一眼看到这种时间格式懵逼了,换成timestamp类型结果还是一样 解决办法: 在属性在加入@JsonFormat(timezone = "GMT+8",patt...
  • 1. Prophet简介Facebook在2017年开源了一个叫fbprophet的时间序列预测的算法,Facebook 所提供的 prophet 算法Prophet是Facebook...
  • [文章翻译]时间序列异常检测

    千次阅读 2019-02-17 20:08:38
    我们将每秒字节数的度量标准化为从0到1,因为虽然傅里叶模型可以使用与输入值一样高且可变的值,但是当值很高时,使用神经网络的方法效果要差得多。 此外,设置这些边界允许我们使用激活函数将数据转换为-1到1或0到1...
  • 时间复杂度_函数传参、传引用、传指针
  • R语言时间序列TAR阈值模型分析

    千次阅读 2019-06-20 16:57:00
    阈值模型用于几个不同的统计领域,而不仅仅是时间序列。总体思路是,当一个变量的值超过一定的阈值时,一个进程可能会有不同的表现。也就是说,当值大于阈值时,可能会应用不同的模型,而不是在阈值以下。 例如,...
  • Database之SQLSever:SQL函数(字符串函数、数学函数、文本和图像函数、日期和时间函数、系统函数等)相关概念及其相关案例之详细攻略 目录 SQL函数(字符串函数、数学函数、文本和图像函数、日期和时间函数、...
  • facebook时间序列预测算法prophet解读+实战原理解读一、时间序列的分解二、趋势项模型基于逻辑回归的趋势项基于线性回归的趋势项模型实战 原理解读 prophet与常用的自回归时间序列预测模型一样,本质上都是拟合过去...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 15,983
精华内容 6,393
关键字:

当值时间