之所以来起逻辑上集体模块的。datetime模块用于是date和time模块的合集。

1、定义

datetime模块用于是date和time模块的合集,datetime有些许个常量,MAXYEAR与MINYEAR,分别是9999与1.

模块:用来起逻辑上集体python(变量,函数,类,逻辑:实现一个力量)代码,本质就是.py结尾的python文件(文件称:test.py,对应的模块名test)

datetime模块定义了5单近乎,分别是

保险:用来打逻辑上组织模块的,本质就是一个目录(必须带__init__.py文件)

1.datetime.date:表示日期的好像

2、导入方法

2.datetime.datetime:表示日期时之近乎

import
module_name

3.datetime.time:表示时间的接近

import
module1_name,module2_name

4.datetime.timedelta:表示时间间隔,即有限独时间点的间距

from module_name
import *

5.datetime.tzinfo:时区的相关消息

from module_alex
import logger as logger_alex   ”’给模块里面的方式起别名”’

无异于、首先看一下datetime.date类:

3、import本质

date类有三单参数,datetime.date(year,month,day),返回year-month-day

导入模块的本来面目就是是拿Python文件说明一方方面面

方法:

导入包的实质就是是执行该包下的__init__.py文件

1.datetime.date.ctime(),返回格式如 Sun Apr 16 00:00:00 2017

__file__目前文件之文书称

2.datetime.date.fromtimestamp(timestamp),根据加的时戮,返回一个date对象;datetime.date.today()作用一样

4、导入优化

3.datetime.date.isocalendar():返回格式如(year,month,day)的元组,(2017,
15, 6)

5、模块的归类

4.datetime.date.isoformat():返回格式如YYYY-MM-DD

 
a.标准库(内置模块)

5.datetime.date.isoweekday():返回给定日期的星期(0-6),星期一=0,星期日=6

 b.开源模块

6.datetime.date.replace(year,month,day):替换给定日期,但不改动原先日期

 c.自定义模块

7.datetime.date.strftime(format):把日子时本给定的format进行格式化。

 
os模块学习实例链接:http://www.3fwork.com/b204/001543MYM018744/

8.datetime.date.timetuple():返回日期对应的time.struct_time对象

time和datetime模块

  time.struct_time(tm_year=2017, tm_mon=4, tm_mday=15, tm_hour=0,
tm_min=0, tm_sec=0, tm_wday=5, tm_yday=105, tm_isdst=-1)

    time模块

9.datetime.date.weekday():返回日期的周日

   
时间表示形式:”2016-7-18
12:50:36″(格式化的字符串表示方法);2.日子穿表示法,time.time()(1500415601.3417745),从1970年交今日的秒数;3)元组(struct_time)共九单元素。由于python的time模块实现主要调用C库,所以各个平台或截然不同。元组形式如下:(time.struct_time(tm_year=2017,
tm_mon=7, tm_mday=19, tm_hour=6, tm_min=9, tm_sec=0, tm_wday=2,
tm_yday=200, tm_isdst=0)

python中时日期格式化符号:

   
在Python中,通常发生立几乎栽艺术来代表时间:1)时间戳 2)格式化的日子字符串
3)元组(struct_time)共九独因素。由于Python的time模块实现重大调用C库,所以各个平台或截然不同。

%y 两员数之岁表示(00-99)

    UTC(Coordinated
Universal
Time
,世界和谐时)亦即格林威治天文时间,世界标准日。在中国吧UTC+8。DST(Daylight
Saving Time)即夏令时。

%Y 四个数的年份表示(000-9999)

   
时间穿(timestamp)的法门:通常来说,时间戳表示的是从1970年1月1日00:00:00初步以秒计算的偏移量。我们运行“type(time.time())”,返回的凡float类型。返回时戳方式的函数主要有time(),clock()等。

%m 月份(01-12)

   
元组(struct_time)方式:struct_time元组共有9独元素,返回struct_time的函数主要出gmtime(),localtime(),strptime()。下面列出这种方法元组中的几乎独要素:

%d 月内被的一样天(0-31)

