内容如题

原因：solaris等os不能做时间的运算处理，个人爱好。之前用c实现了一版，这里再次用python实现一版，后期应该还有改进版

改进：1 代码优化

         2 添加了指定获取月份最后一天的功能

        第四版：

            添加了-d选项，-d date date_format，既可以指定时间字符串和时间格式，格式可以不指定默认为 %Y%m%d或%Y-%m-%d

        第五版：

            1 修进了一些bug

            2 把入口函数添加到类中，方便其他python的调用，而不是单纯的脚本

        第六版：

            在类中使用了初始化函数，方便调用，可以在初始化函数中直接设置需要输入的参数，而不必对内部变量作出设置

         
第七版：

            修改了-d参数从对时间戳的支持，例：-d “
1526606217
” “%s”

代码核心：
核心函数
    datetime.datetime.replace()
    calendar.monthrange()
    datetime.timedelta()
核心思想：
    不指定-l参数，不获取计算后月份天数的最大值，既不获取月份最后一天
    月份加减主要是考虑当前日期天对比计算后的月份最大日期，如果大于计算后的日期天数，则在月份数+1，在日期天数上面替换为当前日期天数减去计算后的月份天数。例如：当前：2018-01-31，月份+1的话是2月，但是2月没有31号，所以计算和的结果为2018-03-03，既月份+1为3，日期为31-28为3。
    指定-l参数和不指定-l参数的不同点，在于月份的计算，指定-l参数则不会计算当前日期大于计算后的日期天数再次对月份和日期计算。例如，2018-01-31，不指定-l，月份+1，则结果会是2018-03-03，指定-l的结果则是2018-02-28。指定-l则是单纯的在月份+1.

点击(此处)折叠或打开

1. #!/usr/bin/env python
   
