编程基础---不同软件中的时间和日期

日期时间功能

linux 中的日期时间

来源
date命令可以获取当前的时间，通过man，可以看到date有很多参数可以用，很容易做到格式化

date +"%F"
输出格式：2011-12-31 

date +"%F %H:%M:%S"
输出格式：2011-12-31 16:29:50

这都是打印出系统的当前时间，如果要获取相对当前时间的某个时间，需要怎么做，通过 -d 参数就能实现。例如：

date -d"tomorrow" +"%F %H:%M:%S"
输出明天这个时候的时间

date -d"yesterday" +"%F %H:%M:%S"
输出昨天这个时候的时间

如果说我想获取13天前的时间怎么办，-d参数还有更加灵活的用法，例如：

date -d"-1 day ago" +"%F %H:%M:%S"
输出明天这个时候的时间

date -d"1 day ago" +"%F %H:%M:%S"
输出昨天这个时候的时间

date -d"1 week ago" +"%F %H:%M:%S"
输出7天前这个时候的时间，等价于
date -d"7 day ago" +"%F %H:%M:%S"

第一个数字可以是负数，负数表示将来时间，正数表示前面已经过去的时间，第二个参数minute、hour、day、month、week。

python中的日期时间功能

本部分来源
主要用到time模块和datetime模块

time模块

time模块表达时间的方式

时间戳: 就是1970年距离现在时间的秒数
格式化的时间字符串: 目前的感觉是格式化的时间字符串并不是python能直接理解的，除非使用parse()等函数可以直接解析，似乎pandas也可以直接解析。
以数组的形式表示: 即struct_time,共九个元素。感觉这个才是python原生的时间格式。很多日期时间操作都会经过struct_time中转一下。struct_time的具体内容如下：

year (four digits, e.g. 1998)
month (1-12)
day (1-31)
hours (0-23)
minutes (0-59)
seconds (0-59)
weekday (0-6, Monday is 0)
Julian day (day in the year, 1-366)
DST (Daylight Savings Time) flag (-1, 0 or 1) 是否是夏令时

常用函数

1、asctime([tuple]) -> string
将struct格式的时间(默认是当前时间)转换成字符串

time.asctime()

结果如下:

'Sun Jul 31 11:10:39 2016'

import time
thisTime = "2016-07-31 12:12:12"#类时间格式的字符串，其实是其他地方更通用的时间字符串格式。比如mysql里，比如excel里也可以设成这种合适。也符合我们日常习惯
timeTuple=time.striptime(thistime,'%Y-%m-%d %H:%M:%S')#转换成struct_time
time.asctime(timeTuple)#将struct_time转换成python里的标准时间格式字符串

结果如下:

'Sun Jul 31 12:12:12 2016'

2、ctime(seconds) -> string
将时间戳(默认为当前时间)转换成时间字符串格式

time.ctime()

结果:

'Sun Jul 31 11:11:33 2016'

time.ctime(1469938332)

结果:

'Sun Jul 31 12:12:12 2016'

3、gmtime(seconds)->(tm_year,tm_mon,tm_day,tm_hour,tm_min,tm_sec,tm_wday,tm_yday, tm_isdst)
将⼀个时间戳转换成⼀个UTC时区(0时区)的struct_time，如果seconds参数未输⼊，则以当前时间为转换标准。

time.gmtime()

结果如下：

time.struct_time(tm_year=2016, tm_mon=7, tm_mday=31, tm_hour=3, tm_min=15, tm_sec=35, tm_wday=6, tm_yday=213, tm_isdst=0)

time.gmtime(1469938332)

结果如下：

time.struct_time(tm_year=2016, tm_mon=7, tm_mday=31, tm_hour=4, tm_min=12, tm_sec=12, tm_wday=6, tm_yday=213, tm_isdst=0)

4、localtime(time) ->(tm_year,tm_mon,tm_day,tm_hour,tm_min,tm_sec,tm_wday,tm_yday,tm_isdst)
将⼀个时间戳转换成⼀个当前时区的struct_time，如果seconds参数未输⼊，则以当前时间为转换标准。

time.localtime()

结果如下：

time.struct_time(tm_year=2016, tm_mon=7, tm_mday=31, tm_hour=11, tm_min=17, tm_sec=17, tm_wday=6, tm_yday=213, tm_isdst=0)

time.localtime(1469938332)

结果如下：

time.struct_time(tm_year=2016, tm_mon=7, tm_mday=31, tm_hour=12, tm_min=12, tm_sec=12, tm_wday=6, tm_yday=213, tm_isdst=0)

