常用模块

time

1 import time
2 #--------------------------我们先以当前时间为准,让大家快速认识三种形式的时间
3 print(time.time()) # 时间戳:1487130156.419527
4 print(time.strftime("%Y-%m-%d %X")) #格式化的时间字符串:‘2017-02-15 11:40:53’
5
6 print(time.localtime()) #本地时区的struct_time
7 print(time.gmtime()) #UTC时区的struct_time

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)) #时间替换

OS模块

OS模块
	getcwd()
	chdir 切换
	curdir 返回当前目录   
	pardir
	mkdir 创建文件夹，/最后一个之前均为进入  如果进入失败或创建的文件夹存在会报错
	makedirs  同上 只不过进入失败就会创建
	removedirs(path) / 最后一个文件夹是否为空，为空删 不为空递归上一级查看 直到不为空位置。 一开始查看的最后一个为空则报错
	rmdir('dirname') 文件夹不空，则报错
	remove  强制性删除
	rename 重命名
	stat  获取文件/目录信息
	sep   
		系统文件分隔符
	os.linesep   行终止符
	os.pathsep 默认 可以用ascii查看
	name  win->'nt'; Linux->'posix'
    
	system 脚本命令  
	environ   系统环境变量
	os.path.abspath 返回规范化的绝对路径
	path.split(path)  （“目录前面”，最后一个）
	basename(path)  返回path最后的文件名。如何path以／或\结尾，那么就会返回空
	path 是否存在
	isabs  是否为绝对路劲 
	isfile   是否为文件
	isdir  是否为存在的目录
	join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径之前的参数将被忽略

	os.path.getatime(path)  返回path所指向的文件或者目录的最后存取时间
os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间
	os.path.getsize(path) 返回path的大小
	在Linux和Mac平台上，该函数会原样返回path，在windows平台上会将路径中所有字符转换为小写，并将所有斜杠转换为饭斜杠。normcase
		子主题 1
	os.path.normpath('c://windows\\System32\\../Temp/')     规范路径 比如../

sys

 sys.argv           命令行参数List，第一个元素是程序本身路径
 sys.exit(n)        退出程序，正常退出时exit(0)
 sys.version        获取Python解释程序的版本信息
sys.maxint         最大的Int值
 sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
 sys.platform       返

json 和plick

看老林博客

shelve模块

writeback 默认False ，返回的对象为<class ‘shelve.DbfilenameShelf’>一个像字典类型的对象 他是不可变类型
设为True 的话 就为 可变类型
f=shelve.open(r’sheve.txt’)
move(src, dst) 递归的去移动文件，它类似mv命令，其实就是重命名。

shutil模块

shutil.copyfileobj(“可读文件对象”，“可写文件对象” ) # 文件A>B的拷贝
shutil.copyfile(文件名’, 文件名) #目标文件无需存在
copymode 拷贝权限
copy 拷贝文件和权限
copy2(src, dst) 拷贝文件和状态信息
rmtree(‘folder1’) 递归删除

=解 压=
shutil.make_archive(base_name, format,…)
base_name： 压缩包的文件名，也可以是压缩包的路径。只是文件名时，则保存至当前目录，否则保存至指定路径，
如 data_bak =>保存至当前路径
如：/tmp/data_bak =>保存至/tmp/
format： 压缩包种类，“zip”, “tar”, “bztar”，“gztar”
root_dir： 要压缩的文件夹路径（默认当前目录）
owner： 用户，默认当前用户
group： 组，默认当前组
logger： 用于记录日志，通常是logging.Logger对象

Logging模块

级别

CRITICAL = 50 #FATAL = CRITICAL
ERROR = 40
WARNING = 30 #WARN = WARNING
INFO = 20
DEBUG = 10
NOTSET = 0 #不设置

默认级别为 warning
logging.error(‘错误error’) ERROR:root:错误error

logging.basicConfig(
level(设置界别)=logging.DEBUG,
format="%(sctime)s %(filenames)s "
datefmt(日期)="%a, %d %b %Y %H:%M:%S",
filename="文件路径",
filemode="w")
接下来打印就会往文件里打印 没有filename="文件路径"和filemode="w" 就会往控制台



格式format参数
%(name)s：Logger的名字，并非用户名，详细查看

%(levelno)s：数字形式的日志级别

%(levelname)s：文本形式的日志级别

%(pathname)s：调用日志输出函数的模块的完整路径名，可能没有

%(filename)s：调用日志输出函数的模块的文件名

%(module)s：调用日志输出函数的模块名

