python 常用模块

#减一天
struct_time = thime.localtime(time.time() - 86400)
print(time.struct_time("%Y-%m-%d %H:%M:%S",struct_time))
#加5年
'%d-%d-%d' % (time.localtime()[0] + 5, time.localtime()[1], time.localtime()[2])


#datetime模块　　
　　#datetime是一个与时间相关的模块，可以处理日期和时间的互换，下面来看一下用法
import datetime
overdue = str(datetime.date.today() + datetime.timedelta(-30))[5:7] + str(datetime.date.today() + datetime.timedelta(-30))[8:]    　　    #返回前30天的日月
print(datetime.datetime.now()) 　　　　　　　　　　# 2016-05-17 15:46:40.784376 获取当前的日期和时间
print(datetime.datetime.now()+datetime.timedelta(days=10)) 　　　　　　　　　　# 2016-05-27 15:47:45.702528 将当前的时间向后推迟10天
print(datetime.date.today()) 　　　　　　　　　　# 2016-05-17 获取当前的日期
print(datetime.datetime.utcnow()) 　　　　　　　　　　# 2016-05-17 08:23:41.150628 获取格林威治时间

print(datetime.datetime.now().timetuple()) 　　　　　　　　　　　　　　　# time.struct_time(tm_year=2016 ... tm_hour=16,...)获取当前一个包含当前时间的结构体
print(datetime.datetime.now().timestamp()) 　　　　　　　　　　　　　　　# 1463473711.057878 获取当前的时间戳
print((datetime.datetime.fromtimestamp(1463473711.057878))) 　　　　　　　　 # 2016-05-17 16:28:31.057878 将时间戳转换成日期和时间
print(datetime.datetime.strptime('2016-05-17 16:28:31','%Y-%m-%d %H:%M:%S')) #2016-05-17 16:28:31 str转换为datetime
print(datetime.datetime.now().strftime('%D, %m %d %H:%M')) #05/23/16, 05 23 10:10　　datetime转换为str

os模块　
os模块是与操作系统相关的模块，比如说对文件和目录的操作，获取路径等，都可以用os模块来实现　，os模块提供的功能太多，下面来简单的看一下常用用法

import os
print(os.getcwd()) # C:UsersTabPycharmProjectsmodules 获取当前工作路径
print(os.environ) # 获取系统环境变量
print(os.getenv('PATH')) # 获取PATH环境变量的值
os.mkdir('test') # 在当前工作空间创建一个test目录
os.remove('path/to/file') # 删除文件
os.rmdir('test') #删除'test'目录
print(os.stat('1.py')) # 返回文件的详细信息 os.stat_result(st_mode=33206 ... st_nlink=1, st_uid=0, st_gid=0, st_size=3152...)
print(os.path.basename(r'C:UsersTabPycharmProjectsmodules1.py')) 　　#获取路径下的文件名 1.py
print(os.path.abspath('1.py')) 　　　　　　　　　　　　　　　　　　　　　　　 　 #获取文件的绝对路径 C:UsersTabPycharmProjectsmodules1.py
print(os.path.dirname(r'C:UsersTabPycharmProjectsmodules1.py')) 　　#获取路径下的路径名
print(os.path.split(r'C:UsersTabPycharmProjectsmodules1.py')) 　　#分割文件和路径
print(os.path.join(r'C:UsersTabPycharmProjectsmodules','1.py')) 　　#合并路径

Json
　　如果要在不同的平台间传递信息的话，就可以用到Json模块，比如说，我们要和前端交互的话，数据之间的传递就可以用Json，Json是一种标准格式，能被所有的语言处理。下面来简单的看一下常用的用法，主要是Python常用数据结构比如dict和list与字符串之间的转换，但是tuple不能，tuple是Python里面特有的，而其他语言没有，再者，Json的loads和dumps方法不太常用。

import json

s='{"name":"jason","age":18}' # 外面不能为双引号
l='[1,2,3,4]'
print(json.loads(s)) # 字符串转字典的时候，字符串里面不能为单引号，否则报错 {'name': 'jason', 'age': 18}
print(json.loads(l),type(json.loads(l))) # 字符串转列表 [1, 2, 3, 4] <class 'list'>
user_list=['alex','jason']
print(type(json.dumps(user_list)),json.dumps(user_list)) #列表转字符串 <class 'str'> ["alex", "jason"]

dic = {'k1':1,'k2':2}
json.dump(dic,open('db','w')) # 将字典序列化导入文件
r=json.load(open('db','r')) # 反序列化从文件中导处
print(r,type(r)) # {'k1': 1, 'k2': 2} <class 'dict'>　

logging

import logging
from logging import handlers

# create logger
logger = logging.getLogger('TEST-LOG')
# 全局日志级别
logger.setLevel(logging.ERROR)

# create console handler and set level to debug
ch = logging.StreamHandler()
# 屏幕日志级别
ch.setLevel(logging.INFO)

