#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __author__="huazai"
"""
md5加密一个文件
Date:2016.08.12
"""

import sys
import hashlib

def md5sum(f):
    m = hashlib.md5()
    with open(f) as fd:
        while True:
            data = fd.read(4096)
            if data:
                m.update(data)
            else:
                break
    return m.hexdigest()

if __name__ == '__main__':
    try:
        print md5sum(sys.argv[1])
    except IndexError:
        print "%s follow a argument" % __file__

ll -R /tmp/mysql/
/tmp/mysql/:
total 12
-rw-r--r-- 1 root root    7 Sep 17 10:04 22.txt
drwxr-xr-x 3 root root 4096 Sep 17 11:15 3dir
-rw-r--r-- 1 root root    5 Sep 17 11:15 88.txt

/tmp/mysql/3dir:
total 8
drwxr-xr-x 2 root root 4096 Sep 17 11:24 2dir
-rw-r--r-- 1 root root    4 Sep 17 11:08 33.txt

/tmp/mysql/3dir/2dir:
total 4
-rw-r--r-- 1 root root 4 Sep 17 11:24 55.txt

roo = os.walk("/tmp/mysql")
for p, d, f in roo:
    print p,d,f
/tmp/mysql ['3dir'] ['88.txt', '22.txt']
/tmp/mysql/3dir ['2dir'] ['33.txt']
/tmp/mysql/3dir/2dir [] ['55.txt']
dirpath, dirnames, filenames
如果目录下面没有目录则dirnames为空

示例
def 递归打印指定目录下的目录和文件(topdir):
    roo = os.walk(topdir)
    for p, d, f in roo:
        for i in f:
            print os.path.join(p,i)
        for j in d:
            print os.path.join(p,j)
            

示例
#!/usr/bin/env python

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __author__="huazai"
"""
实现功能：find  . -type f  -exec md5sum {} \;
Date:2016.08.12
"""

import os
import sys
import hashlib

def md5sum(f):
   m = hashlib.md5()
   with open(f) as fd:
       while True:
           data = fd.read(4096)
           if data:
               m.update(data)
           else:
               break
               return m.hexdigest()

def file_md5(topdir):
    a = os.walk(topdir)
    for p, d, f in a:
        for i in f:
            fn = os.path.join(p,i)
            md5 = md5sum(fn)
            yield "%s %s" % (md5, fn)  # 每调用一次，返回一个文件和该文件的md5值，当然也可以把文件和md5值保存在字典里，读取字典里的key和value

if __name__ == '__main__':
    lines = ''
try:
    topdir = sys.argv[1]
except IndexError:
    print "%s follow a dir" % __file__
    sys.exit()

gen = file_md5(topdir)  #gen是一个生成器对象

for i in gen:
    lines += i+'\n'
print lines
print hashlib.md5(lines).hexdigest()

def list_all_files(rootdir):
    files = []
    list = os.listdir(rootdir) #列出文件夹下所有的目录与文件
    for i in range(0,len(list)):
           path = os.path.join(rootdir,list[i])
           if os.path.isdir(path) and path.find('.idea') == -1 and path.find('.svn') == -1:
               files.extend(list_all_files(path))
           if os.path.isfile(path):
               name, ext = os.path.splitext(path)
               if ext == '.py' and name != '__init__':
                   files.append(path)

    return files

fs = list_all_files(pro_path)

for file in fs:
    __import__(file)

Linux常用环境变量
os.environ['USER']:当前使用用户。
os.environ['LC_COLLATE']:路径扩展的结果排序时的字母顺序。
os.environ['SHELL']:使用shell的类型。
os.environ['LAN']:使用的语言。
os.environ['SSH_AUTH_SOCK']:ssh的执行路径
os.environ['TZ'] :使用的时区

dic={1:1,2:2,3:3}
print dic.items()
[(1, 1), (2, 2), (3, 3)]

找出占用空间大的文件
os.walk
os.path.getsize
dict sort (top10)
#!/usr/bin/env python

import os
import sys
import operator

def gen_dic(topdir):
    dic = {}
    a = os.walk(topdir)
    for p, d, f in a:
        for i in f:
            fn = os.path.join(p, i)
            f_size = os.path.getsize(fn)
            dic[fn] = f_size
    return dic

if __name__ == '__main__':
    dic = gen_dic(sys.argv[1])
    sorted_dic = sorted(dic.iteritems(), key=operator.itemgetter(1), reverse=True)
    for k, v in sorted_dic[:10]:
        print k, '-->', v

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __author__="huazai"
"""
实现功能：find  . -type f  -exec md5sum {} \;
Date:2016.08.12
"""import os

