• 我的第一个python web开发框架(10)——工具函数包说明(一)


      PS:原先是想直接进入功能开发,要用到什么函数时再创建,这样也容易熟悉每个函数的由来和使用方法,但考虑到这样操作,到时会经常在不同文件间切换,不好描述,容易造成混乱,所以还是使用函数库这种方式来说明。

      下面来说说工具函数包,如果想要快速学会一个新的框架,首先要做的事情就是熟悉工具函数包,一方面,能快速知道有哪些基本功能可以直接调用,不用重复造轮子;另一方面,查看项目代码时,会比较快的进入角色,能看明白很多代码是做什么用的,因为工具函数包被调用的机率是最大的。

       那么怎么学习呢?当然是有节奏有计划的一步步深入了,我们可以从上到下逐个查看研究,通过查看代码,我们可以基本了解这个包有什么功能,但也仅仅是了解而已,想要真正掌握,必须要去使用它们,最直接的方法就是编写测试用例进行测试,这样就可以很快熟悉并掌握这些函数具体有什么功能与限制。

      PS:大家在学习工具函数,或其他封装好的类或函数时,在开始时不需要去知道它里面每一行代码是做什么用的,为什么要那么写,只需要知道输入什么参数会得出什么值就可以了,这就是大家所说的封装。我们要开汽车,不需要知道它是怎么造出来的,发动机是怎么运行的,只需要知道怎么操作(接口)就可以了。

       我以前遇到过几位爱钻牛角尖的开发者,想弄明白每一行代码为什么要那样写,当那一行所调用的函数看不懂时,就会再深入一层,看看它更底层是什么原理......就这样,一般人用几分钟就可以知道怎么用的,他花几天也弄不明白,花了好长时间也没法写代码。对于初学者来说,学习一个函数怎么使用,不要钻牛角尖,去研究它的内部是怎么运行的,要研究也要等到你以后精通了再说,不然你看到一个函数就去看它的源码,然后源码中又会调用其他库的源码,其他库的源码又会调用python的内核代码,难道你要搞定python的内核代码后才可以开始开发吗?你能搞的定python内核你就是超级大牛了,可以自己开发一种新语言出来了。

       所以说想要快速学习,最好的办法就是知道这个封装好的函数是干嘛的,它需要输入什么参数,会返回什么内容就已经够了。而最快的熟悉方法就是写单元测试,用你能想到的办法去测试,这样就知道什么时候出错,什么时候正常。

     

      熟悉相关工具函数:

      convert_helper.py是类型转换包,所有字符串转数值、字符串转日期、字符串日期转时间戳等各种类型转换函数,都可以放到这里来。

      1 #!/usr/bin/evn python
      2 # coding=utf-8
      3 
      4 import decimal
      5 import datetime
      6 
      7 
      8 #############################################
      9 # 数值型转换函数
     10 #############################################
     11 def to_int(text):
     12     """将字符串安全转换为int类型,转换失败时默认值为0"""
     13     try:
     14         return int(text)
     15     except:
     16         return 0
     17 
     18 
     19 def to_int0(text):
     20     """将字符串安全转换为int类型,当int值小于0时,返回0"""
     21     result = to_int(text)
     22 
     23     # 判断转换后的结果值是否小于0,是的话返回0
     24     if not result or result < 0:
     25         return 0
     26     else:
     27         return result
     28 
     29 
     30 def to_int1(text):
     31     """将字符串安全转换为int类型,当int值小于1时,返回1"""
     32     result = to_int(text)
     33 
     34     # 判断转换后的结果值是否小于1,是的话返回1
     35     if not result or result < 1:
     36         return 1
     37     else:
     38         return result
     39 
     40 
     41 def to_float(text):
     42     """将字符串安全转换为float类型"""
     43     try:
     44         return float(text)
     45     except:
     46         return 0.0
     47 
     48 
     49 def to_decimal(text):
     50     """将字符串安全转换为int类型"""
     51     try:
     52         return decimal.Decimal(text)
     53     except:
     54         return 0
     55 
     56 
     57 #############################################
     58 # 日期型转换函数
     59 #############################################
     60 def to_datetime(text):
     61     """字符串转时间"""
     62     if not text:
     63         return None
     64 
     65     # 定义字典根据时间字符串匹配不同的格式
     66     time_dict = {
     67         1: "%Y-%m-%d %H:%M:%S.%f",
     68         2: "%Y-%m-%d %H:%M",
     69         3: "%Y-%m-%d %H:%M:%S",
     70     }
     71     # 如果中间含有时间部分就用:判断
     72     try:
     73         if str(text).find('.') > -1:
     74             return datetime.datetime.strptime(text, time_dict[1])
     75         elif ':' in text:
     76             time_list = text.split(':')
     77             return datetime.datetime.strptime(text, time_dict[len(time_list)])
     78         else:
     79             return datetime.datetime.strptime(text, "%Y-%m-%d")
     80     except:
     81         return None
     82 
     83 
     84 def to_date(text):
     85     """字符串转日期"""
     86     d = to_datetime(text)
     87     if d:
     88         return d.date()
     89 
     90 
     91 def to_timestamp10(text):
     92     """将时间格式的字符串转化为长度为10位长度的时间戳"""
     93     d = to_datetime(text)
     94     if d:
     95         return int(d.timestamp())
     96     else:
     97         return 0
     98 
     99 
    100 def to_timestamp13(text):
    101     """将时间格式的字符串转化为长度为13位长度的时间戳"""
    102     d = to_datetime(text)
    103     if d:
    104         return int(d.timestamp() * 1000)
    105     else:
    106         return 0
    View Code

      比如说字符转int函数

    def to_int(text):
        """将字符串安全转换为int类型,转换失败时默认值为0"""
        try:
            return int(text)
        except:
            return 0

      这里我们用try...except...来捕捉转换函数出现的异常,当出现异常时我们设置它的默认值为0,让我们的系统变的更加健壮,不会因为转换失败而崩溃。

      使用这个函数转换出现异常时,我们只是直接将它转换为0,不做记录,因为数值转换时直接抛出异常会让用户体验更差劲,另外对于数值类型来说,如果得出的结果都是0而不是期望值,这也很容易排查出来,在后面章节会讲到web端接收到的请求值都会记录下来,方便我们排错。

    def to_int0(text):
        """将字符串安全转换为int类型,当int值小于0时,返回0"""
        result = to_int(text)
    
        # 判断转换后的结果值是否小于0,是的话返回0
        if not result or result < 0:
            return 0
        else:
            return result
    
    
    def to_int1(text):
        """将字符串安全转换为int类型,当int值小于1时,返回1"""
        result = to_int(text)
    
        # 判断转换后的结果值是否小于1,是的话返回1
        if not result or result < 1:
            return 1
        else:
            return result

      大家可能会奇怪,为什么要增加这两个多余的函数?事实上,这两个函数使用频率比前面那个会更高,因为我们在日常使用当中,经常会要求数值不能小于0或小于1,而to_int()函数转换时,用户如果输入了负数,虽然转换成功了,但这个值却不是我们想要的结果,如果每次都要加上一段代码对值进行判断,那会更加麻烦,所以进行了再次封装,多出来to_int0()和to_int()1两个函数。

      对这几个函数我们用unittest测试一下,看看结果。

      我们在test文件夹创建一个convert_helper_test.py文件,并编写测试代码,用来测试输入各种值,看看是否得到我们期望的值。(PS:使用debug运行时,光标在那个函数中,unittest就会运行那个测试函数,所以如果有多个测试函数要运行时,最好用鼠标点击一下main函数,即入口函数,再运行debug,这样全部测试函数都会运行到

    #!/usr/bin/evn python
    # coding=utf-8
    
    import datetime
    import unittest
    from common import convert_helper
    
    
    class ConvertHelperTest(unittest.TestCase):
        """转换操作包测试类"""
    
        def setUp(self):
            """初始化测试环境"""
            print('------ini------')
    
        def tearDown(self):
            """清理测试环境"""
            print('------clear------')
    
    def test_to_int(self):
            self.assertEqual(convert_helper.to_int('1'), 1)
            self.assertEqual(convert_helper.to_int('1.0'), 0)
            self.assertEqual(convert_helper.to_int('1a'), 0)
            self.assertEqual(convert_helper.to_int('aaa'), 0)
            self.assertEqual(convert_helper.to_int(''), 0)
            self.assertEqual(convert_helper.to_int(None), 0)
            self.assertEqual(convert_helper.to_int('-1'), -1)
            self.assertEqual(convert_helper.to_int(10), 10)
            self.assertEqual(convert_helper.to_int(-10), -10)
    
            self.assertEqual(convert_helper.to_int0('1'), 1)
            self.assertEqual(convert_helper.to_int0('1.0'), 0)
            self.assertEqual(convert_helper.to_int0('1a'), 0)
            self.assertEqual(convert_helper.to_int0('aaa'), 0)
            self.assertEqual(convert_helper.to_int0(''), 0)
            self.assertEqual(convert_helper.to_int0(None), 0)
            self.assertEqual(convert_helper.to_int0('-1'), 0)
            self.assertEqual(convert_helper.to_int0(10), 10)
            self.assertEqual(convert_helper.to_int0(-10), 0)
    
            self.assertEqual(convert_helper.to_int1('1'), 1)
            self.assertEqual(convert_helper.to_int1('1.0'), 1)
            self.assertEqual(convert_helper.to_int1('1a'), 1)
            self.assertEqual(convert_helper.to_int1('aaa'), 1)
            self.assertEqual(convert_helper.to_int1(''), 1)
            self.assertEqual(convert_helper.to_int1(None), 1)
            self.assertEqual(convert_helper.to_int1('-1'), 1)
            self.assertEqual(convert_helper.to_int1(10), 10)
            self.assertEqual(convert_helper.to_int1(-10), 1)
    
    
    if __name__ == '__main__':
        unittest.main()

      在这个单元测试中,我们使用的是python自带的unittest这个模块。

      这里我们调用了unittest的断言函数assertEqual(等于)来判断convert_helper包的to_int()、to_int0()、to_int1()函数的执行结果是否和我们设定的值一致

      通过测试可以看到,to_int系列函数的值是不一样的:

    输入值

    调用函数

    to_int()

    调用函数

    to_int0()

    调用函数

    to_int1()

    非数值型字符串 0 0 1
    -1 -1 0 1
    10 10 10 10

      unittest还有很多其他断言函数提供给我们使用,比如assertNotEqual(不等于)、assertGreaterEqual(大于等于)、assertGreater(大于)、assertAlmostEqual(约等于)、assertIsNotNone(不等于None)、assertIn(in)、assertNotIn(not in)、assertIs(is)、assertDictEqual(字典比较)、assertListEqual(列表比较)......还有好多其他类型的判断处理。

      使用单元测试除了上面所说的好处外,它还可以帮助我们实现自动化测试。比如说项目开发的过程中,有人修改了底层的这些工具函数,增加了新的判断处理,这可能只是一个小小的修改,大家都觉得不会有什么问题,但有可能这点小改动会造成灾难性的故障(我本人就试过,有些很小很小的改动,对多个合作客户调用的接口测试过也没有问题,可没想到遗漏了另外一个客户的测试,然后造成那个合作客户的用户访问都出现异常,无法从我的系统中读取到数据)。而有了这些已经实现了的自动化测试用例在,修改过或上线前,只需要简单的点一下运行,就可以帮我们对所有函数都进行全面的测试,帮我们及时找到可能出现的Bug。

      对于float类型数值和decimal类型数值,如果有需要,大家也可以自己去添加0或1最小值的判断。

      to_datetime()函数,会根据输入的日期字符串格式,转换成对应的日期(如:2017-09-01)、日期时间(2017-09-01 11:11)、日期时分秒(2017-09-01 11:11:11)、日期时分秒毫秒类型(2017-09-01 11:11:11.111),得到的值是datetime类型

      当然也可以直接使用打印输出结果的方式来进行测试,不过结果无法自动进行判断是否是我们期望的值

        def test_to_datetime(self):
            print('---test_to_datetime---')
            print(convert_helper.to_datetime(None))
            print(convert_helper.to_datetime(''))
            print(convert_helper.to_datetime('xxx'))
            print(convert_helper.to_datetime('2017-09-01'))
            print(convert_helper.to_datetime('2017-09-01 11:11'))
            print(convert_helper.to_datetime('2017-09-0111:11'))
            print(convert_helper.to_datetime('2017-09-01 11:11:11'))
            print(convert_helper.to_datetime('2017-09-01 11:11:11.111'))

      得到的结果是:

    ---test_to_datetime---
    None
    None
    None
    2017-09-01 00:00:00
    2017-09-01 11:11:00
    None
    2017-09-01 11:11:11
    2017-09-01 11:11:11.111000

       对于日期类的测试如果使用断言,我们通常要创建生成一个日期变量,然后在进行判断

            self.assertEqual(convert_helper.to_datetime(None), None)
            self.assertEqual(convert_helper.to_datetime(''), None)
            self.assertEqual(convert_helper.to_datetime('xxx'), None)
            result = datetime.datetime(2017, 9, 1)
            self.assertEqual(convert_helper.to_datetime('2017-09-01'), result)
            result = datetime.datetime(2017, 9, 1, 11, 11)
            self.assertEqual(convert_helper.to_datetime('2017-09-01 11:11'), result)
            self.assertEqual(convert_helper.to_datetime('2017-09-0111:11'), None)
            result = datetime.datetime(2017, 9, 1, 11, 11, 11)
            self.assertEqual(convert_helper.to_datetime('2017-09-01 11:11:11'), result)
            result = datetime.datetime(2017, 9, 1, 11, 11, 11, 111000)
            self.assertEqual(convert_helper.to_datetime('2017-09-01 11:11:11.111'), result)

      to_date()函数是用来将各种格式的日期字符串,转换为只含年月日(2017-09-01)的日期格式,具体大家使用代码测试一下就知道了

      to_timestamp10()函数是用来将各种格式的日期字符串,转换为长度为10位长度的时间戳

      to_timestamp13()函数是用来将各种格式的日期字符串,转换为长度为13位长度的时间戳

      具体这些测试例子,可下载文章后面的源码包查看了解

      下面我们来熟悉一下datetime_helper.py这个日期函数操作包,这个包里的函数类型主要有两大类,一种是日期类型转换,将日期类型格式化为字符串类型或转换为数值类型;另一种是对日期类型的比较或运算。

      先上代码:

     1 #!/usr/bin/evn python
     2 # coding=utf-8
     3 
     4 import time
     5 import datetime
     6 
     7 
     8 def to_date(dt):
     9     """将时间格式化为日期字符串"""
    10     if isinstance(dt, datetime.datetime):
    11         return dt.strftime('%Y-%m-%d')
    12     elif isinstance(dt, datetime.date):
    13         return dt.strftime('%Y-%m-%d')
    14     else:
    15         raise Exception("日期类型错误")
    16 
    17 
    18 def to_datetime(dt):
    19     """将时间格式化为日期时间字符串"""
    20     if isinstance(dt, datetime.datetime):
    21         return dt.strftime('%Y-%m-%d %H:%M:%S')
    22     elif isinstance(dt, datetime.date):
    23         return dt.strftime('%Y-%m-%d')
    24     else:
    25         raise Exception("日期类型错误")
    26 
    27 
    28 def to_number():
    29     """当前时间转换为年月日时分秒毫秒共10位数的字符串"""
    30     return datetime.datetime.now().strftime('%Y%m%d%H%M%S')
    31 
    32 
    33 def to_timestamp10():
    34     """获取当前时间长度为10位长度的时间戳"""
    35     return int(time.time())
    36 
    37 
    38 def to_timestamp13():
    39     """获取当前时间长度为13位长度的时间戳"""
    40     return int(time.time() * 1000)
    41 
    42 
    43 def timedelta(sign, dt, value):
    44     """
    45     对指定时间进行加减运算,几秒、几分、几小时、几日、几周、几月、几年
    46     sign: y = 年, m = 月, w = 周, d = 日, h = 时, n = 分钟, s = 秒
    47     dt: 日期,只能是datetime或datetime.date类型
    48     value: 加减的数值
    49     return: 返回运算后的datetime类型值
    50     """
    51     if not isinstance(dt, datetime.datetime) and not isinstance(dt, datetime.date):
    52         raise Exception("日期类型错误")
    53 
    54     if sign == 'y':
    55         year = dt.year + value
    56         if isinstance(dt, datetime.date):
    57             return datetime.datetime(year, dt.month, dt.day)
    58         elif isinstance(dt, datetime.datetime):
    59             return datetime.datetime(year, dt.month, dt.day, dt.hour, dt.minute, dt.second, dt.microsecond)
    60         else:
    61             return None
    62     elif sign == 'm':
    63         year = dt.year
    64         month = dt.month + value
    65         ### 如果月份加减后超出范围,则需要计算一下,对年份进行处理 ###
    66         # 如果月份加减后等于0时,需要特殊处理一下
    67         if month == 0:
    68             year = year - 1
    69             month = 12
    70         else:
    71             # 对年月进行处理
    72             year = year + month // 12
    73             month = month % 12
    74         if isinstance(dt, datetime.date):
    75             return datetime.datetime(year, month, dt.day)
    76         elif isinstance(dt, datetime.datetime):
    77             return datetime.datetime(year, month, dt.day, dt.hour, dt.minute, dt.second, dt.microsecond)
    78         else:
    79             return None
    80     elif sign == 'w':
    81         delta = datetime.timedelta(weeks=value)
    82     elif sign == 'd':
    83         delta = datetime.timedelta(days=value)
    84     elif sign == 'h':
    85         delta = datetime.timedelta(hours=value)
    86     elif sign == 'n':
    87         delta = datetime.timedelta(minutes=value)
    88     elif sign == 's':
    89         delta = datetime.timedelta(seconds=value)
    90     else:
    91         return None
    92 
    93     return dt + delta
    View Code

      to开头的函数都是时间类型转换函数(PS:convert_helper.py包里是对日期格式字符串转为时间类型,而datetime_helper.py里所有操作,都是对时间类型进行处理的,将它们转为其他格式)

      比如to_date()和to_datetime(),这两个函数分别是将时间类型格式化为年月日(2017-09-01)、年月日时分秒(2017-09-01 11:11:11)或数值字符串(20170901111111)

    def to_date(dt):
        """将时间格式化为日期字符串"""
        if isinstance(dt, datetime.datetime):
            return dt.strftime('%Y-%m-%d')
        elif isinstance(dt, datetime.date):
            return dt.strftime('%Y-%m-%d')
        else:
            raise Exception("日期格式错误")
    
    def to_datetime(dt):
        """将时间格式化为日期时间字符串"""
        if isinstance(dt, datetime.datetime):
            return dt.strftime('%Y-%m-%d %H:%M:%S')
        elif isinstance(dt, datetime.date):
            return dt.strftime('%Y-%m-%d')
        else:
            raise Exception("日期格式错误")
    
    def to_number():
        """将当前时间转换为年月日时分秒毫秒共14位数的字符串"""
        return datetime.datetime.now().strftime('%Y%m%d%H%M%S')

      而to_timestamp10()和to_timestamp13()是获取当前时间的时间戳

    def to_timestamp10():
        """获取当前时间长度为10位长度的时间戳"""
        return int(time.time())
    
    def to_timestamp13():
        """获取当前时间长度为13位长度的时间戳"""
        return int(time.time() * 1000)

      对这种输出类型的函数测试,我们测试时直接打印到控制台就可以了

      在test文件夹中创建datetime_helper_test.py文件,然后通过打印来查看各函数会输出什么值

    #!/usr/bin/evn python
    # coding=utf-8
    
    import datetime
    import unittest
    from common import datetime_helper
    
    
    class DatetimeHelperTest(unittest.TestCase):
        """日期函数操作包测试类"""
    
        def setUp(self):
            """初始化测试环境"""
            print('------ini------')
    
        def tearDown(self):
            """清理测试环境"""
            print('------clear------')
    
        def test(self):
            dt = datetime.datetime.now()
            print(datetime_helper.to_datetime(dt))
            print(datetime_helper.to_date(dt))
            print(datetime_helper.to_number())
            print(datetime_helper.to_timestamp10())
            print(datetime_helper.to_timestamp13())
    if __name__ == '__main__':
        unittest.main()

      运行后打印到控制台上的值:

    ------ini------
    2017-09-01 18:45:39
    2017-09-01
    20170901184539
    1504262739
    1504262739217
    ------clear------

      

     1 def timedelta(sign, dt, value):
     2     """
     3     对指定时间进行加减运算,几秒、几分、几小时、几日、几周、几月、几年
     4     sign: y = 年, m = 月, w = 周, d = 日, h = 时, n = 分钟, s = 秒
     5     dt: 日期,只能是datetime或datetime.date类型
     6     value: 加减的数值
     7     return: 返回运算后的datetime类型值
     8     """
     9     if not isinstance(dt, datetime.datetime) and not isinstance(dt, datetime.date):
    10         raise Exception("日期类型错误")
    11 
    12     if sign == 'y':
    13         year = dt.year + value
    14         if isinstance(dt, datetime.date):
    15             return datetime.datetime(year, dt.month, dt.day)
    16         elif isinstance(dt, datetime.datetime):
    17             return datetime.datetime(year, dt.month, dt.day, dt.hour, dt.minute, dt.second, dt.microsecond)
    18         else:
    19             return None
    20     elif sign == 'm':
    21         year = dt.year
    22         month = dt.month + value
    23         ### 如果月份加减后超出范围,则需要计算一下,对年份进行处理 ###
    24         # 如果月份加减后等于0时,需要特殊处理一下
    25         if month == 0:
    26             year = year - 1
    27             month = 12
    28         else:
    29             # 对年月进行处理
    30             year = year + month // 12
    31             month = month % 12
    32         if isinstance(dt, datetime.date):
    33             return datetime.datetime(year, month, dt.day)
    34         elif isinstance(dt, datetime.datetime):
    35             return datetime.datetime(year, month, dt.day, dt.hour, dt.minute, dt.second, dt.microsecond)
    36         else:
    37             return None
    38     elif sign == 'w':
    39         delta = datetime.timedelta(weeks=value)
    40     elif sign == 'd':
    41         delta = datetime.timedelta(days=value)
    42     elif sign == 'h':
    43         delta = datetime.timedelta(hours=value)
    44     elif sign == 'n':
    45         delta = datetime.timedelta(minutes=value)
    46     elif sign == 's':
    47         delta = datetime.timedelta(seconds=value)
    48     else:
    49         return None
    50 
    51     return dt + delta
    View Code

      timedelta()函数,它主要用于时间的加减运算,可以得出加减几秒、几分、几小时、几日、几周、几月、几年后的时间值是什么,这个函数在实际开发中使用频率还算是挺高的。

      PS:原datetime.timedelta函数没有对年和月的加减运算,对这个我进行了扩展,增加了年和月的加减计算

       def test_timedelta(self):
            print('---test_timedelta---')
            result = datetime.datetime(2018, 9, 1)
            print(result)
            self.assertEqual(datetime_helper.timedelta('y', datetime.datetime(2017, 9, 1), 1), result)
            result = datetime.datetime(2016, 9, 1)
            print(result)
            self.assertEqual(datetime_helper.timedelta('y', datetime.datetime(2017, 9, 1), -1), result)
            result = datetime.datetime(2018, 3, 1)
            print(result)
            self.assertEqual(datetime_helper.timedelta('m', datetime.datetime(2017, 9, 1), 6), result)
            result = datetime.datetime(2017, 3, 1)
            print(result)
            self.assertEqual(datetime_helper.timedelta('m', datetime.datetime(2017, 9, 1), -6), result)
            result = datetime.datetime(2017, 3, 1)
            print(result)
            self.assertEqual(datetime_helper.timedelta('m', datetime.datetime(2017, 9, 1), -6), result)
            result = datetime.datetime(2017, 9, 8)
            print(result)
            self.assertEqual(datetime_helper.timedelta('w', datetime.datetime(2017, 9, 1), 1), result)
            result = datetime.datetime(2017, 8, 25)
            print(result)
            self.assertEqual(datetime_helper.timedelta('w', datetime.datetime(2017, 9, 1), -1), result)
            result = datetime.datetime(2017, 9, 2)
            print(result)
            self.assertEqual(datetime_helper.timedelta('d', datetime.datetime(2017, 9, 1), 1), result)
            result = datetime.datetime(2017, 8, 31)
            print(result)
            self.assertEqual(datetime_helper.timedelta('d', datetime.datetime(2017, 9, 1), -1), result)
            result = datetime.datetime(2017, 9, 1, 1)
            print(result)
            self.assertEqual(datetime_helper.timedelta('h', datetime.datetime(2017, 9, 1), 1), result)
            result = datetime.datetime(2017, 8, 31, 23)
            print(result)
            self.assertEqual(datetime_helper.timedelta('h', datetime.datetime(2017, 9, 1), -1), result)
            result = datetime.datetime(2017, 9, 1, 0, 1)
            print(result)
            self.assertEqual(datetime_helper.timedelta('n', datetime.datetime(2017, 9, 1), 1), result)
            result = datetime.datetime(2017, 8, 31, 23, 59)
            print(result)
            self.assertEqual(datetime_helper.timedelta('n', datetime.datetime(2017, 9, 1), -1), result)
            result = datetime.datetime(2017, 9, 1, 0, 0, 1)
            print(result)
            self.assertEqual(datetime_helper.timedelta('s', datetime.datetime(2017, 9, 1), 1), result)
            result = datetime.datetime(2017, 8, 31, 23, 59, 59)
            print(result)
            self.assertEqual(datetime_helper.timedelta('s', datetime.datetime(2017, 9, 1), -1), result)

       运行后打印到控制台上的值:

    ------ini------
    ---test_timedelta---
    2018-09-01 00:00:00
    2016-09-01 00:00:00
    2018-03-01 00:00:00
    2017-03-01 00:00:00
    2017-03-01 00:00:00
    2017-09-08 00:00:00
    2017-08-25 00:00:00
    2017-09-02 00:00:00
    2017-08-31 00:00:00
    2017-09-01 01:00:00
    2017-08-31 23:00:00
    2017-09-01 00:01:00
    2017-08-31 23:59:00
    2017-09-01 00:00:01
    2017-08-31 23:59:59
    ------clear------

      本文对应的源码下载

     

    版权声明:本文原创发表于 博客园,作者为 AllEmpty 本文欢迎转载,但未经作者同意必须保留此段声明,且在文章页面明显位置给出原文连接,否则视为侵权。

    python开发QQ群:669058475(本群已满)、733466321(可以加2群)    作者博客:http://www.cnblogs.com/EmptyFS/

  • 相关阅读:
    Multithread 之 synchronous
    【转】windows exe文件加载
    Transparent 之 SetLayeredWindowAttributes
    任意目录运行vs2005 tools
    【转】volatile
    Qt1命令行编译
    初识Qt
    typedef使用一
    Qthello
    源文件包含源文件
  • 原文地址:https://www.cnblogs.com/EmptyFS/p/7615752.html
Copyright © 2020-2023  润新知