(time.struct_time(tm_year=2017,
tm_mon=7, tm_mday=19, tm_hour=6, tm_min=9, tm_sec=0, tm_wday=2,
tm_yday=200, tm_isdst=0)

%H 24小时制小时数(0-23)

 

%I 12小时制小时数(01-12)

索引(Index) 属性(Attribute) 值(Values)
1  tm_year(年)  比如2011 
2  tm_mon(月)  1 – 12
3  tm_mday(日)  1 – 31
4  tm_hour(时)  0 – 23
5  tm_min(分)  0 – 59
6  tm_sec(秒)  0 – 61
7  tm_wday(weekday)  0 – 6(0表示周一)
8  tm_yday(一年中的第几天)  1 – 366
9  tm_isdst(是否是夏令时)  默认为-1

%M 分钟数(00=59)

 

%S 秒(00-59)

   time模块

 

    year (including
century, e.g. 1998)
      month (1-12)
      day (1-31)
      hours (0-23)
      minutes (0-59)
      seconds (0-59)
      weekday (0-6, Monday is 0)     0代表星期一
      Julian day (day in the year, 1-366)
      DST (Daylight Savings Time) flag (-1, 0 or 1)

%a 本地简化星期名称

    timezone —
difference in seconds between UTC and local standard time

%A 本地完整星期名称

   
返回市区的秒数

%b 本地简化的月名称

    >>>
time.timezone
    -28800

%B 本地完整的月份名称

    altzone —
difference in  seconds between UTC and local DST time
    daylight — whether local time should reflect DST

%c 本地相应的日子表示和日表示

    是否利用夏令时
    tzname — tuple of (standard time zone name, DST time zone name)

%j 年内的同样天(001-366)

    Functions:
    
    (1)time() — return current time in seconds since the Epoch as a
float  
  

%p 本地A.M.或P.M.的等价符

   
返时岁月之时日穿。

%U 一年遭受的星期数(00-53)星期天呢星期的开

    >>>
time.time()
  1500418020.8217583

%w 星期(0-6),星期天啊星期的初步

   
下面来拘禁一个例,运用time.time()来算函数运行的年月,如下:

%W 一年被的星期数(00-53)星期一致呢星期的开端

 

%x 本地相应的日期表示

import time
def calc(first_num,second_num,stop_num):
    '''递归计算斐波那契数列'''
    if first_num == 0:
        print(first_num,second_num)
    third_num = first_num + second_num
    if third_num < stop_num:
        print(third_num)
        calc(second_num,third_num,stop_num)

def calc_time():
    '''计算calc()函数运行的时间'''
    start_time = time.time()
    calc(0,1,10)
    stop_time = time.time()
    run_time = stop_time - start_time
    print(run_time)

calc_time()

%X 本地相应的时空代表

 

%Z 当前时区的名称

    运行结果如下:

%% %号本身

 

 

  0 1
  1
  2
  3
  5
  8
  0.00010323524475097656

二、看一下datetime的time类

   
从者运行结果可以见到,程序运行的进度还是挺快的,不交均等秒时就运行出来了。

time类有5个参数,datetime.time(hour,minute,second,microsecond,tzoninfo),返回08:29:30

   
返回时时的流年戳,其实就算是时空之秒数表示形式,可以为此来算一个程序执行的日,如下:

1.datetime.time.replace()

    (2)clock() — return CPU time since process start as a
float 
     

2.datetime.time.strftime(format):按照format格式返回时

   
这个要留意,在不同的体系上意义不同。在UNIX系统上,它回到的凡“进程时”,它是因此秒表示的浮点数(时间穿)。而当WINDOWS中,第一不行调用,返回的是经过运行的其实时间。而第二蹩脚之后的调用是由第一涂鸦调用以后到本的周转时。(实际上是坐WIN32高达QueryPerformanceCounter()为根基,它于毫秒表示进一步可靠)

3.datetime.time.tzname():返回时区名字

    (3)sleep() — delay for a number of seconds given as a float   

4.datetime.time.utcoffset():返回时区的时日偏移量

   
线程推迟指定的日子运作。单位也秒

 

    

三、datetime的datetime类

import time
def calc(arg1,arg2):
    start_time = time.time()
    arg3 = arg1 + arg2
    time.sleep(3)
    stop_time = time.time()
    run_time = stop_time - start_time
    print(run_time)

calc(1,2)
运行结果如下:
3.00310945510864

datetime类有成百上千参数,datetime(year, month, day[, hour[, minute[,
second[, microsecond[,tzinfo]]]]]),返回年月日,时分秒

 

datetime.datetime.ctime()

   
上面程序就算是当程序中插了time.sleep(3)让程序休眠了3秒,可以见到运行时长增加了,因而当我们写代码的时光,可以加上一些sleep(),给你们老板,完了你们老板说好缓缓,你说优化一下,把sleep()删除,完了次真的快了,你们老板对君刮目相看(今天凡是愚人节)。

datetime.datetime.now().date():返回时日子时之日子有

    (4)gmtime() — convert seconds since Epoch to UTC tuple        

datetime.datetime.now().time():返回时日子时之岁月有些

   
暨localtime()方法类似,gmtime()方法是拿一个时戳转换为UTC时区(0时区)的struct_time。

datetime.datetime.fromtimestamp()

    >>>
time.gmtime()
  time.struct_time(tm_year=2017, tm_mon=7, tm_mday=19,
tm_hour=12, tm_min=46, tm_sec=12, tm_wday=2, tm_yday=200,
tm_isdst=0)
   
gmtime()是回来UTC时区的正儿八经日,我们国家是于东八区,因此会面晚8独时区。

datetime.datetime.now():返回时系统时

   
gmtime()如果无参数,默认是当前系统时,转换为UTC标准日

datetime.datetime.replace()

    def gmtime(seconds=None): # real signature unknown;
restored from __doc__
    ”””

datetime.datetime.strftime():由日期格式转化为字符串格式

    gmtime([seconds]) -> (tm_year, tm_mon, tm_mday,
tm_hour, tm_min,
    tm_sec,
tm_wday, tm_yday, tm_isdst)

  datetime.datetime.now().strftime(‘%b-%d-%Y %H:%M:%S’)
  ’Apr-16-2017 21:01:35′

    Convert
seconds since the Epoch to a time tuple expressing UTC (a.k.a.
    GMT). When
‘seconds’ is not passed in, convert the current time instead.

datetime.datetime.strptime():由字符串格式转化为日期格式

    If the
platform supports the tm_gmtoff and tm_zone, they are available as
    attributes
only.
    ”””
    pass
    (5)localtime() — convert seconds since Epoch to local time
tuple

datetime.datetime.strptime('Apr-16-2017 21:01:35', '%b-%d-%Y %H:%M:%S')
2017-04-16 21:01:35

    def localtime(seconds=None): # real signature unknown;
restored from __doc__
    ”””

 四、datetime的timedelta类

    localtime([seconds]) ->
(tm_year,tm_mon,tm_mday,tm_hour,tm_min,

datetime.datetime.timedelta用于计算两单日子中的差值,例如:

    tm_sec,tm_wday,tm_yday,tm_isdst)

>>> a=datetime.datetime.now()
>>> b=datetime.datetime.now()
>>> a
datetime.datetime(2017, 4, 16, 21, 21, 20, 871000)
>>> b
datetime.datetime(2017, 4, 16, 21, 21, 29, 603000)

    Convert
seconds since the Epoch to a time tuple expressing local time.
    When ‘seconds’
is not passed in, convert the current time instead.
    ”””
    pass

>>> b-a
datetime.timedelta(0, 8, 732000)
>>> (b-a).seconds
8

   
用一个时刻戳转换为即时区的struct_time。secs参数不供,则坐目前岁月为仍

或者

   
time.localtime()是易为地方时间的元组表示形式

time1 = datetime.datetime(2016, 10, 20)
time2 = datetime.datetime(2015, 11, 2)

"""计算天数差值"""
print(time1-time2).days

"""计算两个日期之间相隔的秒数"""
print (time1-time2).total_seconds()

    >>>
time.localtime()
  time.struct_time(tm_year=2017, tm_mon=7, tm_mday=19,
tm_hour=21, tm_min=18, tm_sec=17, tm_wday=2, tm_yday=200,
tm_isdst=0)
    提取时间的法门:

 

class struct_time(builtins.tuple)
 |  The time value as returned by gmtime(), localtime(), and strptime(), and
 |  accepted by asctime(), mktime() and strftime().  May be considered as a
 |  sequence of 9 integers.
 |  
 |  Note that several fields' values are not the same as those defined by
 |  the C language standard for struct tm.  For example, the value of the
 |  field tm_year is the actual year, not year - 1900.  See individual
 |  fields' descriptions for details.
 |  
 |  Method resolution order:
 |      struct_time
 |      builtins.tuple
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __reduce__(...)
 |      helper for pickle
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  tm_gmtoff
 |      offset from UTC in seconds
 |  
 |  tm_hour
 |      hours, range [0, 23]
 |  
 |  tm_isdst
 |      1 if summer time is in effect, 0 if not, and -1 if unknown
 |  
 |  tm_mday
 |      day of month, range [1, 31]
 |  
 |  tm_min
 |      minutes, range [0, 59]
 |  
 |  tm_mon
 |      month of year, range [1, 12]
 |  
 |  tm_sec
 |      seconds, range [0, 61])
 |  
 |  tm_wday
 |      day of week, range [0, 6], Monday is 0
 |  
 |  tm_yday
 |      day of year, range [1, 366]
 |  
 |  tm_year
 |      year, for example, 1993
 |  
 |  tm_zone
 |      abbreviation of timezone name
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  n_fields = 11
 |  
 |  n_sequence_fields = 9
 |  
 |  n_unnamed_fields = 0
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.tuple:
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __getnewargs__(...)
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.n
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __rmul__(self, value, /)
 |      Return self*value.
 |  
 |  count(...)
 |      T.count(value) -> integer -- return number of occurrences of value
 |  
 |  index(...)
 |      T.index(value, [start, [stop]]) -> integer -- return first index of value.
 |      Raises ValueError if the value is not present.

