常用模块之 time,datetime,random,os,sys

2022-12-06 11:18:05

time与datetime模块

先认识几个python中关于时间的名词：

时间戳(timestamp)：通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”，返回的是float类型。1970年之前的日期无法以此表示，太遥远的日期也不行，UNIX和Windows只支持到2038年，时间戳最适合做日期运算。

格式化的时间字符串(Format String)：按照指定格式输出日期字符串

结构化的时间(struct_time)：struct_time元组共有9个元素共九个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天，夏令时)

import time

#我们先以当前时间为准,让大家快速认识三种形式的时间

print(time.time()) # 时间戳:1487130156.419527

print(time.strftime("%Y-%m-%d %X")) #格式化的时间字符串:'2017-02-15 11:40:53'

print(time.localtime()) #本地时区的struct_time

print(time.gmtime())    #UTC时区的struct_time

三种形式的时间实例

"""

    python中时间日期格式化符号：

    ------------------------------------

    %y 两位数的年份表示（00-99）

    %Y 四位数的年份表示（000-9999）

    %m 月份（01-12）

    %d 月内中的一天（0-31）

    %H 24小时制小时数（0-23）

    %I 12小时制小时数（01-12）

    %M 分钟数（00=59）

    %S 秒（00-59）

    %a 本地简化星期名称

    %A 本地完整星期名称

    %b 本地简化的月份名称

    %B 本地完整的月份名称

    %c 本地相应的日期表示和时间表示

    %j 年内的一天（001-366）

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

    %U 一年中的星期数（00-53）星期天为星期的开始

    %w 星期（0-6），星期天为星期的开始

    %W 一年中的星期数（00-53）星期一为星期的开始

    %x 本地相应的日期表示

    %X 本地相应的时间表示

    %Z 当前时区的名称  # 乱码

    %% %号本身

"""

常用的时间日期格式化符号

由于计算机只能读懂时间戳，所以在一些特定的场景下我们会把上面三种时间的表示方式进行转换

# localtime([secs])

