首页 > 范文大全

python 时间模块小结

时间：2022年12月11日

来源：一个收银员

编辑：本站小编

收藏本文

下载本文

下面是小编整理的python 时间模块小结，本文共11篇，欢迎您阅读分享借鉴，希望对您有所帮助。本文原稿由网友“一个收银员”提供。

篇1：python 时间模块小结

一：经常使用的时间方法

1.得到当前时间

使用time模块，首先得到当前的时间戳

In [42]: time.time

Out[42]: 1408066927.208922

将时间戳转换为时间元组 struct_time

In [43]: time.localtime(time.time())

Out[43]: time.struct_time(tm_year=, tm_mon=8, tm_mday=15, tm_hour=9, tm_min=42, tm_sec=20, tm_wday=4, tm_yday=227, tm_isdst=0)

格式化输出想要的时间

In [44]: time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time()))

Out[44]: '2014-08-15 09:43:04'

接上文，不加参数时，默认就是输出当前的时间

In [48]: time.strftime('%Y-%m-%d %H:%M:%S')

Out[48]: '2014-08-15 09:46:53’

当然也可以透过datetime模块来实现，如下：

In [68]: t = time.time()

In [69]: datetime.datetime.fromtimestamp(t).strftime('%Y-%m-%d %H:%M:%S')

Out[69]: '2014-08-15 10:04:51’

同时，也可以只使用datetime模块

In [46]: datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')

Out[46]: '2014-08-15 09:45:27’

In [47]: datetime.datetime.today().strftime('%Y-%m-%d %H:%M:%S')

Out[47]: '2014-08-15 09:46:10'

2.获取时间差，计算程序的执行时间等：

使用time模块：

In [75]: def t():

....: start = time.time()

....: time.sleep(10)

....: end = time.time()

....: print end - start

....:

In [76]: t()

10.0014948845

使用datetime模块：

In [49]: starttime = datetime.datetime.now()

In [50]: endtime = datetime.datetime.now()

In [51]: print (endtime - starttime).seconds

3.计算昨天的日期（发散思维，计算其他日期相加、相减等）：

In [52]: d1 = datetime.datetime.now()

In [53]: d2 = d1 - datetime.timedelta(days=1)

In [54]: d1

Out[54]: datetime.datetime(2014, 8, 15, 9, 54, 10, 68665)

In [55]: d2

Out[55]: datetime.datetime(2014, 8, 14, 9, 54, 10, 68665)

4.时间元组 struct_time转化为时间戳

In [56]: datetime.datetime.now()

Out[56]: datetime.datetime(2014, 8, 15, 9, 57, 52, 779893)

In [57]: datetime.datetime.now().timetuple()

Out[57]: time.struct_time(tm_year=2014, tm_mon=8, tm_mday=15, tm_hour=9, tm_min=58, tm_sec=12, tm_wday=4, tm_yday=227, tm_isdst=-1)

In [58]: time.mktime(datetime.datetime.now().timetuple())

Out[58]: 1408067904.0

5.strptime也挺有用的，将时间字符串转换为时间元组struct_time

In [73]: time.strftime('%Y-%m-%d %H:%M:%S')

Out[73]: '2014-08-15 10:27:36'

In [74]: time.strptime('2014-08-15 10:27:36','%Y-%m-%d %H:%M:%S')

Out[74]: time.struct_time(tm_year=2014, tm_mon=8, tm_mday=15, tm_hour=10, tm_min=27, tm_sec=36, tm_wday=4, tm_yday=227, tm_isdst=-1)

##二：time和datetime模块常用方法简介

表示时间的两种方式：

1. 时间戳(相对于1970.1.1 00:00:00以秒计算的偏移量),时间戳是惟一的

2. 时间元组即(struct_time),共有九个元素，分别表示，同一个时间戳的struct_time会因为时区不同而不同

time 模块常用方法小记

1.time.clock

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

budong@budongdeMacBook-Pro:/tmp$ cat clock.py

#!/usr/bin/env python

import time

if __name__ == '__main__':

time.sleep(1)

print “clock1:%s” % time.clock()

time.sleep(1)

print “clock2:%s” % time.clock()

time.sleep(1)

print “clock3:%s” % time.clock()

运行脚本：

budong@budongdeMacBook-Pro:/tmp$ ./clock.py

clock1:0.059173

clock2:0.059299

clock3:0.059416

2.time.sleep(secs)

线程推迟指定的时间运行

适合放在脚本里，定时sleep一会然后继续干啥

In [138]: while True:

.....: time.sleep(3)

.....: print time.strftime('%H:%M:%S')

.....:

17:21:35

17:21:38

17:21:41

17:21:44

……

3.time.localtime([secs])

将一个时间戳转换成一个当前时区的struct_time，如果seconds参数未输入，则以当前时间为转换标准

未提供secs参数时，按当前时间为准

In [141]: time.localtime()

Out[141]: time.struct_time(tm_year=2014, tm_mon=8, tm_mday=14, tm_hour=17, tm_min=23, tm_sec=48, tm_wday=3, tm_yday=226, tm_isdst=0)

提供secs为当前时间戳时

In [142]: time.time()

Out[142]: 1408008232.217969

In [143]: time.localtime(time.time())

Out[143]: time.struct_time(tm_year=2014, tm_mon=8, tm_mday=14, tm_hour=17, tm_min=24, tm_sec=2, tm_wday=3, tm_yday=226, tm_isdst=0)

4.time.strftime(format[, t])

将指定的struct_time(默认为当前时间)，根据指定的格式化字符串输出

t未指定，传入time.localtime()作为默认参数：

In [156]: time.strftime('%Y-%m-%d %H:%M:%S')

Out[156]: '2014-08-14 17:28:16’