5、mktime(tuple) -> floating point number
将一个以struct_time转换为时间戳。

import time
thisTime = "2016-07-31 12:12:12"
timeTuple = time.strptime(thisTime, "%Y-%m-%d %H:%M:%S")
time.mktime(timeTuple)
#结果为：1469938332.0

6、 strftime(format[, tuple]) -> string
将指定的struct_time(默认为当前时间)，根据指定的格式化字符串输出。

time.strftime("%Y-%m-%d %H:%M:%S")
#结果为：'2016-07-31 11:20:41'
import time
thisTime = "2016-07-31 12:12:12"
timeTuple = time.strptime(thisTime, "%Y-%m-%d %H:%M:%S")
time.strftime("%Y-%m-%d %H:%M:%S",timeTuple)
#结果为：'2016-07-31 12:12:12'

7、strptime(string, format) -> struct_time
将时间字符串根据指定的格式化符转换成数组形式的时间。

import time
thisTime = "2016-07-31 12:12:12"
timeTuple = time.strptime(thisTime, "%Y-%m-%d %H:%M:%S")
print timeTuple
#结果为：time.struct_time(tm_year=2016, tm_mon=7, tm_mday=31, tm_hour=12, tm_min=12, tm_sec=12, tm_wday=6, tm_yday=213, tm_isdst=-1)

8、time() -> floating point number
返回当前时间的时间戳。

time.time()
#结果为：1469935566.776

9、clock() -> floating point number
Python time clock() 函数以浮点数计算的秒数返回当前的CPU时间。用来衡量不同程序的耗时，比time.time()更有用。

这个需要注意，在不同的系统上含义不同。在UNIX系统上，它返回的是"进程时间"，它是用秒表示的浮点数（时间戳）。而在WINDOWS中，第一次调用，返回的是进程运行的实际时间。而第二次之后的调用是自第一次调用以后到现在的运行时间。（实际上是以WIN32上QueryPerformanceCounter()为基础，它比毫秒表示更为精确） 。

start = time.clock()
main()
end = time.clock()
print('finish all in %s' % str(end - start))

datetime模块

datetime模块表达时间的方式

datetime模块表达时间的方式与time模块是一样的，也是时间戳、时间格式字符串和datetime对象(比stuct_time含有更丰富的信息，可直接打印出像字符串一样的时间)。
datetime模块的类更多，函数更多，而且有属性，能够比time模块完成更多的功能。以目前的接触来看，time模块能完成的功能，datetime模块都能做到，而datetime模块能做的time模块未必能做到。
time模块只有time一个类，然后通过该类下的函数完成相应的功能。而datetime有常量和多个类，每个类下又有多个函数。因而这里通过按类来组织相关内容。

datetime中的常量

datetime.MINYEAR，表示datetime所能表示的最小年份，MINYEAR = 1。
datetime.MAXYEAR，表示datetime所能表示的最大年份，MAXYEAR = 9999。

datetime中的类

datetime.date： 表示日期的类。常用的属性有year, month, day；
datetime.time： 表示时间的类。常用的属性有hour, minute, second, microsecond；
datetime.datetime： 表示日期时间。
datetime.timedelta： 表示时间间隔，即两个时间点之间的长度。timedelta是一个单独的对象，timedelta包含数据days、seconds、microseconds。
datetime.tzinfo： 与时区有关的相关信息。

date类

date类表示一个由年、月、日组成的日期。
①类方法与类属性
date类定义了一些常用的类方法与类属性，方便我们操作：
date.max、date.min： date对象所能表示的最大、最小日期；
date.resolution： date对象表示日期的最小单位。这里是天。
date.today()： 返回一个表示当前本地日期的date对象；
date.fromtimestamp(timestamp)： 根据给定的时间戮，返回一个date对象；
datetime.fromordinal(ordinal)： 将Gregorian日历时间转换为date对象；（Gregorian Calendar ：一种日历表示方法，类似于我国的农历，西方国家使用比较多，此处不详细展开讨论。）
②实例方法和属性
date提供的实例方法和属性：
date.year、date.month、date.day： 年、月、日；
date.replace(year, month,day)： 生成一个新的日期对象，用参数指定的年，月，日代替原有对象中的属性。（原有对象仍保持不变）
date.timetuple()： 返回日期对应的time.struct_time对象；
date.toordinal()： 返回日期对应的Gregorian Calendar日期；
date.weekday()： 返回weekday，如果是星期一，返回0；如果是星期2，返回1，以此类推；
data.isoweekday()： 返回weekday，如果是星期一，返回1；如果是星期2，返回2，以此类推；
date.isocalendar()： 返回格式如(year，month，day)的元组；
date.isoformat()： 返回格式如’YYYY-MM-DD’的字符串；标准格式。
date.strftime(fmt)： 自定义格式化字符串。在下面详细讲解。与time模块中的函数一模一样。
③date支持的其他操作
date2 = date1 + timedelta 日期加上一个间隔，返回一个新的日期对象）
date2 = date1 - timedelta 日期隔去间隔，返回一个新的日期对象
timedelta = date1 - date2 两个日期相减，返回一个时间间隔对象
date1 < date2 两个日期进行比较

