今天讲了一些python的实用地方工具模块


loggin模块

用于记录日志

#!/usr/bin/env python
#--*--coding:utf-8--*--
import logging
logging.basicConfig(filename='wgwtest.log', #filename代表记录的日志文件名称
                    format='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',
                    #日志格式参数 包括修改时间 启动程序的用户名 日志告警级别 日志记录的程序名称 告警信息
                    datefmt='%Y-%m-%d %H:%M:%S %p',
                    #日志中asctime的时间格式
                    level=logging.DEBUG)
                    #设置日志等级，设置之后只打印这个等级和这个等级以上的告警
                    #默认的等级是logging.warning
#告警之后写入的告警信息%(message)s的内容
logging.debug('debug')
logging.info('info')
logging.warning('warning')
logging.error('error')
logging.critical('critical')

打印出来的日志内容为

2015-12-04 16:21:15 PM - root - DEBUG -wgwtest:  debug
2015-12-04 16:21:15 PM - root - INFO -wgwtest:  info
2015-12-04 16:21:15 PM - root - WARNING -wgwtest:  warning
2015-12-04 16:21:15 PM - root - ERROR -wgwtest:  error
2015-12-04 16:21:15 PM - root - CRITICAL -wgwtest:  critical

在日志格式的参数方面，还有很多的可以用来设置的

%(levelno)s: 打印日志级别的数值

%(levelname)s: 打印日志级别名称

%(pathname)s: 打印当前执行程序的路径，其实就是sys.argv[0]

%(filename)s: 打印当前执行程序名

%(funcName)s: 打印日志的当前函数

%(lineno)d: 打印日志的当前行号

%(asctime)s: 打印日志的时间

%(thread)d: 打印线程ID

%(threadName)s: 打印线程名称

%(process)d: 打印进程ID

%(message)s: 打印日志信息

日志的打印等级由高到低

CRITICAL = 50
FATAL = CRITICAL
ERROR = 40
WARNING = 30
WARN = WARNING
INFO = 20
DEBUG = 10
NOTSET = 0


time模块

import time
print time.strftime('%Y-%m-%d',time.localtime()) #格式化实现本地当前时间
2015-12-04 18:21:18
import time
print time.asctime(time.localtime())  #以文字形式显示的日期
Fri Dec 04 18:33:10 2015


datetime模块

import datetime
print datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') #获取当前时间
2015-12-04 18:37:42
import datetime
print datetime.datetime.now() - datetime.timedelta(days=5) #获取5天前的日期
2015-11-29 18:44:33.063000
import datetime
print datetime.datetime.now() + datetime.timedelta(minutes=30) #获取30分钟后的时间
2015-12-04 19:18:35.263000


shutil模块

用于对文件，文件夹的高级操作，可以复制文件或者文件夹并且压缩文件夹

shutil.copy()

复制一个目标文件的内容和权限，如果文件不存在就创建一个文件，如果存在就覆盖里面的内容

import shutil
shutil.copy('test','test2')


shutil.copytree()

递归的复制文件，其实就是复制文件夹。可以将文件夹里的所有内容复制到另一个文件夹

import shutil
shutil.copytree('testdir','bak_testdir')
[wgw@mail ~]$ ls -l |grep testdir
drwxrwxr-x  2 wgw   wgw        4096 Dec  4 20:59 bak_testdir
drwxrwxr-x  2 wgw   wgw        4096 Dec  4 20:59 testdir

shutil.rmtree()

递归的删除文件，其实就是删除一个文件夹和文件夹里的文件

import shutil
shutil.rmtree('testdir')
[wgw@mail ~]$ ls -l |grep testdir
drwxrwxr-x  2 wgw   wgw        4096 Dec  4 20:59 bak_testdir

shutil.move()

递归的移动文件，其实就是移动文件夹

import shutil
shutil.move('bak_testdir','new_testdir')
[wgw@mail ~]$ ls -l |grep testdir
drwxrwxr-x  2 wgw   wgw        4096 Dec  4 20:59 new_testdir

该命令也可以用于移动单个文件

