python 中好玩的命

1：输出的是比 i的开平方 小 的最大整数

import math
if __name__ == '__main__':
print int(math.sqrt(48))                          #6

 2:在本地多线程序进行shell，返回结果保存到数组中

# -*- coding:utf-8 -*- 
#!/usr/bin/python 
import paramiko 
import threading 
import logging  
import logging.config 
import sys

logging.config.fileConfig("logging.conf")
logger = logging.getLogger("main")
error_shell=['shutdown','reboot','halt','poweroff','init','kill']  

class MyThread(object):  
    def __init__(self, func_list=None):  
    #所有线程函数的返回值汇总，如果最后为0，说明全部成功  
        self.ret_flag = []  
        self.func_list = func_list  
        self.threads = []  
           
    def set_thread_func_list(self, func_list):  
        """ 
        @note: func_list是一个list，每个元素是一个dict，有func和args两个参数 
        """  
        self.func_list = func_list  
  
   
    def ret_value(self):  
        """ 
        @note: 所有线程函数的返回值之和，如果为0那么表示所有函数执行成功 
        """  
        return self.ret_flag  
  
    def trace_func(self, func, *args, **kwargs):  
        """ 
        @note:替代profile_func，新的跟踪线程返回值的函数，对真正执行的线程函数包一次函数，以获取返回值 
        """  
        ret = func(*args, **kwargs)  
        self.ret_flag.append(ret)   
  
  
  
    def start(self):  
        """ 
        @note: 启动多线程执行，并阻塞到结束 
        """  
        self.threads = []  
        self.ret_flag = []  
        for func_dict in self.func_list:  
            if func_dict["args"]:  
                new_arg_list = []  
                new_arg_list.append(func_dict["func"])  
                for arg in func_dict["args"]:  
                    new_arg_list.append(arg)  
                new_arg_tuple = tuple(new_arg_list)  
                t = threading.Thread(target=self.trace_func, args=new_arg_tuple)  
            else:  
                t = threading.Thread(target=self.trace_func, args=(func_dict["func"],))  
            self.threads.append(t)  
       
        for thread_obj in self.threads:  
            thread_obj.start()  
       
        for thread_obj in self.threads:  
            thread_obj.join()  
 
def ssh2(ip,username,passwd,cmd):
    Information=[];
    try:
        ssh = paramiko.SSHClient()
        ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
        ssh.connect(ip,22,username,passwd,timeout=5)
        for m in cmd:
            if(is_harmful_shell(m)):
                logger.error('not running harmful shell: %s on:%s'%(m,ip))
            else:
                stdin, stdout, stderr = ssh.exec_command(m)
#               stdin.write("Y")   #简单交互，输入 ‘Y’ 
                out = stdout.readlines()
                #屏幕输出
                for o in out:
                    Information.append(o);
                logger.info('Performed on %s machine:'%(ip)+m);
        ssh.close()
        return Information;
    except :
        logger.error( '%s\tError\n'%(ip) +sys.exc_info()[0],sys.exc_info()[1]);

def is_harmful_shell(cmd):
    for m in error_shell:
        if(cmd.lower().find(m.lower())!=-1):
            return True;
    return False;


if __name__=='__main__':
    mt = MyThread() 
    g_func_list = []
    cmd = ['hostname','cat /proc/sys/kernel/random/uuid']#你要执行的命令列表
    username = "root"  #用户名
    passwd = "root"    #密码
    threads = []   #多线程
    print "Begin......"
    for i in range(129,131):
        ip = '192.168.197.'+str(i)
        g_func_list.append({"func":ssh2,"args":(ip,username,passwd,cmd)}) 
    mt.set_thread_func_list(g_func_list)
    mt.start()  
    for k, v in enumerate(mt.ret_value()):
        print k, v

 日志

[loggers]
keys=root,main

[handlers]
keys=consoleHandler,fileHandler

[formatters]
keys=fmt

[logger_root]
level=INFO
handlers=consoleHandler

[logger_main]
level=INFO
qualname=main
handlers=fileHandler

[handler_consoleHandler]
class=StreamHandler
level=INFO
formatter=fmt
args=(sys.stdout,)

[handler_fileHandler]
class=logging.handlers.RotatingFileHandler
level=INFO
formatter=fmt
args=('tst.log','a',20000,5,)

[formatter_fmt]
format=%(asctime)s - %(name)s - %(levelname)s - %(message)s
datefmt=