python datetime 格式化_python 基础 — 常用模块

点击上方蓝字“ Python圈子 ”，进行关注~

import(modulename)：导入模块

math

>>> import math

1、向上取整

math.ceil()

>>> num = 3.14
>>> math.ceil(num)
4

2、向下取整

math.floor()

>>> num = 5.9
>>> math.floor(num)
5
#或
>>> int(num)
5

datetime

>>>from datetime import datetime

1、获取当前格式化日期

>>> print(datetime.now())
2017-09-30 09:12:31.070312

2、获取指定日期和时间

>>> dt = datetime(2017, 10, 1, 6, 30)
>>> print(dt)
2017-10-01 06:30:00

3、把格式化时间转换为时间戳。python 的 tempstamp 是一个浮点数。小数位表示毫秒数

>>> dt = datetime(2017, 9, 30, 9, 48)
>>> dt.timestamp()
1506736080.0

4、格式化时间戳

>>> t = 1506736080.0
>>> print(datetime.fromtimestamp(t))
2017-09-30 09:48:00
注：datetime.utcfromtimestamp(t)：直接转换到utc标准时区的时间

5、datetime 转换为 str

>>> now = datetime.now()
>>> datetime.now().strftime('%Y-%m-%d %H:%M:%S')
'2018-03-03 22:06:44'

6、datetime 加减

>>> from datetime import datetime, timedelta

>>> now = datetime.now()
>>> print(now)
2017-09-30 10:36:54.148904
>>> print(now + timedelta(hours=1))
2017-09-30 11:36:54.148904
>>> print(now + timedelta(days=1))
2017-10-01 10:36:54.148904
>>> (datetime.now()-timedelta(days=1, hours=1, minutes=1, seconds=1)).strftime('%Y-%m-%d %H:%M:%S')
'2018-03-02 21:15:24'

7、datetime.now().timetuple()

返回当前时间 struct_time 格式

>>> datetime.now().timetuple()
time.struct_time(tm_year=2017, tm_mon=10, tm_mday=1, tm_hour=19, tm_min=45, tm_sec=29, tm_wday=6, tm_yday=274, tm_isdst=-1)

8、datetime.now().replace()

传入的参数会替换结果时间，如果什么都没传，则返回调用 replace () 的时间对象

>>> datetime.now().replace(2017,10,1)
datetime.datetime(2017, 10, 1, 19, 49, 53, 838155)

time

>>>import time

1、time.localtime()

>>> time.localtime()
time.struct_time(tm_year=2017, tm_mon=9, tm_mday=30, tm_hour=11, tm_min=28, tm_sec=1, tm_wday=5, tm_yday=273, tm_isdst=0)
索引(index) 属性(attribute) 值(values)
0 tm_year(年) 2017
1 tm_mon(月) 1-12
2 tm_mday(日) 1-31
3 tm_hour(时) 0-23
4 tm_min(分) 0-59
5 tm_sec(秒) 0-59
6 tm_wday(周) 0-6(0是周日)
7 tm_yday 一年中第几天
8 tm_isdst(夏令制)

2、time.sleep (second)：让程序暂停 second 秒后运行

3、time.time ()：返回当前时间戳

>>> time.time()
1506742662.695589

4、获取格式化时间

>>> print(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime()))
2017-09-30 11:41:21

5、time.clock()：

该函数有两个功能，

在第一次调用的时候，返回的是程序运行的实际时间；

以第二次之后的调用，返回的是自第一次调用后，到这次调用的时间间隔

在 win32 系统下，这个函数返回的是真实时间(wall time)，而在 Unix/Linux 下返回的是 CPU 时间。

6、指定日期转换为时间戳

import time
t = "2017-11-24 17:30:00"
#将其转换为时间数组
timeStruct = time.strptime(t, "%Y-%m-%d %H:%M:%S")
#转换为时间戳:
timeStamp = int(time.mktime(timeStruct))
print(timeStamp)
#结果：
1511515800

