下面介绍了如何在不使用任何库函数的情况下将Unix epoch时间转换为(UTC)Gregorian日期。下面的代码只导入time，以验证计算的日期是否与time.gmtime返回的日期相同。在
请注意，在2038年1月19日(星期二)UTC 03:14:08，32位版本的Unix时间戳将停止工作，因为它将溢出32位数字中可以保存的最大值。因此，在32位系统上，不要尝试调用time.gmtime来获取此类时间戳。当然，下面使用的算法不受这些限制。在#!/usr/bin/env python
''' Convert Unix Epoch seconds to (proleptic) Gregorian date
Algorithm by E. G. Richards, https://en.wikipedia.org/wiki/Julian_day
See http://stackoverflow.com/q/35796786/4014959
Python implementation by PM 2Ring 2016.03.07
'''
from time import gmtime
def epoch_seconds_to_gregorian_date(eseconds):
# Algorithm parameters for Gregorian calendar
y = 4716; j = 1401; m = 2; n = 12; r = 4; p = 1461
v = 3; u = 5; s = 153; w = 2; B = 274277; C = -38
#Julian day, rounded
J = int(0.5 + eseconds / 86400.0 + 2440587.5)
f = J + j + (((4 * J + B) // 146097) * 3) // 4 + C
e = r * f + v
g = (e % p) // r
h = u * g + w
D = (h % s) // u + 1
M = (h // s + m) % n + 1
Y = (e // p) - y + (n + m - M) // n
return Y, M, D
# Tests
def test(s):
t = gmtime(s)
gmdate = t.tm_year, t.tm_mon, t.tm_mday
e2gdate = epoch_seconds_to_gregorian_date(s)
assert gmdate == e2gdate, (t, gmdate, e2gdate)
return '%d.%d.%d' % e2gdate
print 'hours'
for i in xrange(25):
s = 3600 * i
print i, test(s)
print '\ndays'
for i in xrange(32):
s = 86400 * i
print i, test(s)
print '\n2 days by seconds...'
for s in xrange(86400 * 2):
test(s)
n = 50
print '\n%d years by days...' % n
for i in xrange(365 * n):
s = 86400 * i
test(s)
print 'Ok'
输出
^{pr2}$
这是一个改进的版本，它还返回小时、分钟和秒。这段代码处理分数秒，但是time.struct_time的字段都是整数，因此我的test函数不能与分数秒一起使用。在#!/usr/bin/env python
''' Convert Unix Epoch seconds to (proleptic) Gregorian date
Algorithm by E. G. Richards, https://en.wikipedia.org/wiki/Julian_day
See http://stackoverflow.com/q/35796786/4014959
Python implementation by PM 2Ring 2016.03.07
'''
from time import time, gmtime
from random import randint
import sys
def epoch_seconds_to_gregorian_date(eseconds):
# Algorithm parameters for Gregorian calendar
y = 4716; j = 1401; m = 2; n = 12; r = 4; p = 1461
v = 3; u = 5; s = 153; w = 2; B = 274277; C = -38
#Julian day, rounded
J = int(0.5 + eseconds / 86400.0 + 2440587.5)
#Date calculation
f = J + j + (((4 * J + B) // 146097) * 3) // 4 + C
e = r * f + v
g = (e % p) // r
h = u * g + w
D = (h % s) // u + 1
M = (h // s + m) % n + 1
Y = (e // p) - y + (n + m - M) // n
#Time calculation
seconds = eseconds % 86400
t = int(seconds)
hr, t = divmod(t, 3600)
mn = t // 60
seconds -= 3600 * hr + 60 * mn
return Y, M, D, hr, mn, seconds
# Tests
def test(s):
t = gmtime(s)
gmdate = t.tm_year, t.tm_mon, t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec
e2gdate = epoch_seconds_to_gregorian_date(s)
assert gmdate == e2gdate, (s, gmdate, e2gdate)
return '%d.%02d.%02d %02d:%02d:%06.3f' % e2gdate
print 'now'
s = time()
print s, epoch_seconds_to_gregorian_date(s), gmtime(s)
print '\nhours'
for i in xrange(25):
s = 3600 * i
print i, test(s)
print '\ndays'
for i in xrange(32):
s = 86400 * i
print i, test(s)
print '\n2 days by seconds...'
for i in xrange(86400 * 2):
test(i)
if i % 10000 == 0:
sys.stderr.write('.')
sys.stderr.write('\n')
n = 50
print '\n%d years by days...' % n
for i in xrange(365 * n):
s = 86400 * i
test(s)
n = 500000
print '\nRandom seconds'
for i in xrange(n):
s = randint(0, 2147483647)
test(s)
if i % 10000 == 0:
sys.stderr.write('.')
sys.stderr.write('\n')
print 'Ok'
输出now
1457355412.48 (2016, 3, 7, 12, 56, 52.476011991500854) time.struct_time(tm_year=2016, tm_mon=3, tm_mday=7, tm_hour=12, tm_min=56, tm_sec=52, tm_wday=0, tm_yday=67, tm_isdst=0)
hours
0 1970.01.01 00:00:00.000
1 1970.01.01 01:00:00.000
2 1970.01.01 02:00:00.000
3 1970.01.01 03:00:00.000
4 1970.01.01 04:00:00.000
5 1970.01.01 05:00:00.000
6 1970.01.01 06:00:00.000
7 1970.01.01 07:00:00.000
8 1970.01.01 08:00:00.000
9 1970.01.01 09:00:00.000
10 1970.01.01 10:00:00.000
11 1970.01.01 11:00:00.000
12 1970.01.01 12:00:00.000
13 1970.01.01 13:00:00.000
14 1970.01.01 14:00:00.000
15 1970.01.01 15:00:00.000
16 1970.01.01 16:00:00.000
17 1970.01.01 17:00:00.000
18 1970.01.01 18:00:00.000
19 1970.01.01 19:00:00.000
20 1970.01.01 20:00:00.000
21 1970.01.01 21:00:00.000
22 1970.01.01 22:00:00.000
23 1970.01.01 23:00:00.000
24 1970.01.02 00:00:00.000
days
0 1970.01.01 00:00:00.000
1 1970.01.02 00:00:00.000
2 1970.01.03 00:00:00.000
3 1970.01.04 00:00:00.000
4 1970.01.05 00:00:00.000
5 1970.01.06 00:00:00.000
6 1970.01.07 00:00:00.000
7 1970.01.08 00:00:00.000
8 1970.01.09 00:00:00.000
9 1970.01.10 00:00:00.000
10 1970.01.11 00:00:00.000
11 1970.01.12 00:00:00.000
12 1970.01.13 00:00:00.000
13 1970.01.14 00:00:00.000
14 1970.01.15 00:00:00.000
15 1970.01.16 00:00:00.000
16 1970.01.17 00:00:00.000
17 1970.01.18 00:00:00.000
18 1970.01.19 00:00:00.000
19 1970.01.20 00:00:00.000
20 1970.01.21 00:00:00.000
21 1970.01.22 00:00:00.000
22 1970.01.23 00:00:00.000
23 1970.01.24 00:00:00.000
24 1970.01.25 00:00:00.000
25 1970.01.26 00:00:00.000
26 1970.01.27 00:00:00.000
27 1970.01.28 00:00:00.000
28 1970.01.29 00:00:00.000
29 1970.01.30 00:00:00.000
30 1970.01.31 00:00:00.000
31 1970.02.01 00:00:00.000
2 days by seconds...
..................
50 years by days...
Random seconds
..................................................
Ok

1.在c3单元格中输入 =EOMONTH(A3,0)函数，
EOMONTH函数语法解析：返回start-date之前或之后指定月份中最后一天的序列号。
语法：EOMONTH(start_date，months)
Start_date参数代表开始日期，它有多种输入方式:带引号的文本串、序列号或其他公式或函数的结果
Month为start_date之前或之后的月份数，正数表示未来日期，负数表示过去日期，0表示当前月份。
2.算出的结果若显示为数值，需要ctrl+1键设置单元格格式改为日期格式即可；
3.2019年1月有多少天，在单元格中=EOMONTH(A3,-1)，里面的-1表示2月份的前一个的月份数，最后结果显示43496，即2019年1月31日，所以2019年的1月份有31天；
4.2019年5月份有多少天，在单元格中输入=EOMONTH(A3,3)，里面的数值3代表2019年2月份后3个月份数，即五月份。最后算出为43616也就是2019年5月31号，2019年的5月份有31天；
5.输入=EOMONTH(C3,12)，可算出2020年2月份的天数并进行验证，结果算出为2020年2月份的天数为29。。

首先你知道他存储的是datetime。
转换格式展示的内容又很多种。一般都是在数据库取出来在进行转换处理。
字母  日期或时间元素  表示  示例
G  Era 标志符  Text  AD
y  年  Year  1996; 96
M  年中的月份  Month  July; Jul; 07
w  年中的周数  Number 27
W  月份中的周数  Number 2 D  年中的天数  Number 189
d  月份中的天数  Number 10
F  月份中的星期  Number 2 E  星期中的天数  Text Tuesday; Tue
a  Am/pm 标记  Text  PM
H  一天中的小时数(0-23)  Number 0
k  一天中的小时数(1-24)  Number 24 K  am/pm 中的小时数(0-11)  Number 0
h  am/pm 中的小时数(1-12)  Number 12
m  小时中的分钟数  Number 30
s  分钟中的秒数  Number 55
S  毫秒数  Number 978
z  时区  General time zone  Pacific Standard Time; PST; GMT-08:00
Z  时区  RFC 822 time zone  -0800
问之前百度。这个是一个开发人员的基本功。
谢邀。

时间序列数据的计算脚本须具备较强的有序计算能力，本文从此类工具中精心挑选了三种，从开发效率、语法表达能力、结构化函数库等方面进行深度对比，考察了各脚本在序号计算、相对位置计算、有序集合计算等重点运算上的表现，esProc 在这几款工具中的表现最为出色。点击适合时间序列数据的计算脚本了解详情。
时间序列数据在这里指按时间排序的日常业务数据。对时间序列数据进行计算时，不仅涉及季度、月份、工作日、周末等常规计算，还经常遇到较为复杂的有序运算，这就要求脚本语言应具备相应的计算能力。一般用于处理时间序列数据的计算脚本有SQL、Python Pandas、esProc，下面就让我们深入了解这些脚本，看看它们的能力差异。
SQL
SQL历史悠久用户众多，在其模型框架内早已发展到极限，几乎每种简单运算都能找到对应的SQL解法，这其中就包括有序运算。
比如比上期的例子：表stock1001存储某支股票的交易信息，主要字段有交易日期transDate、收盘价price，请计算每个交易日与上个交易日相比收盘价的增长率。
这个例子属于相对位置计算，如果使用窗口函数，SQL写法相对容易：
但有些SQL不支持窗口函数，实现比上期就会麻烦得多：
上述代码之所以麻烦，首先是因为SQL是基于无序集合的，本身没有序号，不方便进行有序运算，为了实现有序运算，就要为无序集合硬造出序号列，这个过程需要自关联和分组汇总，代码比较复杂。其次，比上期属于相对位置计算，如果SQL有相对序号，这种计算会简单许多，但SQL没有相对序号，只能将上一行关联到本行，变相实现相邻位置计算，代码因此变得复杂。
基于无序集合的SQL不方便实现有序运算，窗口函数虽然可以缓解这一状况，但如果运算再复杂时，也依然麻烦。
比如中位数的例子：scores表存储学生成绩，主要字段有学生编号studentdid、数学成绩math，请计算数学成绩的中位数。中位数的定义是：如果记录总数L为偶数，则返回中间两个值的均值（序号分别为L/2和L/2+1）；如果L为奇数，则返回唯一的中间值（序号为(L+1)/2）。
SQL计算中位数的代码：
可以看到，虽然已经使用了窗口函数，但SQL仍然很复杂。生成序号的过程对于有序集合来说是多余的，但对SQL来说就是必不可少的步骤，尤其是本例这种必须显式使用序号的情况，这让代码显得复杂。SQL实现分支判断也较麻烦，所以对L为奇数的情况进行处理时，并没有返回唯一的中间值，而是两个同样的中间值求平均，这个技巧虽然可以简化分支判断，但理解起来稍有困难。
如果使用取整函数，则可以巧妙地跳过判断过程，在简化代码的同时计算出中位数。但这种技巧与中位数的原始定义不同，会造成理解困难，这里没有采用。
再看一个稍复杂的例子：连续上涨天数。库表AAPL存储某支股票的股价信息，主要字段有交易日期transDate、收盘价price，请计算该股票最长的连续上涨天数。SQL如下：
按自然思路实现这个任务时，应对日期有序的股票记录进行循环，如果本条记录与上一条记录相比是上涨的，则将连续上涨天数（初始为0）加1，如果是下跌的，则将连续上涨天数和当前最大连续上涨天数（初始为0）相比，选出新的当前最大连续上涨天数，再将连续上涨天数清0。如此循环直到结束，当前最大连续上涨天数即最终的最大连续上涨天数。
但SQL不擅长有序计算，无法用上述自然思路实现，只能用一些难懂的技巧。把按日期有序的股票记录分成若干组，连续上涨的记录分成同一组，也就是说，某天的股价比上一天是上涨的，则和上一天记录分到同一组，如果下跌了，则开始一个新组。最后看所有分组中最大的成员数量，也就是最多连续上涨的天数。
对于这两个稍复杂的有序运算例子，SQL实现起来就已经很困难了，一旦遇到更复杂的运算，SQL几乎无法完成。之所以出现这种结果，是因为SQL的理论基础就是无序集合，这种天然缺陷无论怎样打补丁，都无法从根本上解决问题。
Python Pandas
Pandas是Python的结构化计算库，常被用作时间序列数据的计算脚本。
作为结构化计算函数库，Pandas可以轻松实现简单的有序计算。比如，同样计算比上期，Pandas代码是这样的：
上述前两句是为了从文件读取数据，核心代码仅有一句。需要注意的是，Pandas并不能表示前一行，从而直接实现相对位置计算，但可以用shift(1)函数将列整体下移一行，从而变相实现相对位置计算。代码中行和列、前一行和下一行看上去很像，初学者容易混淆。
作为现代程序语言，Pandas在有序计算方面要比SQL先进，主要体现在Pandas基于有序集合构建，dataFrame数据类型天生具有序号，适合进行有序计算。前面那些稍复杂的有序计算，用SQL会非常困难，用Pandas就相对容易。
同样计算中位数，Pandas核心代码如下：
上述代码中，Pandas可以直接用[N]表示序号，而不用额外制造序号，代码因此得到简化。其次，Pandas是过程性语言，分支判断比SQL易于理解，也不需要技巧来简化代码。
同样稍复杂的例子最长连续上涨天数，Pandas也比SQL容易实现。核心代码如下：
本例中，Pandas可以按照自然思路实现，而不必采取难懂的技巧，代码的表达效率要比SQL高得多。
有点遗憾的是， 有序计算常常要涉及相对位置计算，但Pandas不能直接表达相对位置，只能把列下移一行来变相表示本行的上一行，理解时有点困难。
Pandas在有序计算方面的确比SQL容易些，但遇到更复杂的情况，Pandas也会变得很繁琐，下面试举两例。
比如过滤累计值的例子：表sales存储客户的销售额数据，主要字段有客户client、销售额amount，请找出销售额累计占到一半的前n个大客户，并按销售额从大到小排序。Pandas代码如下：
再比如计算股价最高3天的涨幅：表stock1001存储某支股票的每日股价，主要字段有交易日期transDate、收盘价price，请将股价最高的三天按逆序排列，计算每一天相比前一天的涨幅。Pandas代码如下：
这些更复杂的例子也需要用到一些难懂的技巧去实现，不仅难以编写，而且难以读懂，这里就不再详细解释。
esProc
与Pandas类似，esProc也具有丰富的结构化计算函数，与Pandas不同的是，esProc除了基于有序集合并支持序号机制外，还提供了方便的相邻引用机制，以及丰富的位置函数，从而快捷方便地实现有序计算。
对于简单的有序计算，esProc和其他计算脚本一样，都可以轻松实现。比如同样比上期的esProc代码：
上面代码A1从csv文件取数，A2是核心代码。esProc可以用直观易懂的[-1]表示相对本行的前一行，这是Pandas和SQL都没有的功能，也是esProc更为专业的表现。
同样计算中位数，esProc核心代码如下：
上述代码中，esProc可以直接用[N]表示序号，而不用额外制造序号，代码更为简洁。esProc同样是过程性语法，既可以用if/else语句实现大段的分支，也可以像本例一样，用if函数实现简洁的判断。
同样稍复杂的例子最长连续上涨天数，esProc也比SQL/Pandas容易实现。核心代码如下：
本例中，esProc可以按照自然思路实现，而不必采取特殊的技巧，代码表达效率要比SQL更高。除此外， esProc既可以用循环语句实现大段的循环，也可以像本例一样，用循环函数max实现简洁的循环聚合。
esProc是更为专业的结构化计算语言，即使遇到更复杂的有序计算，也能较为轻松地实现。
比如过滤累计值的例子，esProc只需如下代码：
 本例按自然思维实现，先在A2计算出从最大的客户到每个客户的累计值，再在A3算出最大累计值的一半，在A4算出累计值大于A3的位置，最后按位置取数据就是所需结果。这里有体现esProc专业性的两处特色，其一是A3中的m函数，该函数可以逆序取数，-1表示倒数第一条；其二是A4中的pselect，可以按条件返回序号。这两种函数都可以有效简化有序计算。
再比如计算股价最高那3天的涨幅，esProc只需如下代码：
上述代码中，A2中的ptop表示前N条的位置，和前面的pselect类似，返回的不是记录的集合，而是序号的集合，类似这样的函数在esProc中还有很多，其目的都是简化有序计算。A4中的#也是esProc的特色，直接表示序号字段，使用起来非常方便，不必像SQL那样额外制造，或Pandas那样设定index。
经过比较我们可以发现，esProc具备丰富的结构化函数，是专业的结构化计算语言，可以轻松实现常见的有序计算，即使更复杂的计算也能有效简化，是更加理想的时间序列数据计算脚本。