datetime时间模块,函数编制程序

模块

Time模块:

三种时光代表

在Python中,经常有那二种艺术来代表时间:

  • 时刻戳(timestamp) :      
      平时来讲,时间戳表示的是从196陆年10月二十八日00:00:00始发按秒总结的偏移量。大家运行“type(time.time())”,再次回到的是float类型。
  • 格式化的时光字符串
  • 元组(struct_time)   :      
      struct_time元组共有九个成分共九个因素:(年,月,日,时,分,秒,一年中第几周,一年中第几天,夏令时)

    import time

    # 1 time() :重返当前时光的年华戳
    time.time() #147352544四.03721五

    #———————————————————-

    # 2 localtime([secs])
    # 将2个时光戳转变为眼下时区的struct_time。secs参数未提供,则以当下时刻为准。
    time.localtime() #time.struct_time(tm_year=2016, tm_mon=9, tm_mday=11, tm_hour=0,
    # tm_min=38, tm_sec=39, tm_wday=6, tm_yday=255, tm_isdst=0)
    time.localtime(1473525444.037215)

    #———————————————————-

    # 3 gmtime([secs]) 和localtime()方法类似,gmtime()方法是将二个岁月戳转变为UTC时区(0时区)的struct_time。

    #———————————————————-

    # 4 mktime(t) : 将一个struct_time转化为时间戳。
    print(time.mktime(time.localtime()))#147352574九.0

    #———————————————————-

    # 5 asctime([t]) : 把二个代表时间的元组恐怕struct_time代表为那种样式:’Sun Jun 20 二三:二壹:05 1995’。
    # 假诺没有参数,将会将time.localtime()作为参数字传送入。
    print(time.asctime())#Sun Sep 1一 00:4三:4三 2016

    #———————————————————-

    # 6 ctime([secs]) : 把3个岁月戳(按秒总结的浮点数)转化为time.asctime()的方式。假使参数未给依旧为
    # None的时候,将会暗许time.time()为参数。它的效率也正是time.asctime(time.localtime(secs))。
    print(time.ctime()) # Sun Sep 11 00:四陆:3八 201陆

    print(time.ctime(time.time())) # Sun Sep 11 00:46:38 2016

    # 7 strftime(format[, t]) : 把1个意味时间的元组可能struct_time(如由time.localtime()和
    # time.gmtime()重临)转化为格式化的时刻字符串。如若t未钦赐,将盛传time.localtime()。要是元组中任何3个# 成分越界,ValueError的荒唐将会被抛出。
    print(time.strftime(“%Y-%m-%d %X”, time.localtime()))#二零一六-0九-11 00:4玖:56

    # 8 time.strptime(string[, format])
    # 把3个格式化时间字符串转化为struct_time。实际上它和strftime()是逆操作。
    print(time.strptime(‘201一-0伍-05 16:三7:0陆’, ‘%Y-%m-%d %X’))

    #time.struct_time(tm_year=2011, tm_mon=5, tm_mday=5, tm_hour=16, tm_min=37, tm_sec=6,
    # tm_wday=3, tm_yday=125, tm_isdst=-1)

    #在那一个函数中,format默以为:”%a %b %d %H:%M:%S %Y”。

# 9 sleep(secs)
# 线程推迟指定的时间运行,单位为秒。

# 10 clock()
# 这个需要注意,在不同的系统上含义不同。在UNIX系统上,它返回的是“进程时间”,它是用秒表示的浮点数(时间戳)。
# 而在WINDOWS中,第一次调用,返回的是进程运行的实际时间。而第二次之后的调用是自第一次调用以后到现在的运行
# 时间,即两次时间差。

       
  澳门葡京备用网址 1澳门葡京备用网址 2

help(time)
help(time.asctime)

 

 

  

 

1、定义

为了编制可爱惜的代码,大家把众多函数分组,分别放置分歧的公文里,那样,种种文件包涵的代码就相对较少,大多编制程序语言都利用那种协会代码的措施。在Python中,1个.py文件就称为一个模块(module)。

  Time时间在python中有三种格式:时间戳、格式化时间、struct_time(元祖格局),大家来看下三种格式具身体表面现格局。

模块:用来从逻辑上集体python(变量,函数,类,逻辑:达成三个成效)代码,本质正是.py结尾的python文件(文件名:test.py,对应的模块名test)