time类

time类表示时间，由时、分、秒以及微秒组成。
①time类定义的类属性
time.min、time.max： time类所能表示的最小、最大时间。其中，time.min = time(0, 0, 0, 0)，time.max = time(23, 59, 59, 999999)；
**time.resolution：**时间的最小单位，这里是1微秒；
②time类提供的实例方法和属性
**time.hour、time.minute、time.second、time.microsecond：**时、分、秒、微秒；
**time.tzinfo：**时区信息；
**time.replace([ hour[ , minute[ , second[ ,microsecond[ , tzinfo] ] ] ] ] )：**创建一个新的时间对象，用参数指定的时、分、秒、微秒代替原有对象中的属性（原有对象仍保持不变）；
**time.isoformat()：**返回型如”HH:MM:SS”格式的字符串表示；
**time.strftime(fmt)：**返回自定义格式化字符串。在下面详细介绍；

像date一样，也可以对两个time对象进行比较，或者相减返回一个时间间隔对象。

datetime类

datetime是date与time的结合体，包括date与time的所有信息。
①datetime类定义的类属性与方法
datetime.min、datetime.max： datetime所能表示的最小值与最大值；
datetime.resolution： datetime最小单位；
datetime.today()： 返回一个表示当前本地时间的datetime对象；
datetime.now([tz])： 返回一个表示当前本地时间的datetime对象，如果提供了参数tz，则获取tz参数所指时区的本地时间；
datetime.utcnow()： 返回一个当前utc时间的datetime对象；
datetime.fromtimestamp(timestamp[,tz])： 根据时间戮创建一个datetime对象，参数tz指定时区信息；
datetime.utcfromtimestamp(timestamp)： 根据时间戮创建一个datetime对象；
datetime.combine(date, time)： 根据date和time，创建一个datetime对象；
datetime.strptime(date_string, format)： 将格式字符串转换为datetime对象；
②datetime类提供的实例方法与属性
datetime.year、month、day、hour、minute、second、microsecond、tzinfo： 年、月、日、时、分、秒、毫秒、时区；
datetime.date()： 获取date对象。
datetime.time()： 获取time对象。
**datetime. replace([ year[ , month[ , day[ , hour[ , minute[ , second[ , microsecond[ ,tzinfo] ] ] ] ] ] ] ])： ** 返回一个替换了指定日期时间字段的新datetime对象。
datetime.timetuple ()： 返回一个时间元素, 等价于time.localtime()。
datetime. utctimetuple()： 返回UTC时间元组对象, 等价于time.localtime()。
datetime. toordinal ()： 返回日期对应的Gregorian Calendar 日期。
datetime. weekday ()： 返回 0 ~ 6 表示星期几（星期一是0，依此类推）。
datetime. isocalendar ()： 返回一个三元组格式 (year, month, day)。
datetime. isoformat ([ sep] )： 返回一个 ISO 8601 格式的日期字符串，如 “YYYY-MM-DD”的字符串。
datetime. ctime()： 返回一个日期时间的C格式字符串，等效于time.ctime(time.mktime(dt.timetuple()))；
datetime. strftime (format)： 返回自定义格式化字符串表示日期。

像date一样，也可以对两个datetime对象进行比较，或者相减返回一个时间间隔对象，或者日期时间加上一个间隔返回一个新的日期时间对象。

timedelta类

datetime.timedelta 对象代表两个时间之间的的时间差，两个date或datetime对象相减时可以返回一个timedelta对象。
timedelta包含数据days、seconds、microseconds，表示天数、秒数、微秒数，包含方法total_seconds() ，表示时间间隔的总秒数。

tzinfo类

tzinfo：与时区有关的相关信息。

dateutil模块parser

来源