指定t为time.localtime(1407945600.0)时：

In [157]: time.localtime(1407945600.0)

Out[157]: time.struct_time(tm_year=2014, tm_mon=8, tm_mday=14, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=226, tm_isdst=0)

In [158]: time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(1407945600.0))

Out[158]: '2014-08-14 00:00:00’

5.time.time（）

返回当前时间的时间戳

In [161]: time.time()

Out[161]: 1408008711.730218

6.time.mktime(t)

将一个struct_time转换为时间戳,如下time.localtime接收一个时间戳返回一个struct_time，而time.mktime接收一个struct_time，返回一个时间戳

In [159]: time.localtime(1407945600.0)

Out[159]: time.struct_time(tm_year=2014, tm_mon=8, tm_mday=14, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=226, tm_isdst=0)

In [160]: time.mktime(time.localtime(1407945600.0))

Out[160]: 1407945600.0

残阳似血的博客：

官方time模块：

##datetime 模块常用方法小记

datetime模块常用的主要有下面这四个类：

1. datetime.date: 是指年月日构成的日期(相当于日历)

2. datetime.time: 是指时分秒微秒构成的一天24小时中的具体时间(相当于手表)

3. datetime.datetime: 上面两个合在一起，既包含时间又包含日期

4. datetime.timedelta: 时间间隔对象(timedelta)，

一个时间点(datetime)加上一个时间间隔(timedelta)可以得到一个新的时间点(datetime)。比如今天的上午3点加上5个小时得到今天的上午8点。同理，两个时间点相减会得到一个时间间隔。

1.datetime.date 类

1.新建一个date对象，日期为今天，既可以直接调用datetime.date.today()，也可以直接向datetime.date()传值，如下：

In [4]: today = datetime.date.today()

In [5]: today

Out[5]: datetime.date(2014, 8, 15)

In [6]: t = datetime.date(2014,8,15)

In [7]: t

Out[7]: datetime.date(2014, 8, 15)

2.datetime.date.strftime(format) 格式化为需要的时间，如常用的 “年-月-日小时：分钟：秒” 格式

In [8]: today.strftime('%Y-%m-%d %H:%M:%S')

Out[8]: '2014-08-15 00:00:00’

date对象中小时、分钟、秒默认都是0，纪元年的那个时间

3.datetime.date.timple() 转成struct_time格式，这样传递给time.mktime(t) 后，直接转成时间戳格式

In [9]: today.timetuple()

Out[9]: time.struct_time(tm_year=2014, tm_mon=8, tm_mday=15, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=4, tm_yday=227, tm_isdst=-1)

In [10]: time.mktime(today.timetuple())

Out[10]: 140803.0

4.datetime.date.replace(year, month, day) 返回一个替换后的date对象

In [11]: today.replace(year=)

Out[11]: datetime.date(2013, 8, 15)

5.datetime.date.fromtimestamp(timestamp) 将时间戳转化为date对象

In [12]: datetime.date.fromtimestamp(1408058729)

Out[12]: datetime.date(2014, 8, 15)

2.datetime.time 类

1.新建一个time对象

In [15]: t

Out[15]: datetime.time(8, 45, 20)

2.datetime.time.(format)格式化输出

In [16]: t.strftime('%Y-%m-%d %H:%M:%S')

Out[16]: '1900-01-01 08:45:20’

time对应的年、月、日为1900、01、01，纪元年的那个时间

3.datetime.time.replace([hour[, minute[, second[, microsecond[, tzinfo]]]]]) 返回一个替换后的time对象

In [17]: t.replace(hour=9)

Out[17]: datetime.time(9, 45, 20)

3.datetime.datetime类

其实和date的那些方法差不多了，大概看以下，简单说说

1.新建一个datetime对象，日期为今天，既可以直接调用datetime.datetime.today()，也可以直接向datetime.datetime()传值，如下：

In [21]: d1 = datetime.datetime.today()

In [22]: d1

Out[22]: datetime.datetime(2014, 8, 15, 8, 12, 34, 790945)

In [23]: d2 = datetime.datetime(2014, 8, 15, 8, 12, 34, 790945)

In [24]: d2

Out[24]: datetime.datetime(2014, 8, 15, 8, 12, 34, 790945)

2.datetime.datetime.now([tz]) 当不指定时区时，和datetime.datetime.today()是一样的结果，如下

In [25]: datetime.datetime.now()

Out[25]: datetime.datetime(2014, 8, 15, 8, 14, 50, 738672)

3..datetime.datetime.strftime(format) 格式化为需要的时间，如常用的 “年-月-日小时：分钟：秒” 格式

In [27]: d1

Out[27]: datetime.datetime(2014, 8, 15, 8, 12, 34, 790945)

In [28]: d1.strftime('%Y-%m-%d %H:%M:%S')

Out[28]: '2014-08-15 08:12:34’

4.datetime.datetime.timple() 转成struct_time格式，这样传递给time.mktime(t) 后，直接转成时间戳格式

In [29]: d1

Out[29]: datetime.datetime(2014, 8, 15, 8, 12, 34, 790945)

In [30]: d1.timetuple()

Out[30]: time.struct_time(tm_year=2014, tm_mon=8, tm_mday=15, tm_hour=8, tm_min=12, tm_sec=34, tm_wday=4, tm_yday=227, tm_isdst=-1)

In [31]: time.mktime(d1.timetuple())

Out[31]: 1408061554.0

5.datetime.datetime.replace(year, month, day) 返回一个替换后的date对象

In [32]: d1

Out[32]: datetime.datetime(2014, 8, 15, 8, 12, 34, 790945)

In [33]: d1.replace(year=2000)

Out[33]: datetime.datetime(2000, 8, 15, 8, 12, 34, 790945)