应用模块好处:

  时间戳:142112412431(秒),一玖七零年6月十日算起,一九6九年12月二十一日是Unix诞生的生活。

包:用来从逻辑上集人体模型块的,本质就是1个索引(必须带__init__.py文件)

一、提升可维护性

  格式化时间:2017-0玖-0玖 1八:00:00。

二、导入方法

2、可重用

  struct_time:(tm_year=2017, tm_mon=9, tm_mday=9, tm_hour=13,
tm_min=41, tm_sec=20, tm_wday=5, tm_yday=252, tm_isdst=0)

import
module_name

三、制止函数名和变量冲突

  大家通过help(time)l来查看time模块的函数

import
module1_name,module2_name

模块分类

1.time()

from module_name
import *

模块分为两种:

time.time()函数输出结果为时间戳,单位为秒。

from module_alex
import logger as logger_alex   ”’给模块里面包车型客车方法起小名”’

  • 放到规范模块(又称标准库)。实行help(‘modules’)查看全数Python自带模块列表
  • 其三方开源模块。可通过pip install 模块名 ,安装
  • 自定义安装

2.sleep()

3、import本质

相对导入

time.sleep()函数使代码延迟运转,单位秒。

导入模块的武夷山真面目正是把Python文件说Bellamy(Bellamy)(Dumex)遍

 

3.gmtime()

导入包的面目正是施行该包下的__init__.py文件

仍然有人汇合到那一个错

time.gmtime()函数将参数转化为struct_time,括号中参数填写时间戳,该函数将时刻戳转化为UTC时区元祖。若是括号中参数为空,结果输出为眼下UTC时间。

__file__当下文件的公文名

 

import time
time.gmtime()
print(‘-------------------------------------------------------------------------------------------------------------------’)
time.gmtime(123123124)
输出结果:
time.struct_time(tm_year=2017, tm_mon=9, tm_mday=10, tm_hour=13, tm_min=49, tm_sec=50, tm_wday=6, tm_yday=253, tm_isdst=0)   #当前UTC时间
-------------------------------------------------------------------------------------------------------------------
time.struct_time(tm_year=1973, tm_mon=11, tm_mday=26, tm_hour=0, tm_min=52, tm_sec=4, tm_wday=0, tm_yday=330, tm_isdst=0)  #时间戳转化struct_time元祖

四、导入优化

ValueError: attempted relative import beyond top-level package

咱俩入眼开采struct_time是3个带有几个要素的元祖,假设大家要求取得当中专擅三个要素,我们能够应用以下办法。

伍、模块的分类

 

import time
x=time.gmtime()
print('year:%s'%(x.tm_year))
print('mon:%s'%(x.tm_mon))
输出结果:
year:2017
mon:9

 
a.标准库(内置模块)

其实这七个错误的案由到底是千篇一律的:在提到到相对导入时,package所对应的公文夹必须科学的被python解释器视作package,而不是普通文书夹。不然由于不被看做package,不也许运用package之间的嵌套关系达成python中包的周旋导入。

4.localtime()

 b.开源模块

 

与gmtime()类似,localtime()括号中无法带参数,localtime()输出当前计算机所在时区的struct_time元祖。

 c.自定义模块

文本夹被python解释器视作package须要满意五个原则:

5.mktime()

 
os模块学习实例链接:

 

time.mktime()函数将struct_time元祖转化为时间戳。

time和datetime模块

  1. 文件夹中必须有__init__.py文件,该公文可认为空,但必须存在该文件。
  2. 不能够当做顶层模块来实行该公文夹中的py文件(即不能够看做主函数的入口)。
import time
x=time.localtime()
x
time.mktime(x) #struct_time转化为时间戳
time.time()  
输出结果
time.struct_time(tm_year=2017, tm_mon=9, tm_mday=10, tm_hour=22, tm_min=4, tm_sec=56, tm_wday=6, tm_yday=253, tm_isdst=0)
1505052296.0
1505052309.3117964

    time模块

 

6.strftime()

   
时间代表情势:”201陆-7-18
12:50:3陆”(格式化的字符串表示方法);贰.岁月戳表示方法,time.time()(150041560壹.34177肆5),从一玖七零年到今后的秒数;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)

