python标准库&多线程

一、Python标准库

参考：
python.org /Docs/Turtorial/模块描述
Library Reference 标准库文档

Python标准库常见模板

OS：与操作系统相关
Time/datetime:时间与日期
Math:科学计算
Urlib:网络请求

OS主要针对文件，目录的操作，常用方法：

os.mkdir()创建目录
os.removedirs()删除文件
os.getenv()获取当前目录
os.path.exists(dir or file)判断存在
os.getcwd().print   可选择打印方法

time: 时间

time.asctime()国外的时间格式
time.time()时间戳，自1970.1.1 0:0:0 开始 ，UTC世界时间戳，唯一
time.sleep()等待
time.localtime()将当前时间转成时间元组
time.strftime()将当前时间转换成带格式时间
eg:time.strftime("%Y-%m-%d %H:%M:%S",time.localtime())

urllib：

导入：
python2:
    import urllib2
    response=urllib2.urlopen("http://www.baidu.com")
 python3:
     import urllib.request
     response=urllib.request.urlopen('http://www.baidu.com')#对于返回对象，可在控制台界面查看相关信息，如消息头，请求头..

math:

math.ceil(x)   返回大于等于参数X的最小整数
math.floor(x)  返回小于等于参数x的最大整数
math.sqrt(x)   求平方根

疑问：

时间戳单位
读文件rwab ,写文件方法需总结？
response:object=urllib.request.urlopen()此方式,response:用法？ 

练习：

1、获取两天前的时间：
now_timestamp=time.time()
two_day_before=now_timestamp-60*60*24*2
time_tuple=time.localtime(two_day_before)
print(time.strftime("%Y-%m-%d %H:%M:%S",time_tuple))

2、获取返回对象属性
response:object=urllib.request.urlopen('http://www.baidu.com')
print(response.status)
print(response.headers)
print(response.read())

二、python多线程

1、概念及特性：

进程：

进程是执行中的程序
拥有独立的地址空间、内存、数据栈等
操作系统管理
派生(fork或spawn)新进程
进程间通信(IPC)方式共享信息

线程：

同进程下执行，共享相同的上下文
线程间的信息共享和通信更加容易
多线程并发执行
需要同步原语

python与线程：

解释器主循环
主循环中只有一个控制线程在执行
使用全局解释器锁(GIL)

GIL保证一个线程：

设置GIL
切换进一个线程去运行
执行下面操作之一
    指定数量的字节码指令
    线程主动让出控制权
把线程设置会睡眠状态(切换出线程)
解锁GIL
重复上述步骤

2、python两种线程管理:

_thread:提供了基本的线程和锁
threading:提供了更高级别、功能更全面的线程管理
    支持同步机制
    支持守护线程

_thread模块及方法：

_thread.start_new_thread(function,args,kwargs=None)派生一个新的线程，使用给定得args和可选得kwargs来执行function
_thread.allocate_lock()分配LockType锁对象
_thread.exit()给线程退出指令

LockType锁对象的方法:
    acquire(wait=None)  尝试获取锁对象
    locked()  如果获取了锁对象则返回True，否则，返回False
    release()  释放锁

threading模块：

对象Thread 表示一个执行线程的对象
对象Lock   锁原语对象(和thread模块中的锁一样)
Rlock      可重入锁对象，使单一线程可以(再次)获得已持有的锁(递归锁)
Condition  条件变量对象，使得一个线程等待另一个线程满足特定的"条件"，比如改变状态或某个数据值
Event      条件变量的通用版本，任意数量的线程等待某个事件的发生，在该事件发生后所有线程将被激活
Semaphore  为线程间贡献的有限资源提供了一个"计数器"，如果没有可用资源时会被阻塞
BoundedSemaphore  与Semaphore相似，不过它不允许超过初始值
Timer    与Thread相似，不过它要在运行前等待一段时间
Barrier  创建一个"障碍"，必须达到指定数量的线程后才可以继续

