pathlib：
pathlib介绍-比os.path更好的路径处理方式：https://zhuanlan.zhihu.com/p/33524938
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 输出用于分割文件路径的字符串
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所指向的文件或者目录的最后修改时间
import os print(__file__)
print(os.path.dirname(__file__)) # 取python文件路径名、目录名
print(os.path.dirname(os.path.dirname(__file__))) # 返回上一级目录
print(os.path.basename(__file__)) # 取python文件文件名
# 输出：
C:/Users/w/PycharmProjects/python/hashlib/0718.py
C:/Users/w/PycharmProjects/python/hashlib
C:/Users/w/PycharmProjects/python
0718.py
# -*- coding: utf-8 -*- import os
import sys
#from bin import s3 print(os.path.dirname(__file__))
print(os.path.basename(__file__)) p1 = os.path.dirname(__file__)
p2 = 'bin'
p = os.path.join(p1, p2)
print(p) sys.path.append(p) # 相比于下面的添加路径方法，好处在于改了路径名，不需改代码
#sys.path.append(r'C:\Users\w\PycharmProjects\python\hashlib\bin') for i in sys.path: # 默认根据列表中的路径找模块
print(i)
print('-------------------------') import s3
s3.test() 输出：
C:/Users/w/PycharmProjects/python/hashlib
0718.py
C:/Users/w/PycharmProjects/python/hashlib\bin
C:\Users\w\PycharmProjects\python\hashlib
C:\Users\w\PycharmProjects
C:\Users\w\AppData\Local\Programs\Python\Python35\python35.zip
C:\Users\w\AppData\Local\Programs\Python\Python35\DLLs
C:\Users\w\AppData\Local\Programs\Python\Python35\lib
C:\Users\w\AppData\Local\Programs\Python\Python35
C:\Users\w\AppData\Local\Programs\Python\Python35\lib\site-packages
C:/Users/w/PycharmProjects/python/hashlib\bin
-------------------------
=======in s3========
模块路径添加方法
import os
import sys
sys.path.append(os.path.join(os.path.dirname(__file__), 'bin'))
一行代码添加路径
import sys
import os #导入父目录下的另一个目录到系统路径sys.path sys.path.append(os.path.join(os.path.dirname(os.path.dirname(__file__)), 'day3'))
目录遍历:
os.walk(top, topdown=True, onerror=None, followlinks=False)
可以得到一个三元tupple(dirpath, dirnames, filenames),
第一个为起始路径，第二个为起始路径下的文件夹，第三个是起始路径下的文件。
dirpath 是一个string，代表每一个基于top的目录路径，
dirnames 是一个list，包含了dirpath下所有子目录的名字。
filenames 是一个list，包含了非目录文件的名字。
这些名字不包含路径信息，如果需要得到基于top的全路径，需要使用os.path.join(dirpath, name).
例：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import os
a = '/home/yumiao/sp2p_web-20170413-01'
for dirpath,dirnames,filenames in os.walk('/home/yumiao/sp2p_web-20170413-01'):
for filename in filenames:
#遍历所有文件(绝对路径)
print dirpath+filename
for dir in dirnames:
#遍历所有目录
print dir
# 获取一个目录下所有文件,不包括空目录
import os
for dirpath,dirnames,filenames in os.walk('/root'):
for filename in filenames:
print dirpath+'/'+filename
[root@centos6 yumiao]# tree -L 1 /data/apache-tomcat
/data/apache-tomcat
├── apache-tomcat-sp2p-web-1025
├── tomcat-cms-app-1038
├── tomcat-jenkins-2025
├── tomcat-jenkins-2026
└── tomcat-mobi_server-1029
for dirpath,dirnames,filenames in os.walk(rootdir):
# for filename in filenames:
# directory = dirpath.split(rootdir)
# print directory
#for file in filenames:
# print dirpath+file
#print dirnames
#print dirpath
print filenames
if count > 4:
break
count += 1
dirpath: 是字符串，是目录的路径
/data/apache-tomcat
/data/apache-tomcat/tomcat-jenkins-2026
/data/apache-tomcat/tomcat-jenkins-2026/logs
/data/apache-tomcat/tomcat-jenkins-2026/bin
/data/apache-tomcat/tomcat-jenkins-2026/webapps
/data/apache-tomcat/tomcat-jenkins-2026/webapps/ROOT
dirnames: 是一个列表，dirpath中（除了.和..）包含了所有子目录名字
['tomcat-jenkins-2026', 'tomcat-jenkins-2025', 'tomcat-cms-app-1038', 'tomcat-mobi_server-1029', 'apache-tomcat-sp2p-web-1025']
['logs', 'bin', 'webapps', 'work', 'lib', 'conf', 'temp']
[]
[]
['ROOT']
['images', 'jsbundles', 'help', 'executable', 'scripts', 'WEB-INF', 'css', 'META-INF']
filenames:是一个列表，包含了dirpath路径下所有非目录的文件名
[]
['NOTICE', 'RELEASE-NOTES', 'LICENSE', 'RUNNING.txt']
['catalina.2017-02-07.log', 'catalina.2017-02-13.log', 'catalina.2017-02-14.log', 'catalina.2017-02-12.log', 'access_log.2017-02-07.txt', 'access_log.2017-02-08.txt', 'host-manager.2017-02-07.log', 'catalina.2017-02-11.log', 'catalina.2017-02-09.log', 'catalina.2017-02-10.log', 'catalina.out', 'catalina.2017-02-08.log', 'manager.2017-02-07.log', 'localhost.2017-02-07.log']
['configtest.bat', 'startup.bat', 'version.bat', 'tool-wrapper.sh', 'version.sh', 'catalina-tasks.xml', 'bootstrap.jar', 'configtest.sh', 'digest.bat', 'tomcat-juli.jar', 'catalina.bat', 'tool-wrapper.bat', 'startup.sh', 'setclasspath.sh', 'catalina.sh', 'install.sh', 'setclasspath.bat', 'daemon.sh', 'shutdown.sh', 'commons-daemon-native.tar.gz', 'commons-daemon.jar', 'digest.sh', 'shutdown.bat', 'tomcat-native.tar.gz', 'run.sh']
['jenkins.war']
['LogFileOutputStream$2.class', 'MainDialog$1$1.class', 'MainDialog.class', 'dc-license.txt', 'winstone.jar', 'robots.txt', 'Main.class', 'LogFileOutputStream$1.class', 'JNLPMain.class', 'favicon.ico', 'ColorFormatter.class', 'LogFileOutputStream.class', 'index.jsp', 'Main$FileAndDescription.class', 'MainDialog$1.class']
walk(top, topdown=True, onerror=None, followlinks=False)
Directory tree generator.
For each directory in the directory tree rooted at top (including top
itself, but excluding '.' and '..'), yields a 3-tuple
dirpath, dirnames, filenames
dirpath is a string, the path to the directory. dirnames is a list of
the names of the subdirectories in dirpath (excluding '.' and '..').
filenames is a list of the names of the non-directory files in dirpath.
Note that the names in the lists are just names, with no path components.
To get a full path (which begins with top) to a file or directory in
dirpath, do os.path.join(dirpath, name).
# os.system（在python脚本中执行shell命令）
# Execute the command (a string) in a subshell.
# eg：
a = os.system('echo "this is py"')
print a
注意：
filename = 'demo2'
path = './'
os.system('rm -rf '+path+filename+'/*') 【-rf 后面一定要留一个空格出来否则会报错】
os.system()函数无法返回命令的输出。只会返回C函数运行成功与否的0或其他值。
判断路径或文件
os.path.join：join(a, *p)
Join two or more pathname components, inserting '/' as needed.If any component is an absolute path, all previous path components will be discarded.
An empty last part will result in a path that ends with a separator.
os.path.isabs(...) # 判断是否绝对路径 Test whether a path is absolute
os.path.exists(...) # 判断是否真实存在 exists(path) Test whether a path exists. Returns False for broken symbolic links
os.path.isdir(...) # 判断是否是个目录 Return true if the pathname refers to an existing directory
os.path.isfile(...) # 判断是否是个文件 isfile(path) Test whether a path is a regular file
注意： 把两个路径合成一个时，不要直接拼字符串，而要通过 os.path.join(part1,part2) 函数，这样可以正确处理不同操作系统的路径分隔符。在Linux/Unix/Mac下，os.path.join()返回这样的字符串 part1/part2而Windows下会返回这样的字符串： part1\part2
路径名、文件名分隔
os.path.split(...) # 分隔目录和文件名/文件夹名 split(p) Split a pathname. Returns tuple "(head, tail)" where "tail" is everything after the final slash. Either part may be empty.
os.path.splitdrive(...) # 分隔盘符(windows系统) splitdrive(p) Split a pathname into drive and path. On Posix, drive is always empty.
os.path.splitext(...) # 分隔文件和扩展名 splitext(p) Split the extension from a pathname. Extension is everything from the last dot to the end, ignoring leading dots. Returns "(root, ext)"; ext may be empty.
这些合并、拆分路径的函数并不要求目录和文件要真实存在，它们只对字符串进行操作。
工作目录及创建文件夹操作
os.getcwd() # 获取当前工作目录
os.chdir(...) # 改变工作目录 chdir(path)
os.listdir(...) # 列出目录下的文件 listdir(path)
os.mkdir(...) # 创建单个目录 mkdir(path [, mode=0777])#测试时好像不支持权限参数 注意：创建多级用 os.makedirs()
os.makedirs(...) # 创建多级目录 makedirs(path [, mode=0777]) mkdir recursive.
创建文件夹可能会出错，原因具体有：(1) path 已存在时(不管是文件还是文件夹) (2) 驱动器不存在 (3) 磁盘已满 (4) 磁盘是只读的或没有写权限
删除文件夹/文件
os.rmdir(...) # 删除空文件夹 注意：必须为空文件夹 如需删除文件夹及其下所有文件，需用 shutil
os.remove(...) # 删除单一文件
shutil.rmtree(...) # 删除文件夹及其下所有文件
tip1：清空指定文件夹下所有文件的方法
需要在执行某些代码前清空指定的文件夹，如果直接用os.remove()，可能出现因文件夹中文件被占用而无法删除，解决方法也很简单，先强制删除文件夹，再重新建同名文件夹即可
- import shutil
- shutil.rmtree('要清空的文件夹名')
- os.mkdir('要清空的文件夹名')
产生异常的可能原因: (1) 路径不存在 (2) 路径子目录中有文件或下级子目录（os.rmdir） (3) 没有操作权限或只读
tip2：把一个文件从一个文件夹移动到另一个文件夹，并同时重命名，用shutil：
shutil.move('原文件夹/原文件名','目标文件夹/目标文件名')
重命名文件夹/文件
可对某一文件或文件夹重命名 os.rename(oldfileName, newFilename)
注意：新文件的扩展名不能遗漏，理论上需要保持类型一致；但这也不失为改文件类型的一种方式（相当于直接改文件的扩展名）
shutil
复制、移动文件夹/文件 ：（new不指定路径，默认放到家目录）
shutil.copyfile("old","new") # (不copy权限)复制文件，都只能是文件 copyfile(src, dst) 注意：不会保持源文件权限，如果存在new会强制覆盖！！！
shutil.copytree("old","new") # 复制文件夹，都只能是目录，且new必须不存在 Recursively copy a directory tree using copy2() 保持源文件信息
shutil.copy("old","new") # (copy权限)复制文件/文件夹，复制 old 为 new（new是文件，若不存在，即新建，存在则覆盖！），复制 old 为至 new 文件夹（文件夹已存在）,相当于 cp src dst
shutil.move("old","new") # 移动文件/文件夹至 new 文件夹中 同Unix下的mv命令
shutil.copy2(src, dst) #只能复制文件，只保留stat信息 Copy data and all stat info ("cp -p src dst") The destination may be a directory
import shutil # 高级的 文件、文件夹、压缩包 处理模块
shutil.copyfileobj(open('log.log', 'r'), open('new_log.log', 'w')) # 将文件内容拷贝到另一个文件中 # 仅拷贝权限。内容、组、用户均不变 shutil.copymode(src, dst)
shutil.copymode('f1.log', 'f2.log') # 仅拷贝状态的信息，包括：mode bits, atime, mtime, flags shutil.copystat(src, dst)
shutil.copystat('f1.log', 'f2.log') # 递归的去拷贝文件夹 shutil.copytree(src, dst, symlinks=False, ignore=None)
shutil.copytree('folder1', 'folder2', ignore=shutil.ignore_patterns('*.pyc', 'tmp*'))
# 拷贝源文件，还是只拷贝软连接，用symlinks参数调节
shutil.copytree('f1', 'f2', symlinks=True, ignore=shutil.ignore_patterns('*.pyc', 'tmp*')) # 创建压缩包并返回文件路径，例如：zip、tar
# shutil.make_archive(base_name, format,...) base_name： 压缩包的文件名，也可以是压缩包的路径。只是文件名时，则保存至当前目录，否则保存至指定路径，
如：www =>保存至当前路径
如：/Users/wupeiqi/www =>保存至/Users/wupeiqi/
format： 压缩包种类，“zip”, “tar”, “bztar”，“gztar”
root_dir： 要压缩的文件夹路径（默认当前目录）
owner： 用户，默认当前用户
group： 组，默认当前组
logger： 用于记录日志，通常是logging.Logger对象 #将 /Users/wupeiqi/Downloads/test 下的文件打包放入www.gztar文件，放置当前程序目录
ret = shutil.make_archive("www", 'gztar', root_dir='/Users/wupeiqi/Downloads/test') #将 /Users/wupeiqi/Downloads/test 下的文件打包放置 /Users/wupeiqi/目录
ret = shutil.make_archive("/Users/wupeiqi/www", 'gztar', root_dir='/Users/wupeiqi/Downloads/test') # shutil 对压缩包的处理是调用 ZipFile 和 TarFile 两个模块来进行的，详细：
#处理zip包
import zipfile
# 压缩
z = zipfile.ZipFile('laxi.zip', 'w') # w方式创建，默认清空压缩包中的文件
z.write('a.log')
z.write('data.data') # 添加单独的文件到压缩包中
z.close() # 解压
z = zipfile.ZipFile('laxi.zip', 'r')
r = z.namelist() # 获取压缩文件列表
z.extractall() # 没有文件名，默认解压全部文件，有文件名，则解压单独文件
z.close() #处理tar包
import tarfile
# 压缩
tar = tarfile.open('your.tar','w')
tar.add('/Users/wupeiqi/PycharmProjects/bbs2.log', arcname='bbs2.log')
tar.add('/Users/wupeiqi/PycharmProjects/cmdb.log', arcname='cmdb.log')
tar.close() # 解压
tar = tarfile.open('your.tar','r')
tar.extractall() # 可设置解压地址
tar.close()
commands模块：
commands.getoutput('shell command') # 执行shell命令，返回结果（string类型），忽略返回值
commands.getstatusoutput('shell command') # 执行shell命令, 返回两个元素的元组tuple(status, result)，status为int类型，result为string类型。返回结果包含标准输出和标准错误.
commands.getstatus('file') # 该函数已被python丢弃，不建议使用，它返回 ls -ld file 的结果（String）
以上执行shell命令的相关的模块和函数的功能均在 subprocess 模块中实现，并提供了更丰富的功能
subprocess模块：
import subprocess call方法：执行命令，返回状态码
ret = subprocess.call(["ls", "-l"], shell=False) # shell为False时，会把命令解析为一个字符，所以要以列表形式输入
ret1 = subprocess.call("ls -l", shell=True) # check_call方法：执行命令，如果执行状态码是 0 ，则返回0，否则抛异常
subprocess.check_call(["ls", "-l"])
subprocess.check_call("exit 1", shell=True) # check_output:执行命令，如果状态码是 0 ，则返回执行结果，否则抛异常
subprocess.check_output(["echo", "Hello World!"])
subprocess.check_output("exit 1", shell=True) # Popen方法：用于执行复杂的系统命令，程序不会阻塞，而subprocess.run是阻塞的
参数：
args：shell命令，可以是字符串或者序列类型（如：list，元组）
bufsize：指定缓冲。0 无缓冲,1 行缓冲,其他 缓冲区大小,负值 系统缓冲
stdin, stdout, stderr：分别表示程序的标准输入、输出、错误句柄
preexec_fn：只在Unix平台下有效，用于指定一个可执行对象（callable object），它将在子进程运行之前被调用
close_sfs：在windows平台下，如果close_fds被设置为True，则新创建的子进程将不会继承父进程的输入、输出、错误管道。
所以不能将close_fds设置为True同时重定向子进程的标准输入、输出与错误(stdin, stdout, stderr)。
shell：同上
cwd：用于设置子进程的当前目录
env：用于指定子进程的环境变量。如果env = None，子进程的环境变量将从父进程中继承。
universal_newlines：不同系统的换行符不同，True -> 同意使用 \n
startupinfo与createionflags只在windows下有效
将被传递给底层的CreateProcess()函数，用于设置子进程的一些属性，如：主窗口的外观，进程的优先级等等 # 执行普通命令：
ret1 = subprocess.Popen(["mkdir","t1"])
ret2 = subprocess.Popen("mkdir t2", shell=True) 终端输入的命令分为两种： 输入即可得到输出，如：ifconfig
输入进行某环境，依赖再输入，如：python ，进入python交互环境 # 通过Popen创建目录：
obj = subprocess.Popen("mkdir t3", shell=True, cwd='/home/dev',) # 用于设置子进程的当前目录 # 通过subprocess.PIPE进行交互输入命令、读取（正确/错误）结果[因为subprocess是新启动一个进程，如果主进程想要获取子进程的结果（进程间通信），就要通过管道/socket来实现：即PIPE]
obj = subprocess.Popen(["python"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True)
obj.stdin.write("print(1)\n")
obj.stdin.write("print(2)")
obj.stdin.close() cmd_out = obj.stdout.read()
obj.stdout.close()
cmd_error = obj.stderr.read()
obj.stderr.close() print(cmd_out)
print(cmd_error) # 通过communicate多次单条命令交互
obj = subprocess.Popen(["python"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True)
obj.stdin.write("print(1)\n")
obj.stdin.write("print(2)") out_error_list = obj.communicate() # 相当于去读管道中的内容，obj.stdout.read()，obj.stderr.read()，并把读到的内容进行拼接，其中包含输出和错误输出
print(out_error_list) # 单条命令直接通过communicate执行，并从中获取结果
obj = subprocess.Popen(["python"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True)
out_error_list = obj.communicate('print("hello")')
print(out_error_list)
subprocess
该子模块允许你创建新的流程，连接到它们的输入/输出/错误管道，并获取他们的返回值。该模块打算替换多个旧的模块和功能：os.system 和 os.spawn *
使用subprocess时建议使用run()函数去处理所有它可以处理的情况，因为高级用法可以直接使用底层POPEN接口。
run（）函数是Python 3.5中新添加的。
使用方法：
subprocess.run(args, *, stdin=None, input=None, stdout=None, stderr=None, shell=False, timeout=None, check=False)
args 该参数用于启动进程。这可能是一个列表或一个字符串。 returncode 该参数表示子进程的退出状态。
通常情况下，0作为退出状态表明它成功运行。
负值-N表明子进程被信号N终止（仅POSIX）。 stdout 该参数表示标准输出
从子过程中捕获标准输出。一个字节序列，或字符串 （）如果运行一个字符串被称为与universal_newlines = TRUE。无如果stdout没有抓获。 如果您运行进程与标准错误= subprocess.STDOUT，输出和错误将在此属性相结合，和stderr将是无。 标准错误 从子过程中捕获标准错误。一个字节序列，或（）如果运行一个字符串被称为与universal_newlines = TRUE。无标准错误，如果没有抓获。 check_returncode（） 如果返回码不为零，养CalledProcessError。 先看个例子：
>>> import subprocess
>>> subprocess.run(["ls"])
run_server.py # ls命令返回的结果
CompletedProcess(args=['ls'], returncode=0) # run函数返回的结果
>>> subprocess.run(["ls", "-l"]) # 这个和上面的类似
总用量 4
-rw-r--r-- 1 root root 266 9月 22 14:35 run_server.py
CompletedProcess(args=['ls', '-l'], returncode=0) >>> subprocess.run(["ls"],stdout=subprocess.PIPE) # 加上stdout参数之后，系统命令返回的结果就不会输出了
CompletedProcess(args=['ls'], returncode=0, stdout=b'run_server.py\n') >>> a = subprocess.run(["ls"],stdout=subprocess.PIPE)
>>> print(a)
CompletedProcess(args=['ls'], returncode=0, stdout=b'run_server.py\n')
>>> print(a.stdout,a.args,a.returncode) # 可以对返回值进行操作
b'run_server.py\n' ['ls'] 0
subprocess run方法
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import logging
import subprocess
import sys
import smtplib
import string
import time
import subprocess
import datetime
from smtplib import SMTP_SSL
from email.header import Header
from email.mime.text import MIMEText
import socket #logging.basicConfig(filename='process_log',
logging.basicConfig(
format='%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s',
datefmt='%Y-%m-%d %H:%M:%S %p',
level=10) file_1_1 = logging.FileHandler('/var/log/process_log.log', 'a', encoding='utf-8')
fmt = logging.Formatter(fmt="%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s")
file_1_1.setFormatter(fmt) logger1 = logging.Logger('recommend-node1-doyo-feedstream-go', level=logging.ERROR)
logger1.addHandler(file_1_1) fail_check = 0
check_interval = 5 reload(sys)
sys.setdefaultencoding('utf-8')
text = ''
datetime = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
hostname = socket.gethostname() def S_Mail(text):
HOST = "smtp.exmail.qq.com"
SUBJECT = 'DOYO Process Monitor'.decode('utf-8').encode('gbk')
TO = 'whisky@doyo.tv'
FROM = "monitor@douyu.tv"
BODY = string.join((
"FROM: %s" % FROM,
"To: %s" % TO,
"Subject: %s" %SUBJECT,
"",
text
),"\r\n")
smtp = smtplib.SMTP_SSL(HOST,465)
smtp.ehlo()
smtp.login("monitor@douyu.tv","Hello123456")
smtp.sendmail(FROM,[TO],BODY)
smtp.quit() with open('/tmp/py_Email.log','a') as f:
date=time.strftime("%y-%m-%d %H:%M:%S")
str = date + " " + TO +" " + SUBJECT + "\r\n" + "\n"
str1 = str.decode('gbk').encode('utf-8')
# print("%s" %str1)
f.write(str1) def monitor_process(key_word, cmd, fail_check):
p1 = subprocess.Popen(['ps', '-ef'], stdout=subprocess.PIPE)
p2 = subprocess.Popen(['grep', key_word], stdin=p1.stdout, stdout=subprocess.PIPE)
p3 = subprocess.Popen(['grep', '-v', 'grep'], stdin=p2.stdout, stdout=subprocess.PIPE)
p4 = subprocess.Popen(['egrep', '-v', 'doyo-feedstream-go.log|su www'], stdin=p3.stdout, stdout=subprocess.PIPE) lines = p4.stdout.readlines()
if len(lines) > 0: # process is ok
return
else:
time.sleep(check_interval)
fail_check += 1
if fail_check < 4:
return monitor_process(key_word, cmd, fail_check)
else:
pass
sys.stderr.write('process[%s] is lost, run [%s]\n' % (key_word, cmd))
logger1.critical('process[%s] is lost, run [%s]\n' % (key_word, cmd))
#subprocess.call(cmd,env={'JAVA_HOME': '/usr/java/jdk1.8.0_181/'}, shell=True)
subprocess.call(cmd, shell=True)
msg = 'hostname:{0} msg: process:{1} is lost, run {2} , time: {3}'.format(hostname, key_word, cmd, datetime).decode('utf-8').encode('gbk')
S_Mail(msg) if __name__ == '__main__':
#monitor_process('doyo-feedstream-go', 'cd /data/doyo-feedstream-go/; su www -s nohup ./doyo-feedstream-go &', fail_check)
monitor_process('doyo-feedstream-go', 'cd /data/doyo-feedstream-go/; su www -s ./doyo-feedstream-go &> /dev/null &', fail_check) # no startup.sh,use non-nohup , command finished,su www will exit
subprocess进程检测脚本
交互式输入
并不是所有的操作系统命令都像‘dir’或者‘ipconfig’那样单纯地返回执行结果，还有很多像‘python’这种交互式的命令，你要输入点什么，然后它返回执行的结果。使用run()方法怎么向stdin里输入？ # 错误示例：
import subprocess ret = subprocess.run("python", stdin=subprocess.PIPE, stdout=subprocess.PIPE,shell=True)
ret.stdin = "print('haha')" # 错误的用法
print(ret) # 这样是不行的，ret作为一个CompletedProcess对象，根本没有stdin属性。那怎么办呢？前面说了，run()方法的stdin参数可以接收一个文件句柄。比如在一个1.txt文件中写入print('i like Python')。然后参考下面的使用方法： import subprocess fd = open("d:\\1.txt")
ret = subprocess.run("python", stdin=fd, stdout=subprocess.PIPE,shell=True)
print(ret.stdout)
fd.close()
# 这样做，虽然可以达到目的，但是很不方便，也不是以代码驱动的方式。这个时候，我们可以使用Popen类。 # Popen上场
class subprocess.Popen()
用法和参数与run()方法基本类同，但是它的返回值是一个Popen对象，而不是CompletedProcess对象。 >>> ret = subprocess.Popen("dir", shell=True)
>>> type(ret)
<class 'subprocess.Popen'>
>>> ret
<subprocess.Popen object at 0x0000000002B17668> # Popen对象的stdin、stdout和stderr是三个文件句柄，可以像文件那样进行读写操作。
>>>s = subprocess.Popen("ipconfig", stdout=subprocess.PIPE, shell=True)
>>>print(s.stdout.read().decode("GBK")) # 要实现前面的‘python’命令功能，可以按下面的例子操作：
import subprocess s = subprocess.Popen("python", stdout=subprocess.PIPE, stdin=subprocess.PIPE, shell=True)
s.stdin.write(b"import os\n")
s.stdin.write(b"print(os.environ)")
s.stdin.close() out = s.stdout.read().decode("GBK")
s.stdout.close()
print(out) # 通过s.stdin.write()可以输入数据，而s.stdout.read()则能输出数据。
subprocess的stdin参数应用
>>> ret = subprocess.getoutput('ls -l')
>>> print(ret)
总用量 160
drwxr-xr-x 2 wader wader 4096 12月 7 2015 公共的
drwxr-xr-x 2 wader wader 4096 12月 7 2015 模板
drwxr-xr-x 2 wader wader 4096 12月 7 2015 视频
drwxr-xr-x 2 wader wader 4096 12月 7 2015 图片
drwxr-xr-x 2 wader wader 4096 12月 7 2015 文档
drwxr-xr-x 2 wader wader 4096 4月 13 2016 下载
drwxr-xr-x 2 wader wader 4096 12月 7 2015 音乐
drwxr-xr-x 7 wader wader 4096 5月 26 2016 桌面
>>> retcode, output = subprocess.getstatusoutput('ls -l')
>>> print(retcode)
0
>>> print(output)
总用量 160
drwxr-xr-x 2 wader wader 4096 12月 7 2015 公共的
drwxr-xr-x 2 wader wader 4096 12月 7 2015 模板
drwxr-xr-x 2 wader wader 4096 12月 7 2015 视频
drwxr-xr-x 2 wader wader 4096 12月 7 2015 图片
drwxr-xr-x 2 wader wader 4096 12月 7 2015 文档
drwxr-xr-x 2 wader wader 4096 4月 13 2016 下载
drwxr-xr-x 2 wader wader 4096 12月 7 2015 音乐
drwxr-xr-x 7 wader wader 4096 5月 26 2016 桌面
>>> retcode, output = subprocess.getstatusoutput('ls -l /test')
>>> print(retcode)
2
>>> print(output)
ls: 无法访问/test: 没有那个文件或目录
subprocess.getoutput()与subprocess.getstatusoutput()
sys模块
sys.argv 命令行参数List，第一个元素是程序本身路径
sys.exit(n) 退出程序，正常退出时exit(0)
sys.version 获取Python解释程序的版本信息
sys.maxint 最大的Int值
sys.path 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform 返回操作系统平台名称
sys.stdout.write('please:')
val = sys.stdin.readline()[:-1]
sys.argv（http://www.cnblogs.com/aland-1415/p/6613449.html）
0426.py脚本如下：
import sys
a = sys.argv[0]
b = sys.argv[1]
c = sys.argv[1:]
print a
print b
print c
执行脚本：
/home/yumiao/0426.py 2 Obama vivo trump
输出：
/home/yumiao/0426.py
2
['2', 'Obama', 'vivo', 'trump']
hashlib模块
python3中的hashlib
1. md5加密
hash = hashlib.md5()
hash.update('admin'.encode('utf-8'))
print(hash.hexdigest())
21232f297a57a5a743894a0e4a801fc3 2. sha1加密
hash = hashlib.sha1()
hash.update('admin'.encode('utf-8'))
print(hash.hexdigest())
d033e22ae348aeb5660fc2140aec35850c4da997 3. sha256加密
hash = hashlib.sha256()
hash.update('admin'.encode('utf-8'))
print(hash.hexdigest())
8c6976e5b5410415bde908bd4dee15dfb167a9c873fc4bb8a81f6f2ab448a918 4. sha384加密
hash = hashlib.sha384()
hash.update('admin'.encode('utf-8'))
print(hash.hexdigest())
9ca694a90285c034432c9550421b7b9dbd5c0f4b6673f05f6dbce58052ba20e4248041956ee8c9a2ec9f10290cdc0782 5. sha512加密
hash = hashlib.sha512()
hash.update('admin'.encode('utf-8'))
print(hash.hexdigest())
c7ad44cbad762a5da0a452f9e854fdc1e0e7a52a38015f23f3eab1d80b931dd472634dfac71cd34ebc35d16ab7fb8a90c81f975113d6c7538dc69dd8de9077ec 6. ‘加盐’加密
以上加密算法虽然很厉害，但仍然存在缺陷，通过撞库可以反解。所以必要对加密算法中添加自定义key再来做加密。
1 ###### md5 加密 ############
hash = hashlib.md5('python'.encode('utf-8'))
hash.update('admin'.encode('utf-8'))
print(hash.hexdigest())
75b431c498b55557591f834af7856b9f 7. hmac加密
hmac内部对我们创建的key和内容进行处理后在加密
import hmac
h = hmac.new('python'.encode('utf-8'))
h.update('helloworld'.encode('utf-8'))
print(h.hexdigest())
b3b867248bb4cace835b59562c39fd55
json模块：
（json的loads，dumps方法）
import json
s = '{"desc":"invilad-citykey","status":1002}' # 这种形似列表或字典或元组的字符串(s是由单引号括起来的字符串)，内部元素如果是字符串，必须要加双引号（单引号会报错，如果交给json处理）
l = '[11, 22, 33, 44]'
result = json.loads(s) # 将一个形似列表或字典或元组的字符串，转换成列表或字典（前提，字符串必须符合列表或字典或元组的的格式）
result2 = json.loads(l)
print(result, type(result))
print(result2, type(result2))
# 输出：
{'desc': 'invilad-citykey', 'status': 1002} <class 'dict'>
[11, 22, 33, 44] <class 'list'>
dic = {'first': 1, "second": 2}
user_list = ['peter', 'john']
m = json.dumps(dic)
n = json.dumps(user_list)
print(m, type(m))
print(n, type(n))
#输出
{"first": 1, "second": 2} <class 'str'>
["peter", "john"] <class 'str'>
小结：
json.loads() # 将字符串-->python基本数据类型（内部必须是双引号，否则报错）
json.dumps() # 将python基本数据类型-->字符串
注意：元组在loads时会出错，元组在dumps时会变成列表。因为只有字典、列表是通用数据类型
json：本质就是字符串（内容比较特殊，是列表、字典、元组）
http请求响应内容是字符串，如果要让python处理，需用json的loads方法。
json的load，dump：作用，转换之后写到文件中（不常用）
import json
a = '{"whisky": 666, "tom": 2333, "peter": "ok"}' dic = {"whisky": 666, "tom": 2333, "peter": "ok"}
json.dump(a, open('db', 'a+')) r = json.load(open('db', 'r'))
print(r, type(r)) # 输出：
{'tom': 2333, 'whisky': 666, 'peter': 'ok'} <class 'dict'>
load、dump
pickle：存储读取复杂数据类型（函数、对象）
#处理复杂数据类型（函数等）的方法：pickle(只支持python，不支持Java（支持json）)
import pickle def sayhi(name):
print('hello,', name)
info = {
'name': 'whitesky',
'age': 25,
'func': sayhi
} f = open('test.txt', 'wb') #pickle序列化要带b
f.write(pickle.dumps(info)) #相当于 pickle._dump(info,f) #pickle反序列化 f = open('test.txt', 'rb')
data = pickle.loads(f.read()) # 相当于 pickle.load(f) print(data['func']) f.close() #注意：写程序序列化时要记住只dump一次，只load一次（py3中dump多次，再load时会出错，py2中正常），如果需要存储多个状态，就dump成多个文件
# -*- coding: utf-8 -*- import pickle test = [1, 2] def change(inner_list=[]):
inner_list += [2, 3] change(test) pickle.dump(test, open('test_pickle_file', 'wb'))
print(pickle.load(open('test_pickle_file', 'rb'))) # 输出 [1, 2, 2, 3]
XML
格式如下：
<data>
<country name="Liechtenstein">
<rank updated="yes">2</rank>
<year>2023</year>
<gdppc>141100</gdppc>
<neighbor direction="E" name="Austria" />
<neighbor direction="W" name="Switzerland" />
</country>
<country name="Singapore">
<rank updated="yes">5</rank>
<year>2026</year>
<gdppc>59900</gdppc>
<neighbor direction="N" name="Malaysia" />
</country>
<country name="Panama">
<rank updated="yes">69</rank>
<year>2026</year>
<gdppc>13600</gdppc>
<neighbor direction="W" name="Costa Rica" />
<neighbor direction="E" name="Colombia" />
</country>
</data>
1、解析XML
from xml.etree import ElementTree as ET #打开文件，读取XML内容
str_xml = open('first.xml', 'r').read() #将字符串解析成xml特殊对象，root代指xml文件的根节点
root = ET.XML(str_xml) #或
root1 = ET.XML(open('first.xml', 'r', encoding='utf-8').read())
利用ElementTree.XML将字符串解析成xml对象
from xml.etree import ElementTree as ET # 直接解析xml文件
tree = ET.parse('first.xml') # 获取xml文件的根节点
root = tree.getroot()
利用ElementTree.parse将文件直接解析成xml对象
xml自闭标签：http://www.cnblogs.com/ckysea/p/4627423.html 一个XML标签就是一个XML元素。 一个XML标签分为开始标签和结束标签，在开始标签和结束标签之间的文本被称为标签体。 包含标签体：<a>www.itcast.cn</a>； 如果一个不包含标签体也不包含其他元素，那么可以将开始标签和结束标签合并，这样的标签称为自闭标签 不含标签体及其他元素：<a></a>可以简写为自闭标签：<a/>
小结：
tree：
1.由ELementTree创建 ElementTree(xxx)
2.getroot() 获取xml根节点
3. write（）内存中的xml写入文件中
2、操作XML
a. 遍历XML文档的所有内容，遍历XML中指定的节点
from xml.etree import ElementTree as ET # a.遍历XML文档的所有内容
'''
############ 解析方式一:ElementTree.XML ############
str_xml = open('first.xml', 'r').read()
root = ET.XML(str_xml)
'''
############ 解析方式二:ElementTree.parse ############
tree = ET.parse('first.xml')
root = tree.getroot() # print(root.tag) # 顶层标签 for second_tag in root:
print(second_tag.tag, second_tag.attrib)
for third_tag in second_tag:
print(third_tag.tag, third_tag.text) # b.遍历XML中指定的节点
# 遍历XML中所有的year节点
for node in root.iter('year'):
print(node.attrib, node.text)
b.修改节点内容
由于修改的节点时，均是在内存中进行，其不会影响文件中的内容。所以，如果想要修改，则需要重新将内存中的内容写到文件。
######## 解析方式一:ElementTree.XML ########
str_xml = open('first.xml', 'r').read()
root = ET.XML(str_xml)
print(root.tag) # 顶层标签
# 循环所有的year节点
for node in root.iter('year'):
new_year = int(node.text) + 1
node.text = str(new_year)
# 设置属性
node.set('name', 'alex')
node.set('age', '')
# 删除属性
del node.attrib['name'] ############ 保存文件 ############
tree = ET.ElementTree(root)
tree.write("newnew.xml", encoding='utf-8') ##### 解析方式二:ElementTree.parse #####
tree = ET.parse('first.xml')
root = tree.getroot()
# 修改节点方法同方式一
# 保存文件方式和一有区别
tree.write("newnew.xml", encoding='utf-8')
两种方式修改、保存节点的内容
tree作用总结：
xml自闭标签：http://www.cnblogs.com/ckysea/p/4627423.html 一个XML标签就是一个XML元素。 一个XML标签分为开始标签和结束标签，在开始标签和结束标签之间的文本被称为标签体。 包含标签体：<a>www.itcast.cn</a>； 如果一个不包含标签体也不包含其他元素，那么可以将开始标签和结束标签合并，这样的标签称为自闭标签 不含标签体及其他元素：<a></a>可以简写为自闭标签：<a/>
小结：
tree的作用：
1.由ELementTree创建 ElementTree(root根节点)
2.getroot方法，获取xml根节点
3. write（）内存中的xml写入文件中，要保存xml字符串必须要有tree
创建tree的方式：
创建tree的两种方式：
tree = ET.parse('文件名')
tree = ET.ElementTree（根节点（Element对象））
c.删除节点（remove方法只能删除子节点，所以remove前要先找到父节点，通过父节点删除子节点）
from xml.etree import ElementTree as ET
############ 解析字符串方式打开 ############
str_xml = open('first.xml', 'r').read()
root = ET.XML(str_xml) # root代指xml文件的根节点data print(root.tag)
# 遍历data下的所有country节点
for node in root.findall('country'): # findall/find不能跨节点查找,只能从最外层逐层查找
for s in node.findall('year'):
node.remove(s) tree = ET.ElementTree(root)
tree.write("newnew.xml", encoding='utf-8')
解析字符串方式打开
from xml.etree import ElementTree as ET
tree = ET.parse('first.xml')
root = tree.getroot() for country in root.findall('country'):
for s in country.findall('rank'):
rank = int(country.find('rank').text)
if rank > 50:
country.remove(s) # rank节点大于50的删除 tree.write("newnew.xml", encoding='utf-8')
解析文件方式
3、创建XML文档
# 创建XML文档
from xml.etree import ElementTree as ET
# 创建根节点
root = ET.Element('family') # 创建节点老大
son1 = root.makeelement('son', {'name': '老大'})
# 或
# son1 = ET.Element('son', {'name': '儿1'}) #创建老二
son2 = root.makeelement('son', {'name': '老二'})
# 或
# son2 = ET.Element('son', {"name": '儿2'}) #在老大中创建两个孙子节点
grandson1 = ET.Element('grandson', {'name': '儿11'})
grandson2 = ET.Element('grandson', {'name': '儿22'})
#或
# grandson1 = son1.makeelement('grandson', {'name': '儿11'})
# grandson2 = son1.makeelement('grandson', {'name': '儿12'})
son1.append(grandson1)
son1.append(grandson2) #添加老大到根节点
root.append(son1)
root.append(son2) tree = ET.ElementTree(root)
tree.write('0815.xml',encoding='utf-8')
创建方式一
from xml.etree import ElementTree as ET # 创建根节点
root = ET.Element("famliy") # 创建节点大儿子
son1 = ET.SubElement(root, "son", attrib={'name': '儿1'})
# 创建小儿子
son2 = ET.SubElement(root, "son", attrib={"name": "儿2"}) # 在大儿子中创建一个孙子
grandson1 = ET.SubElement(son1, "age", attrib={'name': '儿11'})
grandson1.text = '孙子' et = ET.ElementTree(root) #生成文档对象
et.write("test.xml", encoding="utf-8", xml_declaration=True, short_empty_elements=False) 创建方式（三）
方式二
<family>
<son name="老大">
<grandson name="儿11" />
<grandson name="儿22" />
</son>
<son name="老二" />
</family>
创建好的XML
XML设置缩进
from xml.etree import ElementTree as ET
from xml.dom import minidom def prettify(elem):
"""将节点转换成字符串，并添加缩进。
"""
rough_string = ET.tostring(elem, 'utf-8')
reparsed = minidom.parseString(rough_string)
return reparsed.toprettyxml(indent="\t") # 创建根节点
root = ET.Element("famliy") # 创建大儿子
# son1 = ET.Element('son', {'name': '儿1'})
son1 = root.makeelement('son', {'name': '儿1'})
# 创建小儿子
# son2 = ET.Element('son', {"name": '儿2'})
son2 = root.makeelement('son', {"name": '儿2'}) # 在大儿子中创建两个孙子
# grandson1 = ET.Element('grandson', {'name': '儿11'})
grandson1 = son1.makeelement('grandson', {'name': '儿11'})
# grandson2 = ET.Element('grandson', {'name': '儿12'})
grandson2 = son1.makeelement('grandson', {'name': '儿12'}) son1.append(grandson1)
son1.append(grandson2) # 把儿子添加到根节点中
root.append(son1)
root.append(son1) raw_str = prettify(root) f = open("xxxoo.xml",'w',encoding='utf-8')
f.write(raw_str)
f.close()
configparser
configparser用于处理特定格式的文件，其本质上是利用open来操作文件。（ini配置文件例子）
[section1] # 节点
k1 = v1 # 值
k2:v2 # 值 [section2] # 节点
k1 = v1 # 值 [test_ansible]
node1 = 192.168.2.3
ansible_ssh_port = 22
ansible_ssh_user = gxy_ansible
ansible_su_pass = 123456
汉字 = 123
import configparser # 获取所有节点的值
config = configparser.ConfigParser()
config.read('ini', encoding='utf-8') # 读到内存当中
ret = config.sections() # 获取所有节点的值
print(ret)
# 输出：['section1', 'section2', 'test_ansible'] # 获取指定节点下所有的键值对
config = configparser.ConfigParser()
config.read('ini', encoding='utf-8')
ret = config.items('test_ansible') # 获取指定节点下所有的键值对
print(ret)
# 输出[('node1', '192.168.2.3'), ('ansible_ssh_port', '22'), ('ansible_ssh_user', 'gxy_ansible'), ('ansible_su_pass', '123456'), ('汉字', '123')] # 获取指定节点下所有的键
config = configparser.ConfigParser()
config.read('ini',encoding='utf-8')
ret = config.options('test_ansible') # 获取指定节点下所有的键
print(ret)
# 输出：['node1', 'ansible_ssh_port', 'ansible_ssh_user', 'ansible_su_pass', '汉字'] # 获取指定节点下指定key的值
config = configparser.ConfigParser()
config.read('ini', encoding='utf-8')
value = config.get('test_ansible', 'node1') # 获取指定节点下指定key的值
# v = config.getint('test_ansible', 'ansible_su_pass') # 字符串转换为整形
# v1 = config.getfloat('test_ansible', 'ansible_su_pass')
# v2 = config.getboolean('test_ansible', 'node1')
print(value)
# 输出： 192.168.2.3 # 检查、删除、添加节点
config = configparser.ConfigParser()
config.read('ini', encoding='utf-8')
# 检查
has_sec = config.has_section('test_ansible')
print(has_sec) # 输出： True
# 添加节点
config.add_section('test_ansible_new')
config.write(open('new_ini', 'w', encoding='utf-8'))
# 删除节点
config.remove_section('section2')
config.write(open('new_ini', 'w', encoding='utf-8')) # 检查、删除、设置指定组内的键值对
config = configparser.ConfigParser()
config.read('ini', encoding='utf-8') has_opt = config.has_option('test_ansible', '汉字') # 检查,('键','值')
print(has_opt) config.remove_option('section1', 'k1')
config.write(open('delete_ini', 'w', encoding='utf-8')) config.set('section1', 'k2', '') # 设置, 有则改，没有则新增
config.write(open('set_ini', 'w', encoding='utf-8'))
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=10) logging.debug('debug')
logging.info('info')
logging.warning('warning')
logging.error('error')
logging.critical('critical')
logging.log(10,'log')
日志等级：
CRITICAL = 50
FATAL = CRITICAL
ERROR = 40
WARNING = 30
WARN = WARNING
INFO = 20
DEBUG = 10
NOTSET = 0
注：只有【当前写等级level】大于【日志等级】时，日志文件才被记录。
多文件日志
对于上述记录日志的功能，只能将日志记录在单文件中，如果想要设置多个日志文件，logging.basicConfig将无法完成，需要自定义文件和日志操作对象。
# 定义文件
file_1_1 = logging.FileHandler('l1_1.log', 'a', encoding='utf-8')
fmt = logging.Formatter(fmt="%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s")
file_1_1.setFormatter(fmt) file_1_2 = logging.FileHandler('l1_2.log', 'a', encoding='utf-8')
fmt = logging.Formatter()
file_1_2.setFormatter(fmt) # 定义日志
logger1 = logging.Logger('s1', level=logging.ERROR)
logger1.addHandler(file_1_1) #两个日志文件全部加入logger1文件对象中，则记录日志时，会同时写入两个文件
logger1.addHandler(file_1_2) # 写日志
logger1.critical('')
# 定义文件
file_2_1 = logging.FileHandler('l2_1.log', 'a')
fmt = logging.Formatter()
file_2_1.setFormatter(fmt) # 定义日志
logger2 = logging.Logger('s2', level=logging.INFO)
logger2.addHandler(file_2_1)
日志（二）
如上述创建的两个日志对象
- 当使用【logger1】写日志时，会将相应的内容写入 l1_1.log 和 l1_2.log 文件中
- 当使用【logger2】写日志时，会将相应的内容写入 l2_1.log 文件中
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=10) # 日志记录的方法：
logging.debug('debug') # 内部调用的logging.log， 相当于logging.log(10,'debug')
logging.info('info')
logging.warning('warning') # 建议用这
logging.error('error')
logging.critical('critical')
logging.log(10,'log') # 定义文件
#创建第一个文件对象（FileHandler方法）
file_1_1 = logging.FileHandler('l1_1.log', 'a', encoding='utf-8') # 定义文件名为：l1_1.log
fmt = logging.Formatter(fmt="%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s") # logging.Formatter格式化处理
file_1_1.setFormatter(fmt) #创建第二个文件对象
file_1_2 = logging.FileHandler('l1_2.log', 'a', encoding='utf-8')
fmt = logging.Formatter()
file_1_2.setFormatter(fmt) # 定义日志
#创建写日志的对象
logger1 = logging.Logger('s1', level=logging.ERROR) # s1会写到logging.Formatter的%(name)处
logger1.addHandler(file_1_1) # 将文件对象加入写日志的对象中，用于写日志
logger1.addHandler(file_1_2) # 写日志
logger1.critical('') # 关联了上面两个文件（file_1_1和file_1_2），所以一条日志信息会同时写入上面两个文件中 # 实战：
同时定义两个日志文件，
# 定义文件
file_1_1 = logging.FileHandler('run.log', 'a', encoding='utf-8') # 定义文件名为：run.log
fmt = logging.Formatter(fmt="%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s")
file_1_1.setFormatter(fmt) # 定义日志
logger1 = logging.Logger('s1', level=logging.ERROR)
logger1.addHandler(file_1_1) # 写日志
logger1.critical('') # 定义文件
file_1_1 = logging.FileHandler('error.log', 'a', encoding='utf-8') # 定义文件名为：error.log
fmt = logging.Formatter(fmt="%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s")
file_1_1.setFormatter(fmt) # 定义日志
logger1 = logging.Logger('s1', level=logging.ERROR)
logger1.addHandler(file_1_1) # 写日志
logger1.critical('') CMDB中的应用：
def initialize_run_log(self):
self.check_path_exist(self.run_log_file)
file_1_1 = logging.FileHandler(self.run_log_file, 'a', encoding='utf-8') # 文件对象
fmt = logging.Formatter(fmt="%(asctime)s - %(levelname)s : %(message)s") # 设置日志格式
file_1_1.setFormatter(fmt) # 设置日志格式
logger1 = logging.Logger('run_log', level=logging.INFO)
logger1.addHandler(file_1_1)
self.run_logger = logger1 def initialize_error_log(self):
self.check_path_exist(self.error_log_file)
file_1_1 = logging.FileHandler(self.error_log_file, 'a', encoding='utf-8')
fmt = logging.Formatter(fmt="%(asctime)s - %(levelname)s : %(message)s")
file_1_1.setFormatter(fmt)
logger1 = logging.Logger('run_log', level=logging.ERROR)
logger1.addHandler(file_1_1)
self.error_logger = logger1 def log(self, message, mode=True):
"""
写入日志
:param message: 日志信息
:param mode: True表示运行信息，False表示错误信息
:return:
"""
if mode:
self.run_logger.info(message)
else:
self.error_logger.error(message)
logging方法实践
https://www.cnblogs.com/liujiacai/p/7804848.html
http://python.jobbole.com/81666/
https://www.jianshu.com/p/d615bf01e37b 多进程日志
https://www.cnblogs.com/bethansy/p/7716747.html
traceback捕获并打印异常：
异常处理是日常操作了，但是有时候不能只能打印我们处理的结果，还需要将我们的异常打印出来，这样更直观的显示错误
下面来介绍traceback模块来进行处理
try:
1/0
except Exception, e:
print e
输出结果是integer division or modulo by zero，只知道是报了这个错，但是却不知道在哪个文件哪个函数哪一行报的错。 使用traceback
try:
1/0
except Exception, e:
traceback.print_exc()
Traceback (most recent call last): File "test_traceback.py", line 3, in <module> 1/0 ZeroDivisionError: integer division or modulo by zero # 这样非常直观有利于调试。 # traceback.print_exc()跟traceback.format_exc()有什么区别呢？
print_exc()则直接给打印出来;
format_exc()返回字符串;
即traceback.print_exc()与print traceback.format_exc()效果是一样的。
print_exc()还可以接受file参数直接写入到一个文件。
比如:
traceback.print_exc(file=open('tb.txt','w+')) # 写入到tb.txt文件去。
也可以使用logger.exception(msg,_args)，它等价于logger.error(msg,exc_info = True,_args)，
将
logger.error("Faild to open sklearn.txt from logger.error",exc_info = True)
替换为，
logger.exception("Failed to open sklearn.txt from logger.exception")
控制台和日志文件log.txt中输出，
Start print log
Something maybe fail.
Failed to open sklearn.txt from logger.exception
Traceback (most recent call last):
File "G:\zhb7627\Code\Eclipse WorkSpace\PythonTest\test.py", line 23, in <module>
open("sklearn.txt","rb")
IOError: [Errno 2] No such file or directory: 'sklearn.txt'
Finish
import和__import__()有什么不同？ import作用:
导入/引入一个python标准模块，其中包括.py文件、带有__init__.py文件的目录； __import__作用:
同import语句同样的功能，但__import__是一个函数，并且只接收字符串作为参数，所以它的作用就可想而知了。其实import语句就是调用这个函数进行导入工作的，import sys <==>sys = __import__('sys')。
import和__import__()
s.rsplit()和s.split()区别是什么啊 一个从左开始，一个从右开始。
如果是这样没有区别：
>>> s = 'asd dfdf ff'
>>> s.split()
['asd', 'dfdf', 'ff']
>>> s.rsplit()
['asd', 'dfdf', 'ff'] 这样就看出不同了。
>>> s.split(' ',1)
['asd', 'dfdf ff']
>>> s.rsplit(' ',1)
['asd dfdf', 'ff']
s.rsplit()和s.split()区别是什么啊
random模块：
# random 模块
import random print(random.random())
print(random.randint(1, 2)) # Return random integer in range [a, b], including both end points.
print(random.randrange(1, 10)) # Choose a random item from range(start, stop[, step]) 不包括stop边界 # 生成随机验证码
import random
verification_code = ''
for i in range(6):
rand = random.randrange(0, 4)
if rand == 3 or rand == 1:
num = random.randint(0, 9)
verification_code += str(num)
else:
num = random.randint(65, 91)
letter = chr(num)
verification_code += letter
print(verification_code) import random
verification_code = ''
for i in range(6):
rand = random.randrange(0, 6)
if i == rand:
num = random.randint(0, 9)
verification_code += str(num)
else:
num = random.randint(65, 91)
letter = chr(num)
verification_code += letter
print(verification_code)
importlib
#环境：python 3.6 # 文件结构 ├── clazz
│ ├── __init__.py
│ ├── a.py
│ └── b.py
└── main.py # a.py 的代码 def show():
print("show A") # b.py 的代码 def show():
print("show B") 从main中导入clazz包中的a 和b 模块
main.py import importlib # 绝对导入
a = importlib.import_module("clazz.a")
a.show()
# show A # 相对导入
b = importlib.import_module(".b", "clazz")
b.show()
# show B 注意，相对导入有个一点.， 类似路径
unix时间戳：
# 10位时间戳获取方法： >>> import time
>>> t = time.time()
>>> print t
1436428326.76
>>> print int(t)
1436428326
>>> # 13位时间戳获取方法： （1）默认情况下python的时间戳是以秒为单位输出的float >>> import time
>>> time.time()
1436428275.207596 # 通过把秒转换毫秒的方法获得13位的时间戳：
import time
millis = int(round(time.time() * 1000)) # round()四舍五入函数。
print millis import time current_milli_time = lambda: int(round(time.time() * 1000))
Then:
>>> current_milli_time()
1378761833768
#!/usr/bin/env python3
# -*-coding:utf-8 -*-
# xiaoe直播监控脚本
__author__ = 'budyu'
__date__ = '2019/4/4 21:34' import requests
import json
import sys
import logging
import datetime # logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s',datefmt='%Y-%m-%d %H:%M:%S %p',level=10) # file_handler = logging.FileHandler('/var/log/alive_mon.log', 'a', encoding='utf-8')
# fmt = logging.Formatter(fmt="%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s")
# file_handler.setFormatter(fmt) # logger1 = logging.Logger('alive_mon_log', level=logging.DEBUG)
# logger1.addHandler(file_handler) start_time = ''
stop_time = '' now = datetime.datetime.now()
one_min_delta = now - datetime.timedelta(minutes=1)
# now_time = one_min_delta.strftime('%Y-%m-%d %H:%M:%S')
now_time_minute = one_min_delta.strftime('%M')
result = int(now_time_minute) % 5
# print(result)
# print(not result)
# 取0，5，10，15，20...分钟
if not result:
stop_time = one_min_delta.strftime('%Y-%m-%d %H:%M:%S')
stop_time = datetime.datetime.strptime(stop_time, "%Y-%m-%d %H:%M:%S")
# print(stop_time, '----------------------------')
else:
stop_time_min = int(now_time_minute) - result
stop_time = one_min_delta.strftime('%Y-%m-%d %H:{}:%S').format(str(stop_time_min).zfill(2))
stop_time = datetime.datetime.strptime(stop_time, "%Y-%m-%d %H:%M:%S")
# print(stop_time, '||||||||||||||||||||||||||||') start_time = stop_time - datetime.timedelta(minutes=5)
# print(start_time, 'start_time @@@@@@@@@@@@@@@@@@@@@@') alive_panel_url = 'http://134.175.37.247:1224/alive_panel'
online_user_url = 'http://134.175.37.247:1224/alive_online_users' payload = {'start_at': start_time, 'stop_at': stop_time}
# payload = {'start_at': '2019-04-10 17:0:20', 'stop_at': '2019-04-10 17:0:00'}
# print(payload)
panel_ret = requests.get(
url=alive_panel_url,
# params=payload
)
online_user_ret = requests.get(
url=online_user_url,
params=payload
) # print(panel_ret.text, 'panel_ret -----------')
# print(online_user_ret.text, ' online_user_ret ----------------') response_panel = json.loads(panel_ret.text)
response_online_user = json.loads(online_user_ret.text)
# print(response_panel, '======================')
# print(response_online_user, '======================') if response_panel['code'] == 0:
try:
if sys.argv[1] == 'avgInterTime':
avgInterTime = response_panel.get('data')['avgInterTime']
print(int(avgInterTime))
elif sys.argv[1] == 'interFailRate':
interFailRate = response_panel.get('data')['interFailRate']
print(interFailRate)
elif sys.argv[1] == 'interReqCount':
interReqCount = response_panel.get('data')['interReqCount']
print(int(interReqCount))
elif response_online_user['code'] == 0 and sys.argv[1] == 'onlineUsers':
onlineUsers = response_online_user.get('data')['onlineUsers']
print(int(onlineUsers))
else:
print(
"response_online_user failed! (Usage: python {0} avgInterTime|interFailRate|interReqCount|onlineUsers)".format(
sys.argv[0]))
except Exception as e:
# logger1.critical('may be get wrong argument ！')
print("reponse error! INFO:{0}".format(e)) elif response_panel['code'] == 12:
# logger1.critical('no data repsonse from {0}'.format(requests_url))
print('no data')
elif response_panel['code'] == 8:
# logger1.critical('request timeout from {0}'.format(requests_url))
print('request time error')
经常使用的时间方法 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=2014, 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 2.计算昨天的日期（发散思维，计算其他日期相加、相减等）： 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) 3.时间元组 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 4.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 残阳似血的博客：<http://qinxuye.me/article/details-about-time-module-in-python/> 官方time模块：<http://python.me/library/time.html#module-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]: 1408032000.0 4.datetime.date.replace(year, month, day) 返回一个替换后的date对象
In [11]: today.replace(year=2013)
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) 当前时间 datetime.datetime.now() 时间间隔 datetime.timedelta(参数=数值) #参数：weeks，days，hours，minutes，seconds，microseconds，milliseconds import datetime nowtime = datetime.datetime.now()
print(nowtime) #当前时间 print(datetime.datetime.now() - datetime.timedelta(days=1)) #1天前 默认格式2019-02-11 13:27:16.231381
print(datetime.datetime.now() + datetime.timedelta(days=1)) #1天后 print((datetime.datetime.now() - datetime.timedelta(weeks=2)).strftime("%Y-%m-%d %H:%M:%S")) #两周前
print((datetime.datetime.now() + datetime.timedelta(weeks=2)).strftime("%Y-%m-%d %H:%M:%S")) #两周后 print((datetime.datetime.now() - datetime.timedelta(days=1)).strftime("%Y-%m-%d %H:%M:%S")) #1天前
print((datetime.datetime.now() + datetime.timedelta(days=1)).strftime("%Y-%m-%d %H:%M:%S"))#1天后 print((datetime.datetime.now() - datetime.timedelta(hours=2)).strftime("%Y-%m-%d %H:%M:%S")) #2小时前
print((datetime.datetime.now() + datetime.timedelta(hours=2)).strftime("%Y-%m-%d %H:%M:%S")) #2小时后 print((datetime.datetime.now() - datetime.timedelta(minutes=30)).strftime("%Y-%m-%d %H:%M:%S"))# 30分钟前
print((datetime.datetime.now() + datetime.timedelta(minutes=30)).strftime("%Y-%m-%d %H:%M:%S")) #30分钟后 print((datetime.datetime.now() - datetime.timedelta(seconds=10)).strftime("%Y-%m-%d %H:%M:%S")) #10秒前
print((datetime.datetime.now() + datetime.timedelta(seconds=10)).strftime("%Y-%m-%d %H:%M:%S")) #10秒后
常用事件方法
python datetime time 时间模块
https://www.jianshu.com/p/70180a1766a2
日期、时间戳互转：
# 引入模块
import time, datetime # str类型的日期转换为时间戳
# 字符类型的时间
tss1 = '2013-10-10 23:40:00'
# 转为时间数组
timeArray = time.strptime(tss1, "%Y-%m-%d %H:%M:%S")
print timeArray
# timeArray可以调用tm_year等
print timeArray.tm_year #
# 转为时间戳
timeStamp = int(time.mktime(timeArray))
print timeStamp # # 结果如下
time.struct_time(tm_year=2013, tm_mon=10, tm_mday=10, tm_hour=23, tm_min=40, tm_sec=0, tm_wday=3, tm_yday=283, tm_isdst=-1)
2013
1381419600 # 更改str类型日期的显示格式
tss2 = "2013-10-10 23:40:00"
# 转为数组
timeArray = time.strptime(tss2, "%Y-%m-%d %H:%M:%S")
# 转为其它显示格式
otherStyleTime = time.strftime("%Y/%m/%d %H:%M:%S", timeArray)
print otherStyleTime # 2013/10/10 23:40:00 tss3 = "2013/10/10 23:40:00"
timeArray = time.strptime(tss3, "%Y/%m/%d %H:%M:%S")
otherStyleTime = time.strftime("%Y-%m-%d %H:%M:%S", timeArray)
print otherStyleTime # 2013-10-10 23:40:00 # 时间戳转换为指定格式的日期
# 使用time
timeStamp = 1381419600
timeArray = time.localtime(timeStamp)
otherStyleTime = time.strftime("%Y--%m--%d %H:%M:%S", timeArray)
print otherStyleTime # 2013--10--10 23:40:00
# 使用datetime
timeStamp = 1381419600
dateArray = datetime.datetime.utcfromtimestamp(timeStamp)
otherStyleTime = dateArray.strftime("%Y--%m--%d %H:%M:%S")
print otherStyleTime # 2013--10--10 15:40:00 # 获取当前时间并且用指定格式显示
# time获取当前时间戳
now = int(time.time()) #
timeArray = time.localtime(now)
print timeArray
otherStyleTime = time.strftime("%Y--%m--%d %H:%M:%S", timeArray)
print otherStyleTime # 结果如下
time.struct_time(tm_year=2018, tm_mon=8, tm_mday=11, tm_hour=9, tm_min=51, tm_sec=17, tm_wday=5, tm_yday=223, tm_isdst=0)
2018--08--11 09:51:17 # datetime获取当前时间，数组格式
now = datetime.datetime.now()
print now
otherStyleTime = now.strftime("%Y--%m--%d %H:%M:%S")
print otherStyleTime # 结果如下：
2018-08-11 09:51:17.362986
2018--08--11 09:51:17
获取最近一个月每天的日期：
#coding:utf-8
# from common.contest import * import datetime
import time
begin_date = (datetime.datetime.now() - datetime.timedelta(days =30)).strftime("%Y-%m-%d")
date_list = []
begin_date = datetime.datetime.strptime(begin_date, "%Y-%m-%d")
end_date = datetime.datetime.strptime(time.strftime('%Y-%m-%d',time.localtime(time.time())), "%Y-%m-%d")
while begin_date <= end_date:
date_str = begin_date.strftime("%Y-%m-%d")
date_list.append(date_str)
begin_date += datetime.timedelta(days=1) print date_list C:\Python27\python.exe E:/squid_frame/weibo_pc_spider_local/test.py
['2019-03-18', '2019-03-19', '2019-03-20', '2019-03-21', '2019-03-22', '2019-03-23', '2019-03-24', '2019-03-25', '2019-03-26', '2019-03-27',
'2019-03-28', '2019-03-29', '2019-03-30', '2019-03-31', '2019-04-01', '2019-04-02', '2019-04-03', '2019-04-04', '2019-04-05', '2019-04-06',
'2019-04-07', '2019-04-08', '2019-04-09', '2019-04-10', '2019-04-11', '2019-04-12', '2019-04-13', '2019-04-14', '2019-04-15', '2019-04-16',
'2019-04-17'] Process finished with exit code 0
# 时间、字符串互转
https://www.cnblogs.com/alfred0311/p/7885349.html def time_format(time_str):
""" str -> datetime"""
if 'T' in time_str:
if '+08:00' in time_str:
UTC_FORMAT = "%Y-%m-%dT%H:%M:%S+08:00"
return datetime.datetime.strptime(time_str, UTC_FORMAT)
if 'Z' in time_str:
UTC_FORMAT = "%Y-%m-%dT%H:%M:%SZ"
return datetime.datetime.strptime(time_str, UTC_FORMAT) + datetime.timedelta(hours=8)
else:
UTC_FORMAT = "%Y-%m-%d %H:%M:%S"
return datetime.datetime.strptime(time_str, UTC_FORMAT)
# Python time & datetime & string 相互转换 #!/usr/bin/env python
# -*- coding:utf-8 -*- # @Datetime : 2017/11/23 下午12:37
# @Author : Alfred Xue
# @E-Mail : Alfred.Hsueh@gmail.com
# @GitHub : https://github.com/Alfred-Xue
# @Blog : http://www.cnblogs.com/alfred0311/ import datetime
import time # 日期时间字符串
st = "2017-11-23 16:10:10"
# 当前日期时间
dt = datetime.datetime.now()
# 当前时间戳
sp = time.time() # 1.把datetime转成字符串
def datetime_toString(dt):
print("1.把datetime转成字符串: ", dt.strftime("%Y-%m-%d %H:%M:%S")) # 2.把字符串转成datetime
def string_toDatetime(st):
print("2.把字符串转成datetime: ", datetime.datetime.strptime(st, "%Y-%m-%d %H:%M:%S")) # 3.把字符串转成时间戳形式
def string_toTimestamp(st):
print("3.把字符串转成时间戳形式:", time.mktime(time.strptime(st, "%Y-%m-%d %H:%M:%S"))) # 4.把时间戳转成字符串形式
def timestamp_toString(sp):
print("4.把时间戳转成字符串形式: ", time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(sp))) # 5.把datetime类型转外时间戳形式
def datetime_toTimestamp(dt):
print("5.把datetime类型转外时间戳形式:", time.mktime(dt.timetuple())) # 1.把datetime转成字符串
datetime_toString(dt)
# 2.把字符串转成datetime
string_toDatetime(st)
# 3.把字符串转成时间戳形式
string_toTimestamp(st)
# 4.把时间戳转成字符串形式
timestamp_toString(sp)
# 5.把datetime类型转外时间戳形式
datetime_toTimestamp(dt)