于是那一个主题材料的消除办法正是,既然您在views.py里实践了针锋相对导入,那就不用把views.py当作入口程序,能够由此上一流的manage.py调用views.py

time.strftime()函数语法:strftime(format[, tuple])

   
在Python中,经常有那两种方法来表示时间:壹)时间戳 贰)格式化的岁月字符串
3)元组(struct_time)共7个因素。由于Python的time模块达成重大调用C库,所以各类平台也许大相径庭。

 

常用的format:     %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].        秒

    UTC(Coordinated
Universal
Time
,世界协调时)亦即格林威治天文时间,世界标准时间。在中NokiaUTC+八。DST(Daylight
Saving Time)即夏令时。

.
├── __init__.py
├── crm
│   ├── __init__.py
│   ├── admin.py
│   ├── apps.py
│   ├── models.py
│   ├── tests.py
│   ├── views.py  #from ..proj import settings , ..返回上一级目录后和入口程序manage.py在同一个目录了,所以报错。。
├── manage.py  #from crm import views , 入口程序manage.py所在目录是根目录
└── proj
    ├── __init__.py
    ├── settings.py #from .import urls  
    ├── urls.py
    └── wsgi.py
#事实证明还是不行,报错
ValueError: attempted relative import beyond top-level package
import time
x=time.localtime()
time.strftime('%Y-%m-%d,%H:%M:%S',x)
输出结果:
'2017-09-10,22:14:05'

   
时间戳(timestamp)的不二等秘书籍:常常来讲,时间戳表示的是从一96七年三月二16日00:00:00伊始按秒总计的偏移量。大家运营“type(time.time())”,重临的是float类型。再次来到时间戳方式的函数重要有time(),clock()等。

1、Python中意味着时间的三种方式:

出口结果为格式话的字符串,函数中format格式大家能够私行定义,第壹个函数时间格式%Y-%m-%d,%H:%M:%S,第二个函数时间格式%m-%d,%Y %H:%M:%S

   
元组(struct_time)方式:struct_time元组共有七个因素,重回struct_time的函数主要有gmtime(),localtime(),strptime()。上边列出那种方式元组中的多少个因素:

  1. 时间戳
  2. 格式化的时刻字符串
  3. 元祖(struct_time)共柒个成分。由于Python的time模块完毕主要调用C库,所以各类平台不一样。 
time.strftime('%m-%d,%Y  %H:%M:%S',x)
输出结果:
'09-10,2017  22:14:05'

(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)

二、多少个概念

 7.strptime

 

UTC(时间协和时)亦即格林威治天文时间。世界标准时间。

time.strptime()函数输入参数字符串和格式化字符,输出struct_time元组。

索引(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

时间戳(timestamp)的方式

import time
time.strptime('2017-09-11,12:12:12','%Y-%m-%d,%H:%M:%S')
输出结果:
time.struct_time(tm_year=2017, tm_mon=9, tm_mday=11, tm_hour=12, tm_min=12, tm_sec=12, tm_wday=0, tm_yday=254, tm_isdst=-1)

 

元祖格局:

strptime()函数在动用时需注意的是 ‘2017-0玖-1壹,1贰:12:1二’和’%Y-%m-%d,%H:%M:%S’参数要挨个对应,举例‘2017-0玖-11’要对应日期格式‘%Y-%m-%d’,其中的‘-’符号也要相应,同理,时间也要对应。

   time模块

time & datetime模块

8.asctime

    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)

  • time.time()
    呈现一玖陆玖年到后天系统时间的秒数

    time.time() /3600 /24/365
    48.19778262615837

  • time.localtime([secs])
    :将七个时间戳调换为日前时区的struct_time。secs参数暗中同意是现阶段时刻。

    time.localtime()
    time.struct_time(tm_year=2018, tm_mon=3, tm_mday=2, tm_hour=12, tm_min=36, tm_sec=4, tm_wday=4, tm_yday=61, tm_isdst=0)
    a = time.localtime()
    a.tm_year
    2018

    用来拼接

    ‘%s-%s-%s’ %(a.tm_year,a.tm_mon,a.tm_mday)

time.asctime()

    timezone —
difference in seconds between UTC and local standard time

‘2018-3-2’