Thread类1：Thread对象数据属性

    name 线程名
    ident 线程的标识符
    daemon 布尔标志，表示这个线程是否是守护线程
    Thread对象方法
    _init_(group=None,target=None,name=None,args=(),kwargs={},verbose=None,daemon=None)
    实例化一个线程对象，需要有一个可调用的target,以及其参数args或kwargs。还可以传递name或group参数，不过后者还未实现。此外，verbose标志也是可接受的。而daemon的值将会设定thread.daemon属性/标志

Thread2:对象属性

    start()    开始执行该线程
    run()      定义线程功能的方法(通常在子类中被应用开发者重写)
    join(timeout=None)  直至启动的线程终止之前一直挂起：除非给出了timeout(秒)，否则会一直阻塞
    getName() 返回线程名
    setName(name) 设定线程名
    isAlivel/is_alive() 布尔标志，表示这个线程是否还存活
    isDaemon()  如果是守护线程，则返回True；否则，返回False
    setDaemon(daemonic) 把线程的守护标志设定为布尔值 daemonic (必须在线程start()之前调用)

3、疑问：
原语？
threading是否继承自_thread
ide格式化操作？

4、练习：
方法1、主函数调用多个方法_串行：

def loop0():
    logging.info("start loop0 at"+ctime())
    sleep(4)
    logging.info("end loop0 at"+ctime())
    
def loop1():
    logging.info("start loop1 at"+ctime())
    sleep(2)
    logging.info("end loop1 at"+ctime())
    
def main():
    logging.info("start all at"+ctime())
    loop0()
    loop1()
    logging.info("end all at"+ctime())

if __name__==__'main'__:
    main()

方法2、用thread模块实现多线程&需保证主线程等各线程执行结束

def main():
    logging.info("start all at"+ctime())
    _thread.start_new_thread(loop0,()) 派生线程，执行loop0()函数
    _thread.start_new_thread(loop1,())
    sleep(6)
    logging.info("end all at"+ctime())
if __name__==__'main'__:
    main()    

方法3、

loops=[2,4]
def loop(nloop,nsec,lock):
    logging.info("start loop"+str(nloop)+"at"+ctime())
    sleep(nsec)
    logging.info("end loop"+str(nloop)+ "at"+ctime())
    lock.release()

def main():
    logging.info("start all at"+ctime())
    locks=[]
    nloops=range(len(loops))
    for i in nloops:
        lock=_thread.allocate_lock()
        lock.acquire()
        locks.append(lock)
    for i in nloops:
        _thread.start_new_thread(loop,(i,loops[i],locks[i]))
    for i in nloops:
        while locks[i].locked():pass
    logging.info("end all at"+ctime())

if __name__==__'main'__:
    main()   

方法4、

def loop(nloop,nsec):
    logging.info("start loop"+str(nloop)+"at"+ctime())
    sleep(nsec)
    logging.info("end loop"+str(nloop)+ "at"+ctime())

def main():
    logging.info("start all at"+ctime())
    threads=[]
    nloops=range(len(loops))
    for i in nloops:
        t=threading.Thread(target=loop,args=(i,loops[i]))
        threads.append(t)
    for i in nloops:
        threads[i].start()
    for i in nloops:
        threads[i].join()
    logging.info("end all at"+ctime())

if __name__==__'main'__:
    main()   

方法5、

class MyThread(threading.Thread):
    def __init__(self,func,args,name=''):
        threading.Thread.__init__(self)
        self.func=func
        self.args=args
        self.name=name
    def run(self):
        self.func(*self.args)

def loop(nloop,nsec):
    logging.info("start loop"+str(nloop)+"at"+ctime())
    sleep(nsec)
    logging.info("end loop"+str(nloop)+"at"+ctime())

def main():
    logging.info("start all at"+ctime())
    threads=[]
    nloops=range(len(loops))
    for i in nloops:
        t=MyThread(loop,(i,loopsp[i],loop.__name__)
        threads.append(t)
    for i in nloops:
        threads[i].start()
    for i in nloops:
        threads[i].join()
    logging.info("end all at"+ctime())

if __name__==__'main'__:
    main()1.