7、指定时间戳格式化

timeStamp = 1511515800
localTime = time.localtime(timeStamp)
strTime = time.strftime("%Y-%m-%d %H:%M:%S", localTime)
print(strTime)
结果：
2017-11-24 17:30:00

sys

>>>import sys

1、sys.argv

获取传入脚本的参数，第一个参数是脚本本身

test.py
print(sys.argv)
F:\python\test>python test.py 1 2 3
['test.py', '1', '2', '3']

2、sys.path

返回模块的搜索路径，从当前文件所在路径开始搜索

>>> sys.path
['', 'D:\\Software\\python36.zip', 'D:\\Software\\DLLs', 'D:\\Software\\lib', 'D:\\Software', 'D:\\Software\\lib\\site-packages']

3、sys.version

返回 python 版本信息

>>> sys.version
'3.6.2 (v3.6.2:5fd33b5, Jul 8 2017, 04:57:36) [MSC v.1900 64 bit (AMD64)]'

4、sys.exit()

退出程序，和 exit () 功能一样

>>> sys.exit('good bye')
good bye
C:\Users\HONOUR-CYY>

5、sys.platform

返回操作系统平台名称

>>> sys.platform
'win32'

6、sys.stdout.write(str)

在屏幕上打印数据

>>> sys.stdout.write('hello')
hello
>>> sys.stdout.write('\r') #刷新之前输出到屏幕的内容

7、sys.stdout.flush()

刷新缓冲区的内容到屏幕

pickle

序列化：把变量从内存中变成可存储或传输的过程称之为序列化

>>>import pickle

1、pickle.dumps()

把任意对象序列化成一个 bytes，

>>> d = dict(name='chenyy', age=20)
>>> a = pickle.dumps(d)
>>> a
b'\x80\x03}q\x00(X\x04\x00\x00\x00nameq\x01X\x06\x00\x00\x00chenyyq\x02X\x03\x00\x00\x00ageq\x03K\x14u.'

pickel.dump ()：直接把一个序列化对象写入文件

>>> f = open('dump.txt', 'wb')
>>> pickle.dump(d, f)
>>> f.close()

2、pickel.loads()

反序列化出对象

>>> pickle.loads(a)
{'name': 'chenyy', 'age': 20}

pickle.load ()：方法从一个 file-like Object 中直接反序列化出对象

>>> f = open('dump.txt', 'rb')
>>> d pickle.load(f)
>>> f .close()
>>> d
{'name': 'chenyy', 'age': 20}

json

>>> import json

1、json.dumps()

把对象转化为一个字符串

>>> d = dict(name='chenyy', age=18)
>>> json.dumps(d)
'{"name": "chenyy", "age": 18}'
json.dump()方法可以直接把json写入一个file-like Object

2、json.loads()

把 json 反序列化为 python 对象

>>> json_str = json.dumps(d)
>>> json.loads(json_str )
{'name': 'chenyy', 'age': 18}

json.load () 方法从 file-like Object 中读取字符串并反序列化

os

1、os.getcwd()

获取当前工作目录

>>> os.getcwd()
'C:\\Users\\HONOUR-CYY'

2、os.chdir(dir)

改变当前脚本工作目录

>>> os.chdir('D:')
>>> os.getcwd()
'D:\\'

3、os.pardir

返回当前目录的父目录('..')

>>> os.pardir
'..'

4、os.curdir

返回当前目录('.')

>>> os.curdir
'.'

5、os.makedirs(dir)

递归生成多层目录

>>> os.makedirs('a/b/c')

6、os.removedirs(dir)

递归向上删除空目录。如果目录非空则抛出异常

>>> os.removedirs('D:/a/b/c')

7、os.mkdir(dir)

生成目录

os.mkdir('b')

8、os.rmdir(dir)

删除一个空目录

9、os.listdir()

返回指定目录下的所有文件和子目录，包括隐藏文件，以列表形式返回。只会获取一层

10、os.remove(file)

删除一个文件