from dateutil.parser import parse
timeStr=parse('Sat Dec 16 21:26:55 CST 2017').strftime('%Y-%m-%d %H:%M:%S')
timeStr
#'2017-12-16 21:26:55'

pyspark中的时期时间

来源：

• pyspark.sql.functions.current_date()
• pyspark.sql.functions.current_timestamp()
• pyspark.sql.functions.date_add(start, days)
• pyspark.sql.functions.date_format(date, format)
• pyspark.sql.functions.date_sub(start, days)
• pyspark.sql.functions.date_trunc(format, timestamp)
• pyspark.sql.functions.datediff(end, start)
• pyspark.sql.functions.dayofmonth(col)
• pyspark.sql.functions.dayofweek(col)
• pyspark.sql.functions.dayofyear(col)

spark.sql中的时间

spark 里from_unixtime等时区问题
spark sql默认会用当前机器的时区，在产线环境下需要设置job的时区，或者直接在conf里配置好。
在shell里可加入配置--conf "park.sql.session.timeZone = UTC"

或者在代码里设置

spark.conf.set("spark.sql.session.timeZone", "UTC")

一般在数据传输的时候是不带时区，比如在以parquet格式导入导出数据时，可以是标准的datetime.datetime格式数据，也可能是时间戳,尤其是时间戳，它只是一串数字或字符。它能代表什么关键看我们怎么看它。

pyspark.sql.functions.date_format(date, format)

spark.sql中date_format默认是用本机的时间来识别
假如原始parquet中是以utc时区导出的时间，然后我们在用spark.sql读入数据时，由于parquet中存储的时标准的时间格式，那么spark.sql会自动识别这种数据类型，但是以本机的时间来识别的，因而这里就会多8小时的错位。所以需要在读取文件数据之前设置

spark.conf.set("spark.sql.session.timeZone", "UTC")

具体如下：

from pyspark import SparkContext
from pyspark.sql import SparkSession
from pyspark.sql.functions import date_format


if __name__=="__main__":
	sc=SparkContext(appName='myApp')
	spark=SparkSession.builder.config("spark.debug.maxToStringFields", "100").enableHiveSupport().getOrCreate()
	spark.conf.set("spark.sql.session.timeZone", "UTC")
	sql ="set hive.exec.dynamic.partition=true"
	spark.sql(sql)
	sql = "set hive.exec.dynamic.partition.mode=nonstrict"
	spark.sql(sql)
	hdfsPath="hdfs://ndhdfs/user/test/BBB-DATA2/*/*/*.parquet"
	#print(hdfsPath)
	dfTemp =spark.read.parquet(hdfsPath)
	df=dfTemp.select(date_format(dfTemp.sample_ts,format='yyyy-MM-dd HH:mm:ss').alias("sample_ts"),dfTemp.insert_date,dfTemp.insert_hour,date_format(dfTemp.sample_ts,format='yyyy-MM-dd').alias("partition_date"))
	#df.show()
	df.registerTempTable("df_Temp")
	sql = "use test"
	spark.sql(sql)
	sql = "insert into table df partition(partition_date) select * from df_Temp"
	spark.sql(sql)
	sc.stop()

告诉系统我应该按UTC来解释这个时间
是不是如果原始数据以本地时间存储（本身会+8小时），这里如果没设置，又会再加8小时，最终差16小时呢？

pyspark.sql.functions.from_unixtime

pyspark.sql.functions.from_unixtime默认是按utc时区去理解这个时间
如果原文件已经是按本地时间存储，而我们使用pyspark.sql.functions.from_unixtime去转换的时候，此时是按utc时区去理解这个时间戳的，因而最终看到的类似’2019-01-28 15：45：45’这样的时间的时候也是多了8个小时，因而需要设置

spark.conf.set("spark.sql.session.timeZone", "Asia/Shanghai")

具体如下：

from pyspark import SparkContext
from pyspark.sql import SparkSession
from pyspark.sql.functions import from_unixtime
from pyspark.sql.functions import date_format