6.datetime.datetime.fromtimestamp(timestamp) 将时间戳转化为datetime对象

In [34]: time.time()

Out[34]: 1408061894.081552

In [35]: datetime.datetime.fromtimestamp(1408061894)

Out[35]: datetime.datetime(2014, 8, 15, 8, 18, 14)

4.datetime.timedelta类

没啥好说的，主要做时间的加减法用，如下：

In [78]: today = datetime.datetime.today()

In [79]: yesterday = today - datetime.timedelta(days=1)

In [80]: yesterday

Out[80]: datetime.datetime(2014, 8, 14, 15, 8, 25, 783471)

In [81]: today

Out[81]: datetime.datetime(2014, 8, 15, 15, 8, 25, 783471)

篇2：Python 时间操作例子和时间格式化参数小结

2014-06-06理解python多线程（python多线程简明教程）

2013-12-12python之模拟鼠标键盘动作具体实现

2014-02-02python定时器使用示例分享

2013-12-12Python抓取Discuz!用户名脚本代码

2014-04-04Python的ORM框架SQLAlchemy入门教程

2013-03-03python中关于时间和日期函数的常用计算总结(time和datatime)

2014-03-03Python 列表(List)操作方法详解

-07-07python self,cls,decorator的理解

2014-02-02python列表操作使用示例分享

2014-06-06pycharm 使用心得（一）安装和首次使用

篇3：Python 时间操作例子和时间格式化参数小结

热点排行

Python入门教程超详细1小时学会

python 中文乱码问题深入分析

比较详细Python正则表达式操作指

Python字符串的encode与decode研

Python open读写文件实现脚本

Python enumerate遍历数组示例应

Python 深入理解yield

Python+Django在windows下的开发

python 文件和路径操作函数小结

python 字符串split的用法分享

篇4：python中日期和时间格式化输出的方法小结

作者：八大山人字体：[增加减小] 类型：

这篇文章主要介绍了python中日期和时间格式化输出的方法,实例总结了Python常见的日期与事件操作技巧,非常具有实用价值,需要的朋友可以参考下

本文实例总结了python中日期和时间格式化输出的方法，分享给大家供大家参考。具体分析如下：

python格式化日期时间的函数为datetime.datetime.strftime；由字符串转为日期型的函数为：datetime.datetime.strptime()，两个函数都涉及日期时间的格式化字符串，这里提供详细的代码详细演示了每一个参数的使用方法及范例。

下面是格式化日期和时间时可用的替换符号 %a 输出当前是星期几的英文简写

>>>import datetime>>>now=datetime.datetime.now()>>>now.strftime(‘%a‘)‘Sun‘

%A 输出完整的星期几名称英文

>>>import datetime>>>now=datetime.datetime.now()>>>now.strftime(‘%A‘)‘Sunday‘

%b 输出月份的英文简写

>>>import datetime>>>now=datetime.datetime.now()>>>now.strftime(‘%b‘)‘Sep‘

%B 输出月份的英文完整名称

>>>import datetime>>>now=datetime.datetime.now()>>>now.strftime(‘%B‘)‘September‘

%c 以本地时间显示日期和时间

>>>import datetime>>>now=datetime.datetime.now()>>>now.strftime(‘%c‘)‘09/15/13 21:43:29‘

%d 显示1-31之间的数，每月的第几天，也就是年月日中的日

>>>import datetime>>>now=datetime.datetime.now()>>>now.strftime(‘%d‘)‘15‘

%H 以24小时制显示小时，比如，02,14

>>>import datetime>>>now=datetime.datetime.now()>>>now.strftime(‘%H‘)‘21‘

%I 以12小时制的方式显示当前小时，例如当前jb51.net服务器的时间为晚上21点，使用%I显示09

>>>import datetime>>>now=datetime.datetime.now()>>>now.strftime(‘%I‘)‘09‘

%j 显示当前日期为一年中的第几天，如当前jb51.net服务器时间为9月15日，则显示为258，也就是一年中的第258天

>>>import datetime>>>now=datetime.datetime.now()>>>now.strftime(‘%j‘)‘258‘

%m 显示1-12之间的月份

>>>import datetime>>>now=datetime.datetime.now()>>>now.strftime(‘%m‘)‘09‘

%M 显示00-59之间的分钟数

>>>import datetime>>>now=datetime.datetime.now()>>>now.strftime(‘%M‘)‘43‘

%p 以 A.M./P.M.方式显示是上午还是下午

>>>import datetime>>>now=datetime.datetime.now()>>>now.strftime(‘%p‘)‘PM‘

%S 显示0-59之间的秒数

>>>import datetime>>>now=datetime.datetime.now()>>>now.strftime(‘%S‘)‘29‘

%U 显示一年中的第几周，星期天为一周的第一天，例如当前www.jb51.net服务器时间为209月15日，星期天，显示为第37周

>>>import datetime>>>now=datetime.datetime.now()>>>now.strftime(‘%U‘)‘37‘

%w 显示一周中的第几天，其中星期天为0，星期一为1，例如：jb51.net当前日期为年9月17日星期二，则显示结果为2

>>>import datetime>>>now=datetime.datetime.now()>>>now.strftime(‘%w‘)‘2‘

%W 显示一年中的第几周，和U%把不同的是星期一为一周的第一天，例如当前www.jb51.net服务器时间为2013年9月17日，星期二，显示为第37周，范围在0-51之间

>>>import datetime>>>now=datetime.datetime.now()>>>now.strftime(‘%W‘)‘37‘

%x 显示当地的日期，例如jb51.net本地时间为：北京时间2013年9月17日

>>>import datetime>>>now=datetime.datetime.now()>>>now.strftime(‘%x‘)‘09/17/13‘

%X 显示当地的时间，例如jb51.net本地时间为：北京时间2013年9月17日 07:55:04