11、os.rename('oldname','newname')

重命名文件或目录

12、os.stat()

获取文件或目录信息

>>> os.stat('./d.txt')
os.stat_result(st_mode=33206, st_ino=562949953466137, st_dev=462496, st_nlink=1, st_uid=0, st_gid=0, st_size=12, st_atime=1506996315, st_mtime=1506996321, st_ctime=1506996315)

13、os.sep

返回操作系统特定的分隔符，win 下为 '\'，Linux 下为‘/’

>>> os.sep
'\\'

14、os.linesep

返回操作系统的行终止符 win 下为 "\r\n"，Linux 下为 "\n"

>>> os.linesep
'\r\n'

16、os.name

返回当前操作系统

win：
>>> os.name
'nt'
linux：
>>> os.name
'posix'

17、os.system(command)

可以用来直接运行 shell 命令

>>> os.system('tree')
卷 文档 的文件夹 PATH 列表
卷序列号为 0000008E 0007:0EA0
E:.
└─d
└─b
└─c
0

18、os.environ

返回系统环境变量

19、os.path.abspath(path)

返回 path 规范化的绝对路径

>>> os.path.abspath('./d.txt')
'E:\\test\\d.txt'

20、os.path.split(path)

将 path 分割成目录和文件名，以元组返回

>>> os.path.split('D:/test/d.txt')
('D:/test', 'd.txt')
>>> os.path.split('F:/python/a')
('F:/python', 'a')

21、os.path.dirname(path)

返回 path 的目录，即 os.path.split (path) 获取的第一个元素

>>> os.path.dirname('D:/test/d.txt')
'D:/test'
>>> os.path.dirname('F:/python/a')
'F:/python'

22、os.path.basename(path)

返回 os.path.split (path) 获取的第二个元素

>>> os.path.basename('D:/test/d.txt')
'd.txt'
>>> os.path.basename('F:/python/a')
'a'

23、os.path.exists(path)

判断 path 是否存在，返回布尔值