None

   
    (6)asctime() — convert time tuple to string

def asctime(p_tuple=None): # real signature unknown; restored from __doc__
    """
    asctime([tuple]) -> string

    Convert a time tuple to a string, e.g. 'Sat Jun 06 16:26:11 1998'.
    When the time tuple is not present, current time as returned by localtime()
    is used.
    """
    return ""

    把一个表示时间之元组或者struct_time表示为这种样式:‘Sun Jun 20 23:21:05 1993’。如果无参数,将见面以time.localtime()作为参数传入。

    >>>
x_time = time.localtime()
  >>> x_time.tm_year   
#领取年,这个属于属性,而无是方式,tm_year是元组时间的一个性能
  2017
    >>> x_time.tm_min     #分钟数
  26
    >>> x_time.tm_yday   #当年底第几天
  200
    >>> x_time.tm_mday   #当月底第几上
  19
     
    (7)ctime() — convert time in seconds to string 

   
把一个岁月戳(按秒计算的浮点数)转化为time.asctime()的款型。如果参数不受要也None的时光,将会默认time.time()为参数。它的作用相当给time.asctime(time.localtime(secs))。

    >>>
time.ctime()
    ‘Wed Jul 19 22:01:29 2017’

    (8)mktime() — convert local time tuple to seconds since