>>>import datetime>>>now=datetime.datetime.now()>>>now.strftime(‘%X‘)‘07:55:04‘

%y 显示(00 - 99) 之间的年份，例如：jb51.net服务器时间为：2013年9月17日，则显示结果为13

>>>import datetime>>>now=datetime.datetime.now()>>>now.strftime(‘%y‘)‘13‘

%Y 显示完整年份，例如：jb51.net服务器时间为：2013年9月17日，则显示结果为2013

>>>import datetime>>>now=datetime.datetime.now()>>>now.strftime(‘%Y‘)‘2013‘

%z, %Z 输出时区，如果不能显示，则显示为空字符 %% 用于显示%符号

>>>now.strftime(‘%%‘)‘%‘

在举一个完整的例子：

显示当前日期时间：格式为：年-月-日时:分:秒

>>>datetime.datetime.now().strftime(‘%Y-%m-%d %H:%M:%S‘);‘2013-09-17 08:06:17‘

希望本文所述对大家的Python程序设计有所帮助，

篇5：Python中字典的基础知识小结

作者：一路向北字体：[增加减小] 类型：转载时间：-08-19

这篇文章主要介绍了Python中字典的基础知识归纳小结,都是Python入门学习中的基本知识,值得反复巩固:)需要的朋友可以参考下

定义一个字典

>>>d = {“server”:“mpilgrim”, “database”:“master”} 1>>>d{‘server‘: ‘mpilgrim‘, ‘database‘: ‘master‘}>>>d[“server”] 2‘mpilgrim‘>>>d[“database”] 3‘master‘>>>d[“mpilgrim”] 4

Traceback (innermost last):

File “”, line 1, in ?

KeyError: mpilgrim

首先，我们创建了一个拥有两个元素的新字典，并将其赋值给变量 d，每一个元素都是一个键-值对，整个元素集合用大括号括起来。

server 是一个键字，它所关联的值为 mpilgrim，用 d[“server”] 来引用。

database 是一个键字，它所关联的值为 master，用 d[“database”] 来引用。

你可以通过键字来得到值，但是不能通过值得到键字。所以 d[“server”] 为 mpilgrim，但是使用 d[“mpilgrim”] 会引发一个异常，因为 mpilgrim 不是一个键字。

修改一个字典

>>>d{‘server‘: ‘mpilgrim‘, ‘database‘: ‘master‘}>>>d[“database”] = “pubs” 1>>>d{‘server‘: ‘mpilgrim‘, ‘database‘: ‘pubs‘}>>>d[“uid”] = “sa” 2>>>d{‘server‘: ‘mpilgrim‘, ‘uid‘: ‘sa‘, ‘database‘: ‘pubs‘}

不能在一个字典中有重复的键字。给一个存在的键字赋值会抹掉原来的值。

可以在任何时候加入新的键-值对。这种语法同修改存在的值一样。(是的，它可能某天会给你带来麻烦，你可能认为增加了新值，但实际上只是反复地修改了同样的值，因为你的键字没有按照你的想象改变。)

注意新的元素（键字为 uid，值为 sa）出现在字典中间。实际上，它只不过是一种巧合，在第一个例子中的元素看上去是有序的。现在它们看上去无序了则更是一种巧合。

Note

字典没有元素顺序的概念。说元素顺序乱了是不正确的，它们只是简单的无序。这是一个重要的特性，它会在你想要以一种特定的，可重复的顺序（象以键字的字母表顺序）存取字典元素的时候骚扰你。有一些实现的方法，它们只是没有加到字典中去。

在字典中混用数据类型

>>>d{‘server‘: ‘mpilgrim‘, ‘uid‘: ‘sa‘, ‘database‘: ‘pubs‘}>>>d[“retrycount”] = 3 1>>>d{‘server‘: ‘mpilgrim‘, ‘uid‘: ‘sa‘, ‘database‘: ‘master‘, ‘retrycount‘: 3}>>>d[42] = “douglas” 2>>>d{‘server‘: ‘mpilgrim‘, ‘uid‘: ‘sa‘, ‘database‘: ‘master‘, 42: ‘douglas‘, ‘retrycount‘: 3}

字典不是只用于字符串。字典的值可以是任意数据类型，包括字符串，整数，对象，或者甚至其它的字典。在一个单个字典里，字典的值并不需要全都是同一数据类型，可以根据需要混用和配匹。

字典的关键字要严格一些，但是它们可以是字符串，整数和几种其它的类型（后面还会谈到这一点）。也可以在一个字典中混用和配匹关键字。

从字典中删除元素

>>>d{‘server‘: ‘mpilgrim‘, ‘uid‘: ‘sa‘, ‘database‘: ‘master‘, 42: ‘douglas‘, ‘retrycount‘: 3}>>>del d[42] 1>>>d{‘server‘: ‘mpilgrim‘, ‘uid‘: ‘sa‘, ‘database‘: ‘master‘, ‘retrycount‘: 3}>>>d.clear() 2>>>d{}

del 允许你根据键字将单个元素从字典中删除。

clear 会删除一个字典中所有元素。注意空的大括号所表示的集合说明一个字典没有元素，

字符串是大小写敏感

>>>d = {}>>>d[“key”] = “value”>>>d[“key”] = “other value” 1>>>d{‘key‘: ‘other value‘}>>>d[“Key”] = “third value” 2>>>d{‘Key‘: ‘third value‘, ‘key‘: ‘other value‘}

将一个值赋给一个存在的字典关键字只是简单的用新值替换旧值。

这样做不会将一个值赋给一个存在的字典关键字，因为在Python中字符串是大小写敏感的，所以 ‘key‘ 与 ‘Key‘ 是不同的。这样就在字典中生成了一个新的键/值对。对你来说可能差不多，但对于Python来说，完全是不同的。