# create file handler and set level to warning when是时间单位 ， intterval是时间数量 ， backupCount=是最大备份数，maxBytes 是最大字节
# fh = handlers.TimedRotatingFileHandler("access.log",when="S",interval=5,backupCount=3)
fh = handlers.RotatingFileHandler("access.log",maxBytes=4,backupCount=2)
# 文件日志级别
fh.setLevel(logging.WARNING)

# create formatter
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')

# add formatter to ch and fh
ch.setFormatter(formatter)
fh.setFormatter(formatter)

# add ch and fh to logger
logger.addHandler(ch)
logger.addHandler(fh)

# 'application' code
logger.debug('debug message')
logger.info('info message')
logger.warn('warn message')
logger.error('error message')
logger.critical('critical message')

shelve 模块
shelve模块是一个简单的k，v将内存数据通过文件持久化的模块，可以持久化任何pickle可支持的python数据格式

#!/usr/bin/env python

import shelve

d = shelve.open('shelve_test') #打开一个文件


class Test(object):
def __init__(self,n):
self.n = n


t = Test(123)
t2 = Test(123334)

name = ["alex","rain","test"]
d["test"] = name #持久化列表
d["t1"] = t #持久化类
d["t2"] = t2

xml 模块

<configuration>

<property>
<name>hadoop.tmp.dir</name>
<value>/data/tmp/hadoop/tmp</value>
</property>
<property>
<name>fs.defaultFS</name>
<value>hdfs://0.0.0.0:9000</value>
</property>

</configuration>

—————————————————————————————————————————

In [3]: from xml.etree.ElementTree import parse

In [4]: f = open('core-site.xml')

In [5]: et = parse(f)

In [8]: root = et.getroot()

In [9]: root
Out[9]: <Element 'configuration' at 0x7f95ff1c4c90>

In [10]: root.tag
Out[10]: 'configuration'

In [11]: root.attrib #root的属性
Out[11]: {}

In [13]: root.text.strip()    #text是标签中的值，可以去掉空字符串
Out[13]: ''

In [14]: for child in root:
....: print child.tag
....: 
property
property
_______________________________
root.find
root.findall
root.iterfind
#这些只能查子元素，不能查孙子元素

In [15]: root.findall('property')
Out[15]: 
[<Element 'property' at 0x7f95ff1c4cd0>,
<Element 'property' at 0x7f95ff1c4dd0>]

In [16]: root.iterfind('property')
Out[16]: <generator object select at 0x7f95ff1be550>

In [18]: for e in root.iterfind('property'): print e.tag
property
property

—————————————————————————————————————————

In [22]: list(root.iter('name'))
Out[22]: [<Element 'name' at 0x7f95ff1c4d10>, <Element 'name' at 0x7f95ff1c4e10>]

In [24]: root.findall('property/*')    #匹配property下的所有子节点
Out[24]: 
[<Element 'name' at 0x7f95ff1c4d10>,
<Element 'value' at 0x7f95ff1c4d50>,
<Element 'name' at 0x7f95ff1c4e10>,
<Element 'value' at 0x7f95ff1c4e50>]

In [25]: root.findall('.//name')    #可以找到所有子元素
Out[25]: [<Element 'name' at 0x7f95ff1c4d10>, <Element 'name' at 0x7f95ff1c4e10>]

In [26]: root.findall('.//name/..')    #找到父元素
Out[26]: 
[<Element 'property' at 0x7f95ff1c4cd0>,
<Element 'property' at 0x7f95ff1c4dd0>]

root.findall('元素标签[@属性名]')

root.findall('元素标签[@属性名="特定值"]')

In [38]: root.findall('property[name]') #有name这个子元素的标签
Out[38]: 
[<Element 'property' at 0x7f95ff1c4cd0>,
<Element 'property' at 0x7f95ff1c4dd0>]

In [39]: root.findall('property[name="fs.defaultFS"]')
#有name这个子元素并且等于特定的值的标签
Out[39]: [<Element 'property' at 0x7f95ff1c4dd0>]

In [41]: root.findall('property[1]')    #第一个
Out[41]: [<Element 'property' at 0x7f95ff1c4cd0>]

In [42]: root.findall('property[2]')    #第二个
Out[42]: [<Element 'property' at 0x7f95ff1c4dd0>]

In [43]: root.findall('property[last()]')    #倒数第一个
Out[43]: [<Element 'property' at 0x7f95ff1c4dd0>]

In [44]: root.findall('property[last()-1]')    #倒数第二个
Out[44]: [<Element 'property' at 0x7f95ff1c4cd0>]

hashlib模块

hash：一种算法 ,3.x里代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法
三个特点：
1.内容相同则hash运算结果相同，内容稍微改变则hash值则变
2.不可逆推
3.相同算法：无论校验多长的数据，得到的哈希值长度固定。

import hashlib

m=hashlib.md5()# m=hashlib.sha256()