>>> os.path.exists('E:/test/d')
True
>>> os.path.exists('E:/test/d.txt'
True

24、os.path.isabs(path)

是否为绝对路径，返回布尔值

>>> os.path.isabs('E:/test/d.txt')
True
>>> os.path.isabs('./x.txt')
False

25、os.path.isfile(file)

判断文件是否存在，返回布尔值。目录返回 False

>>> os.path.isfile('./d.txt')
True

26、os.path.isdir(dir)

判断目录是否存在，返回布尔值。文件返回 False

>>> os.path.isdir('./d')
True

27、os.path.join(path1[, path2...])

将多个路径组合后返回

>>> os.path.join('/data','myproject','chenyy')
'/data/myproject/chenyy'

28、os.path.getatime(path)

返回 path 所指向的文件或者目录的最后存取时间，浮点数

>>> os.path.getatime('./d.txt')
1506996315.766825

29、os.path.getmtime(path)

返回 path 所指向的文件或目录的最后修改时间，浮点数

>>> os.path.getmtime('./d.txt')
1506996321.7812703

30、os.path.getctime(path)

返回 path 的创建时间，浮点数

>>> os.path.getctime('./d.txt')
1506996315.766825

31、os.path.getsize(file)

返回文件大小，如果是目录则返回 0

>>> os.path.getsize('./d.txt')
12
>>> os.path.getsize('./d')
0

32、os.path.splitext(file)

>>> os.path.splitext('log.text')
以元组形式返回文件名和后缀
('log', '.text')

33、os.startfile(path)

windows 中特有的函数，启动外部程序

hashlib

>>> import hashlib
>>> md5 = hashlib.md5()
>>> md5.update('123456'.encode('utf-8'))
>>> md5.hexdigest()
'e10adc3949ba59abbe56e057f20f883e'
如果数据量很大，可以分块多次调用update()，最后计算的结果是一样的：
>>> md5 = hashlib.md5()
>>> md5.update('123'.encode('utf-8'))
>>> md5.update('456'.encode('utf-8'))
>>> md5.hexdigest()
'e10adc3949ba59abbe56e057f20f883e'

configparser

解析配置文件(假设有个 ini 的配置文件，内容如下)

[cyy]
age = 18
name = cyy
[chenyy]
age : 24
name : chenyy

>>> import configparser
>>> con = configparser.ConfigParser()
>>> con.read('ini', encoding='utf-8')
['ini']

con.sections()

获取所有节点

>>> con.sections()
['cyy', 'chenyy']

con.options(section)

获取指定节点下所有键

>>> con.options('cyy')
['age', 'name']

con.items(section)

获取指定节点下所有键值对

>>> con.items('chenyy')
[('age', '24'), ('name', 'chenyy')]

con.get(section,key)

获取指定节点下指定键对应的值

>>> con.get('chenyy','age')
'24'
con.getint(section,key) #把返回的值转换为整型
con.getfloat(section,key) #把返回的值转换为浮点型
con.getboolean(section,key) #把返回的值转换为布尔型

con.has_section(section)

检查节点是否存在，返回布尔值

>>> con.has_section('abc')
False
>>> con.has_section('cyy')
True

con.add_section(section)

con.write(open(file,'w'))

添加节点

>>> con.add_section('abc')
>>> con.write(open('ini','w'))

con.remove_section(section)

con.write(open(file,'w'))

删除节点，返回布尔值，删除成功后需要写入保存

>>> con.remove_section('abc')
True
>>> con.write(open('ini','w'))

con.has_option(section,key)

检查节点下的 key 是否存在，返回布尔值

>>> con.has_option('cyy','age')
True

con.set(section,key,value)

con.write(open(file,'w'))

设置指定节点下的键值对

>>> con.set('chenyy','name','chenyy')
>>> con.write(open('ini','w'))

con.remove_option(section,key)

con.write(open(file,'w'))

删除指定节点下的键，返回布尔值，删除成功后需要写入文件保存

>>> con.remove_option('chenyy','name')
True
>>> con.write(open('ini','w'))

shutil

文件、文件夹、压缩包处理模块

>>> import shutil

1、shutil.copyfileobj(oldfile_object,newfile_object)

将文件内容拷贝到另一个文件中

>>> import shutil
>>> shutil.copyfileobj(open('ini','r'),open('new','w'))

2、shuutil.copyfile(filepath,filepath)

拷贝文件，文件不存在则创建

>>> shutil.copyfile('d.txt','./d/d.txt')
'./d/d.txt'

3、shutil.copymode()

仅拷贝权限，内容，组，用户均不变

4、shutil.copystat()

仅拷贝文件的状态信息，包括：mode bits, atime, mtime, flags

5、shutil.copy()

拷贝文件和权限

6、shutil.copy2()

拷贝文件和状态

7、shutil.copytree(olddir, newdir, symlinks=False, ignore=None)

递归拷贝目录下的所有文件和文件夹，newdir 不存在则创建

参数 ignore=shutil.ignore_patterns (pattern)，代表不拷贝正则匹配项匹配到的文件或目录

8、shutil.rmtree(dir)

递归删除目录下的所有文件和文件夹

9、shutil.move(olddir, newdir)

递归移动目录，也可重命名目录，类似 linux 的 mv

10、shutil.make_archive(filename, format, root_dir,owner,group)

压缩文件，返回压缩后的压缩包绝对路径

filename：压缩包的文件名，可以指定路径

format：压缩包种类，zip,tar,bztar,gztar

root_dir：需要压缩文件的路径

owner：用户，默认当前用户、

group：组，默认当前组

>>> shutil.make_archive('../www','gztar',root_dir='./o')
'E:\\www.tar.gz'

zipfile

>>> import zipfile

压缩文件

z = zipfile.ZipFile(zipname,format)

z.write(filename)

z.close()

format：文件写入模式，'w', 'a'。w 方式会清空压缩包里的所有内容

>>> import zipfile
>>> z = zipfile.ZipFile('test.zip', 'a')
>>> z.write('./d.txt') #如果写入一个目录则只会写入一个空目录，不会写入该目录下其它文件或文件夹
>>> z.close()

解压文件

z = zipfile.ZipFile(zipname,format)

z.extractall()

z.close()

解压过后压缩包文件仍然在

>>> zip = zipfile.ZipFile('./test.zip','r')
>>> zip.extractall()
>>> zip.close()

z = zipfile.ZipFile(zipname,format)

z.namelist()

z.close()

以列表返回压缩包里的所有文件和目录

>>> z = zipfile.ZipFile('test.zip','r')
>>> z.namelist()
['new', 'd/']

z = zipfile.ZipFile(zipname,format)

z.extract(file)

z.close()

解压压缩包里的指定文件或目录

>>> z = zipfile.ZipFile('test.zip','r')
>>> z.extract('new')
'E:\\test\\new'
>>> z.close()

tarfile

>>> import tarfile

压缩

tar = tarfile.open(tarname,format)
tar.add(filepath,arcname=alias)
tar.close()
#arcname：把文件压缩进压缩包后可以换个文件名
#解压
tar = tarfile.open(tarname,format)
tar.extractall()
tar.close()

logging

记录日志>>> import logging

logging.basicConfig(
    filename='log.log',
    format='%(asctime)s - %(name)s - %(levelname)s - %(module)s: %(message)s',
    datefmt='%Y-%m-%d %H:%M:%S %p',
    level=logging.INFO
)
#level：日志等级
CRITICAL = 50
FATAL = CRITICAL
ERROR = 40
WARNING = 30
WARN = WARNING
INFO = 20
DEBUG = 10
NOTSET = 0

logging.critical()
logging.fatal()
logging.error()
logging.waring()
logging.info()
logging.debug()

collections

namedtuple (name,[属性 list])

namedtuple 是一个函数，它用来创建一个自定义的 tuple 对象，并且规定了 tuple 元素的个数，并可以用属性而不是索引来引用 tuple 的某个元素

>>> from collections import namedtuple
>>> P = namedtuple('Point', ['x', 'y'])
>>> p = P(1, 2)
>>> p.x
1
>>> p.y
2

deque

使用 list 存储数据时，按索引访问元素很快，但是插入和删除元素就很慢了，因为 list 是线性存储，数据量大的时候，插入和删除效率很低。

deque 是为了高效实现插入和删除操作的双向列表，适合用于队列和栈

>>> from collections import deque
>>> q = deque(['a', 'b', 'c'])
>>> q.append('d')
>>> q.appendleft('o')
>>> q
deque(['o', 'a', 'b', 'c', 'd'])

deque 除了实现 list 的 append () 和 pop () 外，还支持 appendleft () 和 popleft ()

defaultdict

defaultdict 创建的字典在引用的 key 不存在时返回一个默认值

>>> from collections import defaultdict
>>> dd = defaultdict(lambda: 'N/A')
>>> dd['key1'] = 'a'
>>> dd['key1']
'a'
>>> dd['key2']
'N/A'

OrderedDict

OrderedDict 会根据插入 key 的顺序排序

>>> from collections import OrderedDict
>>> od = OrderedDict()
>>> od['a'] = 1
>>> od['c'] = 2
>>> od['b'] = 3
>>> od
OrderedDict([('a', 1), ('c', 2), ('b', 3)])

itertools

chain()

chain () 可以把一组迭代对象串联起来，形成一个更大的迭代器

>>> import itertools
>>> for i in itertools.chain('abc', 'xyz', 'def'):
... print(i)
...
a
b
c
x
y
z
d
e
f

注：原文源自网络END

◆  当初脑子进了水，偏偏要做互联网…

◆  这才是我们认识的程序员！！！

◆  致前行者 | 中国AI创业悲喜十年

◆  互联网人十二时辰的真实写照

◆  程序员与产品经理的友谊:打成共识