s = os.system('ls')
print s # 只能看到命令成功与否的返回值，不能保存命令执行结果

pipe_out = os.popen('ls')
pipe_out.read() # 读取命令的执行结果

(pipe_in, pipe_out) = os.popen2('sort')
pipe_in.write('z\n')
pipe_in.write('a\n')
pipe_in.close() # 关闭管道 关闭文件
pipe_out.read()

pipe_in, pipe_out, pipe_err = os.popen3('sort')
pipe_err.read()

pipe_in, pipe_out_err = os.popen4('sort')

在*nix下，当shell=True时，如果arg是个字符串，就使用shell来解释执行这个字符串。如果args是个列表，则第一项被视为命令，
其余的都视为是给shell本身的参数。也就是说，等效于：
subprocess.Popen([], args[], ...])

注意：当调用mysqldump 这种命令时候，他会把> %s  也会当成命令的参数，所以不能用shlex.split(cmd)
cmd = "/usr/local/mysql/bin/mysqldump  -u%s -p%s  -P%s  -h%s   --all-databases > %s " % (mysqluser,mysqlpwd,mysqlport,mysqlhost,sqlfile)
p = Popen(shlex.split(cmd), stdout=PIPE,stderr=PIPE)

#!/usr/bin/env python
# -*- coding:utf-8 -*-
############################
# File Name: test_platform.py
# Author: frank
# Mail: frank0903@aliyun.com
# Created Time:2017-06-05 14:31:31
############################

import platform

'''
python中，platform模块给我们提供了很多方法去获取操作系统的信息
如：
import platform
platform.platform() #获取操作系统名称及版本号，'Linux-3.13.0-46-generic-i686-with-Deepin-2014.2-trusty'
platform.version() #获取操作系统版本号，'#76-Ubuntu SMP Thu Feb 26 18:52:49 UTC 2015'
platform.architecture() #获取操作系统的位数，('32bit', 'ELF')
platform.machine() #计算机类型，'i686'
platform.node() #计算机的网络名称，'XF654'
platform.processor() #计算机处理器信息，''i686'
platform.uname() #包含上面所有的信息汇总，('Linux', 'XF654', '3.13.0-46-generic', '#76-Ubuntu SMP Thu Feb 26 18:52:49 UTC 2015', 'i686', 'i686')

还可以获得计算机中python的一些信息：
import platform
platform.python_build()
platform.python_compiler()
platform.python_branch()
platform.python_implementation()
platform.python_revision()
platform.python_version()
platform.python_version_tuple()
'''

# global var
# 是否显示日志信息
SHOW_LOG = True

def get_platform():
    '''获取操作系统名称及版本号'''
    return platform.platform()

def get_version():
    '''获取操作系统版本号'''
    return platform.version()

def get_architecture():
    '''获取操作系统的位数'''
    return platform.architecture()

def get_machine():
    '''计算机类型'''
    return platform.machine()

def get_node():
    '''计算机的网络名称'''
    return platform.node()

def get_processor():
    '''计算机处理器信息'''
    return platform.processor()

def get_system():
    '''获取操作系统类型'''
    return platform.system()

def get_uname():
    '''汇总信息'''
    return platform.uname()

def get_python_build():
    ''' the Python build number and date as strings'''
    return platform.python_build()

def get_python_compiler():
    '''Returns a string identifying the compiler used for compiling Python'''
    return platform.python_compiler()

def get_python_branch():
    '''Returns a string identifying the Python implementation SCM branch'''
    return platform.python_branch()

def get_python_implementation():
    '''Returns a string identifying the Python implementation. Possible return values are: ‘CPython’, ‘IronPython’, ‘Jython’, ‘PyPy’.'''
    return platform.python_implementation()

def get_python_version():
    '''Returns the Python version as string 'major.minor.patchlevel'
    '''
    return platform.python_version()

def get_python_revision():
    '''Returns a string identifying the Python implementation SCM revision.'''
    return platform.python_revision()

def get_python_version_tuple():
    '''Returns the Python version as tuple (major, minor, patchlevel) of strings'''
    return platform.python_version_tuple()

def show_os_all_info():
    '''打印os的全部信息'''
    print('获取操作系统名称及版本号 : [{}]'.format(get_platform()))
    print('获取操作系统版本号 : [{}]'.format(get_version()))
    print('获取操作系统的位数 : [{}]'.format(get_architecture()))
    print('计算机类型 : [{}]'.format(get_machine()))
    print('计算机的网络名称 : [{}]'.format(get_node()))
    print('计算机处理器信息 : [{}]'.format(get_processor()))
    print('获取操作系统类型 : [{}]'.format(get_system()))
    print('汇总信息 : [{}]'.format(get_uname()))