if __name__=="__main__":
	sc=SparkContext(appName='myApp')
	spark=SparkSession.builder.config("spark.debug.maxToStringFields", "100").enableHiveSupport().getOrCreate()
	spark.conf.set("spark.sql.session.timeZone", "Asia/Shanghai")
	sql ="set hive.exec.dynamic.partition=true"
	spark.sql(sql)
	sql = "set hive.exec.dynamic.partition.mode=nonstrict"
	spark.sql(sql)
	hdfsPath="hdfs://ndhdfs/apps/hive/warehouse/AAA.db/aaa_data/2019010823*/*.parquet"
	#print(hdfsPath)
	dfTemp =spark.read.parquet(hdfsPath)
	df=dfTemp
	hdfsPath="hdfs://ndhdfs/apps/hive/warehouse/AAA.db/aaa_data/20190109*/*.parquet"
	dfTemp =spark.read.parquet(hdfsPath)
	df=df.unionAll(dfTemp)
	hdfsPath="hdfs://ndhdfs/apps/hive/warehouse/AAA.db/aaa_data/2019011000*/*.parquet"
	dfTemp =spark.read.parquet(hdfsPath)
	df=df.unionAll(dfTemp)
	df=df.select(df.ID,df.DEVICEID,from_unixtime(df.DATATIME/1000).alias("DATATIME"),from_unixtime(df.CREATION_DATE/1000).alias("CREATION_DATE"),df.LAST_UPDATED_BY,from_unixtime(df.LAST_UPDATE_DATE/1000).alias("LAST_UPDATE_DATE"),df.ATTRIBUTE1,df.ATTRIBUTE2,df.ATTRIBUTE3,df.ATTRIBUTE4,df.ATTRIBUTE5,from_unixtime(df.DATATIME/1000,format='yyyy-MM-dd').alias("partition_date"))
	#df.show()
	df.registerTempTable("df_Temp")
	sql = "use test"
	spark.sql(sql)
	sql = "insert into table df partition(partition_date) select * from df_Temp"
	spark.sql(sql)
	spark.stop()

date_format和from_unixtime两者默认的时间是不一样的（应该是这样，如有错误帮忙反馈）。
关于时间的更多资料可查看python时区设置——pytz模块

python3实现万年历（包括公历、农历、节气、节日）

python3实现万年历（包括公历、农历、节气、节日）
全年所有节假日
节假日api接口之获取指定日期的节假日信息
java 节假日日期接口 http://api.goseek.cn/Tools/holiday?date=XXX

这部分的节假日是按国家放假来的，法定节日就是2，周末是1，其他0；这里的节假日像儿童节这类就不算在里面。
获取指定日期的节假日信息
1、接口地址：http://api.goseek.cn/Tools/holiday?date=数字日期
2、返回数据：工作日对应结果为 0, 休息日对应结果为 1, 节假日对应的结果为 2
3、节假日数据说明：本接口包含2017年起的中国法定节假日数据，数据来源国务院发布的公告，每年更新1次，确保数据最新
4、示例：
http://api.goseek.cn/Tools/holiday?date=20170528
返回数据：
{“code”:10001,“data”:2}

#-*-coding:utf-8-*-

import requests
import datetime
import pymysql
import pandas as pd


class HolidayParser:
    def holidayParser(self,daysPre=60,daysTotal=700,winSum=['20180115','20180225','20170116','20170219','20160118','20160221','20180723','20180902','20170717','20170903','20160718','20160904']):
        dateStart = datetime.date.today()+datetime.timedelta(days=daysPre)
        holidayLabels=[]
        for i in range(daysTotal):
            dateSearch=dateStart-datetime.timedelta(days=i)
            dateSearch = dateSearch.strftime('%Y%m%d')
            if (dateSearch>=winSum[0] and dateSearch<=winSum[1]) or (dateSearch>=winSum[2] and dateSearch<=winSum[3]) or (dateSearch>=winSum[4] and dateSearch<=winSum[5]):
                winterSummerLabel=1
            elif (dateSearch>=winSum[6] and dateSearch<=winSum[7]) or (dateSearch>=winSum[8] and dateSearch<=winSum[9]) or (dateSearch>=winSum[10] and dateSearch<=winSum[11]):
                winterSummerLabel=2
            else:
                winterSummerLabel = 0
            urlStr='http://api.goseek.cn/Tools/holiday?date=%s'%(dateSearch)
            r = requests.get(url=urlStr)
            # if r.status_code==200:
            temp=r.text
            #{"code":10000,"data":2}
            temp=temp.split(sep=':')
            temp=temp[2][:-1]
            # print('%s,%s,%d'%(dateSearch,temp,winterSummerLabel))
            holidayLabels.append([dateSearch,temp,winterSummerLabel])
        holidayLabels=pd.DataFrame(holidayLabels)
        holidayLabels.columns=['date','holidayLabel','winSumLabel']
        return holidayLabels


if __name__=="__main__":
    HPars=HolidayParser()
    holidayLabels=HPars.holidayParser(daysPre=60,daysTotal=720)
    holidayLabels.to_csv('test.csv')

Java中的日期时间功能