%(funcName)s：调用日志输出函数的函数名

%(lineno)d：调用日志输出函数的语句所在的代码行

%(created)f：当前时间，用UNIX标准的表示时间的浮 点数表示

%(relativeCreated)d：输出日志信息时的，自Logger创建以 来的毫秒数

%(asctime)s：字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒

%(thread)d：线程ID。可能没有

%(threadName)s：线程名。可能没有

%(process)d：进程ID。可能没有

%(message)s：用户输出的消息

四 logging模块的Formatter，Handler，Logger，Filter对象
#logger：产生日志的对象
#Filter：过滤日志的对象
#Handler：接收日志然后控制打印到不同的地方，FileHandler用来打印到文件中，StreamHandler用来打印到终端
#Formatter对象：可以定制不同的日志格式对象，然后绑定给不同的Handler对象使用，以此来控制不同的Handler的日志格式

Handler对象：

FileHandler 最终弄到文件里
logging.FileHandler(‘t1.log’)
logging.StreamHandler()

Formatter日志格式

formmater2=logging.Formatter('%(asctime)s :  %(message)s',  datefmt='%Y-%m-%d %H:%M:%S %p',)

handle控制输出对象.setFormatter(日志格式对象)
logger对象.addHandle(handle控制输出对象)

#loger 的配置文件

import os
import logging.config

# 定义三种日志输出格式 开始

standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]' \
                  '[%(levelname)s][%(message)s]' #其中name为getlogger指定的名字

simple_format = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'

id_simple_format = '[%(levelname)s][%(asctime)s] %(message)s'

# 定义日志输出格式 结束

logfile_dir = os.path.dirname(os.path.abspath(__file__))  # log文件的目录

logfile_name = 'all2.log'  # log文件名

# 如果不存在定义的日志目录就创建一个
if not os.path.isdir(logfile_dir):
    os.mkdir(logfile_dir)

# log文件的全路径
logfile_path = os.path.join(logfile_dir, logfile_name)

# log配置字典
LOGGING_DIC = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'standard': {
            'format': standard_format
        },
        'simple': {
            'format': simple_format
        },
    },
    'filters': {},
    'handlers': {
        #打印到终端的日志
        'console': {
            'level': 'DEBUG',
            'class': 'logging.StreamHandler',  # 打印到屏幕
            'formatter': 'simple'
        },
        #打印到文件的日志,收集info及以上的日志
        'default': {
            'level': 'DEBUG',
            'class': 'logging.handlers.RotatingFileHandler',  # 保存到文件
            'formatter': 'standard',
            'filename': logfile_path,  # 日志文件
            'maxBytes': 1024*1024*5,  # 日志大小 5M
            'backupCount': 5,
            'encoding': 'utf-8',  # 日志文件的编码，再也不用担心中文log乱码了
        },
    },
    'loggers': {
        #logging.getLogger(__name__)拿到的logger配置
        '': {   
            'handlers': ['default', 'console'],  # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕
            'level': 'DEBUG',
            'propagate': True,  # 向上（更高level的logger）传递
        },
    },
}

import logging.config
from config.setting import 那个字典
logging.config.dictConfig(LOGGING_DIC) #通过字典配置logging
loger=logging.getLogger(“loger_name”) #去配置文件夹里找logger名得到对象赋值给loge

re模块

# =================================匹配模式=================================
#正则匹配
import re
#\w   大写取反
print(re.findall('\w','hello egon 123')) #['h', 'e', 'l', 'l', 'o', 'e', 'g', 'o', 'n', '1', '2', '3']
#\s  大写取反  \n \t 都被匹配
print(re.findall('\s','hello  egon  123')) #[' ', ' ', ' ', ' ']

#\d  大写取反  数字
print(re.findall('\d','hello egon 123')) #['1', '2', '3']



#^与$
print(re.findall('^h','hello egon 123')) #['h']
print(re.findall('3$','hello egon 123')) #['3']

# 重复匹配：| . | * | ? | .* | .*? | + | {n,m} |
. 除了\n 任意字符  re.S就可以匹配了
print(re.findall('a.b','a\nb',re.S)) #['a\nb']

#* 0~N   最后一个字符可有可无 没有的话也符合

print(re.findall('ab*','a')) #['a']
print(re.findall('ab*','abbbb')) #['abbbb']

#? 要么一个要么没有 多的话不符合
print(re.findall('ab?','a')) #['a']  
print(re.findall('ab?','abbb')) #['ab']
#匹配所有包含小数在内的数字
print(re.findall('\d+\.?\d*',"asdfasdf123as1.13dfa12adsf1asdf3")) #['123', '1.13', '12', '1', '3']