m.update('hello'.encode('utf8'))
print(m.hexdigest()) #5d41402abc4b2a76b9719d911017c592

m.update('alvin'.encode('utf8'))

print(m.hexdigest()) #92a7e713c30abbb0319fa07da2a5c4af

m2=hashlib.md5()
m2.update('helloalvin'.encode('utf8'))
print(m2.hexdigest()) #92a7e713c30abbb0319fa07da2a5c4af

'''
注意：把一段很长的数据update多次，与一次update这段长数据，得到的结果一样
但是update多次为校验大文件提供了可能。
'''

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

suprocess模块

import subprocess

'''
sh-3.2# ls /Users/egon/Desktop |grep txt$
mysql.txt
tt.txt
事物.txt
'''

res1=subprocess.Popen('ls /Users/jieli/Desktop',shell=True,stdout=subprocess.PIPE)
res=subprocess.Popen('grep txt$',shell=True,stdin=res1.stdout,
stdout=subprocess.PIPE)

print(res.stdout.read().decode('utf-8'))


#等同于上面,但是上面的优势在于,一个数据流可以和另外一个数据流交互,可以通过爬虫得到结果然后交给grep
res1=subprocess.Popen('ls /Users/jieli/Desktop |grep txt$',shell=True,stdout=subprocess.PIPE)
print(res1.stdout.read().decode('utf-8'))

    res = subprocess.Popen(body_obj['choice_cmd'],
                           shell=True,
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE)
    err = res.stderr.read()
    if err:
        back_msg = err
    else:
        back_msg = res.stdout.read()

增删改查

[section1]
k1 = v1
k2:v2
  
[section2]
k1 = v1
 
import ConfigParser
  
config = ConfigParser.ConfigParser()
config.read('i.cfg')
  
# ########## 读 ##########
#secs = config.sections()
#print secs
#options = config.options('group2')
#print options
  
#item_list = config.items('group2')
#print item_list
  
#val = config.get('group1','key')
#val = config.getint('group1','key')
  
# ########## 改写 ##########
#sec = config.remove_section('group1')
#config.write(open('i.cfg', "w"))
  
#sec = config.has_section('wupeiqi')
#sec = config.add_section('wupeiqi')
#config.write(open('i.cfg', "w"))

re模块

'.' 默认匹配除
之外的任意一个字符，若指定flag DOTALL,则匹配任意字符，包括换行
'^' 匹配字符开头，若指定flags MULTILINE,这种也可以匹配上(r"^a","
abc
eee",flags=re.MULTILINE)
'$' 匹配字符结尾，或e.search("foo$","bfoo
sdfsf",flags=re.MULTILINE).group()也可以
'*' 匹配*号前的字符0次或多次，re.findall("ab*","cabb3abcbbac") 结果为['abb', 'ab', 'a']
'+' 匹配前一个字符1次或多次，re.findall("ab+","ab+cd+abb+bba") 结果['ab', 'abb']
'?' 匹配前一个字符1次或0次
'{m}' 匹配前一个字符m次
'{n,m}' 匹配前一个字符n到m次，re.findall("ab{1,3}","abb abc abbcbbb") 结果'abb', 'ab', 'abb']
'|' 匹配|左或|右的字符，re.search("abc|ABC","ABCBabcCD").group() 结果'ABC'
'(...)' 分组匹配，re.search("(abc){2}a(123|456)c", "abcabca456c").group() 结果 abcabca456c
'A' 只从字符开头匹配，re.search("Aabc","alexabc") 是匹配不到的
'' 匹配字符结尾，同$
'd' 匹配数字0-9
'D' 匹配非数字
'w' 匹配[A-Za-z0-9]
'W' 匹配非[A-Za-z0-9]
's' 匹配空白字符、	、
、
 , re.search("s+","ab	c1
3").group() 结果 '	'

'(?P<name>...)' 分组匹配 re.search("(?P<province>[0-9]{4})(?P<city>[0-9]{2})(?P<birthday>[0-9]{4})","371481199306143242").groupdict("city") 结果{'province': '3714', 'city': '81', 'birthday': '1993'}

最常用的匹配语法

re.match 从头开始匹配
re.search 匹配包含
re.findall 把所有匹配到的字符放到以列表中的元素返回
re.splitall 以匹配到的字符当做列表分隔符
re.sub 匹配字符并替换

反斜杠的困扰
与大多数编程语言相同，正则表达式里使用""作为转义字符，这就可能造成反斜杠困扰。假如你需要匹配文本中的字符""，那么使用编程语言表示的正则表达式里将需要4个反斜杠"\\"：前两个和后两个分别用于在编程语言里转义成反斜杠，转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。Python里的原生字符串很好地解决了这个问题，这个例子中的正则表达式可以使用r"\"表示。同样，匹配一个数字的"\d"可以写成r"d"。有了原生字符串，你再也不用担心是不是漏写了反斜杠，写出来的表达式也更直观。