Epoch

   
将一个struct_time转化为时间戳

   
将元组形式之岁月转发为秒的岁月穿,如下所示:

    >>> x =
time.localtime()
  >>> x
  time.struct_time(tm_year=2017, tm_mon=7, tm_mday=19,
tm_hour=21, tm_min=36, tm_sec=17, tm_wday=2, tm_yday=200,
tm_isdst=0)

  >>> time.mktime(x)
  1500471377.0

    (9)strftime() — convert time tuple to string according to format
specification

   
把一个象征时的元组或者struct_time(如出于time.localtime()和time.gmtime()返回)转化为格式化的时刻字符串。如果t未指定,将盛传time.localtime()。如果元组中其他一个因素越界,ValueError的缪将会见于撇下来。

 

def strftime(format, p_tuple=None): # real signature unknown; restored from __doc__
    """
    strftime(format[, tuple]) -> string

    Convert a time tuple to a string according to a format specification.
    See the library reference manual for formatting codes. When the time tuple
    is not present, current time as returned by localtime() is used.

    Commonly used format codes:

    %Y  Year with century as a decimal number.
    %m  Month as a decimal number [01,12].
    %d  Day of the month as a decimal number [01,31].
    %H  Hour (24-hour clock) as a decimal number [00,23].
    %M  Minute as a decimal number [00,59].
    %S  Second as a decimal number [00,61].
    %z  Time zone offset from UTC.
    %a  Locale's abbreviated weekday name.
    %A  Locale's full weekday name.
    %b  Locale's abbreviated month name.
    %B  Locale's full month name.
    %c  Locale's appropriate date and time representation.
    %I  Hour (12-hour clock) as a decimal number [01,12].
    %p  Locale's equivalent of either AM or PM.

    Other codes may be available on your platform.  See documentation for
    the C library strftime function.
    """
    return ""

 

格式 含义 备注
%a 本地(locale)简化星期名称  
%A 本地完整星期名称  
%b 本地简化月份名称  
%B 本地完整月份名称  
%c 本地相应的日期和时间表示  
%d 一个月中的第几天(01 – 31)  
%H 一天中的第几个小时(24小时制,00 – 23)  
%I 第几个小时(12小时制,01 – 12)  
%j 一年中的第几天(001 – 366)  
%m 月份(01 – 12)  
%M 分钟数(00 – 59)  
%p 本地am或者pm的相应符
%S 秒(01 – 61)
%U 一年中的星期数。(00 – 53星期天是一个星期的开始。)第一个星期天之前的所有天数都放在第0周。
%w 一个星期中的第几天(0 – 6,0是星期天)
%W 和%U基本相同,不同的是%W以星期一为一个星期的开始。  
%x 本地相应日期  
%X 本地相应时间  
%y 去掉世纪的年份(00 – 99)  
%Y 完整的年份  
%Z 时区的名字(如果不存在为空字符)  
%% ‘%’字符  

    时间变的个简写格式:

    %Y  Year with
century as a decimal number.
    %m  Month as a decimal number [01,12].
    %d  Day of the month as a decimal number [01,31].
    %H  Hour (24-hour clock) as a decimal number [00,23].
    %M  Minute as a decimal number [00,59].
    %S  Second as a decimal number [00,61].
    %z  Time zone offset from UTC.
    %a  Locale’s abbreviated weekday name.
    %A  Locale’s full weekday name.
    %b  Locale’s abbreviated month name.
    %B  Locale’s full month name.
    %c  Locale’s appropriate date and time representation.
    %I  Hour (12-hour clock) as a decimal number [01,12].
    %p  Locale’s equivalent of either AM or PM.

    (10)strptime() — parse string to time tuple according to format
specification

   
把一个格式化时间字符串转化为struct_time。实际上它与strftime()是逆操作。