如何访问字典中的值:

>>>dict2 = {‘name‘:‘earth‘,‘port‘:80} >>>for key in dict2.keys(): ... print ‘key=%s,value=%s‘ %(key,dict2[key])...key=name,value=earthkey=port,value=80>>>for key in dict2: ... print ‘key=%s,value=%s‘ %(key,dict2[key])...key=name,value=earthkey=port,value=80

获取字典某个元素值:

>>>dict2[‘name‘]‘earth‘>>>print ‘host %s is running on port %d‘ %(dict2[‘name‘],dict2[‘port‘])host earth is running on port 80

检查字典中是否有某个键的方法 has_key()或in,not in

>>>‘name‘ in dict2True>>>‘server‘ in dict2False>>>‘name‘ in dict2 True>>>dict2[‘name‘]‘earth‘>>>dict2.has_key(‘server‘)False>>>dict2.has_key(‘name‘) True

一个字典中混用数字和字符串的例子:

>>>dict3 = {}>>>dict3[1] = ‘abc‘>>>dict3[‘1‘] = 3.14159>>>dict3[3.2] = ‘xyz‘>>>dict3{‘1‘: 3.14159, 1: ‘abc‘, 3.2: ‘xyz‘}

整体赋值:

>>>dict3 = {‘1‘: 3.14159, 1: ‘abc‘, 3.2: ‘xyz‘,33:‘hehe‘}>>>dict3{‘1‘: 3.14159, 1: ‘abc‘, 3.2: ‘xyz‘, 33: ‘hehe‘}

更新字典:

>>>dict2[‘name‘] = ‘venus‘>>>dict2[‘port‘] = 6969>>>dict2[‘arch‘] = ‘sunos5‘>>>print ‘host %(name)s is running on port %(port)d‘ %dict2host venus is running on port 6969

删除字典元素和字典

>>>dict2{‘arch‘: ‘sunos5‘, ‘name‘: ‘venus‘, ‘port‘: 6969}>>>del dict2[‘name‘]>>>dict2{‘arch‘: ‘sunos5‘, ‘port‘: 6969}>>>dict2.clear()>>>dict2{}>>>del dict2>>>dict2Traceback (most recent call last): File “”, line 1, in NameError: name ‘dict2‘ is not defined>>>dict3{‘1‘: 3.14159, 1: ‘abc‘, 3.2: ‘xyz‘, 33: ‘hehe‘}>>>dict3.pop(33) ‘hehe‘>>>dict3{‘1‘: 3.14159, 1: ‘abc‘, 3.2: ‘xyz‘}

注:避免使用内建对象名字作为变量的标识符

类似: dict,list,file,bool,str,input,len

篇6：Python 时间处理datetime实例

热点排行

Python入门教程超详细1小时学会

python 中文乱码问题深入分析

比较详细Python正则表达式操作指

Python字符串的encode与decode研

Python open读写文件实现脚本

Python enumerate遍历数组示例应

Python 深入理解yield

Python+Django在windows下的开发

python 文件和路径操作函数小结

python 字符串split的用法分享

篇7：Python时间戳的使用

1.将字符串的时间转换为时间戳

方法:

a = “-10-10 23:40:00”

将其转换为时间数组

importtime

timeArray = time.strptime(a, “%Y-%m-%d %H:%M:%S”)

转换为时间戳:

timeStamp = int(time.mktime(timeArray))

timeStamp == 1381419600

2.字符串格式更改

如a = “2013-10-10 23:40:00”,想改为 a = “2013/10/10 23:40:00”

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

timeArray = time.strptime(a, “%Y-%m-%d %H:%M:%S”)

therStyleTime = time.strftime(“%Y/%m/%d %H:%M:%S”, timeArray)

3.时间戳转换为指定格式日期:

方法一:

利用localtime转换为时间数组,然后格式化为需要的格式,如

timeStamp = 1381419600

timeArray = time.localtime(timeStamp)

therStyleTime = time.strftime(“%Y-%m-%d %H:%M:%S”, timeArray)

therStyletime == “2013-10-10 23:40:00”

方法二:

importdatetime

timeStamp = 1381419600

dateArray = datetime.datetime.utcfromtimestamp(timeStamp)

therStyleTime = dateArray.strftime(“%Y-%m-%d %H:%M:%S”)

therStyletime == “2013-10-10 23:40:00”

4.获取当前时间并转换为指定日期格式

方法一:

importtime

获得当前时间时间戳

now = int(time.time()) ->这是时间戳

转换为其他日期格式,如:“%Y-%m-%d %H:%M:%S”

timeArray = time.localtime(timeStamp)

therStyleTime = time.strftime(“%Y-%m-%d %H:%M:%S”, timeArray)

方法二:

importdatetime

获得当前时间

now = datetime.datetime.now() ->这是时间数组格式

转换为指定的格式:

therStyleTime = now.strftime(“%Y-%m-%d %H:%M:%S”)

5.获得三天前的时间

方法:

importtime

importdatetime

先获得时间数组格式的日期

threeDayAgo = (datetime.datetime.now() - datetime.timedelta(days = 3))

转换为时间戳:

timeStamp = int(time.mktime(threeDayAgo.timetuple()))

转换为其他字符串格式:

therStyleTime = threeDayAgo.strftime(“%Y-%m-%d %H:%M:%S”)

注:timedelta()的参数有:days,hours,seconds,microseconds

6.给定时间戳,计算该时间的几天前时间:

timeStamp = 1381419600

先转换为datetime

importdatetime

importtime

dateArray = datetime.datetime.utcfromtimestamp(timeStamp)

threeDayAgo = dateArray - datetime.timedelta(days = 3)

参考5,可以转换为其他的任意格式了

