锐客网

  1. 首页 > 生活百科 > it技术 > >

python中dt函数 python的ddt

IT技术Datetime

python datetime处理时间python时间处理方法datetime()python中dt函数 ， 下面就举几个代码案例进行说明 ， 代码如下：
# -*- coding: utf-8 -*-
# 运行环境:Python3.4
#datetime类
#datetime是date与time的结合体，包括date与time的所有信息 。
#它的构造函数如下：
#datetime. datetime (year, month, day[ , hour[ , minute[ , second[ , microsecond[ , tzinfo] ] ] ] ] )
【python中dt函数 python的ddt】 #各参数的含义与date、time的构造函数中的一样 ， 要注意参数值的范围 。
# 1. datetime类定义的类属性与方法：
#datetime.min、datetime.max：datetime所能表示的最小值与最大值；
#print: datetime.max: 9999-12-31 23:59:59.999999
#print: datetime.min: 0001-01-01 00:00:00
fromdatetimeimport*
import time
print('datetime.max:'str(datetime.max ))
print('datetime.min:'str(datetime.min))
#datetime.resolution：datetime最小单位；
#print: datetime.resolution: 0:00:00.000001
print('datetime.resolution:'str(datetime.resolution ))
#datetime.today()：返回一个表示当前本地时间的datetime对象；
#print: today(): 2012-09-12 19:37:50.721000
print('today():'str(datetime.today() ))
#datetime.now([tz])：返回一个表示当前本地时间的datetime对象，如果提供python中dt函数了参数tz ， 则获取tz参数所指时区的本地时间；
#print: now(): 2012-09-12 19:37:50.738000
print('now():' str( datetime.now() ))
#datetime.utcnow()：返回一个当前utc时间的datetime对象；
#print: 2012-09-12 11:37:50.739000
print('utcnow():'str(datetime.utcnow() ))
#datetime.fromtimestamp(timestamp[, tz])：根据时间戮创建一个datetime对象 ， 参数tz指定时区信息；
#print: fromtimestamp(tmstmp): 2012-09-12 19:37:50.741000
print('fromtimestamp(tmstmp):'str(datetime.fromtimestamp(time.time()) ))
#datetime.utcfromtimestamp(timestamp)：根据时间戮创建一个datetime对象；
#print: utcfromtimestamp(tmstmp): 2012-09-12 11:37:50.742000
print('utcfromtimestamp(tmstmp):'str(datetime.utcfromtimestamp(time.time())) )
#datetime.combine(date, time)：根据date和time，创建一个datetime对象；
#print: datetime.combine(date,time):2012-09-12 19:46:05
d = date(2012,9,12)
fromdatetimeimport*
t = time(19,46,5)
print ('datetime.combine(date,time): ' str(datetime.combine(d,t)))
#datetime.strptime(date_string, format)：将格式字符串转换为datetime对象；
#print: 2007-03-04 21:08:12
print (datetime.strptime("2007-03-04 21:08:12", "%Y-%m-%d %H:%M:%S"))
#2. datetime类提供的实例方法与属性
dt = datetime.strptime("2012-09-12 21:08:12", "%Y-%m-%d %H:%M:%S")
#print: 2012 9 12 21 8 12 0 None
print (dt.year)
print(dt.month)
print(dt.day)
print(dt.hour)
print(dt.minute)
print(dt.second)
print(dt.microsecond)
print(dt.tzinfo)
print (dt.date())
print (dt.time())
print (dt.replace(year = 2013))
print (dt.timetuple())
print (dt.utctimetuple())
print (dt.toordinal())
print (dt.weekday())
print (dt.isocalendar())
#print dt.isoformat([sep])
#datetime. ctime ()：返回一个日期时间的C格式字符串，等效于time.ctime(time.mktime(dt.timetuple()))；
#3. 格式字符串
# datetime. strftime (format)
# %a 星期的简写 。如 星期三为Web
# %A 星期的全写 。如 星期三为Wednesday
# %b 月份的简写 。如4月份为Apr
# %B月份的全写 。如4月份为April
# %c:日期时间的字符串表示 。（如： 04/07/10 10:43:39）
# %d:日在这个月中的天数（是这个月的第几天）
# %f:微秒（范围[0,999999]）
# %H:小时（24小时制，[0, 23]）
# %I:小时（12小时制，[0, 11]）
# %j:日在年中的天数 [001,366]（是当年的第几天）
# %m:月份（[01,12]）
# %M:分钟（[00,59]）
# %p:AM或者PM
# %S:秒（范围为[00,61]，为什么不是[00, 59]，参考python手册~_~）
# \u:周在当年的周数当年的第几周），星期天作为周的第一天
# %w:今天在这周的天数 ， 范围为[0, 6]，6表示星期天
# %W:周在当年的周数（是当年的第几周），星期一作为周的第一天
# %x:日期字符串（如：04/07/10）
# %X:时间字符串（如：10:43:39）
# %y:2个数字表示的年份
# %Y:4个数字表示的年份
# %z:与utc时间的间隔 （如果是本地时间 ， 返回空字符串）
# %Z:时区名称（如果是本地时间，返回空字符串）
# %%:%% = %
dt = datetime.now()
#print: (%Y-%m-%d %H:%M:%S %f):2012-09-12 23:04:27 145000
print ('(%Y-%m-%d %H:%M:%S %f): 'str(dt.strftime('%Y-%m-%d %H:%M:%S %f')))
#print: (%Y-%m-%d %H:%M:%S %p):12-09-12 11:04:27 PM
print ('(%Y-%m-%d %H:%M:%S %p): ' str(dt.strftime('%y-%m-%d %I:%M:%S %p')))
#print: %a: Wed
print ('%%a: %s ' % dt.strftime('%a'))
#print: %A: Wednesday
print ('%%A: %s ' % dt.strftime('%A'))
#print: %b: Sep
print ('%%b: %s ' % dt.strftime('%b'))
#print: %B: September
print ('%%B: %s ' % dt.strftime('%B'))
#print: 日期时间%c: 09/12/12 23:04:27
print ('日期时间%%c: %s ' % dt.strftime('%c'))
#print: 日期%x：09/12/12
print ('日期%%x：%s ' % dt.strftime('%x'))
#print: 时间%X：23:04:27
print ('时间%%X：%s ' % dt.strftime('%X'))
#print: 今天是这周的第3天
print ('今天是这周的第%s天 ' % dt.strftime('%w'))
#print: 今天是今年的第256天
print ('今天是今年的第%s天 ' % dt.strftime('%j'))
#print: 今周是今年的第37周
print ('今周是今年的第%s周 ' % dt.strftime('\u'))
上面代码案例运行结果如下：
atetime.max:9999-12-31 23:59:59.999999
datetime.min:0001-01-01 00:00:00
datetime.resolution:0:00:00.000001
today():2014-05-04 15:58:18.141186
now():2014-05-04 15:58:18.193146
utcnow():2014-05-04 07:58:18.243958
fromtimestamp(tmstmp):2014-05-04 15:58:18.291558
utcfromtimestamp(tmstmp):2014-05-04 07:58:18.342550
datetime.combine(date,time): 2012-09-12 19:46:05
2007-03-04 21:08:12
2012
9
12
21
8
12
None
2012-09-12
21:08:12
2013-09-12 21:08:12
time.struct_time(tm_year=2012, tm_mon=9, tm_mday=12, tm_hour=21, tm_min=8, tm_sec=12, tm_wday=2, tm_yday=256, tm_isdst=-1)
time.struct_time(tm_year=2012, tm_mon=9, tm_mday=12, tm_hour=21, tm_min=8, tm_sec=12, tm_wday=2, tm_yday=256, tm_isdst=0)
734758
2
(2012, 37, 3)
(%Y-%m-%d %H:%M:%S %f): 2014-05-04 15:58:19 326295
(%Y-%m-%d %H:%M:%S %p): 14-05-04 03:58:19 PM
%a: Sun
%A: Sunday
%b: May
%B: May
日期时间%c: Sun May4 15:58:19 2014
日期%x：05/04/14
时间%X：15:58:19
今天是这周的第0天
今天是今年的第124天
今周是今年的第18周
怎么用python语句写出公式dt＝b的平方－4acimport
math
a,b,c
=
input("请输入3个数字(空格分隔)：").split()
a
=
float(a)
b
=
float(b)
c
=
float(c)
d
=
(b**2)
-
(4*a*c)
if
a==0
and
b==0
and
c==0
:
print("有无穷个解")elif
d
=
0:
x1
=
(-b-d/(2*a))
x2
=
(-b d/(2*a))
print('结果为：%.2f,%.2f'%(x1,x2));
else:
print("无解")
python中timedelta方法怎么用#! /usr/bin/python# coding=utf-8from datetime import datetime,timedelta"""timedelta代表两个datetime之间的时间差"""now = datetime.now()
past = past = datetime(2010,11,12,13,14,15,16)
timespan = now - past#这会得到一个负数
past - now
attrs = [
("days","日"),( 'seconds',"秒"),( 'microseconds',"毫秒")#('min',"最小"),( 'max',"最大"),]for k,v in attrs:"timespan.%s = %s #%s" % (k,getattr(timespan, k),v)"""总共相差的秒数"""timespan.total_seconds()"""实例化一个timespan
请注意它的参数顺序
timedelta([days[, seconds[, microseconds[, milliseconds[, minutes[, hours[, weeks]]]]]]])"""timespan = timedelta(days=1)
now - timespan #返回的是datetime型
nowtimespan
timespan * 2 #还可以乘哦 。代表二倍
timespan / 13#增加一个月from calendar import monthrange
nowtimedelta(days=monthrange(start.year,start.month)[1])
实例1：
'''时间d距离now()的长度，比如：1分钟前，1小时前，1月前 ， 1年前'''
Python代码
# -*- encoding=UTF-8 -*-
import datetime
def timebefore(d):
chunks = (
(60 * 60 * 24 * 365, u'年'),
(60 * 60 * 24 * 30, u'月'),
(60 * 60 * 24 * 7, u'周'),
(60 * 60 * 24, u'天'),
(60 * 60, u'小时'),
(60, u'分钟'),
)
#如果不是datetime类型转换后与datetime比较
if not isinstance(d, datetime.datetime):
d = datetime.datetime(d.year,d.month,d.day)
now = datetime.datetime.now()
delta = now - d
#忽略毫秒
before = delta.days * 24 * 60 * 60delta.seconds#python2.7直接调用 delta.total_seconds()
#刚刚过去的1分钟
if before = 60:
return u'刚刚'
for seconds,unit in chunks:
count = before // seconds
if count != 0:
break
return unicode(count) unit u"前"
实例2：
‘’‘当前的时间上加一天或一年减一天等操作’‘’
Python代码1
#!/usr/bin/env python
# -*- coding:utf-8 -*-
from datetime import datetime,timedelta
now = datetime.now()
yestoday = now - timedelta(days=1)
tommorow = nowtimedelta(days=1)
next_year = nowtimedelta(days = 365)
Python代码2
#使用replace()代替日期加减
from datetime import datetime
now1 = datetime.now()
now1# datetime.datetime(2017, 2, 10, 22, 29, 48, 288500)
# 增加一天或减少一天
now2 = now1.replace(day=9)
now2# datetime.datetime(2017, 2, 9, 22, 29, 48, 288500)
# timestrap() 函数是把日期转化为时间戳，时间戳就是秒数
time_span = now1.timestrap() - now2.timestrap()/(24*3600)
time_span # 1
日期常用问题
1：　Datetime中offset-naive与offset-aware时间的计算
在使用Django时，默认是开启对多时区的支持的，在获取时间的时候会是如下形式：
datetime.datetime(2014, 4, 18, 15, 37, 7, tzinfo=UTC)
我们可以利用django.utils.timezone中提供的localtime方法来将该时间转换为本地时间：
1234dtdatetime.datetime(2014, 4, 18, 15, 37, 7, tzinfo=UTC) localtime(dt)datetime.datetime(2014, 4, 18, 23, 37, 7, tzinfo=LocalTimezone)
有时候，我们需要将该时间与当前时间做比较，例如计算差值 ， 你可能会想到直接这么做：
123import datetime now = datetime.datetime.now() now - dt
不过这是不对的，并告知如下错误：
123Traceback (most recent call last):File "console", line 1, in moduleTypeError: can't subtract offset-naive and offset-aware datetimes
问题就出在利用datetime.datetime.now()得到的当前时间是offset-naive的，而另外一个却是offset-aware的，因此我们需要将这里的dt转成与now一样的形式，可以这么做：
12345dt = dt.replace(tzinfo=None) dtdatetime.datetime(2014, 4, 18, 15, 37, 7) now - dtdatetime.timedelta(0, 34108, 443000)
备注：1：timezone 获取的日期增加和修改（比如加一天减一天）
from django.utiles import timezone
from datetime
t1 = timezone.now()
# torrow
t1＋datetime.timedelta(days=1,hours=1)
2：python得到两个时间段的每一天的列表
date_list = []
begin_date = datetime.datetime.strptime(begin_date, "%Y-%m-%d")
end_date = datetime.datetime.strptime(end_date, "%Y-%m-%d")while begin_date = end_date:
date_str = begin_date.strftime("%m-%d")
date_list.append(date_str)
begin_date= datetime.timedelta(days=1)print date_list
＃　方法2(安装boto3 库　pip install boto3)：
from datetime import datetime
from dateutil.rrule import rrule, DAILY
a = datetime(2009, 5, 30)
b = datetime(2009, 6, 9)
for dt in rrule(DAILY, dtstart=a, until=b):
print dt.strftime("%Y-%m-%d")
＃　在原来日期上增加一年
from dateutil.relativedelta import relativedelta
from django.utils import timezone
t1 = timezone.now()
neww_year = t1relativedelta(years=1)

python中时间序列数据的一些处理方式 datetime.timedelta对象代表两个时间之间的时间差，两个date或datetime对象相减就可以返回一个timedelta对象 。
利用以下数据进行说明：
如果我们发现时间相关内容的变量为int,float,str等类型，不方便后面的分析，就需要使用该函数转化为常用的时间变量格式：pandas.to_datetime
转换得到的时间单位如下：
如果时间序列格式不统一，pd.to_datetime()的处理方式：
当然 ， 正确的转换是这样的：
第一步：to_datetime()
第二步：astype(datetime64[D]),astype(datetime64[M])
本例中：
order_dt_diff必须是Timedelta('0 days 00:00:00')格式，可能是序列使用了diff()
或者pct_change() 。
前者往往要通过'/np.timedelta'去掉单位days 。后者其实没有单位 。
假如我们要统计某共享单车一天内不同时间点的用户使用数据 ， 例如
还有其他维度的提?。辍⒃隆⑷铡⒅?nbsp;， 参见：
Datetime properties
注意 ：.dt的对象必须为pandas.Series,而不可以是Series中的单个元素
如何使用python计算常微分方程？常用形式
odeint(func, y0, t,args,Dfun)
一般这种形式就够用了 。
下面是官方的例子，求解的是
D(D(y1))-t*y1=0
为了方便，采取D=d/dt 。如果我们令初值
y1(0) = 1.0/3**(2.0/3.0)/gamma(2.0/3.0)
D(y1)(0) = -1.0/3**(1.0/3.0)/gamma(1.0/3.0)
这个微分方程的解y1=airy(t) 。
令D(y1)=y0，就有这个常微分方程组 。
D(y0)=t*y1
D(y1)=y0
Python求解该微分方程 。
from scipy.integrate import odeint
from scipy.special import gamma, airy
y1_0 = 1.0/3**(2.0/3.0)/gamma(2.0/3.0)
y0_0 = -1.0/3**(1.0/3.0)/gamma(1.0/3.0)
y0 = [y0_0, y1_0]
def func(y, t):
...return [t*y[1],y[0]]
def gradient(y,t):
...return [[0,t],[1,0]]
x = arange(0,4.0, 0.01)
t = x
ychk = airy(x)[0]
y = odeint(func, y0, t)
y2 = odeint(func, y0, t, Dfun=gradient)
print ychk[:36:6]
[ 0.3550280.3395110.3240680.3087630.2936580.278806]
print y[:36:6,1]
[ 0.3550280.3395110.3240670.3087630.2936580.278806]
print y2[:36:6,1]
[ 0.3550280.3395110.3240670.3087630.2936580.278806]
得到的解与精确值相比，误差相当小 。
=======================================================================================================
args是额外的参数 。
用法请参看下面的例子 。这是一个洛仑兹曲线的求解 ， 并且用matplotlib绘出空间曲线图 。（来自《python科学计算》）
from scipy.integrate import odeint
import numpy as np
def lorenz(w, t, p, r, b):
# 给出位置矢量w ， 和三个参数p, r, b 计算出
# dx/dt, dy/dt, dz/dt 的值
x, y, z = w
# 直接与lorenz 的计算公式对应
return np.array([p*(y-x), x*(r-z)-y, x*y-b*z])
t = np.arange(0, 30, 0.01) # 创建时间点
# 调用ode 对lorenz 进行求解, 用两个不同的初始值
track1 = odeint(lorenz, (0.0, 1.00, 0.0), t, args=(10.0, 28.0, 3.0))
track2 = odeint(lorenz, (0.0, 1.01, 0.0), t, args=(10.0, 28.0, 3.0))
# 绘图
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
fig = plt.figure()
ax = Axes3D(fig)
ax.plot(track1[:,0], track1[:,1], track1[:,2])
ax.plot(track2[:,0], track2[:,1], track2[:,2])
plt.show()
===========================================================================
scipy.integrate.odeint(func, y0, t, args=(), Dfun=None, col_deriv=0, full_output=0, ml=None, mu=None, rtol=None, atol=None, tcrit=None, h0=0.0, hmax=0.0, hmin=0.0, ixpr=0, mxstep=0, mxhnil=0, mxordn=12, mxords=5, printmessg=0)
计算常微分方程（组）
使用 FORTRAN库odepack中的lsoda解常微分方程 。这个函数一般求解初值问题 。
参数：
func : callable(y, t0, ...)计算y在t0 处的导数 。
y0 : 数组y的初值条件（可以是矢量）
t : 数组为求出y，这是一个时间点的序列 。初值点应该是这个序列的第一个元素 。
args : 元组func的额外参数
Dfun : callable(y, t0, ...)函数的梯度(Jacobian) 。即雅可比多项式 。
col_deriv : boolean.True，Dfun定义列向导数（更快），否则Dfun会定义横排导数
full_output : boolean可选输出，如果为True 则返回一个字典 ， 作为第二输出 。
printmessg : boolean是否打印convergence 消息 。
返回： y : array, shape (len(y0), len(t))
数组，包含y值 ， 每一个对应于时间序列中的t 。初值y0 在第一排 。
infodict : 字典 ， 只有full_output == True 时，才会返回 。
字典包含额为的输出信息 。
键值：
‘hu’vector of step sizes successfully used for each time step.
‘tcur’ vector with the value of t reached for each time step. (will always be at least as large as the input times).
‘tolsf’ vector of tolerance scale factors, greater than 1.0, computed when a request for too much accuracy was detected.
‘tsw’value of t at the time of the last method switch (given for each time step)
‘nst’cumulative number of time steps
‘nfe’cumulative number of function evaluations for each time step
‘nje’cumulative number of jacobian evaluations for each time step
‘nqu’a vector of method orders for each successful step.
‘imxer’index of the component of largest magnitude in the weighted local error vector (e / ewt) on an error return, -1 otherwise.
‘lenrw’the length of the double work array required.
‘leniw’the length of integer work array required.
‘mused’a vector of method indicators for each successful time step: 1: adams (nonstiff), 2: bdf (stiff)
其他参数，官方网站和文档都没有明确说明 。相关的资料，暂时也找不到 。
关于python中dt函数和python的ddt的介绍到此就结束了 ， 不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站 。

    推荐阅读


    上一篇：猫咪抢直播的肉吃什么，猫猫吃播是真吃吗

    下一篇：电脑直播怎样可以看镜头，电脑直播怎样可以看镜头画面