把多少个代表时间的元组只怕struct_time表示为那种格局:‘Sun Jun 20 23:21:05 1993’。若是没有参数,将会将time.localtime()作为参数字传送入。

   
再次来到市区的秒数

  •  time.gtime([secs]):和localtime()方法类似,gmtime()是将2个日子戳转变为UTC时区(0时区)的struct_time。比大家的localtime慢半钟头。
import time
time.asctime()  #不带函数,time.localtime()作为参数传入
输出结果:
'Mon Sep 11 10:07:10 2017'

    >>>
time.timezone
    -28800

澳门葡京备用网址 3澳门葡京备用网址 4

9.ctime()

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

1 time.gmtime(12463123)
2 time.struct_time(tm_year=1970, tm_mon=5, tm_mday=25, tm_hour=5, tm_min=58, tm_sec=43, tm_wday=0, tm_yday=145, tm_isdst=0)

time.ctime([secs]):把二个日子戳(按秒计算的浮点数)转化为time.asctime()的样式。假使参数未给依旧为None的时候,将会暗中同意time.time()为参数。它的意义也便是time.asctime(time.localtime(secs))

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

View Code

import time
time.ctime()
输出结果:
'Mon Sep 11 10:09:36 2017'

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

  • time.mktime(t):将一个struct time 转化为时间戳
  • time.sleep(secs):线程推迟钦点的时刻运作。单位为秒
  • time.asctime[t]:把1个意味着时间的元祖恐怕struct_time表示为这种格局:

    time.asctime(a)
    ‘Fri Mar 2 12:36:20 2018’

  • time.ctime([datetime时间模块,函数编制程序。secs]):把叁个光阴戳(按秒总结的浮点数)转化为time.asctime()的款型。假设参数未给依然为None的时候,将会暗许time.time()为参数。约等于==
    time.astime(time.localtime(secs))。

    time.ctime(100)
    ‘Thu Jan 1 08:01:40 1970’

格式间转移格局:

   
回去当前时间的时日戳。

 

澳门葡京备用网址 5

    >>>
time.time()
  1500418020.8217583

  • time.strftime(format[, tuple]) 

    澳门葡京备用网址,time.strftime(‘%Y-%m’,a)
    ‘2018-03’

 

   
上边来看二个例子,运用time.time()来测算函数运维的小运,如下:

format:

澳门葡京备用网址 6

 

字符串转时间格式对应表
 

 

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()
  Meaning Notes
%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.  
%d Day of the month as a decimal number [01,31].  
%H Hour (24-hour clock) as a decimal number [00,23].  
%I Hour (12-hour clock) as a decimal number [01,12].  
%j Day of the year as a decimal number [001,366].  
%m Month as a decimal number [01,12].  
%M Minute as a decimal number [00,59].  
%p Locale’s equivalent of either AM or PM. (1)
%S Second as a decimal number [00,61]. (2)
%U Week number of the year (Sunday as the first day of the week) as a decimal number [00,53]. All days in a new year preceding the first Sunday are considered to be in week 0. 如:今天是今年的多少周 (3)
%w Weekday as a decimal number [0(Sunday),6].  
%W Week number of the year (Monday as the first day of the week) as a decimal number [00,53]. All days in a new year preceding the first Monday are considered to be in week 0. (3)
%x Locale’s appropriate date representation.  
%X Locale’s appropriate time representation.  
%y Year without century as a decimal number [00,99].  
%Y Year with century as a decimal number.  
%z Time zone offset indicating a positive or negative time difference from UTC/GMT of the form +HHMM or -HHMM, where H represents decimal hour digits and M represents decimal minute digits [-23:59, +23:59].  
%Z Time zone name (no characters if no time zone exists).  
  %% A literal '%'character.

总计:时间代表有二种格式:struct_time,时间戳,格式化时间。时间戳->struct_time使用localtime()和gmtime(),gmtime()能够带参数,localtime()不能够带参数,gmtime()暗中同意输出结果为utc时区时间。struct_time
->时间戳使用mktime()函数。struct_time
->格式化时间利用strftime(),格式化时间->struct_time使用strptime(),在接纳时索要专注字符串时间格式对应。

 

 

 

    运维结果如下:

澳门葡京备用网址 7

 

 

  0 1
  1
  2
  3
  5
  8
  0.00010323524475097656

  •  datetime模块

   