篇8：Python中集合类型（set）学习小结

这篇文章主要介绍了Python中集合类型（set）学习小结,本文讲解了set的初始化、运算操作、基本方法等内容,需要的朋友可以参考下

set 是一个无序的元素集合，支持并、交、差及对称差等数学运算，但由于 set 不记录元素位置，因此不支持索引、分片等类序列的操作，

初始化

代码如下:

s0 = set()

d0 = {}

s1 = {0}

s2 = {i % 2 for i in range(10)}

s = set(‘hi‘)

t = set([‘h‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘])

print(s0, s1, s2, s, t, type(d0))

运行结果：

代码如下:

set() {0} {0, 1} {‘i‘, ‘h‘} {‘e‘, ‘o‘, ‘l‘, ‘h‘}

提示

1.s0、d0：使用 {} 只能创建空字典，创建空集必须用 set()；

2.ss、sl：set 中的元素是无序不重复的，可以利用这个特点去除列表中的重复元素。

运算操作

代码如下:

print(s.intersection(t), s & t) # 交集

print(s.union(t), s | t) # 并集

print(s.difference(t), s - t) # 差集

print(s.symmetric_difference(t), s ^ t) # 对称差集

print(s1.issubset(s2), s1 <= s2) # 子集

print(s1.issuperset(s2), s1 >= s2) # 包含

运行结果：

代码如下:

{‘h‘} {‘h‘}

{‘l‘, ‘h‘, ‘i‘, ‘o‘, ‘e‘} {‘l‘, ‘h‘, ‘i‘, ‘o‘, ‘e‘}

{‘i‘} {‘i‘}

{‘i‘, ‘l‘, ‘o‘, ‘e‘} {‘i‘, ‘l‘, ‘o‘, ‘e‘}

True True

False False

提示

1.非运算符的方法接受任何可迭代对象作为参数，如 s.update([0, 1])；

2.其他等价操作：s.update(t) 与 s |= t，s.intersection_update(t) 与 s &= t，s.difference_update(t) 与 s -= t，s.symmetric_difference_update(t) 与 s ^= t 等，

基本方法

代码如下:

s = {0}

print(s, len(s)) # 获取集合中的元素的总数

s.add(“x”) # 添加一个元素

print(s)

s.update([1,2,3]) # 添加多个元素

print(s, “x” in s) # 成员资格测试

s.remove(“x”) # 去掉一个元素

print(s, “x” not in s)

s.discard(“x”) # 如果集合存在指定元素，则删除该元素

c = s.copy() # 复制集合

print(s, s.pop()) # 弹出集合中的一个不确定元素，如果原集合为空则引发 KeyError

s.clear() # 删除集合中的元素

print(s, c)

运行结果：

代码如下:

{0} 1

{0, ‘x‘}

{0, ‘x‘, 1, 2, 3} True

{0, 1, 2, 3} True

{1, 2, 3} 0

set() {0, 1, 2, 3}

篇9：Python常用模块

Python模块

模块是Python最高级别的程序组织单元，他将程序代码和数据封装起来以便重用，

实际来看模块往往对应Python程序文件。本质就是用一些代码实现某些功能的集合

这个集合可以是一个.py文件，也可以是一个包（一个文件夹中，有一个.py入口文件）

一、导入模块

import module

from module.xx import xx

from module.xx import xx as rename

from module.xx import *

导入一个py文件，解释器解释该文件

导入一个包

导入模块根据路径 sys.path如果有该路径，就可直接导入

如果sys.path么有想要的路径，通过sys.path.append('路径')

二、开源模块

下载安装

1、yum、pip、apt-get

2、源码编译安装：Python setup.py build Python setup install

三、常用模块

1、os模块#用作系统级别的工作

os.popen('id').read # 执行系统命令得到返回结果

os.system() # 得到返回状态返回无法截取

os.name # 返回系统平台 Linux/Unix用户是'posix'

os.getenv() # 读取环境变量

os.putenv() # 设置环境变量

os.getcwd() # 当前工作路径

os.chdir() # 改变当前工作目录

os.walk('/root/') # 递归路径

文件处理

mkfifo()/mknod() # 创建命名管道/创建文件系统节点

remove()/unlink() # 删除文件

rename()/renames() # 重命名文件

*stat() # 返回文件信息

symlink() # 创建符号链接

utime() # 更新时间戳

tmpfile() # 创建并打开('w+b')一个新的临时文件

walk() # 遍历目录树下的所有文件名

目录/文件夹

chdir()/fchdir() # 改变当前工作目录/通过一个文件描述符改变当前工作目录

chroot() # 改变当前进程的根目录

listdir() # 列出指定目录的文件

getcwd()/getcwdu() # 返回当前工作目录/功能相同,但返回一个unicode对象

mkdir()/makedirs() # 创建目录/创建多层目录

rmdir()/removedirs() # 删除目录/删除多层目录

访问/权限

saccess() # 检验权限模式

chmod() # 改变权限模式

chown()/lchown() # 改变owner和groupID功能相同,但不会跟踪链接

umask() # 设置默认权限模式

文件描述符操作

open() # 底层的操作系统open(对于稳健,使用标准的内建open()函数)

read()/write() # 根据文件描述符读取/写入数据按大小读取文件部分内容

dup()/dup2() # 复制文件描述符号/功能相同,但是复制到另一个文件描述符

设备号

makedev() # 从major和minor设备号创建一个原始设备号

major()/minor() # 从原始设备号获得major/minor设备号

os.path模块

os.path.expanduser('~/.ssh/key') # 家目录下文件的全路径

分隔

os.path.basename() # 去掉目录路径,返回文件名

os.path.dirname() # 去掉文件名,返回目录路径

os.path.join() # 将分离的各部分组合成一个路径名