shutil.move('logger.pyc','1.pyc')


shutil模块还有压缩文件夹的功能

make_archive(base_name, format, root_dir=None)
这个功能有三个基本参数，base_name表示打包之后的文件名，format表示打包的格式(“zip”, “tar”, “bztar”，“gztar”),root_dir表示要被打包的目录路径（默认是本地）
import shutil
shutil.make_archive('wgw','gztar','/home/wgw')
[wgw@mail ~]$ ls -l |grep wgw.tar.gz
-rw-rw-r--  1 wgw   wgw         138 Dec  4 21:32 wgw.tar.gz


subprocess模块

该模块的作用是执行系统命令，并且把系统命令的结果返回，也可以返回运行结果的代码

import subprocess
obj=subprocess.Popen(['df','-h'],shell=False,stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
print obj.wait()
print obj.stderr.read()
print obj.stdout.read()

默认情况下，shell=False此时要运行的命令需要一个个输入到列表中。  当shell=True就表示要调用系统的shell来运行命令了。cwd参数表示要执行命令的路径

obj=subprocess.Popen('df -h',shell=True，cwd='/home/wgw')


stdin, stdout, stderr：分别表示程序的标准输入、输出、错误句柄，通过subprocess.PIPE的管道传输出来，并通过obj.stdout.read()将结果读取出来。当命令的执行结果正确的时候obj.wait()的值为0，当执行结果不争取的时候值为1



面向对象的编程

所谓类就是同一种事物共通属性的集合。函数写在类下面就改名叫类里面的方法了。但是函数的定义方法还是一样的。

class person():
    #定义这个类可以传入的参数，self是默认必须有的
    def __init__(self,name,age):
        '''把类外面的参数值传入类里面，这样类里的方法要用
        外面传入的参数的时候直接只用self.xxx就可以使用这些值了
        '''
        self.name=name
        self.age=age
    #在类里面函数就改名叫做方法了，但是和函数一样也可以为方法自己单独定义参数
    def take_money(self,money):
        return '%s take $%d'%(self.name,money)
    #定义一个无参数的方法
    def sayhi(self):
        return 'my name is %s age is %d'%(self.name,self.age)
#将类实例化
user1=person('wgw',32)
user2=person('haha',35)
#打印调用类里面的方法之后的结果
print user1.take_money(3000)
print user1.sayhi()
print '#'*20
print user2.take_money(6000)
print user2.sayhi()
wgw take $3000
my name is wgw age is 32
####################
haha take $6000
my name is haha age is 35



我个人的理解，所谓的类就是一个大的模板，类里面的方法就是这个模板包含的功能。但是这个模板建立好了之后并不运行。只有模板被调用了也就是实例化了这个模板才变成真正的功能模块，提供相应的功能。

举个现实的例子就是，我们需要软件打字。那么office就是集成了打字功能的类。这里类里面打字的方法有word，有excel还有ppt都可以实现打字功能。但是这三个方法又不完全一样。现在的office只是个名称而已，是抽象的。我们不能光靠说office软件名称电脑就自己把字打出来了。我们需要把office装到个人的电脑上才能让自己打字。软件装在电脑上这个步骤就是把office具体的实例化了，变成user1电脑上的office了。把这个人的属性加到office就叫实例化。

office类里面包含了word、ppt、excel三个方法呢。user1和user2两个用户分别实例化之后就可以调用各自电脑上的word方法进行打字了。也可以分别调用不同的方法打字。以后user3、user4再有打字需求都可以调用office类来解决，这样既可以实现代码的复用又可以调用不同的方法满足灵活性的需求。有更新需求了只需要调整类里面的代码就可以了。office安装在谁的电脑上这个参数必须在def __init__()类的初始化部分声明参数，并且通过self.name=name 这个方法将用户名这种参数导入到类的内部。这样调用word等方法的时候通过self.name就才可以知道打字能跑在谁的电脑上。


类和函数最大的区别就是，类是抽象的不实例化没意义，只有里面方法才是处理问题的。但函数是写出来代码里就具体包含了要实现的功能。