# 将一个时间戳转换为当前时区的struct_time。secs参数未提供，则以当前时间为准。

 time.localtime()

 time.localtime(1539582935.9421027)

 gmtime([secs]) 和localtime()方法类似，gmtime()方法是将一个时间戳转换为UTC时区（0时区）的struct_time。

 # mktime(t) : 将一个struct_time转化为时间戳。

 print(time.mktime(time.localtime()))

 # strftime(format[, t]) : 把一个代表时间的元组或者struct_time（如由time.localtime()和

 # time.gmtime()返回）转化为格式化的时间字符串。如果t未指定，将传入time.localtime()。如果元组中任何一个

 # 元素越界，ValueError的错误将会被抛出。

 print(time.strftime("%Y-%m-%d %X", time.localtime()))#2018-10-15 13:57:56

 # time.strptime(string[, format])

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

 print(time.strptime('2011-05-05 16:37:06', '%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"。

利用结构化时间转换

# asctime([t]) : 把一个表示时间的元组或者struct_time表示为这种形式：'Sun Jun 20 23:21:05 1993'。

# 如果没有参数，将会将time.localtime()作为参数传入。

print(time.asctime())#Sun Sep 11 00:43:43 2016

# ctime([secs]) : 把一个时间戳（按秒计算的浮点数）转化为time.asctime()的形式。如果参数未给或者为

# None的时候，将会默认time.time()为参数。它的作用相当于time.asctime(time.localtime(secs))。

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

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

时间戳与格式化时间转换为时间字符串

时间加减

import datetime

print(datetime.datetime.now()) #返回 2016-08-19 12:47:03.941925

print(datetime.date.fromtimestamp(time.time()) )  # 时间戳直接转成日期格式 2016-08-19

print(datetime.datetime.now() )

print(datetime.datetime.now() + datetime.timedelta(3)) #当前时间+3天

print(datetime.datetime.now() + datetime.timedelta(-3)) #当前时间-3天

print(datetime.datetime.now() + datetime.timedelta(hours=3)) #当前时间+3小时

print(datetime.datetime.now() + datetime.timedelta(minutes=30)) #当前时间+30分

时间替换

c_time  = datetime.datetime.now()

print(c_time.replace(minute=3,hour=2))

时间运算

random模块

 import random

print(random.random()) #(0,1)----float    大于0且小于1之间的小数

print(random.randint(1,3))  #[1,3]      大于等于1且小于等于3之间的整数

print(random.randrange(1,3)) #[1,3)    大于等于1且小于3之间的整数

print(random.choice([1,'',[4,5]]))      #1或者23或者[4,5]

print(random.sample([1,'',[4,5]],2))    #列表元素任意2个组合

print(random.uniform(1,3))      #大于1小于3的小数，如1.927109612082716 

item=[1,3,5,7,9]

random.shuffle(item) #打乱item的顺序,相当于"洗牌"

print(item)

random常见用法

os模块

os模块是与计算机操作系统交互的一个接口

os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径

os.chdir("dirname")  改变当前脚本工作目录；相当于shell下cd

os.curdir  返回当前目录: ('.')

os.pardir  获取当前目录的父目录字符串名：('..')

os.makedirs('dirname1/dirname2')    可生成多层递归目录

os.removedirs('dirname1')    若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推

os.mkdir('dirname')    生成单级目录；相当于shell中mkdir dirname

os.rmdir('dirname')    删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname

os.listdir('dirname')    列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印

os.remove()  删除一个文件

os.rename("oldname","newname")  重命名文件/目录

os.stat('path/filename')  获取文件/目录信息

os.sep    输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"

os.linesep    输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"

os.pathsep    输出用于分割文件路径的字符串 win下为;,Linux下为:

os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix'

os.system("bash command")  运行shell命令，直接显示

os.environ  获取系统环境变量

os.path.abspath(path)  返回path规范化的绝对路径

os.path.split(path)  将path分割成目录和文件名二元组返回

os.path.dirname(path)  返回path的目录。其实就是os.path.split(path)的第一个元素

os.path.basename(path)  返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素

os.path.exists(path)  如果path存在，返回True；如果path不存在，返回False

os.path.isabs(path)  如果path是绝对路径，返回True

os.path.isfile(path)  如果path是一个存在的文件，返回True。否则返回False

os.path.isdir(path)  如果path是一个存在的目录，则返回True。否则返回False

os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径之前的参数将被忽略

os.path.getatime(path)  返回path所指向的文件或者目录的最后存取时间

os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间

os.path.getsize(path) 返回path的大小

os操作大全

os.path.normpath（）

在Linux和Mac平台上，该函数会原样返回path，在windows平台上会将路径中所有字符转换为小写，并将所有斜杠转换为饭斜杠。

>>> os.path.normcase('c:/windows\\system32\\')

'c:\\windows\\system32\\'   

规范化路径，如..和/

>>> os.path.normpath('c://windows\\System32\\../Temp/')

'c:\\windows\\Temp'   

>>> a='/Users/jieli/test1/\\\a1/\\\\aa.py/../..'

>>> print(os.path.normpath(a))

/Users/jieli/test1

os.path.normcase()与os.path.normpath()

os路径处理

#方式一：推荐使用

import os

#具体应用

import os,sys

possible_topdir = os.path.normpath(os.path.join(

    os.path.abspath(__file__),

    os.pardir, #上一级

    os.pardir,

    os.pardir

))

sys.path.insert(0,possible_topdir)

#方式二：不推荐使用

os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

路径处理

sys模块

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

sys.modules.keys()   #返回所有已经导入的模块列表

sys.exc_info()    #获取当前正在处理的异常类,exc_type、exc_value、exc_traceback当前处理的异常详细信息

sys.exit(n)    #程序，正常退出时exit(0)

sys.hexversion    #获取Python解释程序的版本值，16进制格式如：0x020403F0

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

sys.maxint     #最大的Int值

sys.maxunicode    #最大的Unicode值

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

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

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

sys.stdout     #标准输出

sys.stdin     #标准输入

sys.stderr     #错误输出

sys.exc_clear()   #用来清除当前线程所出现的当前的或最近的错误信息

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

sys.byteorder    #本地字节规则的指示器，big-endian平台的值是'big',little-endian平台的值是'little'

sys.copyright    #记录python版权相关的东西

sys.api_version   #解释器的C的API版本

sys.version_info   #获取Python解释器的版本信息

sys.getwindowsversion  #获取Windows的版本

sys.getdefaultencoding  #返回当前你所用的默认的字符编码格式

sys.getfilesystemencoding #返回将Unicode文件名转换成系统文件名的编码的名字

sys.setdefaultencoding(name) #用来设置当前默认的字符编码

sys.builtin_module_names #Python解释器导入的模块列表

sys.executable    #Python解释程序路径

sys.stdin.readline   #从标准输入读一行，sys.stdout.write("a") 屏幕输出a

处理模块：我们在使用模块的某一个功能前，需要用import,__import__命令导入。那我们在执行import module_name的时候，python内部发生了什么呢？简单的说，就是搜索module_name。根据sys.path的路径来搜索module.name

import sys

print（sys.path）

['', '/usr/lib/python2.7', '/usr/lib/python2.7/plat-x86_64-linux-gnu', '/usr/lib/python2.7/lib-tk', '/usr/lib/python2.7/lib-old', '/usr/lib/python2.7/lib-dynload', '/usr/local/lib/python2.7/dist-packages', '/usr/lib/python2.7/dist-packages', '/usr/lib/python2.7/dist-packages/PILcompat', '/usr/lib/python2.7/dist-packages/gtk-2.0', '/usr/lib/pymodules/python2.7', '/usr/lib/python2.7/dist-packages/ubuntu-sso-client']

我们以后写好的模块就可以放到上面的某一个目录下，便可以正确搜索到了。当然也可以添加自己的模块路径。sys.path.append(“my module path”)。

>>> sys.path.append('my module path')

>>> sys.path

['', '/usr/lib/python2.7', '/usr/lib/python2.7/plat-x86_64-linux-gnu', '/usr/lib/python2.7/lib-tk', '/usr/lib/python2.7/lib-old', '/usr/lib/python2.7/lib-dynload', '/usr/local/lib/python2.7/dist-packages', '/usr/lib/python2.7/dist-packages', '/usr/lib/python2.7/dist-packages/PILcompat', '/usr/lib/python2.7/dist-packages/gtk-2.0', '/usr/lib/pymodules/python2.7', '/usr/lib/python2.7/dist-packages/ubuntu-sso-client', 'my module path']

path列表是一个由目录名构成的列表, Python 从中查找扩展模块( Python 源模块, 编译模块,或者二进制扩展).
启动 Python 时,这个列表根据内建规则, PYTHONPATH 环境变量的内容, 以及注册表( Windows 系统)等进行初始化.
由于它只是一个普通的列表, 你可以在程序中对它进行操作。使用sys模块查找已导入的模块（sys.modules）：
modules 字典包含所有加载的模块。 import 语句在从磁盘导入内容之前会先检查这个字典。Python 在处理你的脚本之前就已经导入了很多模块.

>>> import sys

>>> type(sys.modules)

<type 'dict'>

>>> sys.modules.keys()

['copy_reg', 'sre_compile', '_sre', 'encodings', 'site', '__builtin__', 'sysconfig', '__main__', 'encodings.encodings',

 'abc', 'posixpath', '_weakrefset', 'errno', 'encodings.codecs', 'sre_constants', 're', '_abcoll', 'types', '_codecs', 

'encodings.__builtin__', '_warnings', 'genericpath', 'stat', 'zipimport', '_sysconfigdata', 'warnings', 'UserDict', 

'encodings.utf_8', 'sys', 'codecs', 'readline', '_sysconfigdata_nd', 'os.path', 'sitecustomize', 'signal', 'traceback',

 'linecache', 'posix', 'encodings.aliases', 'exceptions', 'sre_parse', 'os', '_weakref']

>>> len(sys.modules.keys())

43

打印进度条

#指定宽度

print("[%-15s]"%'#')

print("[%-15s]"%'##')

#打印%

print("%s%%"%(100))  #第二个%号代表取消第一个%的特殊意义

#可传参来控制宽度

print('[%%-%ds]' %50) #[%-50s]

print(('[%%-%ds]' %50) %'#')

print(('[%%-%ds]' %50) %'##')

print(('[%%-%ds]' %50) %'###')

'''

字符串输出 %s,%10s--右对齐，占位符10位；%-10-----左对齐，占位符10位；

'''

import sys

import time

def progress(percent,width=50):

    if percent >= 1:

        percent=1

    show_str=('[%%-%ds]' %width) %(int(width*percent)*'#')

    print('\r%s %d%%' %(show_str,int(100*percent)),file=sys.stdout,flush=True,end='')

#\r是回车的意思

#应用

data_size=102500

recv_size=0

while recv_size < data_size:

    time.sleep(0.1) #模拟数据的传输延迟

    recv_size+=1024 #每次收1024

    percent=recv_size/data_size #接收的比例

    progress(percent,width=70) #进度条的宽度70

print官方文档分析

print(…)

print(value, …, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False)

Prints the values to a stream, or to sys.stdout by default.

Optional keyword arguments:

file: a file-like object (stream); defaults to the current sys.stdout.

sep: string inserted between values, default a space.

end: string appended after the last value, default a newline.

flush: whether to forcibly flush the stream.

参数解析

value：需要输出的值，可以是多个，用”,”分隔。

sep：多个输出值之间的间隔，默认为一个空格。

end：输出语句结束以后附加的字符串，默认是换行（’\n’）。

file：输出的目标对象，可以是文件也可以是数据流，默认是“sys.stdout”。

flush：flush值为True或者False，默认为Flase,表示是否立刻将输出语句输出到目标对象。

print参数分析

默认：print(value, …, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False)

>>> print("hello world")

hello world12

当value有多个：

>>> print("hello","world")

hello world12

当sep为”,”

>>> print("hello","world",sep=",")

hello,world12

当end为“”

>>>print("hello","world",end="")

>>>print("hello","world")

hello worldhello world123

当file指向test.txt

test = open("test.txt", "w")

print("hello","world",sep="\n", file=test)

123

此时当前目录下会新建一个test.txt文件里面内容为

hello

world12

flush=False

该参数只有两个选项True or False。

当flush=False时,输出值会存在缓存，然后在文件被关闭时写入。

当flush=True时,输出值强制写入文件。

实际举例

functools

该模块为高阶函数提供支持——作用于或返回函数的函数被称为高阶函数。在该模块看来，一切可调用的对象均可视为本模块中所说的“函数”。

python3.6中的functools

import functools

for i in dir(functools):

    print(i)

运行结果

'''

MappingProxyType

RLock

WRAPPER_ASSIGNMENTS

WRAPPER_UPDATES

WeakKeyDictionary

_CacheInfo

_HashedSeq

__all__

__builtins__

__cached__

__doc__

__file__

__loader__

__name__

__package__

__spec__

_c3_merge

_c3_mro

_compose_mro

_convert

_find_impl

_ge_from_gt

_ge_from_le

_ge_from_lt

_gt_from_ge

_gt_from_le

_gt_from_lt

_le_from_ge

_le_from_gt

_le_from_lt

_lru_cache_wrapper

_lt_from_ge

_lt_from_gt

_lt_from_le

_make_key

cmp_to_key

get_cache_token

lru_cache

namedtuple

partial

partialmethod

recursive_repr

reduce

singledispatch

total_ordering

update_wrapper

wraps

'''

partial函数(偏函数)

把一个函数的某些参数设置默认值，返回一个新的函数，调用这个新函数会更简单

import functools

def show_parameter(*args, **kw):

    print(args)

    print(kw)

p1 = functools.partial(show_parameter(), 1, 2, 3)

p1()

'''

(1, 2, 3)

{}

'''

p1(4, 5, 6)

'''

(1, 2, 3, 4, 5, 6)

{}

'''

p1(a='python', b='itcast')

'''

(1, 2, 3)

{'a': 'python', 'b': 'itcast'}

'''

p2 = functools.partial(show_parameter, a=3, b='linux')

p2()

'''

()

{'a': 3, 'b': 'linux'}

'''

p2(1, 2)

'''

(1, 2)

{'a': 3, 'b': 'linux'}

'''

p2(a='python', b='itcast')

'''

()

{'a': 'python', 'b': 'itcast'}

'''

wraps函数

使用装饰器时，有一些细节需要被注意。例如，被装饰后的函数其实已经是另外一个函数了（函数名等函数属性会发生改变）。

添加后由于函数名和函数的doc发生了改变，对测试结果有一些影响，例如

def outter(func):

    "outter function"

    def wrapper():

        "wrapper function"

        print('outter something')

        return func()

    return wrapper

@outter

def test():

    "test function"

    print('I am test')

test()

print(test.__doc__)    #这里面的__doc__改变了

执行结果

'''

outter something

I am test

wrapper function

'''

所以，Python的functools包中提供了一个叫wraps的装饰器来消除这样的副作用

import functools

def outter(func):

    "outter function"

    @functools.wraps(func)

    def wrapper():

        "wrapper function"

        print('outter something')

        return func()

    return wrapper

@outter

def test():

    "test function"

    print('I am test')

test()

print(test.__doc__)

执行结果

'''

outter something

I am test

test function

'''

码农公寓