os.path.spllt() # 返回(dirname(),basename())元组

os.path.splitdrive() # 返回(drivename,pathname)元组

os.path.splitext() # 返回(filename,extension)元组

信息

os.path.getatime() # 返回最近访问时间

os.path.getctime() # 返回文件创建时间

os.path.getmtime() # 返回最近文件修改时间

os.path.getsize() # 返回文件大小(字节)

查询

os.path.exists() # 指定路径(文件或目录)是否存在

os.path.isabs() # 指定路径是否为绝对路径

os.path.isdir() # 指定路径是否存在且为一个目录

os.path.isfile() # 指定路径是否存在且为一个文件

os.path.islink() # 指定路径是否存在且为一个符号链接

os.path.ismount() # 指定路径是否存在且为一个挂载点

os.path.samefile() # 两个路径名是否指向同一个文件

2、sys模块#提供解释器相关操作

sys.argv # 命令行参数List，第一个元素是程序本身路径

sys.exit(2) # 退出脚本返回状态会被try截取

sys.exc_info() # 获取当前正在处理的异常类

sys.version # 获取Python解释程序的版本信息

sys.maxint # 最大的Int值 9223372036854775807

sys.maxunicode # 最大的Unicode值

sys.modules # 返回系统导入的模块字段，key是模块名，value是模块

sys.path # 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值

sys.platform # 返回操作系统平台名称

sys.stdout # 标准输出

sys.stdin # 标准输入

sys.stderr # 错误输出

sys.exec_prefix # 返回平立的python文件安装的位置

sys.stdin.readline() # 从标准输入读一行

sys.stdout.write(“a”) # 屏幕输出a

3、hashlib模块# 用于加密相关的操作

常规加密

import hashlib

hash_md5 = hashlib.md5()

hash_md5.update('admin')

print(hash_md5.hexdigest())

hash = hashlib.sha512()

hash.update('admin')

print hash.hexdigest()

#以上加密算法虽然依然非常厉害，但时候存在缺陷，即：通过撞库可以反解。所以，有必要对加密算法中添加自定义key再来做加密。

添加自定义key做加密

import hashlib

hash = hashlib.md5('898oaFs09f')

hash.update('admin')

print hash.hexdigest()

超加密-对我们创建的key和内容继续加密

import hmac

h = hmac.new('wueiqi')

h.update('hellowo')

print h.hexdigest()

4、json和pickle模块 #用于序列化数据

json，#json解决简单数据类型的序列换

pickle，#能存储python的复杂数据类型

Json模块提供了四个功能：dumps、dump、loads、load

pickle模块提供了四个功能：dumps、dump、loads、load

name_tra=json.dumps('[1,2,3,4,5]') #dunmps将序列化的数据放到内存

with open('json_tra','wb') as f_json:

f_json.write(name_tra)

with open('json_tra1','wb') as f_json:#dump直接将内存中序列化的数据写入文件

json.dump(a,f_json)

time_now=datetime.datetime.now()

pickle_mem=p.dumps(time_now)

pickle_load=p.loads(pickle_mem)

5、subprocess模块

subprocess包来fork一个子进程，并运行一个外部的程序，

subprocess包中定义有数个创建子进程的函数。subprocess还提供了一些管理标准流(standard stream)和管道(pipe)的工具，从而在进程间使用文本通信。

subprocess.call()

父进程等待子进程完成

返回退出信息(returncode，相当于Linux exit code)

b=subprocess.call(['ls','-l'])

b=subprocess.call(“ls -l”,shell=True)

shell=True,允许shell命令是字符串形式。

subprocess.check_call()

父进程等待子进程完成

返回0

检查退出信息，如果returncode不为0，则举出错误subprocess.CalledProcessError，该对象包含有returncode属性，可用try…except…来检查

subprocess.check_call([“ls”, “-l”])

subprocess.check_call(“exit 1”, shell=True)

subprocess.check_output()

父进程等待子进程完成

返回子进程向标准输出的输出结果

检查退出信息，如果returncode不为0，则举出错误subprocess.CalledProcessError，该对象包含有returncode属性和output属性，output属性为标准输出的输出结果，可用try…except…来检查

6、shuit模块 #文件的复制移动

shutil.copyfile('data.db', 'archive.db') # 拷贝文件

shutil.move('/build/executables', 'installdir') # 移动文件或目录

7、logging模块#格式化记录日志

#通过logging.basicConfig函数对日志的输出格式及方式做相关配置,日志将被写入文件

logging.basicConfig(level=logging.DEBUG,

format='%(asctime)s [line:%(lineno)d] %(levelname)s %(message)s',

datefmt='%Y/%m/%d %H:%M:%S',

filename='myapp.log',

filemode='a')

logging.debug('This is debug message')

logging.info('This is info message')

logging.warning('This is warning message')

#logging.basicConfig函数各参数:

#datefmt: 指定时间格式，同time.strftime()

#filename: 指定日志文件名

#filemode: 和file函数意义相同，指定日志文件的打开模式，'w'或'a'

#level: 设置日志级别，默认为logging.WARNING

#format: 指定输出的格式和内容，format可以输出很多有用信息，如上例所示:

# %(asctime)s: 打印日志的时间

# %(levelname)s: 打印日志级别名称

# %(message)s: 打印日志信息

# %(levelno)s: 打印日志级别的数值

# %(lineno)d: 打印日志的当前行号

# %(pathname)s: 打印当前执行程序的路径，其实就是sys.argv[0]

# %(filename)s: 打印当前执行程序名

# %(funcName)s: 打印日志的当前函数

# %(thread)d: 打印线程ID

# %(threadName)s: 打印线程名称

# %(process)d: 打印进程ID

#将日志同时写入文件，并打印到屏幕