从上边运营结果能够见到,程序运转的进度照旧挺快的,不到一秒时间就运维出来了。

相对来讲于time模块,datetime的接口越来越直、更便于调用

   
再次来到当前光阴的岁月戳,其实正是时间的秒数表示方式,能够用来测算一个程序施行的时刻,如下:

  • datetime模块定义了下边那多少个类: 

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

datetime.date:表示日期的类。常用的品质有year,month,day

   
那一个供给留意,在不相同的系统上意思差别。在UNIX系统上,它回到的是“进度时间”,它是用秒表示的浮点数(时间戳)。而在WINDOWS中,第三回调用,重回的是经过运营的实际时间。而第壹遍之后的调用是自第3次调用以往到近日的周转时刻。(实际上是以WIN3二上QueryPerformanceCounter()为根基,它比纳秒表示进一步纯粹)

datetime.time:表示时间的类。常用的品质有hour,minute,second,microsecond;

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

datetime.datetime:表示日期时间

   
线程推迟钦赐的时间运作。单位为秒

datetime.timedelta:表示时间距离。即八个时间点之间的长短

    

datetime.tzinfo:与时区有关的相干消息。 

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

小编们供给记住的方式仅以下多少个:

 

  1.  d=datetime.datetime.now()
    再次回到当前的datetime日期类型

   
上边程序就是在程序中插入了time.sleep(三)让程序休眠了3秒,能够看来运转时间长度扩充了,因此当我们写代码的时候,能够加上一些sleep(),给你们总老总,完了你们COO说好慢,你说优化一下,把sleep()删除,完了先后真的快了,你们老董对你另眼相待(前几日是愚人节)。

 

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

d = datetime.datetime.now()
d
datetime.datetime(2018, 3, 10, 0, 27, 37, 198725)

   
和localtime()方法类似,gmtime()方法是将叁个光阴戳转变为UTC时区(0时区)的struct_time。

2.datetime.date.fromtimestamp()  把2个时间戳转为datetime日期类型

    >>>
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区,由此会晚八个时区。

>>>import time datetime
>>>d = time.time()
>>>d
1521179662.136708
>>>datetime.date.fromtimestamp(d)
datetime.date(2018, 3, 16)

   
gmtime()借使未有参数,默许是现阶段系统时间,调换为UTC规范时间

三.时日运算 datetime.timedelta()

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

>>>n = datetime.datetime.now()
>>>n
datetime.datetime(2018, 3, 16, 14, 1, 43, 796969)
>>>t = datetime.timedelta() 
>>>t
datetime.timedelta(0)
>>>t = datetime.timedelta(1)   #括号内数字默认天为单位
>>>n - t
datetime.datetime(2018, 3, 15, 14, 1, 43, 796969)
>>>t = datetime.timedelta(hours=3) #时间3小时
>>>n - t
datetime.datetime(2018, 3, 16, 11, 1, 43, 796969)

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

 

    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.

  

    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

4.光阴替换

n
datetime.datetime(2018, 3, 16, 14, 1, 43, 796969)
n.replace(year=2017)
datetime.datetime(2017, 3, 16, 14, 1, 43, 796969)

n.replace(year=2017,month=8,day=21)
datetime.datetime(2017, 8, 21, 14, 1, 43, 796969)

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

 5.random模块

randint

randrange

random

choice

sample

shuffle 洗牌

>>>random.randint(1,3)  #int取值范围包含3
3
>>>random.randrange(1,3) #range不包含3
2
>>>random.randrange(0,100,2) #随机选取0到100间的偶数
>>>random.random()  #随机选取浮点数
0.1801425031180679
>>>random.choice('sgaad3q645%^&*(')  #从给定的字符串返回一个随机字符
'^'
>>>random.sample('dasgar134t6316',3)  #从给定字符串返回指定个数的字符串
['d', 's', '3']

 

 【应用】生成自由字符串

>>> import string
>>> string.digits
'0123456789'
>>> string.ascii_letters
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
>>> string.ascii_lowercase
'abcdefghijklmnopqrstuvwxyz'
>>> string.ascii_uppercase
'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
>>> string.punctuation
'!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'
>>> string.ascii_lowercase + string.digits
'abcdefghijklmnopqrstuvwxyz0123456789'
>>> s=string.ascii_lowercase + string.digits
>>> random.choice(s)
'c'
>>> random.sample(s,5)  #随机取出5个字符生成列表
['8', '3', 'j', 'o', 'x']
>>> ''.join(random.sample(s,5))
'w8zlt'
>>> '_'.join(random.sample(s,5))  #join将列表取出并用_连接成字符串
'w_0_a_n_j'

 洗牌