#.* 取最大长符合的

#.*?为非贪婪匹配：推荐使用
print(re.findall('a.*?b','a1b22222222b')) #['a1b']

#+
print(re.findall('ab+','a')) #[]
print(re.findall('ab+','abbb')) #['abbb']

#{n,m} 贪婪
print(re.findall('ab{2}','abbb')) #['abb']
print(re.findall('ab{2,4}','abbb')) #['abb']
print(re.findall('ab{1,}','abbb')) #'ab{1,}' ===> 'ab+'
print(re.findall('ab{0,}','abbb')) #'ab{0,}' ===> 'ab*'

#[]  
print(re.findall('a[1*-]b','a1b a*b a-b')) #[]内的都为普通字符了，且如果-没有被转意的话，应该放到[]的开头或结尾
print(re.findall('a[^1*-]b','a1b a*b a-b a=b')) #[]内的^代表的意思是取反，所以结果为['a=b']
print(re.findall('a[0-9]b','a1b a*b a-b a=b')) #[]内的^代表的意思是取反，所以结果为['a=b']
print(re.findall('a[a-z]b','a1b a*b a-b a=b aeb')) #[]内的^代表的意思是取反，所以结果为['a=b']
print(re.findall('a[a-zA-Z]b','a1b a*b a-b a=b aeb aEb')) #[]内的^代表的意思是取反，所以结果为['a=b']

#\# print(re.findall('a\\c','a\c')) #对于正则来说a\\c确实可以匹配到a\c,但是在python解释器读取a\\c时，会发生转义，然后交给re去执行，所以抛出异常
print(re.findall(r'a\\c','a\c')) #r代表告诉解释器使用rawstring，即原生字符串，把我们正则内的所有符号都当普通字符处理，不要转义
print(re.findall('a\\\\c','a\c')) #同上面的意思一样，和上面的结果一样都是['a\\c']

#():分组
print(re.findall('ab+','ababab123')) #['ab', 'ab', 'ab']
print(re.findall('(ab)+123','ababab123')) #['ab']，匹配到末尾的ab123中的ab  输出结果一定为（）相符合的内容，（）几个就几个
print(re.findall('(?:ab)+123','ababab123')) #findall的结果不是匹配的全部内容，而是组内的内容,?:可以让结果为匹配的全部内容
print(re.findall('href="(.*?)"','<a href="http://www.baidu.com">点击</a>'))#['http://www.baidu.com']
print(re.findall('href="(?:.*?)"','<a href="http://www.baidu.com">点击</a>'))#['href="http://www.baidu.com"']

#|
print(re.findall('compan(?:y|ies)','Too many companies have gone bankrupt, and the next one is my company'))

() 是把当作一个整体，使输出结果只为括号里内容，(？：)则为 取消
re的其他方法：
search 把第一个符合条件的放进 容器里，下次可以使用group(0)调用出来 没有返回None
match 同 search 但是只看开头 ，如果符合就添加到容器里，下次可以使用group(0)调用出来 没有返回None
split() #[’’, ‘’, ‘cd’]，先按’a’分割得到’‘和’bcd’,再对’'和’bcd’分别按’b’分割

sub 替换：
返回值=re.sub(被替换,替换后的字符，目标字符，次数)
subn 会返回一个 （替换后的元组，替换的次数）
还可以使用 \1 做格式化输出
print(’===>’,re.sub(’^(\w+)(.?\s)(\w+)(.?\s)(\w+)(.*?)$’,r’\5\2\3\4\1’,‘alex make love’))
查询到的分组互换位置

命名分组：
re.findall("(?Pimport re)(?Pimport fincd).*(?P=name)",s,re.S) 返回定义了name的列表 [(名字1，名字2)]

print(re.search("(?Pimport re)(?Pimport fincd).*(?P=name)",s,re.S).groupdict()) #返回一个字典{命名分组：命名分组值…命名分组：命名分组}

print(re.findall("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h/1>hello")) group(0)为整体 剩下的为括号里的内容

如果表达式为 （）|… 会先筛选成进列表，但不符合（）内容都会变为“”
[]都为普通字符串
正则找到为了找到原义\ 需要3个“\” 或者 4个“\”
.*？为非贪婪匹配

complit(正则表达式) =>将一个正则表达式转换为匹配格式对象
就可以用这个对象 使用正则的一些方法了