来源：Java日期时间(Date/Time)

mysql中的日期时间功能

mysql 获取当前日期及格式化

mysql的yearweek 和 weekofyear函数
MYSQL中取当前周/月/季/年的第一天与最后一天

日期和时间的格式化参数

mysql日期和时间的格式化参数

日期的格式format有如下形式，mysql中其他函数中设置日期格式也是一样的：
%S, %s 两位数字形式的秒（ 00,01, ..., 59）
%I, %i 两位数字形式的分（ 00,01, ..., 59）
%H 两位数字形式的小时，24 小时（00,01, ..., 23）
%h 两位数字形式的小时，12 小时（01,02, ..., 12）
%k 数字形式的小时，24 小时（0,1, ..., 23）
%l 数字形式的小时，12 小时（1, 2, ..., 12）
%T 24 小时的时间形式（hh:mm:ss）
%r 12 小时的时间形式（hh:mm:ss AM 或hh:mm:ss PM）
%p AM或PM
%W 一周中每一天的名称（Sunday, Monday, ..., Saturday）
%a 一周中每一天名称的缩写（Sun, Mon, ..., Sat）
%d 两位数字表示月中的天数（00, 01,..., 31）
%e 数字形式表示月中的天数（1, 2， ..., 31）
%D 英文后缀表示月中的天数（1st, 2nd, 3rd,...）
%w 以数字形式表示周中的天数（ 0 = Sunday, 1=Monday, ..., 6=Saturday）
%j 以三位数字表示年中的天数（ 001, 002, ..., 366）
%U 周（0, 1, 52），其中Sunday 为周中的第一天
%u 周（0, 1, 52），其中Monday 为周中的第一天
%M 月名（January, February, ..., December）
%b 缩写的月名（ January, February,...., December）
%m 两位数字表示的月份（01, 02, ..., 12）
%c 数字表示的月份（1, 2, ...., 12）
%Y 四位数字表示的年份
%y 两位数字表示的年份
%% 直接值“%”

python日期和时间的格式化参数

%a 星期几的简写 Weekday name, abbr.
%A 星期几的全称 Weekday name, full
%b 月分的简写 Month name, abbr.
%B 月份的全称 Month name, full
%c 标准的日期的时间串 Complete date and time representation
%d 十进制表示的每月的第几天 Day of the month
%H 24小时制的小时 Hour (24-hour clock)
%I 12小时制的小时 Hour (12-hour clock)
%j 十进制表示的每年的第几天 Day of the year
%m 十进制表示的月份 Month number
%M 十时制表示的分钟数 Minute number
%S 十进制的秒数 Second number
%U 第年的第几周，把星期日做为第一天（值从0到53）Week number (Sunday first weekday)
%w 十进制表示的星期几（值从0到6，星期天为0）weekday number
%W 每年的第几周，把星期一做为第一天（值从0到53） Week number (Monday first weekday)
%x 标准的日期串 Complete date representation (e.g. 13/01/08)
%X 标准的时间串 Complete time representation (e.g. 17:02:10)
%y 不带世纪的十进制年份（值从0到99）Year number within century
%Y 带世纪部分的十制年份 Year number
%z，%Z 时区名称，如果不能得到时区名称则返回空字符。Name of time zone
%% 百分号

日期时间操作

获取当前日期和时间

软件：mysql
函数：NOW()
解释：获取当前日期和时间
例子：SELECT NOW()
结果： 2017-12-15 17:14:31
以上结果为mysql系统中的日期和时间的标准格式

mysql中其他一样功能的函数
CURRENT_TIMESTAMP()、CURRENT_TIMESTAMP、localtime()、localtime、localtimestamp 、localtimestamp()

软件：mysql
函数：sysdate()
解释：获取当前日期和时间
例子：SELECT sysdate()
结果： 2017-12-15 17:47:07
sysdate() 日期时间函数跟 now() 类似，不同之处在于：now() 在执行开始时值就得到了， sysdate() 在函数执行时动态得到值。有时一条命令很长，可能运行很长时间，这时now()记录的是命令开始的时间，而sysdate()是记录命令执行到sysdate()时刻的时间。

获取当前日期

软件：mysql
函数：CURDATE()
解释：获取当前日期
例子：SELECT CURDATE()
结果：2017-12-15
以上结果为mysql系统中的日期的标准格式

软件：mysql
函数：CURRENT_DATE()
解释：获取当前日期
例子：SELECT CURRENT_DATE()
结果：2017-12-15
以上结果为mysql系统中的日期的标准格式