>>> a = list(range(1,10))
>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> random.shuffle(a)
>>> a
[6, 3, 1, 8, 9, 5, 7, 2, 4]
>>> a
[6, 3, 1, 8, 9, 5, 7, 2, 4]
>>> a

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

    tm_sec,tm_wday,tm_yday,tm_isdst)

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

   
将三个时刻戳转变为当下时区的struct_time。secs参数未提供,则以当下日子为准

   
time.localtime()是改动为本土时间的元组表示格局

    >>>
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

   
把3个代表时间的元组大概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

   
把1个格式化时间字符串转化为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

   
澳门葡京备用网址 8

    datetime模块   

   
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模块

    一、datetime模块定义了三个常量:datetime.MINYEA汉兰达和datetime.MAXYEAENVISION,分别代表datetime所能表示的最
小、最新岁份。当中,MINYEA路虎极光 = 一,MAXYEA卡宴 = 999玖。

   
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九天;**

   
date类定义了有些常用的类情势与类属性,方便我们操作:

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

    >>>
datetime.date.max
  datetime.date(9999, 12, 31)
  >>> datetime.date.min
  datetime.date(1, 1, 1)
    最大日子是:999玖-1二-3一,最时辰间是:一-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对象;(格雷戈orian
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()重临的是1个元组格局的时刻,struct_time,参数是一个日子格式的,date.timetuple(datetime.date)

    (4)**date.toordinal():重临日期对应的格雷戈orian
Calendar日期;**

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

    (5)date.weekday():重临weekday,假若是星期一,再次来到0;倘若是星期2,再次来到一,依此类推;**

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

   
date.weekday()是持筹握算星期的,依据外国的措施,0是一周的率先天(周壹),三意味着周4。

    (6)**data.isoweekday():再次来到weekday,假诺是星期一,重返一;假设是星期二,重临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   #
三个日子相减,重回1个日子距离对象**

**    (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,
2四),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(二三, 5九, 5九,
999999);**

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

    (2)time.resolution:时间的小不点儿单位,那里是一皮秒;**

    >>>
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] ] ] ] ]
):创立2个新的时刻对象,用参数内定的时**

**、分、秒、微秒代替本来对象中的属性(原有对象仍维持不变);**

**    (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对象开始展览相比,恐怕相减返回2个岁月距离对象。这里就不提供例子了。

   
三、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():再次回到1个象征近日本地时间的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])再次回到2个UTC时区的年月,私下认可是眼前时刻。
   

    (5)datetime.utcnow():再次回到二个脚下utc时间的datetime对象;**

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

    (6)datetime.fromtimestamp(timestamp[,
tz]):根据时间戮成立1个datetime对象,参数tz指定时区新闻;**

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

    (8)datetime.combine(date,
time):依照date和time,成立3个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对象实行比较,恐怕相减再次回到2个光阴世隔对象,只怕日期时间增进3个距离重临2个新的日卯时间对象。那里不提供详细的例证,看客自身入手试一下~~

   
4、转化为字符串

   
datetime、date、time都提供了strftime()方法,该情势接收3个格式字符串,输出日期时间的字符串表示。下表是从python手册中拉过来的,小编对些举行了简短的翻译(翻译的有点噢口~~)。

格式字符及意义

 

%a   星期的简写。如
星期三为Web
%A   星期的全写。如
星期三为Wednesday
%b  
月份的简写。如11月份为Apr
%B  
月份的全写。如一月份为April
%c: 
日期时间的字符串表示。(如: 04/0拾贰分之7 拾:四3:3九)
%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],陆意味着周四
%W: 
周在当年的周数(是那时的第几周),星期一看作周的率先天
%x: 
日期字符串(如:04/011分之七)
%X: 
时间字符串(如:十:4三:3玖)
%y: 
三个数字代表的年份
%Y: 
五个数字代表的年度
%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模块的详实介绍,希望对我们的学习抱有协理。

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*
*
Website