def show_os_info():
    '''只打印os的信息，没有解释部分'''
    print(get_platform())
    print(get_version())
    print(get_architecture())
    print(get_machine())
    print(get_node())
    print(get_processor())
    print(get_system())
    print(get_uname())

def show_python_all_info():
    '''打印python的全部信息'''
    print('The Python build number and date as strings : [{}]'.format(get_python_build()))
    print('Returns a string identifying the compiler used for compiling Python : [{}]'.format(get_python_compiler()))
    print('Returns a string identifying the Python implementation SCM branch : [{}]'.format(get_python_branch()))
    print('Returns a string identifying the Python implementation : [{}]'.format(get_python_implementation()))
    print('The version of Python ： [{}]'.format(get_python_version()))
    print('Python implementation SCM revision : [{}]'.format(get_python_revision()))
    print('Python version as tuple : [{}]'.format(get_python_version_tuple()))

def show_python_info():
    '''只打印python的信息，没有解释部分'''
    print(get_python_build())
    print(get_python_compiler())
    print(get_python_branch())
    print(get_python_implementation())
    print(get_python_version())
    print(get_python_revision())
    print(get_python_version_tuple())

show_os_all_info()

#csv读取
def read_csv(filepath):
    with codecs.open(filepath,'r') as f:
        csv_file=csv.reader(f)
        headers=next(csv_file) #读表头
        print headers
        for row in csv_file:
            print row

csv_file=csv.reader(codecs.open(filepath,'r'))
for row in islice(csv_file, 1, None):
handle_datafieldforwindows(row)

list1=[']
list2=[']
list3=[']

out = codecs.open('C:/actordata222.csv', 'wb') #一定要以wb方式打开
# csv_writer = csv.writer(out, dialect='excel', delimiter=' ',quotechar='|') #不用逗号作为分隔，用空格作为分隔，那么所有列都会合并到第一列，因为没有了逗号
csv_writer = csv.writer(out, dialect='excel')
csv_writer.writerow(list1)
csv_writer.writerow(list2)
csv_writer.writerow(list3)

如果函数中用到全局变量并且修改了它，那么需要在函数里的变量前加global关键字
系统无法判断你是对全局变量还是局部变量做操作，如果不加global关键字，会报错UnboundLocalError ，如果没有修改/赋值，就不用加global关键字

l=[1,2]

def f():
    l.append(4)

不会报UnboundLocalError 

l=[1,2]

def f():
    l[5]

会报UnboundLocalError 

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#__author__="huazai"
"""
测试
Date:2016.08.12
"""

import subprocess
try:
    subprocess.check_call('exit 1', shell=True) # shell里面退出码非0会触发异常
except subprocess.CalledProcessError:
    print 'call fail'
except Exception, e:
    print e
print 'hello world'

class FuncError(Exception):
def __str__(self):
    return "I am a funError"

def func():
    raise FuncError()

func()
#try:
# func()
#except FuncError, e:
# print e
print 'hello world'

func()

try:
    func()
except Exception , e:
    print e

func()
try:
     func()
except NameError, e:
     print e
except IndexError, e:
     print e
except ValueError, e:
     print e

e表示一个变量，保存异常的信息
当然这个变量名随便起，比如
except NameError, a:
     print a

try:

except:

else:

finally:

while True:
...
else:
...

try:
...
except:
...
else:
...
finally:
...

def write(sql, vars):
    """
    连接pg数据库并进行写的操作
    如果连接失败，会把错误写入日志中，并返回false，如果sql执行失败，也会把错误写入日志中，并返回false，如果所有执行正常，则返回true
    """
    try:
        # 连接数据库
        conn = psycopg2.connect(database=db_name, user=db_user, password=db_pass, host=db_host, port=db_port)
        # 获取游标
        cursor = conn.cursor()
    except Exception as e:
        print(e.args)
        log_helper.error('连接数据库失败：' + str(e.args))
        return False
    try:
        # 执行sql语句
        cursor.execute(sql, vars)
        # 提交事务
        conn.commit()
    except Exception as e:
        print(e.args)
        # 如果出错，则事务回滚
        conn.rollback()
        log_helper.error('sql执行失败:' + str(e.args) + ' sql:' + str(sql))
        return False
    else:
        # 获取数据
        try:
            data = [dict((cursor.description[i][0], value) for i, value in enumerate(row))
                         for row in cursor.fetchall()]
        except Exception as e:
            # 没有设置returning或执行修改或删除语句时，记录不存在
            data = None
    finally:
        # 关闭游标和数据库链接
        cursor.close()
        conn.close()

    # 如果写入数据后，将数据库返回的数据返回给调用者
    return data