软件：python
函数：datetime.date.today()
解释：获取当前日期
例子：
import datetime
today = datetime.date.today()
print(today)
结果：2018-02-23

获取当前时间

软件：mysql
函数：CURRENT_TIME()
解释：获取当前时间
例子：SELECT CURRENT_TIME()
结果：17:54:22

软件：mysql
函数：curtime()
解释：获取当前时间
例子：select curtime();
结果：22:41:30

mysql中其他一样功能的函数
current_time()、current_time

软件：python
函数：time.strftime('%H:%M:%S')
解释：获取当前不含日期的时间
例子：
import time
current_time=time.strftime('%H:%M:%S')
print(current_time)
结果：14:37:18

软件：python
函数：datetime.strftime('%H:%M:%S')
解释：获取当前不含日期的时间
例子：
import datetime
now=datetime.datetime.now()
current_time=now.strftime('%H:%M:%S')
print(current_time)
结果：14:43:30

获得当前 UTC 日期时间

utc_date(), utc_time(), utc_timestamp()

获取本月最后一天（第一天，下月第一天）

软件：mysql
函数：LAST_DAY()
解释：获取本月最后一天
例子：SELECT LAST_DAY(20121231)
结果：2012-12-31
例子：SELECT LAST_DAY(201212)
结果：2012-12-31
例子：select DATE_ADD(curdate(),interval -day(curdate())+1 day);   --获取本月第一天
结果：2017-12-01
例子：select date_add(curdate()-day(curdate())+1,interval 1 month); -- 获取下个月的第一天
结果：2018-01-01
例子：select DATEDIFF(date_add(curdate()-day(curdate())+1,interval 1 month ),DATE_ADD(curdate(),interval -day(curdate())+1 day)) from dual; --获取当前月的天数
结果：31

计算前n天、后n天的时间

软件：python
函数：datetime.timedelta(days=n)
解释：计算前n天、后n天的日期时间
例子：
import datetime
dt = datetime.datetime.now()
yesterday=(dt-datetime.timedelta(days=1)).strftime('%Y-%m-%d %H:%M:%S')
tomorrow=(dt+datetime.timedelta(days=1)).strftime('%Y-%m-%d %H:%M:%S')
print(dt)
print(yesterday)
print(tomorrow)
结果：
2018-02-23 14:26:32.555246
2018-02-22 14:26:32
2018-02-24 14:26:32

软件：mysql
函数：TIMESTAMPADD(interval,int_expr,datetime_expr)
解释：interval是时间的单位，如MINUTE，DAY;int_expr是设置的时间差，可以是负数；datetime_expr是起始时间
例子：
select TIMESTAMPADD(MINUTE,8820,'2012-08-24 09:00:00');  
结果：
+-------------------------------------------------+  
| TIMESTAMPADD(MINUTE,8820,'2012-08-24 09:00:00') |  
+-------------------------------------------------+  
| 2012-08-30 12:00:00                             |   
+-------------------------------------------------+  
1 row in set (0.00 sec)  

计算前n天、后n天的日期

软件：python
函数：datetime.timedelta(days=n)
解释：计算前n天、后n天的日期
例子：
import datetime
today = datetime.date.today()
yesterday=today-datetime.timedelta(days=1)
tomorrow=today+datetime.timedelta(days=1)
print(today)
print(yesterday)
print(tomorrow)
结果：
2018-02-23
2018-02-22
2018-02-24

计算时间差

软件：mysql
函数：TIMESTAMPDIFF(interval,datetime_expr1,datetime_expr2)
解释：返回日期或日期时间表达式datetime_expr1 和datetime_expr2the 之间的整数差。其结果的单位由interval 参数给出。该参数必须是以下值的其中一个：
    FRAC_SECOND：表示间隔是毫秒
    SECOND：秒
    MINUTE：分钟
    HOUR：小时
    DAY：天
    WEEK：星期
    MONTH：月
    QUARTER：季度
    YEAR：年
例子：
select TIMESTAMPDIFF(day,'2012-08-24','2012-08-30');   
结果：
+----------------------------------------------+  
| TIMESTAMPDIFF(day,'2012-08-24','2012-08-30') |  
+----------------------------------------------+  
|                                            6 |   
+----------------------------------------------+
select TIMESTAMPDIFF(MINUTE,'2012-08-24 09:00:00','2012-08-30 12:00:00');  
+-------------------------------------------------------------------+  
| TIMESTAMPDIFF(MINUTE,'2012-08-24 09:00:00','2012-08-30 12:00:00') |  
+-------------------------------------------------------------------+  
|                                                              8820 |   
+-------------------------------------------------------------------+  