logging.basicConfig(level=logging.DEBUG,

format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',

datefmt='%Y/%m%d %H:%M:%S',

filename='myapp.log',

filemode='w')

#打印到屏幕

console = logging.StreamHandler()

console.setLevel(logging.WARNING)

formatter = logging.Formatter('%(name)-12s: %(levelname)-8s %(message)s')

console.setFormatter(formatter)

logging.getLogger().addHandler(console)

8、random模块用于取随机数

random.choice(['apple', 'pear', 'banana']) # 随机取列表一个参数

random.sample(xrange(100), 10) # 不重复抽取10个

random.randrange(3,7) #随机抽取整数范围不包括7

random.random() # 随机浮点数

9、time datetime模块时间模块

时间戳 #1970年1月1日之后的秒，即：time.time()

格式化的字符串 # -11-11 11:11，即：time.strftime('%Y-%m-%d')

结构化时间 # 元组包含了：年、日、星期等... time.struct_time 即：time.localtime()

import time

time.time() # 时间戳[浮点]

time.localtime()[1] - 1 # 上个月

int(time.time()) # 时间戳[整s]

time.strftime('%Y-%m-%d %X') #格式化输出时间

import datetime

datetime.datetime.datetime.now() #现在的时间

datetime.datetime.now() - datetime.timedelta(days=5,hours=3,seconds=3,minutes=2) #减时间

10、re模块正则匹配

#Pattern对象是一个编译好的正则表达式，通过Pattern提供的一系列方法可以对文本进行匹配查找。

pattern=re.compile(strPattern[, flag]):

flag是匹配模式，re.I|re.M表示同时生效。

re.I(re.IGNORECASE): 忽略大小写

M(MULTILINE): 多行模式，改变'^'和'$'的行为

match(string[, pos[, endpos]]) | re.match(pattern, string[, flags]): #结果匹配一次

#match(string[, pos[, endpos]])从string的pos下标处起尝试匹配pattern；如果pattern结束时仍可匹配，则返回一个Match对象；

pos和endpos的默认值分别为0和len(string)；re.match()flags用于编译pattern时指定匹配模式。

#re.match(pattern, string[, flags])不能指定pos和endpos值。所以匹配的是在开头进行匹配。

search(string[, pos[, endpos]]) | re.search(pattern, string[, flags]): #结果匹配一次

#search(string[, pos[, endpos]])从string的pos下标处起尝试匹配pattern，如果pattern结束时仍可匹配，则返回一个Match对象；

若无法匹配，则将pos加1后重新尝试匹配；直到pos=endpos时仍无法匹配则返回None。

#re.search(pattern, string[, flags]) ，用于匹配任意开始位

a='321.423.432.432 33.43.5.42 1.2.443.34 255.52.53.255 2.2.2.2 3.3.3.3'

pattern=re.compile(r'([12]?\\d{1,2}\\.){3}([12]?\\d{1,2})')

print pattern.search(a).group()

split(string[, maxsplit]) | re.split(pattern, string[, maxsplit]):

按照能够匹配的子串将string分割后返回列表。maxsplit用于指定最大分割次数，不指定将全部分割。

#a='qwe123dsa43** ***2*342rew'

#print re.split('[\\d* ]+',a)

findall(string[, pos[, endpos]]) | re.findall(pattern, string[, flags]):

搜索string，以列表形式返回全部能匹配的子串。

p = re.compile(r'\\d+')

print p.findall('one1two2three3four4')

sub(repl, string[, count]) | re.sub(pattern, repl, string[, count]):

使用repl替换string中每一个匹配的子串后返回替换后的字符串。

count用于指定最多替换次数，不指定时全部替换。

a='321.423.432.432 33.43.5.42 1.2.443.34 255.52.53.255 2.2.2.2 3.3.3.3'

pattern=re.compile(r'([12]?\\d{1,2}\\.){3}([12]?\\d{1,2})')

print pattern.sub('bibi',a)

finditer(string[, pos[, endpos]]) | re.finditer(pattern, string[, flags]):

搜索string，返回一个顺序访问每一个匹配结果（Match对象）的迭代器。

a='321.423.432.432 33.43.5.42 1.2.443.34 255.52.53.255 2.2.2.2 3.3.3.3'

pattern=re.compile(r'([12]?\\d{1,2}\\.){3}([12]?\\d{1,2})')

for i in pattern.finditer(a):

print(i.group())

篇10：python修改操作系统时间的方法

作者：lele 字体：[增加减小] 类型：

这篇文章主要介绍了python修改操作系统时间的方法,涉及Python同步网络时间与本机时间的相关技巧,需要的朋友可以参考下

本文实例讲述了python修改操作系统时间的方法，分享给大家供大家参考。具体实现方法如下：

#-*- coding:utf-8 -*-import socketimport structimport timeimport win32apiTimeServer = ‘210.72.145.44‘ #国家授时中心ipPort = 123def getTime(): TIME_1970 = 2208988800L client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) data = ‘\\x1b‘ + 47 * ‘\\0‘ client.sendto(data, (TimeServer, Port)) data, address = client.recvfrom(1024) data_result = struct.unpack(‘!12I‘, data)[10] data_result -= TIME_1970 return data_resultdef setSystemTime(): tm_year, tm_mon, tm_mday, tm_hour, tm_min, tm_sec, tm_wday, tm_yday, tm_isdst = time.gmtime(getTime()) win32api.SetSystemTime(tm_year, tm_mon, tm_wday, tm_mday, tm_hour, tm_min, tm_sec, 0) print “Set System OK!”if __name__ == ‘__main__‘: setSystemTime() print “%d-%d-%d %d:%d:%d” % time.localtime(getTime())[:6]

希望本文所述对大家的Python程序设计有所帮助，