def strptime(string, format): # real signature unknown; restored from __doc__
    """
    strptime(string, format) -> struct_time

    Parse a string to a time tuple according to a format specification.
    See the library reference manual for formatting codes (same as
    strftime()).

    Commonly used format codes:

    %Y  Year with century as a decimal number.
    %m  Month as a decimal number [01,12].
    %d  Day of the month as a decimal number [01,31].
    %H  Hour (24-hour clock) as a decimal number [00,23].
    %M  Minute as a decimal number [00,59].
    %S  Second as a decimal number [00,61].
    %z  Time zone offset from UTC.
    %a  Locale's abbreviated weekday name.
    %A  Locale's full weekday name.
    %b  Locale's abbreviated month name.
    %B  Locale's full month name.
    %c  Locale's appropriate date and time representation.
    %I  Hour (12-hour clock) as a decimal number [01,12].
    %p  Locale's equivalent of either AM or PM.

    Other codes may be available on your platform.  See documentation for
    the C library strftime function.
    """
    return struct_time

def time(): # real signature unknown; restored from __doc__
    """
    time() -> floating point number

    Return the current time in seconds since the Epoch.
    Fractions of a second may be present if the system clock provides them.
    """
    return 0.0

 

 

 

  (11)tzset() —
change the local timezone

   
亿万先生官方网站: 1

    datetime模块   