更改为指定的字符串格式的日期

将当前时间并转换为指定日期格式

软件：mysql
函数：DATE_FORMAT(date,format);
解释：按照format对日期date进行格式化
例子：SELECT DATE_FORMAT(NOW(),'%Y%m%d');
结果： 20171225
例子：SELECT DATE_FORMAT(NOW(),'%Y-%m');
结果： 2017-12

方法:先转换为时间元组,然后转换为其他格式。

软件：python
函数：time.strftime(fmt);
解释：struct_time格式的日期时间换为指定的字符串格式的日期。
例子：
import time
nowStamp = int(time.time())  
timeTuple = time.localtime(nowStamp)
otherTime = time.strftime("%Y-%m-%d %H:%M:%S", timeTuple)
print(otherTime)
#结果为：2016-07-31 10:19:47

软件：python
函数：datetime.strftime(format);
解释：datetime对象转换为指定的字符串格式的日期。
例子：
import datetime
now = datetime.datetime.now()
otherTime = now.strftime("%Y-%m-%d %H:%M:%S")
print(otherTime)
#结果为：2016-07-31 10:21:45

**将时间格式字符串转换为指定日期格式 **

软件：python
函数：datetime.datetime(struct_time);
解释：struct_time格式的日期时间转换成标准的日期时间。
例子：
import datetime
s1='20120125'
a=time.strptime(s1,'%Y%m%d')
a_datetime=datetime.datetime(*a[:6])
print(a_datetime)
结果： 2012-01-25 00:00:00

方法:先转换为时间元组,然后转换为其他格式。

软件：python
函数：time.strftime(fmt);
解释：struct_time格式的日期时间换为指定的字符串格式的日期。
例子：
import time
thisTime = "2016-07-31 12:12:12"
timeTuple = time.strptime(thisTime, "%Y-%m-%d %H:%M:%S")
otherTime = time.strftime("%Y/%m/%d %H:%M:%S", timeTuple)
print(otherTime)
#结果为：2016/07/31 12:12:12

软件：python
函数：datetime.strftime(format);
解释：datetime对象转换为指定的字符串格式的日期。
例子：
detester = '20170108T08:30:00'
dates = datetime.datetime.strptime(detester,'%Y%m%dT%H:%M:%S')
#print(dates.hour)
# # dates=datetime.datetime.now()
detester = dates.strftime('%Y-%m-%d %H:%M:%S')
print(detester)
#结果为：2017-01-08 08:30:00

将时间戳转换为指定的字符串格式的日期

方法：先将时间戳转换为时间元组，再转换为指定的字符串格式的日期。

软件：python
函数：time.strftime(fmt);
解释：将时间戳转换为指定的字符串格式的日期。
例子：
import time
timeStamp = 1469938332
timeTuple = time.localtime(timeStamp)
otherTime = time.strftime("%Y-%m-%d %H:%M:%S", timeTuple)
print(otherTime)
#结果为：2016-07-31 12:12:12

软件：python
函数：datetime. strftime (format);
解释：将时间戳转换为指定格式的日期。
例子：
import datetime
timeStamp = 1469938332
dt= datetime.datetime.utcfromtimestamp(timeStamp)#也可以使用datetime.fromtimestamp(timestamp[,tz])
otherTime = dt.strftime("%Y-%m-%d %H:%M:%S")
print(otherTime)
#结果为：2016-07-31 04:12:12

字符串转换成日期

软件：python
函数：strptime(string, format);
解释：将指定的格式化符时间字符串转换成数组形式的时间。
例子：
import time
s1='20120125'
a=time.strptime(s1,'%Y%m%d')
print(a)
结果： time.struct_time(tm_year=2012, tm_mon=1, tm_mday=25, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=2, tm_yday=25, tm_isdst=-1)

将字符串格式的日期转换为时间戳

方法：先将其转换为时间元组，再转换为时间戳。

软件：python
函数：time.mktime(timeTuple);
解释：将struct_time转换为时间戳。
例子：
import time
thisTime = "2016-07-31 12:12:12"
timeTuple = time.strptime(thisTime, "%Y-%m-%d %H:%M:%S")
timeStamp = int(time.mktime(timeTuple))
print(timeStamp)
#结果： 1469938332

如果想单独使用python中的datetime模块转换为时间戳，则只能使用timedelta进行换算

时间序列操作

时间序列操作请参考pandas中关于时间序列的内容