2. # _*_coding:utf–8_*_
3. # Auth by raysuen
4. # version v7.0
7. import datetime
8. import time
9. import calendar
10. import sys
11. import re
14. # 时间计算的类
15. class DateColculation(object):
16.     rdate = {
17.         “time_tuple”: time.localtime(),
18.         “time_format”: “%Y-%m-%d %H:%M:%S %A”,
19.         “colculation_string”: None,
20.         “last_day”: False,
21.         “input_time”: None,
22.         “input_format”: None
23.     }
24.     def __init__(self,time_tuple=None,out_format=None,col_string=None,isLastday=None,in_time=None,in_format=None):
25.         if time_tuple != None:
26.             self.rdate[“time_tuple”] = time_tuple
27.         if out_format != None:
28.             self.rdate[“time_format”] = out_format
29.         if col_string != None:
30.             self.rdate[“colculation_string”] = col_string
31.         if isLastday != None:
32.             self.rdate[“last_day”] = isLastday
33.         if in_time != None:
34.             self.rdate[“input_time”] = in_time
35.         if in_format != None:
36.             self.rdate[“input_format”] = in_format
37.     # 月计算的具体实现函数
38.     def __R_MonthAdd(self, col_num, add_minus, lastday, time_truct):
39.         R_MA_num = 0 # 记录计算的月的数字
40.         R_ret_tuple = None # 返回值，None或者时间元组
41.         R_MA_datetime = None # 临时使用的datetime类型
42.         if type(col_num) != int: # 判断传入的参数是否为数字
43.             print(“the parameter type is wrong!”)
44.             exit(5)
45.         if time_truct == None:
46.             R_MA_datetime = datetime.datetime.now() # 获取当前时间
47.         else:
48.             R_MA_datetime = datetime.datetime.fromtimestamp(time.mktime(time_truct))
50.         if add_minus.lower() == “add”: # 判断是否为+
51.             R_MA_num = R_MA_datetime.month + col_num
52.             if R_MA_num > 12: # 判断相加后的月份数是否大于12，如果大于12，需要在年+1
53.                 while R_MA_num > 12:
54.                     R_MA_datetime = R_MA_datetime.replace(year=R_MA_datetime.year + 1)
55.                     R_MA_num = R_MA_num – 12
56.                 R_ret_tuple = self.__days_add(R_MA_datetime, R_MA_num, lastday).timetuple()
57.             else:
58.                 R_ret_tuple = self.__days_add(R_MA_datetime, R_MA_num, lastday).timetuple()
59.         elif add_minus.lower() == “minus”: # 判断是否为–
60.             while col_num >= 12: # 判断传入的参数是否大于12，如果大于12则对年做处理
61.                 R_MA_datetime = R_MA_datetime.replace(year=R_MA_datetime.year – 1)
62.                 col_num = col_num – 12
63.             # R_MA_num = 12 + (R_MA_datetime.month – col_num) # 获取将要替换的月份的数字
65.             if R_MA_datetime.month – col_num < 0: # 判断当前月份数字是否大于传入参数(取模后的)，小于0表示，年需要减1，并对月份做处理
66.                 if R_MA_datetime.day > calendar.monthrange(R_MA_datetime.year – 1, R_MA_datetime.month)[
67.                     1]: # 如果年减一后，当前日期的天数大于年减一后的天数，则在月份加1，天变更为当前日期天数减变更后的月份天数
68.                     R_MA_datetime = R_MA_datetime.replace(year=R_MA_datetime.year – 1, month=R_MA_datetime.month + 1,
69.                                                           day=(R_MA_datetime.day >
70.                                                                calendar.monthrange(R_MA_datetime.year – 1,
71.                                                                                    R_MA_datetime.month)[1])) # 年减1
72.                 else:
73.                     R_MA_datetime = R_MA_datetime.replace(year=R_MA_datetime.year – 1) # 年减1
74.                 R_MA_datetime = self.__days_add(R_MA_datetime, 12 – abs(R_MA_datetime.month – col_num), lastday)
75.             elif R_MA_datetime.month – col_num == 0: # 判断当前月份数字是否等于传入参数(取模后的)，等于0表示，年减1，月份替换为12，天数不变(12月为31天，不可能会存在比31大的天数)
76.                 R_MA_datetime = R_MA_datetime.replace(year=R_MA_datetime.year – 1, month=12)
77.             elif R_MA_datetime.month – col_num > 0: # 默认表示当前月份–传入参数(需要减去的月数字)大于0，不需要处理年
78.                 R_MA_datetime = self.__days_add(R_MA_datetime, R_MA_datetime.month – col_num, lastday)
79.             R_ret_tuple = R_MA_datetime.timetuple()
80.         return R_ret_tuple # 返回时间元组
82.     def __days_add(self, formal_MA_datetime, formal_MA_num, lastday):
83.         R_MA_datetime = formal_MA_datetime
84.         R_MA_num = formal_MA_num
85.         if lastday: # 如果计算月最后一天，则直接把月份替换，天数为月份替换后的最后一天
86.             R_MA_datetime = R_MA_datetime.replace(month=R_MA_num,
87.                                                   day=calendar.monthrange(R_MA_datetime.year, R_MA_num)[
88.                                                       1]) # 月份替换，天数为替换月的最后一天
89.         else:
90.             if R_MA_datetime.day > \
91.                     calendar.monthrange(R_MA_datetime.year, R_MA_num)[
92.                         1]: # 判断当前日期的天数是否大于替换后的月份天数，如果大于，月份在替换后的基础上再加1，天数替换为当前月份天数减替换月份天数
93.                 R_MA_datetime = R_MA_datetime.replace(month=R_MA_num + 1,
94.                                                       day=R_MA_datetime.day –
95.                                                           calendar.monthrange(R_MA_datetime.year, R_MA_num)[
96.                                                               1]) # 月份在替换月的数字上再加1，天数替换为当前月份天数减替换月份天数
97.             else:
98.                 R_MA_datetime = R_MA_datetime.replace(month=R_MA_num) # 获取替换月份，day不变
100.         return R_MA_datetime
102.     # 月计算的入口函数
103.     def R_Month_Colculation(self, R_ColStr, lastday, time_truct):
104.         R_ret_tuple = None
106.         if R_ColStr.find(“-“) != –1: # 判断–是否存在字符串
107.             col_num = R_ColStr.split(“-“)[–1].strip() # 获取需要计算的数字
108.             if col_num.strip().isdigit(): # 判断获取的数字是否为正整数
109.                 R_ret_tuple = self.__R_MonthAdd(int(col_num.strip()), “minus”, lastday, time_truct) # 获取tuple time时间格式
110.             else: # 如果获取的数字不为正整数，则退出程序
111.                 print(“Please enter right format symbol!!”)
112.                 print(“If you don’t kown what values is avalable,please use -h to get help!”)
113.                 exit(4)
114.         elif R_ColStr.find(“+”) != –1: # 判断+是否存在字符串
115.             col_num = R_ColStr.split(“+”)[–1].strip() # 获取需要计算的数字
116.             if col_num.strip().isdigit(): # 判断获取的数字是否为正整数
117.                 R_ret_tuple = self.__R_MonthAdd(int(col_num.strip()), “add”, lastday, time_truct) # 获取tuple time时间格式
118.             else:
119.                 print(“Please enter right format symbol!!”)
120.                 print(“If you don’t kown what values is avalable,please use -h to get help!”)
121.                 exit(4)
122.         return R_ret_tuple
124.     # 天计算的实现函数
125.     def R_Day_Colculation(self, R_ColStr, time_truct):
126.         R_ret_tuple = None
128.         if time_truct == None: # 判断是否指定了输入时间，没指定则获取当前时间，否则使用指定的输入时间
129.             R_Datatime = datetime.datetime.now()
130.         else:
131.             R_Datatime = datetime.datetime.fromtimestamp(time.mktime(time_truct))
133.         if R_ColStr.find(“-“) != –1: # 判断–是否存在字符串
134.             col_num = R_ColStr.split(“-“)[–1].strip() # 获取需要计算的数字
135.             if col_num.strip().isdigit(): # 判断获取的数字是否为正整数
136.                 R_ret_tuple = (R_Datatime + datetime.timedelta(
137.                     –int(col_num.strip()))).timetuple() # 获取tuple time时间格式
138.             else: # 如果获取的数字不为正整数，则退出程序
139.                 print(“Please enter right format symbol!!”)
140.                 print(“If you don’t kown what values is avalable,please use -h to get help!”)
141.                 exit(4)
142.         elif R_ColStr.find(“+”) != –1: # 判断+是否存在字符串
143.             col_num = R_ColStr.split(“+”)[–1].strip() # 获取需要计算的数字
144.             if col_num.strip().isdigit(): # 判断获取的数字是否为正整数
145.                 R_ret_tuple = (R_Datatime + datetime.timedelta(
146.                     int(col_num.strip()))).timetuple() # 获取tuple time时间格式
147.             else:
148.                 print(“Please enter right format symbol!!”)
149.                 print(“If you don’t kown what values is avalable,please use -h to get help!”)
150.                 exit(4)
151.         return R_ret_tuple
153.     # 周计算的实现函数
154.     def R_Week_Colculation(self, R_ColStr, time_truct):
155.         R_ret_tuple = None
157.         if time_truct == None: # 判断是否指定了输入时间，没指定则获取当前时间，否则使用指定的输入时间
158.             R_Datatime = datetime.datetime.now()
159.         else:
160.             R_Datatime = datetime.datetime.fromtimestamp(time.mktime(time_truct))
162.         if R_ColStr.find(“-“) != –1: # 判断–是否存在字符串
163.             col_num = R_ColStr.split(“-“)[–1].strip() # 获取需要计算的数字
164.             if col_num.strip().isdigit(): # 判断获取的数字是否为正整数
165.                 R_ret_tuple = (R_Datatime + datetime.timedelta(
166.                     weeks=–int(col_num.strip()))).timetuple() # 获取tuple time时间格式
167.             else: # 如果获取的数字不为正整数，则退出程序
168.                 print(“Please enter right format symbol!!”)
169.                 print(“If you don’t kown what values is avalable,please use -h to get help!”)
170.                 exit(4)
171.         elif R_ColStr.find(“+”) != –1: # 判断+是否存在字符串
172.             col_num = R_ColStr.split(“+”)[–1].strip() # 获取需要计算的数字
173.             if col_num.strip().isdigit(): # 判断获取的数字是否为正整数
174.                 R_ret_tuple = (R_Datatime + datetime.timedelta(
175.                     weeks=int(col_num.strip()))).timetuple() # 获取tuple time时间格式
176.             else:
177.                 print(“Please enter right format symbol!!”)
178.                 print(“If you don’t kown what values is avalable,please use -h to get help!”)
179.                 exit(4)
180.         return R_ret_tuple
182.     # 年计算的实现函数
183.     def R_Year_Colculation(self, R_ColStr, time_truct):
184.         R_ret_tuple = None
186.         if time_truct == None: # 判断是否指定了输入时间，没指定则获取当前时间，否则使用指定的输入时间
187.             R_Y_Datatime = datetime.datetime.now()
188.         else:
189.             R_Y_Datatime = datetime.datetime.fromtimestamp(time.mktime(time_truct))
191.         if R_ColStr.find(“-“) != –1: # 判断–是否存在字符串
192.             col_num = R_ColStr.split(“-“)[–1].strip() # 获取需要计算的数字
193.             if col_num.strip().isdigit(): # 判断获取的数字是否为正整数
194.                 # 判断当前时间是否为闰年并且为二月29日，如果是相加/减后不为闰年则在月份加1，日期加1
195.                 if calendar.isleap(
196.                         R_Y_Datatime.year) and R_Y_Datatime.month == 2 and R_Y_Datatime.day == 29 and calendar.isleap(
197.                         R_Y_Datatime.year – int(col_num.strip())) == False:
198.                     R_ret_tuple = (
199.                     R_Y_Datatime.replace(year=R_Y_Datatime.year – int(col_num.strip()), month=R_Y_Datatime.month + 1,
200.                                          day=1)).timetuple() # 获取tuple time时间格式
201.                 else:
202.                     R_ret_tuple = (
203.                         R_Y_Datatime.replace(
204.                             year=R_Y_Datatime.year – int(col_num.strip()))).timetuple() # 获取tuple time时间格式
205.             else: # 如果获取的数字不为正整数，则退出程序
206.                 print(“Please enter right format symbol!!”)
207.                 print(“If you don’t kown what values is avalable,please use -h to get help!”)
208.                 exit(4)
209.         elif R_ColStr.find(“+”) != –1: # 判断+是否存在字符串
210.             col_num = R_ColStr.split(“+”)[–1].strip() # 获取需要计算的数字
211.             if col_num.strip().isdigit(): # 判断获取的数字是否为正整数
212.                 # 判断当前时间是否为闰年并且为二月29日，如果是相加/减后不为闰年则在月份加1，日期加1
213.                 if calendar.isleap(
214.                         R_Y_Datatime.year) and R_Y_Datatime.month == 2 and R_Y_Datatime.day == 29 and calendar.isleap(
215.                     R_Y_Datatime.year + col_num.strip()) == False:
216.                     R_ret_tuple = (
217.                         R_Y_Datatime.replace(year=R_Y_Datatime.year – int(col_num.strip()),
218.                                              month=R_Y_Datatime.month + 1, day=1)).timetuple() # 获取tuple time时间格式
219.                 else:
220.                     R_ret_tuple = (
221.                         R_Y_Datatime.replace(
222.                             year=R_Y_Datatime.year + int(col_num.strip()))).timetuple() # 获取tuple time时间格式
223.             else:
224.                 print(“Please enter right format symbol!!”)
225.                 print(“If you don’t kown what values is avalable,please use -h to get help!”)
226.                 exit(4)
227.         return R_ret_tuple
229.     # 获取月的最后一天
230.     def R_Month_lastday(self, time_tuple):
231.         R_MA_datetime = datetime.datetime.fromtimestamp(time.mktime(time_tuple)) # time_tuple
232.         R_MA_datetime = R_MA_datetime.replace(day=(calendar.monthrange(R_MA_datetime.year, R_MA_datetime.month)[1]))
233.         return R_MA_datetime.timetuple()
236.     def R_colculation(self):
237.         ret_tupletime = None
238.         ColStr = self.rdate[“colculation_string”]
239.         lastday = self.rdate[“last_day”]
240.         input_time = None
242.         if ColStr != None:
243.             if type(ColStr) != str:
244.                 print(“Please enter right format symbol!!”)
245.                 print(“If you don’t kown what values is avalable,please use -h to get help!”)
246.                 exit(3)
247.             if (ColStr.find(“-“) != –1) and (ColStr.find(“+”) != –1):
248.                 print(“Please enter right format symbol!!”)
249.                 print(“If you don’t kown what values is avalable,please use -h to get help!”)
250.                 exit(3)
252.         if self.rdate[“input_time”] != None:
253.             if self.rdate[“input_format”] == None:
254.                 i = 1
255.                 while 1:
256.                     try:
257.                         if i < 2:
258.                             input_time = time.strptime(self.rdate[“input_time”], “%Y%m%d”)
259.                         else:
260.                             input_time = time.strptime(self.rdate[“input_time”], “%Y-%m-%d”)
261.                         break
262.                     except ValueError as e:
263.                         if i < 2:
264.                             i+=1
265.                             continue
266.                         print(“The input time and format do not match.”)
267.                         exit(98)
269.             elif self.rdate[“input_format”] == “%s”:
270.                 if self.rdate[“input_time”].isdigit():
271.                     input_time = time.localtime(int(self.rdate[“input_time”]))
272.                 else:
273.                     print(“The input time must be number.”)
274.                     exit(97)
275.             else:
276.                 try:
277.                     input_time = time.strptime(self.rdate[“input_time”], self.rdate[“input_format”])
278.                 except ValueError as e:
279.                     print(“The input time and format do not match.”)
280.                     exit(98)
282.         if lastday:
283.             if ColStr == None:
284.                 if input_time != None:
285.                     ret_tupletime = self.R_Month_lastday(input_time)
286.                 else:
287.                     ret_tupletime = self.R_Month_lastday(time.localtime())
288.             # day的计算
289.             elif ColStr.strip().lower().find(“day”) != –1: # 判断是否传入的字符串中是否存在day关键字
290.                 ret_tupletime = self.R_Month_lastday(self.R_Day_Colculation(ColStr.strip().lower(), input_time))
292.             # month的计算
293.             elif ColStr.strip().lower().find(“month”) != –1: # 判断是否传入的字符串中是否存在day关键字
294.                 ret_tupletime = self.R_Month_lastday(self.R_Month_Colculation(ColStr.strip().lower(), lastday, input_time))
295.             # week的计算
296.             elif ColStr.strip().lower().find(“week”) != –1: # 判断是否传入的字符串中是否存在day关键字
297.                 ret_tupletime = self.R_Month_lastday(self.R_Week_Colculation(ColStr.strip().lower(), input_time))
298.             # year的计算
299.             elif ColStr.strip().lower().find(“year”) != –1: # 判断是否传入的字符串中是否存在day关键字
300.                 ret_tupletime = self.R_Month_lastday(self.R_Year_Colculation(ColStr.strip().lower(), input_time))
302.             else:
303.                 print(“Please enter right format symbol of -c.”)
304.                 print(“If you don’t kown what values is avalable,please use -h to get help!”)
305.                 exit(3)
306.         else:
307.             if ColStr == None:
308.                 if self.rdate[“input_time”] != None:
309.                     ret_tupletime = input_time
310.                 else:
311.                     ret_tupletime = time.localtime()
312.             # day的计算
313.             elif ColStr.strip().lower().find(“day”) != –1: # 判断是否传入的字符串中是否存在day关键字
314.                 ret_tupletime = self.R_Day_Colculation(ColStr.strip().lower(), input_time)
316.             # month的计算
317.             elif ColStr.strip().lower().find(“month”) != –1: # 判断是否传入的字符串中是否存在day关键字
318.                 ret_tupletime = self.R_Month_Colculation(ColStr.strip().lower(), lastday, input_time)
319.             # week的计算
320.             elif ColStr.strip().lower().find(“week”) != –1: # 判断是否传入的字符串中是否存在day关键字
321.                 ret_tupletime = self.R_Week_Colculation(ColStr.strip().lower(), input_time)
322.             # year的计算
323.             elif ColStr.strip().lower().find(“year”) != –1: # 判断是否传入的字符串中是否存在day关键字
324.                 ret_tupletime = self.R_Year_Colculation(ColStr.strip().lower(), input_time)
326.             else:
327.                 print(“Please enter right format symbol of -c.”)
328.                 print(“If you don’t kown what values is avalable,please use -h to get help!”)
329.                 exit(3)
331.         return ret_tupletime
334. def func_help():
335.     print(“”“
     
336.     NAME:
337.         rdate –display date and time
338.     SYNOPSIS:
339.         rdate [-f] [time format] [-c] [colculation format] [-d] [input_time] [input_time_format]
340.     DESCRIPTION:
342.         -c: value is day/week/month/year,plus +/-,plus a number which is number to colculate
344.         -l: obtain a number which is last day of month
346.         -d:
347.             input_time: enter a time string
348.             input_time_format: enter a time format for input time,default %Y%m%d or %Y-%m-%d
350.         -f:
352.          %A is replaced by national representation of the full weekday name.
353.          %a is replaced by national representation of the abbreviated weekday name.
354.          %B is replaced by national representation of the full month name.
355.          %b is replaced by national representation of the abbreviated month name.
356.          %C is replaced by (year / 100) as decimal number; single digits are preceded by a zero.
357.          %c is replaced by national representation of time and date.
358.          %D is equivalent to “%m/%d/%y”.
359.          %d is replaced by the day of the month as a decimal number (01-31).
360.          %E* %O*
361.                 POSIX locale extensions. The sequences %Ec %EC %Ex %EX %Ey %EY %Od %Oe %OH %OI %Om %OM %OS %Ou %OU %OV %Ow %OW %Oy are supposed to provide alternate
362.                 representations.
363.                 Additionally %OB implemented to represent alternative months names (used standalone, without day mentioned).
364.          %e is replaced by the day of the month as a decimal number (1-31); single digits are preceded by a blank.
365.          %F is equivalent to “%Y-%m-%d”.
366.          %G is replaced by a year as a decimal number with century. This year is the one that contains the greater part of the week (Monday as the first day of
367.                 the week).
368.          %g is replaced by the same year as in “%G”, but as a decimal number without century (00-99).
369.          %H is replaced by the hour (24-hour clock) as a decimal number (00-23).
370.          %h the same as %b.
371.          %I is replaced by the hour (12-hour clock) as a decimal number (01-12).
372.          %j is replaced by the day of the year as a decimal number (001-366).
373.          %k is replaced by the hour (24-hour clock) as a decimal number (0-23); single digits are preceded by a blank.
374.          %l is replaced by the hour (12-hour clock) as a decimal number (1-12); single digits are preceded by a blank.
375.          %M is replaced by the minute as a decimal number (00-59).
376.          %m is replaced by the month as a decimal number (01-12).
377.          %n is replaced by a newline.
378.          %O* the same as %E*.
379.          %p is replaced by national representation of either ante meridiem (a.m.) or post meridiem (p.m.) as appropriate.
380.          %R is equivalent to “%H:%M”.
381.          %r is equivalent to “%I:%M:%S %p”.
382.          %S is replaced by the second as a decimal number (00-60).
383.          %s is replaced by the number of seconds since the Epoch, UTC (see mktime(3)).
384.          %T is equivalent to “%H:%M:%S”.
385.          %t is replaced by a tab.
386.          %U is replaced by the week number of the year (Sunday as the first day of the week) as a decimal number (00-53).
387.          %u is replaced by the weekday (Monday as the first day of the week) as a decimal number (1-7).
388.          %V is replaced by the week number of the year (Monday as the first day of the week) as a decimal number (01-53). If the week containing January 1 has
389.                 four or more days in the new year, then it is week 1; otherwise it is the last week of the previous year, and the next week is week 1.
390.          %v is equivalent to “%e-%b-%Y”.
391.          %W is replaced by the week number of the year (Monday as the first day of the week) as a decimal number (00-53).
392.          %w is replaced by the weekday (Sunday as the first day of the week) as a decimal number (0-6).
393.          %X is replaced by national representation of the time.
394.          %x is replaced by national representation of the date.
395.          %Y is replaced by the year with century as a decimal number.
396.          %y is replaced by the year without century as a decimal number (00-99).
397.          %Z is replaced by the time zone name.
398.          %z is replaced by the time zone offset from UTC; a leading plus sign stands for east of UTC, a minus sign for west of UTC, hours and minutes follow with
399.                 two digits each and no delimiter between them (common form for RFC 822 date headers).
400.          %+ is replaced by national representation of the date and time (the format is similar to that produced by date(1)).
401.          %-* GNU libc extension. Do not do any padding when performing numerical outputs.
402.          %_* GNU libc extension. Explicitly specify space for padding.
403.          %0* GNU libc extension. Explicitly specify zero for padding.
404.          %% is replaced by `%’.
406.     EXAMPLE:
407.          rdate –2017-10-23 11:04:51 Monday
408.          rdate -f “%Y–%m_%d” –2017-10-23
     
409.          rdate -f “%Y–%m_%d” -c “day–3” –2017-10-20
     
410.          rdate -f “%Y–%m_%d” -c “day+3” –2017-10-26
     
411.          rdate -f “%Y–%m_%d” -c “month+3” –2017-7-23
     
412.          rdate -f “%Y–%m_%d” -c “year+3” –2020-7-23
     
413.          rdate -c “week – 1” -f “%Y–%m–%d %V” –2018-02-15 07
     
414.          rdate -c “day – 30” -f “%Y–%m–%d” -l –2018-01-31
     
415.          rdate -d “1972–01–31” “%Y–%m–%d” –1972-01-31 00:00:00 Monday
     
416.     ““”)
419. if __name__ == “__main__”:
420.     d1 = DateColculation()
421.     if len(sys.argv) > 1:
422.         i = 1
423.         while i < len(sys.argv):
424.             if sys.argv[i] == “-h”: # 判断输入的参数是否为–h,既获取帮助
425.                 func_help()
426.                 exit(0)
427.             elif sys.argv[i] == “-f”: # –f表示format,表示指定的输出时间格式
428.                 i = i + 1
429.                 if i >= len(sys.argv): # 判断–f的值的下标是否大于等于参数个数，如果为真则表示没有指定–f的值
430.                     print(“The value of -f must be specified!!!”)
431.                     exit(1)
432.                 elif sys.argv[i] == “-c”:
433.                     print(“The value of -f must be specified!!!”)
434.                     exit(1)
435.                 elif re.match(“^-“, sys.argv[i]) != None: # 判断–f的值，如果–f的下个参数以–开头，表示没有指定–f值
436.                     print(“The value of -f must be specified!!!”)
437.                     exit(1)
438.                 d1.rdate[“time_format”] = sys.argv[i] # 获取输出时间格式
439.             elif sys.argv[i] == “-c”: # –c表示colculation,计算
440.                 i = i + 1
441.                 if i >= len(sys.argv): # 判断–f的值的下标是否大于等于参数个数，如果为真则表示没有指定–f的值
442.                     print(“The value of -c must be specified!!!”)
443.                     exit(2)
444.                 elif sys.argv[i] == “-f”:
445.                     print(“The value of -c must be specified!!!”)
446.                     exit(2)
447.                 elif (re.match(“^-“, sys.argv[i]) != None): # 判断–f的值，如果–f的下个参数以–开头，表示没有指定–f值
448.                     print(“The value of -c must be specified!!!”)
449.                     exit(2)
450.                 d1.rdate[“colculation_string”] = sys.argv[i] # 获取需要计算的字符串参数内容
451.             elif sys.argv[i] == “-d”: # –d date 表示指定输入的时间和输入的时间格式
452.                 i += 1
453.                 if i >= len(sys.argv): # 判断–d的值的下标是否大于等于参数个数，如果为真则表示没有指定–的值
454.                     print(“The value of -d must be specified!!!”)
455.                     exit(3)
456.                 elif (re.match(“^-“, sys.argv[i]) != None): # 判断–d的值，如果–df的下个参数以–开头，表示没有指定–df值
457.                     print(“The value of -c must be specified!!!”)
458.                     exit(3)
459.                 d1.rdate[“input_time”] = sys.argv[i]
460.                 if (i+1 < len(sys.argv) and re.match(“^-“, sys.argv[(i+1)]) == None):
461.                     d1.rdate[“input_format”] = sys.argv[i+1]
462.                     i+=1
463.             elif sys.argv[i] == “-l”: # –l表示获取月份的最后一天
464.                 d1.rdate[“last_day”] = True
465.             else:
466.                 print(“You must enter right parametr.”)
467.                 print(“If you don’t kown what values is avalable,please use -h to get help!”)
468.                 exit(3)
469.             i = i + 1
470.         d1.rdate[“time_tuple”] = d1.R_colculation() # 获取时间的元组，通过R_colculation函数，R_colculation参数为传入一个需要计算的时间字符串
471.         print(time.strftime(d1.rdate[“time_format”], d1.rdate[“time_tuple”]))
472.         exit(0)
473.     else: # 如果不输入参数，则输出默认格式化的本地时间
474.         print(time.strftime(d1.rdate[“time_format”], d1.rdate[“time_tuple”]))
475.         exit(0)