(http://www.jb51.net/article/77981.htm)

   
Python提供了多只放置模块用于操作日期时,像calendar,time,datetime。time模块我以前面的稿子已有介绍,它提供的接口及C标准库time.h基本一致。相比于time模块,datetime模块的接口则更直观、更便于调用。

   
1、datetime中寓三单类date ,time,datetime
函数datetime.combine(date,time)可以获取dateime,datetime.date()、datetime.time()可以收获date和time。

    2.datetime
time与sting的转化

   
今天就是来讲讲datetime模块

    1、datetime模块定义了点儿独常量:datetime.MINYEAR和datetime.MAXYEAR,分别表示datetime所能代表的最好
小、最深东。其中,MINYEAR = 1,MAXYEAR = 9999。

   
2.datetime模块定义了下就几乎单近乎:

   (1)datetime.date:表示日期的切近。常用之习性有year,month,day;

  
(2)datetime.time:表示时间之类似。常用的性能有hour,minute,second,microsecond;

   (3)datetime.datetime:表示日期时

   (4)datetime.timedelta:表示时间间隔,即有限独时间点之间的尺寸;

   (5)datetime.tzinfo:与时区有关的连锁消息

 

 

   
注:上面这些品种的对象是不可变(immutable)的。

   
下面详细介绍这些看似以方式。

   
一、date类

   
date类表示一个日期。日期由年、月、日结(地球人且了解)。date类的构造函数如下:

    class
datetime.date(year,month,day):参数的意思就未多作解释了,只是立刻几乎碰而顾一下: 

    >>> today
= datetime.date(2017,5,16)
  >>> print(type(today),today)
  <class ‘datetime.date’> 2017-05-16
    datetime.date(year,month,day是怪成一个日子的接近。

    (1)year的限制是[MINYEAR, MAXYEAR],即[1,
9999];

    (2)、month的限量是[1,
12]。(月份是打1开头之,不是从0开始的~_~);**

    (3)、day的顶深价值根据加的year,
month参数来控制。例如闰年2月份产生29上;**

   
date类定义了有的常用之好像措施及类属性,方便我们操作:

   (1)、date.max、date.min:date对象所能够表示的卓绝酷、最小日期;

    >>>
datetime.date.max
  datetime.date(9999, 12, 31)
  >>> datetime.date.min
  datetime.date(1, 1, 1)
    最特别时是:9999-12-31,最小时间是:1-1-1

    (2)、date.resolution:date对象表示日期的最好小单位。这里是天。

    >>>
datetime.date.resolution
  datetime.timedelta(1)
    从者可以见到,日期最小之表示单位凡:天。

    (3)、date.today():返回一个象征即当地日期的date对象;

    >>>
datetime.date.today()
  datetime.date(2017, 7, 19)

   
datetime.date.today()返回当天之日期,类似于Excel函数中的today()函数。

    (4)、date.fromtimestamp(timestamp):根据加的时戮,返回一个date对象;
    date.fromtimestamp(timestamp):根据加的时空戮,返回一个date对象;

    import
time,datetime
    >>>
datetime.date.fromtimestamp(int(time.mktime(time.localtime())))
  datetime.date(2017, 7, 19)

   
将一个日子戳转化为date()对象,fromtimestamp(timestamp)

    (5)**datetime.fromordinal(ordinal):**将Gregorian日历时间转移为date对象;(Gregorian
Calendar
:一栽日历表示方法,类似于我国之阴历,西方国家行使比较多,此处不详细展开讨论。)

   
date提供的实例方法和性质:

    (1)**date.year、date.month、date.day:年、月、日;**

    >>> import datetime,time
  >>> dated = datetime.date(2017,8,19)
  >>> dated.year
  2017
  >>> dated.month
  8
  >>> dated.day
  19

   
上面例子中,我们定义了一个日期,并且了解了哪些提取日期的年、月、日,date.year,date.month,date.day,这些还是日期的习性,而非是道,因而不需要加括号。

    (2)date.replace(year, month,
day):生成一个初的日子对象,用参数指定的年景,月,日代替原有对象被之习性。(原有对象仍保持不换)**

     >>>
dated.replace(year = 2016)
  datetime.date(2016, 8, 19)

  >>>
dated.replace(year=2013,month=4,day=2)
  datetime.date(2013, 4, 2)

   
上面,我们得以行使date.replace()来转日期的情,但是里面凡是键值对,指明你只要改的凡year,month,day中之哇一个。

    (3)date.timetuple():返回日期对应的time.struct_time对象;**

    def timetuple(self):
    ”Return local
time tuple compatible with time.localtime().”
    return
_build_struct_time(self._year, self._month, self._day,
    0, 0,
0, -1)

    >>> x =
datetime.date.timetuple(datetime.date.today())
  >>> print(x)
  time.struct_time(tm_year=2017, tm_mon=7, tm_mday=20, tm_hour=0,
tm_min=0, tm_sec=0, tm_wday=3, tm_yday=201, tm_isdst=-1)
   
可以看看,date.timetuple()返回的凡一个元组形式之日子,struct_time,参数是一个日子格式的,date.timetuple(datetime.date)

    (4)**date.toordinal():返回日期对应的Gregorian
Calendar日期;**

    >>>
datetime.date.toordinal(datetime.date.today())
  736530

    (5)date.weekday():返回weekday,如果是星期一,返回0;如果是星期2,返回1,以此类推;**

    >>>
datetime.date.weekday(datetime.date.today())
  3

   
date.weekday()是精打细算星期的,按照国外的方式,0是一律宏观之首先上(周一),3意味周四。

    (6)**data.isoweekday():返回weekday,如果是星期一,返回1;如果是星期2,返回2,以此类推;**

    >>>
datetime.date.isoweekday(datetime.date.today())
  4
   
date.isoweekday()就是咱们东方人习惯的日期方式,与date.weekday()错开一龙。

    (7)date.isocalendar():返回格式如(year,month,day)的元组;**

    >>>
date.isocalendar(date.today())
  (2017, 29, 4)

    (8)**date.isoformat():返回格式如’YYYY-MM-DD’的字符串;**

    >>>
date.isoformat(date.today())
  ’2017-07-20′

   
date.isoformat()返回一个日期形式之字符串。

    (9)date.strftime(fmt):自定义格式化字符串。在脚详细讲解.

    >>> now =
date(2010,4,6)
  >>> tomorrow = now.replace(day=7)
  >>> print(“now:”,now,”tomorrow:”,tomorrow)
  now: 2010-04-06 tomorrow: 2010-04-07
  >>> print(“timetuple()”,now.timetuple())
  timetuple() time.struct_time(tm_year=2010, tm_mon=4, tm_mday=6,
tm_hour=0, tm_min=0, tm_sec=0, tm_wday=1,       tm_yday=96,
tm_isdst=-1)
  >>> print(“weekday():”,now.weekday())
  weekday(): 1
  >>> print(“isoweekday():”,now.isoweekday())
  isoweekday(): 2
  >>> print(“isocalendar():”,now.isocalendar())
  isocalendar(): (2010, 14, 2)
  >>> print(“isoformat():”,now.isoformat())
  isoformat():
2010-04-06

   
date还对一些操作进行了重载,它同意我们针对日期进行如下一些操作:

    (1)date2 =
date1 + timedelta  #
日期加上一个距离,返回一个新的日子对象(timedelta将于下面介绍,表示时间距离);**

**    (2)date2 = date1 – timedelta   #
日期隔去间隔,返回一个新的日子对象;**

**    (3)timedelta = date1 – date2   #
两独日子相减,返回一个工夫间隔对象**

**    (4)date1 < date2  #
两单日子进行比较**

    注:
对日期进行操作时,要防止日期过其所能代表的范围。
  使用例子:

    >>> now = date.today()
  >>> tomorrow =
now.replace(day=22)
  >>> delta = tomorrow –
now
  >>>
print(“now:”,now,”tomorrow:”,tomorrow)
  now: 2017-07-20 tomorrow:
2017-07-22
  >>>
print(“timedelta:”,delta)
  timedelta: 2 days,
0:00:00
    >>> print(now+delta)
  2017-07-22
  >>> print(tomorrow>now)
  True**
   
二、Time类**

**   
**time类表示时间,由时、分、秒和微秒组成。time类的构造函数如下:

    class
datetime.time(hour[ , minute[ , second[ , microsecond[ , tzinfo] ]
] ] )
:各参数的意思不作讲,这里留意一下参数tzinfo,它意味着时区信息。注意一下各国参数的取值范围:hour的克也[0,
24),minute的界定吗[0, 60),second的限制也[0,
60),microsecond的限定吗[0,
1000000)。

   
 time类定义的类属性:

    (1)t**ime.min、time.max:time类所能够表示的卓绝小、最酷日子。其中,time.min
= time(0, 0, 0, 0), time.max = time(23, 59, 59,
999999);**

    >>> time.min
  datetime.time(0, 0)
  >>> time.max
  datetime.time(23, 59, 59, 999999)

    (2)time.resolution:时间的最好小单位,这里是1微秒;**

    >>>
time.resolution
  datetime.timedelta(0, 0, 1)

   
time类提供的实例方法以及特性:

    (1)time.hour、time.minute、time.second、time.microsecond:时、分、秒、微秒;**

**    (2)time.tzinfo:时区信息;**

**    (3)time.replace([ hour[ , minute[ , second[ ,
microsecond[ , tzinfo] ] ] ] ]
):创建一个初的时对象,用参数指定的时**

**、分、秒、微秒代替本来对象被之习性(原有对象仍保持不转换);**

**    (4)time.isoformat():返回型如”HH:MM:SS”格式的字符串表示;**

**    (5)time.strftime(fmt):返回从定义格式化字符串。在底下详细介绍;**

from datetime import *
tm = time(23, 46, 10) 
print 'tm:', tm 
print 'hour: %d, minute: %d, second: %d, microsecond: %d' \ 
    % (tm.hour, tm.minute, tm.second, tm.microsecond) 
tm1 = tm.replace(hour = 20) 
print 'tm1:', tm1 
print 'isoformat():', tm.isoformat() 

# # ---- 结果 ---- 
# tm: 23:46:10 
# hour: 23, minute: 46, second: 10, microsecond: 0 
# tm1: 20:46:10 
# isoformat(): 23:46:10 

 

   
像date一样,也得针对少独time对象进行比较,或者相减返回一个时空间隔对象。这里就是不提供例子了。

   
三、datetime类

   
datetime是date与time的结合体,包括date与time的有着信息。它的构造函数如下:datetime.datetime
(year, month, day[ , hour[ , minute[ , second[ , microsecond[ ,
tzinfo] ] ] ] ]
),各参数的意思和date、time的构造函数中之同,要小心参数值的限定。

   
datetime类定义之类属性与法:

    **(1)**datetime.min、datetime.max:datetime所能代表的无比小值与最酷价值;**

    >>> datetime.min
  datetime.datetime(1, 1, 1, 0, 0)
  >>> datetime.max
  datetime.datetime(9999, 12, 31, 23, 59, 59, 999999)

    (2)datetime.resolution:datetime最小单位;**

    >>>
datetime.resolution
  datetime.timedelta(0, 0, 1)

    (3)datetime.today():返回一个象征目前当地时间之datetime对象;**

    >>>
datetime.today()
  datetime.datetime(2017, 7, 20, 6, 49, 21,
928607)

    (4)datetime.now([tz]):返回一个意味着手上地面时间的datetime对象,如果提供了参数tz,则抱tz参数所指时区的当地时间;**

    >>>
datetime.now()

  datetime.datetime(2017, 7, 20, 6, 49, 27,
320608)

    now(tz=None)
method of builtins.type instance
    Returns new datetime object representing current time local to tz.
    
      tz
        Timezone object.
    
    If no tz is specified, uses local timezone.
    datetime.now([tz])返回一个UTC时区的工夫,默认是时光阴。
   

    (5)datetime.utcnow():返回一个脚下utc时间的datetime对象;**

    >>>
datetime.utcnow()
  datetime.datetime(2017, 7, 19, 22, 55, 29,
127130)

    (6)datetime.fromtimestamp(timestamp[,
tz]):根据时间戮创建一个datetime对象,参数tz指定时区信息;**

    (7)datetime.utcfromtimestamp(timestamp):根据时间戮创建一个datetime对象;**

    (8)datetime.combine(date,
time):根据date和time,创建一个datetime对象;**

    (9)datetime.strptime(date_string,
format):将格式字符串转换为datetime对象;**

 

   
datetime类提供的实例方法和特性(很多性或措施以date和time中一度起过,在这来相近的意义,这里仅仅摆这些方法名,具体意思不再逐个进行介绍,可以参见上文对date与time类的执教。)

    (1)**datetime.year、month、day、hour、minute、second、microsecond、tzinfo:** 

    (2)datetime.date():获取date对象;**

  (3)datetime.time():获取time对象;**

**    (4)datetime. replace ([ year[ , month[ , day[
, hour[ , minute[ , second[ , microsecond[ , tzinfo] ] ] ] ] ]
]
]):**

**    (5)datetime. timetuple
()**

**    (6)datetime. utctimetuple
()**

**    (7)datetime. toordinal
()**

**    (8)datetime. weekday
()**

**    (9)datetime. isocalendar
()**

**    (10)datetime. isoformat ([ sep]
)**

**    (11)datetime. ctime
():返回一个日子时之C格式字符串,等效为time.ctime(time.mktime(dt.timetuple()));**

**    (12)datetime. strftime
(format)**

   
 
比如date一样,也得以本着个别独datetime对象进行较,或者相减返回一个工夫间隔对象,或者日期时长一个距离返回一个初的日子时对象。这里不提供详细的例子,看客自己下手试一下~~

   
季、转化为字符串

   
datetime、date、time都提供了strftime()方法,该法接收一个格式字符串,输出日期时的字符串表示。下表是从python手册中拉过来的,我本着几进行了大概的翻译(翻译的小噢口~~)。

格式字符及意义

 

%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): ' , dt.strftime( '%Y-%m-%d %H:%M:%S %f' ) 
print  '(%Y-%m-%d %H:%M:%S %p): ' , dt.strftime( '%y-%m-%d %I:%M:%S %p' ) 
print  '%%a: %s ' % dt.strftime( '%a' ) 
print  '%%A: %s ' % dt.strftime( '%A' ) 
print  '%%b: %s ' % dt.strftime( '%b' ) 
print  '%%B: %s ' % dt.strftime( '%B' ) 
print  '日期时间%%c: %s ' % dt.strftime( '%c' ) 
print  '日期%%x:%s ' % dt.strftime( '%x' ) 
print  '时间%%X:%s ' % dt.strftime( '%X' ) 
print  '今天是这周的第%s天 ' % dt.strftime( '%w' ) 
print  '今天是今年的第%s天 ' % dt.strftime( '%j' ) 
print  '今周是今年的第%s周 ' % dt.strftime( '%U' ) 

# # ---- 结果 ----  
# (%Y-%m-%d %H:%M:%S %f): 2010-04-07 10:52:18 937000  
# (%Y-%m-%d %H:%M:%S %p): 10-04-07 10:52:18 AM  
# %a: Wed  
# %A: Wednesday  
# %b: Apr  
# %B: April  
# 日期时间%c: 04/07/10 10:52:18  
# 日期%x:04/07/10  
# 时间%X:10:52:18  
# 今天是这周的第3天  
# 今天是今年的第097天  
# 今周是今年的第14周  

 

 

 

dt = datetime.now() 
print '(%Y-%m-%d %H:%M:%S %f): ', dt.strftime('%Y-%m-%d %H:%M:%S %f') 
print '(%Y-%m-%d %H:%M:%S %p): ', dt.strftime('%y-%m-%d %I:%M:%S %p') 
print '%%a: %s ' % dt.strftime('%a') 
print '%%A: %s ' % dt.strftime('%A') 
print '%%b: %s ' % dt.strftime('%b') 
print '%%B: %s ' % dt.strftime('%B') 
print '日期时间%%c: %s ' % dt.strftime('%c') 
print '日期%%x:%s ' % dt.strftime('%x') 
print '时间%%X:%s ' % dt.strftime('%X') 
print '今天是这周的第%s天 ' % dt.strftime('%w') 
print '今天是今年的第%s天 ' % dt.strftime('%j') 
print '今周是今年的第%s周 ' % dt.strftime('%U') 

# # ---- 结果 ---- 
# (%Y-%m-%d %H:%M:%S %f): 2010-04-07 10:52:18 937000 
# (%Y-%m-%d %H:%M:%S %p): 10-04-07 10:52:18 AM 
# %a: Wed  
# %A: Wednesday  
# %b: Apr  
# %B: April  
# 日期时间%c: 04/07/10 10:52:18  
# 日期%x:04/07/10  
# 时间%X:10:52:18  
# 今天是这周的第3天  
# 今天是今年的第097天  
# 今周是今年的第14周 

 

python之time,datetime,string转换

   

#把datetime转成字符串 
def datetime_toString(dt): 
  return dt.strftime("%Y-%m-%d-%H") 

#把字符串转成datetime 
def string_toDatetime(string): 
  return datetime.strptime(string, "%Y-%m-%d-%H") 

#把字符串转成时间戳形式 
def string_toTimestamp(strTime): 
  return time.mktime(string_toDatetime(strTime).timetuple()) 

#把时间戳转成字符串形式 
def timestamp_toString(stamp): 
  return time.strftime("%Y-%m-%d-%H", tiem.localtime(stamp)) 

#把datetime类型转外时间戳形式 
def datetime_toTimestamp(dateTim): 
  return time.mktime(dateTim.timetuple()) 

 

以上就是是关于python时间模块中之datetime模块的事无巨细介绍,希望对大家的学习有助。

相关文章

网站地图xml地图