【python之旅】python的模块

一、定义模块：
　　模块：用来从逻辑上组织python代码（变量、函数、类、逻辑：实现一个功能），本质就是以.py结尾的python文件（文件名：test.py ，对应的模块名就是test）
　　包：用来从逻辑上组织模块的，本质就是一个目录（必须带有__init__.py的文件）
二、导入方法：
　　1、import module_guyun

 #命名为module_guyun.py
 #需要导入的模块内容
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 # Author :GU
 name = "guyun"
 def say_hallo():
     print("hello guyun")
 ########################
 #导入模块
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 # Author :GU
 import module_guyun
 print(module_guyun.name)
 module_guyun.say_hallo()
 执行结果：
 guyun
 hello guyun

　　2、from module_alex import logger as logger_guyun #别名

　　当要导入的模块与本模块命名重复时，别名要导入的模块可以解决这个问题

 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 # Author :GU
 name = "guyun"
 def say_hallo():
     print("hello guyun")
 def logger():
     print("in the module_guyun")
 def running():
     pass
 ##################
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 # Author :GU
 from module_guyun import logger as logger_guyun
 def logger():
     print("in the main")
 logger()
 logger_guyun()
 ##执行结果：
 in the main
 in the module_guyun

　　3、导入一个包实际的本质就是导入一个__init__.py

　　包package_test里面的init文件

 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 # Author :GU
 print("from test package package_test")

　　现在把package_testp_test文件导入p_test

 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 # Author :GU
 import package_test
 ##执行结果：
 from test package package_test

　　4、当文件目录不再同一级目录之后该如何调用

　　-module_test

　　　　-main.py

　　-module_guyun.py

　　现在main.py去调用module_guyun.py

 #module_guyun.py文件
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 # Author :GU
 name = "guyun"
 def say_hallo():
     print("hello guyun")
 def logger():
     print("in the module_guyun")
 def running():
     pass
 ##main.py文件
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 # Author :GU
 #from module_guyun import logger as logger_guyun
 import sys,os
 x  = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 #print(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 sys.path.append(x)
 import module_guyun
 module_guyun.say_hallo()
 module_guyun.logger()
 ####
 #执行结果：
 hello guyun
 in the module_guyun

　　5、如何导入一个包

　　-package_test

　　　　-test1.py

　　　　-__init__.py

　　-p_test.py

 #init文件
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 # Author :GU
 print("from test package package_test")
 from . import test1
 #test1文件
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 # Author :GU
 def test():
     print("in the test1")
 ###调用文件
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 # Author :GU
 import package_test ###执行init.py文件
 package_test.test1.test()
 #执行结果：
 from test package package_test
 in the test1
 ####达到的目的就是在同一级目录倒入一个包的文件，中间通过init文件调度

总结

• 　　import module_alex
• 　　import module_alex，module2_alex #调用多个模块
• 　　for module_alex import *    ###不建议用
• 　　from module_alex import m1,m2,m3   ##调用一个模块中的多个小模块
• 　　from module_alex import logger as logger_alex  ###别名

三、import本质（路径搜索和搜索路径）

　　导入模块的本质就是把python文件解释一遍

　　import moile_name ------->module_name.py ----->module_name.py的路径----->sys.path
导入包的本质就是在执行这个包里面的__init__.py文件

四、导入优化
　　aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAdUAAAFQCAIAAABmpnPLAAAgAElEQVR4nOzdd1xTV/8H8Ouo42nt01/71KfLtj601bqqVlu1Vqt1D8RRRx2ttc466xaVS5iCLEERRJSNCIKDLUtAEAXZhLADIUAWgYTsfH9/JEAICIpKpH7fL1591dyTc09ubj4599xzbwhACCGkC4SuG4AQQq8pzF+EENINzF+EENINzF+EENINzN/nQYuMLO/2k7n3HPc53eO9wOYghHqVZ8vfgN22n35q1/wXFMqXvqRmveKY6dd3Lvj0008/mHE69tmeWZ9zfteyrz/99NNPP/34ww++/+t67ctp4T9AfkDEzAl2n35qZ3Ff101B6OV42vxVyoq3D6b0ecd2uXMVgDDK3P/zISRBXIt5qa17pVHP63//0/Go7j69xHjqkB7KX6VMLFX0wHoAAJRyqUyufAEVcTz+uDq0D0kQ5HDDkhdQnw4oRI2SJoniBWwNhVQiexEb9WkopT23t7z2njJ/5XkXfAf2Nx62Pr0OAECUeiVKf6br5MnRD19m415tvSd/S7x2OeX0wHoAABgR5leS6wXy56+p6Hbcynmukye7Oj56/sp0QZSzbNCZOUdzWc9dkzTT8qR3xQto0tModP7dvqiH1vXae8r85Xv/7vRGX3L4ieKX25zepNfkb93NvfPt0l/+egAAeIn2fzrcZr+I/O3t+HG3PntB+Vt2ce7vPZW/NX7rf8T87SkvMn/rs/Mop2PIy+X1L6Rpr7r2+SsseJBVxRe2KdVQGPuwUt7BMWgP5W9jUcKJlV/8YJ76ktcDACCqznHaM/OnI14vKH8b4pySTxzLfp7RBz6d6XcuJTKHL3kRDQIAfm6BGRlzyrWsixOnZUU75lgTg6yeP3+5D71WfTuwZ/KXnxe6a+77mL89ptP8lYlzQpP/0PfV1/eaOMy8bx/yX1+66ev76ev76etHhlAb5AAAyrqiEoutvvr6fnMn2Q3ob/zv+cmVjfxI18jmknfuVLettpZ2WN+3eamf/qnHZWz1eTwRs8adEty6SN9PX9/vt+PRlocjNun76ev7LV8ddDFJ8DQvjENLsN6vr69/OqIy8by+vr6+/tajFqnUQl+T/b/o6+vrH4rWSr7Hl/SbbbX0K2F39IHN9lCX2PC3e+xtm5b8lfIzb9lt1l/w/cLDd8vY6tdSnetO2aI/f8oCo3BxB4N3XeZvkefWTeq1HTCNKWx8mlfdStL4OMBYX19//tRR7/yr/zsjf2x+cX+dv5XF1y5dFWpyaK2+vr6+/i+/7/J5xO2gQuYjG8Pt6jpW/rrr9JWQyNsVzd813HhbfX39hTMnffLuwCGfT1ywaKm+vr6+/ibSKa7m2doN4voGXyPV7nHl63fM+hABWqc4mWHRWnuIvr7f0etZZs071S7HIo5QIZfSLfR95/3o8vG/LxheSiG332gpvN86q5DTbsW8Kqd9IQYtde6OD8tp2dOUnLKyM9t89fX95k22H/SG8eDZSXRBY6x7VMtOfku1kzfVR7nErNf31f/hXJ8+JNHP5P0vXBc013kuRfYMG4KV726xV19ff874D/v06Tts4tzmd/B0RGX7NyjfecVy1eLfDZ0eVgg7qLAweMPaVeo6Nh02t7ALeVzYpPqiFNTGXD6hr68/77svBg/o+96Yn5vX9bdnUnHTMzQaPZtO81epbKpvLKVxaLSKsysc+vclP9nxmEbj0GgcGo3PE6lPs8jE4uoyDo1GP7fhwpv9yTdnxJ7eajd0osfxU2E/jrEmCJPPTpW2VJnrc2f6WOvBfY33+nFoNGaAWdDXH1l+OtzDrVgJAAqptDgiac5YC4IgCcLb7WH5gZlG/QebvjXI1dCvOMLYpU9fs++WpdCe4oXJRA0FwSbTR3w09LM/Ami0tFi3NV+/9eGktdYBcfm0hJOTh0w686C5LOu2of6YT2eYxtJoNBot/abhujmj5hk9rhdpVph9dfN3X04/fZdGo9FoWbEO+5brvTnoW1X+KuVCXk3cxd2Tft4UWqLOX4W0icVIsFg2deaBG6JnzF9umuf6BfqGfqk0Go1Gy7jhuG/WMAO7qPyOPlVPoFQIOQwajUajhR6d/NWk/ddpauW1PKFm77SxKM5wo8Eum+DH+TQarTApzGzxRz8dcorT7LWx8qOObP3FzC8ml0aj0Whp8dZz/vV/0zccvc9o3toNTBqNRqPF266f9cN667SsAhqNRqOVMmobnnWKjEIuZ1dxaDTObUv/z98liXb5K63nB+xzIAiSIOzWncxwO+H2zmBy8HvW48aH+oU9/GXKmQFv+/iXC5VKSXlq0fFlZwnC5N33Ld98w8ONxqHlVXmd9vl8iOWwdffyqsUtddIT03//+ey/B1JWOlbTaKz4oHvz/mc29JNL5M1akRygdSevdPrd5e0B5MDpccY77P474cqhk+E/jz9LECYfHC9RtZ5fxy+hcWg0jts6khhoOW1b6gP1R4ZT0/gs59BkTazqChqNRqN5r+4/YMXZhOZ3sKpe0ubwoi7eYcH0pebhqm2e4mn0xw+frbuSWalZiHbz1OI1+29k5NBoNBrtoY/51glvvb3q7F2uah9XSPmsShqNRqPd2PXZ0EmG0c3rorMbxXgy7uV5keMPD2yuvDOYJAjyw7FXvHMAWCUHf3J8sz9lznn1Z5l1L2XOGIs+fZ0cNI5vMi9d/997JEFcj1MAAHDTMgwmWRLEOctMKTQJI0yvEgQ5Y296ERcg+hZBUPS+C7n7dAft7GSX+eOmHosoA4DG6jzDucPXngxRdVMidg0ctvIyAwBAyYwwHf/5xsB6za/5PJufxg3e4NMybFAbazd9xDSje5or1h5/oN0y+nFBa/4CAECx+8bZs58xf5X0xL9X6G9zu68xu48RYrh2+NyT+cxn7AUDAORazxjzI+UJ4w+8EvcDvyw96lPaelDRkOZ39NtJG64/YqofkHDizxsfPhHMaH2atOy+287NW27naPWky33/WjJn14sZf6iJiBk7zKx9/gJACsWJIMym/ZrwmAfw4N7H75kNeNPS8j5AZfnhlU4EYWcYwwcAcS3LZoMtQZB950fnVzcf0NRUmW5y7kOQy89Vq87zC0rKDy8526eP7f6AmpawKY97sGQ0SRBXfZhizVWn2Xu+/xZJEOTQkW5XswHYZcfmnX+rP2Wmg/YwQ/gO8oWMPwDEbe3/xPEHJe322p8WHr5F05h0Uurxx9yhy2zrRc3dbV7GmXVHnOMLNY7p6uPtf19+9Eptg1aX/NHJLz7C8Yce8+Lzd8CbdscjGtovVYjZnvu8PiIoM8xK2yxgFe2ccLYPQS5xYEoBuGkZyydbEoRXUKOsOX+tfjHJYzR1L3/XuORXgyp/14zb5ZKsallL/sprkk7qf//ziVsCSZuv+Zo7h4cNmWCZKQEAkJd571kyfNL+1DrNoY+XlL/CrBuU2ct3RORp1gOFIYbTPp9q86jqqV55G53kr4KR7bt23nzbu22uIqlO8/114qgDXin1qk0i5SVfPr5p/am7RTxpS642VaUkx2YUaX0f9GT+Wi/emVEO6vwdNMTNj/6k/HU2DKzSaKjg7tmQrweSxJz4OqlSKRen+oaOJYzH/p6cX6sRRg01jn9cfrcfOfoQTXMoSpW//QaePRTabhSnrR7JX36Sy+7v1hhmVbV5I7Kvbh4xdLY7o7lL0ZDruHn9rjPXaByNF8hN876dydd+pzB/e9SLz9+3v4jI7GgpJyt/848WBGF3PErr1EVT0E6nvn3IT+cmlfR4/tYkuy2b8MOJOwUSrYTk3Fn7nyHfWWUBALDSzX6dMnO/X12bnfXl5K+cFXt++/RJy0wcPfw12B1a/tX7xGrXgqd65W08OX+VsqJY0zl63+02v6y5rotme38YTsw9cZ2h/lDLmPmRhsvHzlq3+/wVf39//6wnbv9ekb9QHJow6wuSILxDRHIxt95hvRVBWK21KKhuM+AkSXK8MeJdkvhfaJbGo6r8HTQs7HFX7e+J/JVVBp1c/f2Pm+xdvTXfQatdP330NvF7YMs3hCDnpsP6qe//fOCSv7//zfCYJ58ix/ztUS8+f/89P7myo6VVKZmrx5Md5S8kGl/o15f86MuI9B7P39JIq3kjZtqmlLY7M5J6cOg77x2IBgCg39tvMHaRaQS3zefz5eSviHHLfM3XI378c78h2c719G58lp+cvwpJ7vV94z7+euW2Y+3X5RmT16DR8eMW3fNwJMkDKz/v32/6b0YWju6p5e2Ho3tf/gpZXOMFRh3lL+T63B77IUkQ/tEaD6ryd/DsJHpX7e+J/G2kue9fOOKbBXuPnGr/Dobktxk5qbp/1dKMPL519v+GfrZ8p5GdX0wVr/3gPOZvj+q5/O20/+uo2f81mNRz+Vub7LZswg/H2/d/2ar+bzaAuv+7qgfzd6r+sfulTzXN4yl0kb9TJ6/wftjRhIcOCcvjAq/7Xr24e/n42X/ZP6JrRXCvyF/pY9+o7z8iic+CU8QKMbf+XOf9X73QbI1HX8H8nbrRllYn7mBpR6ScvIhr165YH1o0Z9pv9tH1TTj+oEs9l78KTrXt5kv/Jig/mrYd/wWmxXd2fQlyyTmmrMfzV16TfFL/+98cHzRpdYDTHT57Z/KZLPX4r8+epSNW2VTxNPfyl5O/SkHG9dMzf/zFM42u1aJ8f/9E1gvo/5aEhycWF4sBAORV6R4rp0w7FZClNceoPC4uMS9PFa5NLEbEFbsMjS9NpULGeHB9x+bfbSKobT/32vnLTE9PTEl56nRv46Xlb2OE5Y0R/UhiSSJfqlSKm2Id/D8ijMdojf8C79pe74/7djz+2538fZw6eaKzfVo3toR2/j5yckpU/Z+Cl3Bh57czt0aUsLX2sEw3t0Sx+s1hpEYER96t0fh2kYv42dcMp6w63faUBrTP34KAgMS6um40Gj2NnstfAKhTzX/o4xuh8eDjlvkPSoAez18AZdbVzSM/WN52/kPt9b++f2uzT8s+nee/b+KwRZ701iRhJzn/PObdPmvdWh+5f2nh+DXOOYyWZ3HTPA0mvT+uG/Mflo9bSAljabaIFnL8Umg5pxuXEdRe2zH5rS1+zf+kX/MPy8trznFe6ZUDP03ZYtVmSLc67ZKnRyxNfRJVwik/b7zZMKTtrL+6nLOnj5nfyml7yM6LsV7/xXpLJl/1yecmJoZFR2t93T6tF5e/5LyT+dXNAVyTkf/bdyRB2B4IrlO9Lar5D0QfN9uU1vNTzfMfPHxqOpj/0I38vW/uMqh/QGx37uJQembagImmyc3/zDA6HdpSjbLo9tqZX6w6/1imef4422PrhfjG5lPKvIxr646aJtDaznnO85+33iShVutUOePyqs8G7Gz5gNJcXMIYjG7MukFPpYv8lYklzHI2lVpuvdyhf1/yk+0ZVCqbSuUwOK33A5GKxIwSNpVa4bD+wpv9ySHTo+OpbCqVW8OVtD8KzfW9M2OUZZ++Tmdi2VQqO9I5dNJIy8/1PC+XqOf/FoUnzRljQRDujhm8mvIq8zU2BGG5YF9adkUD7ep1gqB8Oi7gWk5Tl5MSZSJ+3g3K9BGLKGGZAgBGZuiORSN+pdwo4zfymGWXfx3w4QLLR3WNcgAA9p2Ty8Z99ocHVSX2/M7V3y2kZPI1s4UTZf7r6A+WX6ZSqVRqZozvPrMtK78a99VwvVGjSfX9CXiP7TfPGbrUJL+ggEqlZiXcsLtwYPPMOd8M1xsx4oR6srFcxGFU0KhUKjV6z/g3v1nvcJ9KpVJLavgizUvkuGleG+Z9/f0eb1WD0qN99+w76pNW0b3bzTHDyDEfTyKjqVQqNTnY2zskjKGR7I1F8SfXT5q0yfLew1wqlZr9INb86E6zwMyWkQUpt8Jlx8QhXy0kvSOzVQ3KTb9hs/23nZbpTO11cVIuL500bf+1VCqVmp4Q5XvZJbeLaQLaFHI5q5JNpbKT3O589aEpQXh7UNlUKofOVL/pUl79tb0OBHFm5rrktKr6lIvX3xtCGfjmxXNJ9dUZeVvmOxCEzY6rlVxpS/6avPkmZfT2h1QqOyORtmMaZch7NuutCqs1UqUyKf2PWdaDB9gfuFFNpbJTwx6vm2L232FuxhrzfxklbCqV7vjbxbcHkIOmRMZR2VQql8npYCdXuxc5/APzj8d7OkWwk9xujxnlsMqlm1c70i6tHjdhuWsSlUqlRjqSHo8ZmktZCecWTv3f1COhqjcn7fbFTbvIiKK6lo8IPytw/awR73+/PfBRlnoffxRqtkV/7/mk+nbjFlVB+z59b5JVHJVKpSZ4O3tFp3QwSoxekC7yl1dS6XDIz8DAv+1f8NnASq66K6ZkFZVYbmtf5s75m9Udf/RyM9qUPK15/VvtFdOQ5kXJvr6hzf9/09X13po1AQYG/gYG14/Z5HY5OsqhJZz928DAwMDAwDodIMJK9f9/eySkhTvsXrHcwOCXjSevpLa2MNPNoNlxl/AOv/KzPf9UFdh0yCKuiBpm5pdc3fZEMveh7c7fVWU27DUKz6fd9Y/Oq+S1RqugOMj6yDoDLdsuxhaJtL5ROKmWWzaol+881Tobt1uy3Depatpt4tzB7AV+3tVTe35Rldi43SaqbY9VxEu9deWs4/lTBzc1N/iX3YbuTwpW2s2T61cbGBgY/L7nWNyzXzQrrm/wI9vvToEnHPJVJ/yY4Xdb9jELi5hduwINDPwNDK5t3Rp19mxU86LQ29Wt4w+rt15bs76lqptnfejtL3+D8uKju2+0rnFvQnhum+vfrLa3b9Xtc0FVnVxtz4hKaCm87zJd0t0bwynk0juW6k1v5JPCE7UrURd/YuUKdYn9Z2IK2kxehNosZ1ffG15mv65d2fwO/mbhk/SkQeM0J3Whg3bXirs3eISeDt5/Hf1jPWn+A0KvCMxf9M8kl1XZ/eL77XAzgrAcO9N7rWHWcx1BIPQSYP72Nsqko5O6YBzzDDeK+KdSKpuKHzIetvzl1bc/akdItzB/ex25WNiFbo8zIoR6EuYvQgjpBuYvQgjpBuYvQgjpRmf5y2azFQqFQqFgs9kikQgAxGIxi8VSPVhbWyuVSgFAKBRyuVyFQiGXy6urq+VyuVKpbGho4PP5SqVSLpczGAzVgzweTyAQKJVKmUxWU1Pz9JWr6mmpXKF4ultCC4Vw+TIUFgIAFBbC5csgFEJDA9jaQk0NyOXw4AEEBYFYDPX1YGQEXC5IpRAVBXfvglQKHA4YG0N9PYhEcP06PHoECgVUV4O9PTQ2glAIly5BUREAQEEBXLmirvzsWairA7kcUlIgOFhd+cmTwOWCRAIRERAbCzIZcDhgYgJ8PohEcO0apKeDQgFVVXDuHDQ2gkAALi5QUgJKJeTlgacnNDVBQwNYWQGbDXI53L8PN2+CWAw8HhgaqisPC4P4eHXlZmbqyv38IDMTFAqg08HJSV35xYtQVgZKJeTkgJcXNDUBnw+WlsBmg0wGiYlw+zZIJMDjwfHjwOOBRAJ37sC9eyCTAZsN5ubA50NTE/j4QFYWKJVQXg4XLoBAAAIBnD8PFRWgVEJWFvj6qit/yrcMtRCLITAQ0tJAoYCaGrCzU+91ly8DjQYAUFgI7u6tu3RtrfYuffq0epeOjISYGO1dOiCgs106Px+uXlVXbm0N3bnwHXWts/zl8XhMJpPFYjGZTDqdLhAI6HR6TU1NXV1dTU1NTU1NRUVFY2NjZWVldXU1m82urq6uq6uj0+n19fVVVVUMBoPH41VWVtbV1TEYDA6HU11dXVVV1dDQUF5eXltbq1m5UCik0+lMJlNVeW1trWblHA6HwWC0VM7hdDB9XhuXCxcvwpkzsGcPZGTAnj1w5gxcvAhWVmBvD9u2QXw8HD4MFAr4+sLJk+DsDPv3w61bcPIkGBrCnTuwdy9cuACnT4O3N5iYwKFDcO8ebN8OdnZw9ixcuABWVrB7Nzx6BHv3gqUluLqCpSU4OMDWrRAbC4cPg7Ex+PvDiRNw8SIcOAAhIXDqFJw4AWFhsHs3nD8PRkbg6QmmpnDwICQmwo4dYGsLNjbg5ATW1rB7N6Slwb59YGEBly6BuTmcOwdbt8Ldu3DkCJAkXLsGx46BiwscPAg3bsCpU3D8OISHw65d4OQExsZw9SqYmcHff0NyMuzcCTY2YGcH587B2bPw11+Qmgr794O5OVy+DKam4OgI27dDVBQcPQpGRnD9Ohw5Aq6ucPgwBAbC6dNw7BhERsKOHeDkBCYmcOUKmJvDgQOQkgK7doGNDTg4gIMD2NjArl1w/z4cOABmZnDlCpiYAJvd9VuGWggE4OMDFAocOgTx8bBtG9jbg5UVODurd+n09NZd+swZ9S4dF9e6Sxsaqnfpmzfh5Ek4cQLu3IE9e9S7tJcXmJjAwYNtdunz51t36X37tHdp9BJ0lr+qzimDwZDJZGKxOC8vTywWy+VyJpNZW1srl8tFIhGVSpVIJDKZrLKyUtULFggExcXFUqlUKpWWlpY2NjYqlcr6+vqKigqZTCaRSAoLC0UikUKhYLFYqq6xVuV1dXUKhUKzcjqdzuPxlEqlQCAoKSlRdY27EBoKFApwuUCjwejRQKMBlwsUCri4QGMj5OXB7NlQVga1tbB7t7qjeu8erF0LVVVQVQW//ALJyeo+yN69UFcHZWUwYwbk50NDA5w/D2ZmwONBYSGMGwdFRcDhgJERXLoEAgHk5sLcuVBeDjU1sGMH3LoFEgnExcH69cBgQGUlrFgBqanqnu/ff0NdHZSWwvTp6sodHcHSUl35hAnqyk+eBHd3EAggJwcWLICKCmAyYds2CA0FqRTu3oVNm6C6Guh0WLYMHj6Epibw9YVDh4DFgpISmDoVCgqAzwc7O7C2hvp6oFJh0iQoLgY2G44fBw8PEAohMxMWLVJXvmULhIere0+bN6srX7IEMjKgqQm8vODoUWCzoaQEvvsOqFTg88HGBmxsgM+HggL4/nsoKQEWC44cAW9veJq3DLXIzITdu6G2FsrKYNYsyMuDxka4eBFMTNS79Jgx6l3a2LiDXfqvvyAkBMRiSEiAdeuAwVDv0vfvqw/m9u1T73Wd79KnT4Obm3qXRi8Bjv8ihJBuYP4ihJBuYP4ihJBuYP4ihJBuYP4ihJBuYP4ihJBuYP4ihJBuYP4ihJBuYP4ihJBuYP4ihJBuYP4ihJBuYP4ihJBuYP4ihJBuYP4ihJBuYP4ihJBuYP4ihJBuYP4ihJBuYP4ihJBuYP4ihJBuYP4ihJBuYP4ihJBuYP4ihJBuYP4ihJBuYP4ihJBuYP4ihJBuYP4ihJBuYP4ihJBuYP4ihJBuYP4ihJBuYP4ihJBuYP4ihJBuYP4ihJBuYP4ihJBuYP4ihJBuYP4ihJBuYP4ihJBuYP4ihJBuYP4ihJBuYP4ihJBuYP4ihJBuYP72DoLS5MC4dI5QDqBMCzS5k8vXdYsQQs+LKOmIRCLRdcNQK2HFQ8/L9gH3y0RSBQCUJPtYmv4dlocRjFDvRkjbKS0tFYlEnT+t4HrkT2ujswXynmllZ2SidF+jbecS6nXdkJdEwipxNvzjkPs9rkypekQpF2aHWZ02ssqs0W3TEELPpYPxh7Kysifmb5Mw0tLnrX+Z9u9LEmNuP2qUdXe9ijpq5d+zjQf+y/ztt80Hv2FMENfCG2XPEOese0fmTnzv7bffHvLmgH9/ttIsktvdprzSFJKcAOPtmz1KtR4XFHse2r7XOowpUuqkXQih5/eM+QsAAKVRyfNGPFf+CqtSZ/elvDP5mnMiD4DvufFc3z7kR19GpD97VeLG9H1T/7H521B+a9ecGQ732e0X8XOub1yzzfMRAwMYoV5KJ/krjt5jQwyx0bcoEgAANCW7Rv+xOeTAsZzybtT1T85f5rU1I6Zt9KN3vLQ2+O+FSw4HceSYwAj1SjrJX87ZKUbEu3arXaq69fQ2/sn5W+I6YcBXZslPPM9WG37q6/Hrgqq7PQqEENIlzN+eVh7ruMspuEHU9abLsZs+YPCm6KYnl+DH7xw9eoVHp4cNFXHHdm9aesCf+cwtRQi9XE+Xv3Ulhxe4fannoKfnoKfnPHm847APOsxfvu8WFz11MQe9GSEBj+tbSzSyfU5en6jnoKdn994gkuhLeet92+bCN2O7exDddf6m2es1+2HT6cQSQfsiGRdXjhmpKjJ+7SH3W96nFk3V09M7mKxRJuvq75PHqsqMNdjpGBJgtXKGnp7e3oQ2NeWdWzjjCz09PT29iQs3+TxqbRSvKugPPT09Pb1hQ98esOIsRyCVN/GCTy/Q09PT01vtnFzcbsZfjcfaYQOn2JR09uqr3NeMeHNXeCclaNf3j/u4HzFwpscTRjEQQrpCZDWj0Wiqh9rkr1LJuv9wyQTLvv0o227KAORlKY+W6xn37aOVv0p5VvpPY637vWFyKAYAoDIpY9V44z59yLVuXIX2Snuq/6usCzk6/6O3JzkUAQBAY5HHoaX//Wp9UD6zNeyV7HCTlf+b/neGQAIAwC5w3DVdbxWZHmT28fu7YtRleDG2v42avjOxtgEAoL7c89DszxcfvBdgPerzXZHNG6ouyWXRxOnHwkqVAACCzJvk1H4T/r6azGvzzVLmtXXBB8vOsvi55nM/2hdUVZ8ZtGH6B6N3ebIFWl9mVW7LPxn8V2Snr57ptXFkv6nWZZ0UyfOdPeHTAVPNtGdQvJaUSqVEIpFIJAqFQiqVSiQSqVSq60ah11fn/V+luLzs+IpzxEDLP6/WSptztP34g6S63Gj5+bcGXbDNaD1aLr0V8/1wCkFcud6gtYYeyV+FuPjOmTnfb/Gl1Wk8Sg/4a8kHCyiVzTOXWalXl0/7xTGtrCX8KuMvLF2w6sqjipZHuI8DN8xaYRld0HJQUP3Ae+2SJY5xtOZOq1JcGn9o7Yrdbkm81o8zO9Z+++jpu+KLORoJzIu2WD186d+XDv4RqHr11Q8t9q7cc/lBo3YHOJMc9cELyF+koa0wlHAAACAASURBVLS0dPz48ePHj3d2dtbX1x8/fvzixYt13Sj0+uo0fxWSrJDYae8ZDZlyO7a0qSVE2uWvLDc44adPyH/Pis7VGG+AkrzV39v2JcjFV7QCuCfyV1qbbrlx1vy/Pav4bfqVvJRz0z//Zm8UR/XPyjinRT+v8Xhc2TL1mJcRsG7aqjPxhS15yEz1+GXBcqfE1iECfl7Ytp+XG93MbB7LaMoNtVy09I+QTJbmuorDzWd/OcowvFDWGsC8aIvVwz/5yvRel1evMS6v/GTwhuvCzsowvTaO7LfgYl1nZVAH1q9fn5GRoetWoNddp/nbJAiz9HmbIL/ckEStbU0x7fyVNoRaXh9OkO9P8jt0LObUqVj1399B3396ph9BvrmnsO0aeiJ/2ZnBm3/4fu/V+/VaF3U0Jv499rNhR+6p/iWqTrPctOqX0z6VEjkAgLAuzvXAopVHbhVwWp4nrs1y2LFu1VG3IoEYAEDES/U6rr9ij39GjbqzK+cmuv01We+7DbuOnNKwe93sz98lljs8lLS2gRdtsXr44lPFjeKuXlnDje2fDfzidHZnZYrOzfvys2NJXVWFtGH+oldBp/kraAg66U50mb9C3vXTPh8Q5LD5oVd8cq9fz9P6C36sg/4v44HP2gmTDQPTG7WfkWkyQa/flpvN/5QU+h8eNXLszwbLV61atWrp8nWbD15NKmk7GiAtDiG/Gztm5pJlq1atWrVs+doNe1zjqPUtESpm3bXfNH78IqNzXtfbuV/EVWj1fzec5Qi6Hnasu7bxjUH6wawnlygLXPTV9/tjesvUj1cI5i96FXSav2JhjH3Ah13mr0IQbR8ygiAHLk+sbXiaS4h7In/r88K2z57yp3MCVyvoWFFbR38y3lT92ePn3t5Nmt+ITctTo5Yx2KK2ZwwbC2OOmFC8I1KayxSU0llNmi9UzLprv2nqgr13C9ulvbZnyF8Q3vnljf/760b1k5YXeP/5xfTdD16Fu3D0Npi/6FWgnb9MJrO+vuVWNpKMoOjJhBExOyK9onVGWrvxX8nj6zE/fEASo2+mcNqeRXqY9Pl/zfdon0PqkfNvDQUuO+euMQxkakViptsEvVlWuep2ch/6rPx+aJ8+ffp8Z/6kGQL12SG/zfiwT58+fb49XfyEVlDv2s+busAhplDrLFqWu3tYeblGQD5L/gJkW077YqJpZscLiy6tm7nNKVPWbn4J6hLmL3oVtOavUqlks9lsdptbDQjL6UZrzg3qd/Z3pzKeHECpbKqutN/q/h5BEsRl+zRmrer0EKPi9EbXwQOMx+zJotVKAAAUMm51yakfL3y64F6F9kp7aP5Z2V0b/W/mmoW1nCWTNbILrhxYNvGAh6Q5tKQCDv1xwL6FM0aNbKH30TsjN1mHtsyRkAp5Vdk3jq6YM7a1zBcfvzdiLRlQ3HK+sS7H/q+f5+45l1qmznuFRFibdo3iEVbM1sxkdjhl1We/Pm3+SkXR+8ZNOuJfrF1aISmPOr/it5PRZZzOJ06LH1364ev3iTFHsnGelQbMX/QqaM1fDodTV9f+RLqUFpuxe4Hj24NdjvrlBgVkme/zGfWh9btDyA/HXl1mcM2j+fRQfXbe0V1eXw6kvLU0JigoP8jr/pYlV3786YZPbuuMtEZGbXxEflBQ2m9fGRFvWU3bkRQUlB8UVJTDlDzz1Rfiusz4yOCgoGs+1otHvD/119OeQUFBQVF5dZpXjjQ89KZsnrPlZJDKZesj29dtsX/AqFevTlyfeNlo5dYT8XSuRgPq7rkcnfGfMcdj2AAAksaHfmfW/HEwjFan0Y3lpHoZzf1w7MGbrdeeNVCjTXbN/3GDSWBgUFBQkM/V84dPWYRkVKpyTyKsSA4KCgpy3jtnwjuTf/PwDQgKvhWXWdXFaTiFrOiG9bo/LKIquBrTOBSN9MRzB3bbBGTyu0pV+m3DiZ8NIv5v6Q28WaUGzF/0KlDnb01NDYv1xBM9jYXFDmfiDA1jDA1jDE1S3LweO9vFeCfVS7WPfHnh5gnqYoYxhtaZj+hNmkVYecUXrWNaC6j/ksMLhM+cv4KS2y62pw212EWVtJvXVXa3ZbGTf3Sl5rnA2myrLRv+PHeXpXXpg/CB4bQfj4SxAAC4RS57Nm4wu83QSrqmDPMFcw8GtB20aKAG2FqoV2Z9MTKvdZMKeRlXtRp7ytj5Vk4HV+O1JROwwlxPHrS9UsRV96MljcxQ171Wl29Xak+s7khN5iUHC8MLsZynKPv6wPxFrwICABgMBo/H03VLdEFUc8dm5+wZq13uV7ZO0RWW37HZ8c3cQ/crhQAAEnbsxb/nTF9+LqZY1NIBbqqKvrB/8tx90dSemHvQxCoNu3zUxCOcJZABKGMvbjF2u1HE6nIGG3oizF/0KiAYDEZDw9P0o/6RFEJOFTXI8udZP0yYMFHtm+mbjjtH5dXI1LekUDTVMwtv2i6dP+Ob1jI//HrAPjS7WtxTJ7/EPEZ5dZ1ErgQADj2XUY+juc8F8xe9CgiN2Q6vK6VcIhaLWomlsnZ3A1LKJZI2ZSTty6DeA/MXvQrw94/Ra0T184alpaV//vlnVFRUaWkpnY73hUM6g/mLXiN0On3x4sWLFy+Oi4vbs2fP4sWLt2zZoutGodcX5i9CCOkG5i9CCOlGZ/lbXV0tl8sVCgWTyRQIBADQ1NTEYDDkcrlcLq+srBSLxQDQ0NBQW1urUCjkcnlZWZlMJlMqlVwul8PhKJVKmUxWUlIik8kUCkVdXR2fz1cqlVKptKKiQlV5dXW1UChsqVxVD51Ol0gkSqWypXKZTFZaWtq+ctWDmpVLJBI6na5VuVAorK6ubqlcKpUqlUo+n19XV6dVOYfD4XK5WpXX1tY2NDRoVc5gMJqamrQqr6ioaF+5agtoVV5WVqaqR1U5AIjF4srKStXmbalcIBAwmUytyuvr61ksllblbDabx+NpVV5TU9PY2KhVeVVVlUyGvxqHkI51lr+NjY2VlZVMJrO2trasrKyhoaG0tLSurq66urqqqorFYhUXF9fX15eXl6vKVFRUcLnckpISDodTWVlZVVXFZrNLS0t5PF55ebnqiXQ6ncfjFRUVsdnsTipns9mqyisqKtpXXlVVpSpTUlKiWXlFRUV9fX1xcbFm5aWlpY2NjaWlpbW1tUwms7KyUrPy6urqurq68vJyHo9XWlrKZrNVlXM4nJKSEi6XW1FRoXqiZuVVVVWqJ5aWljY0NJSVlWlWXlRUxOPx6HR6h5VXVla2r7y8vFxVOYvFal95TU2NqnIOh6NZOYvFKisrq6+vV1XOYDAqKyu5XG5xcbGqctUTy8vL+Xx+SUkJi8ViMBgMBkP1xdBjOxlCqEOd5a+qp6nqfMlkMiqVKpVKVT1NNput6sbSaDRVD5HBYPD5fAAQiUSqzpdcLi8vL1d1PxsaGlSdL5lMVlxcrOrEcbncmpoaVeUFBQWqymtra1V9W6lUWlRU1Hnlqh5iQ0NDVVWVqp6ioiJV5RwOR9VxlkqlnVdeVVWl6n42NTWVl5erKm+5CRyfz1f1yjupXFVPTU2Nqm8rlUqLi4tlMpnqKEFVuVAoVHX5WypX9ZFbKqfRaKrK2Wy2Kh+lUimVSlVVzmQyVX1biUSiWbmqb6tZeWlpqVgsVvWRVb1ymUxWWFioqpzFYtXV1SmVOHcOId3D8V+EENINzF+EENINzF+EENINzF+EENINzF+EENINzN+XQ6mQiIRimRIAZE18vgh/og0hpA3z96VgF8S5XbAMzqoHgGzPLevNvPJrRF0+CyH0WsH8ffH4Obcox/Z7Zbbe2DPPd+N2Q8fc9r/uhBB6jWH+vmjch5RZKw1D89r+sBAv1nrN3pMhxV3+3BBC6LWB+ftice4aL5i2LaL9rxIJKx9abPv1ZEC2UAetQgi9inpt/rLvuwWl84U9cl6roeB2ZAKtsqnLgrUxlpM+X+vLk7RfpFQI0oNPbl1nmFr9ElqIEOqFemv+KnJ89lyMYgl64iZeyop4W3ef1PKueq4K6oVfZvx8LEzxhJsrsHIjtq/8iRKc1XWQI4ReA70yf+VNvBiH9Qanr/ZA/iqkwseBxr8fNOwyf8XZfsunzD8ZXfbEe9twqc57Vq8y9K9oxHuPIYR6W/6KSpM8PDwumu794at/fzR763nXKx4eHh4eAdHJxY3aZZvoj+/d8FC71+GZLxE3935YcxEPv4js/Ow0Zss8sepHHh4ebvamK78b+p9v9Y1sL3l4eHh4eAWHZnf0o/PSnIBjU0Yv9SxgPvneYtwE591zfjmZTm/XWITQ66eX5a8w77a5ubm5+dG1U7/+4vtVJ0lTc3Nzc3MHv9BsnkYxmYCVeM3qxJHTJqS5ubm5ufnva5YcvOidytIoIxVw7l4+fuQkaaQqYv7H98NmLl+79nZZc4myGHNzc3PzU9uWTxs5atauI8bm5ubm5mcuXrlf20HTGu5f2j1+4e7kCl4HC9UE6X7Hp8zbHJpfi/d/RAj1svxtVuG3Z+ncHU8Yf1DIi26Y6i/f6ZFS0by8JtJx7+zxay+mMlpK1T302mlw8E4pu7mKuiRPi/Xzfrxwv75tddx7LnuWGnQ5/lAXYfH7V4uO5zAanlxGkO53fMrU1f5ZDLweDiH0D8xfuaSQ1B+zyj5J86JffuWjgz99udEkrKXryogxXTX7WLLGUIJCwk694+gdp3WZxFPmLz/Reee4VZi/CKGn9Q/MX2lTyMaPvz51u1KmgUfPPj6HmLD25IPmHnA9I3bb6H7frDyYUC6TyWRPmrTw1PnbeN9t9/ipm+6UsJ5cRvDI9/iUVfuSijsaQEYIvWb+gfkrybEa/8bAoZ9/Pbad1YcdczR6txxawulfx479evi7g94wsLmfk5fPqJe2q+8p8xcqIi1njZjrkFH5xCSXVd82/2PpprN5NeKnfqUIoX+sf2b+Tv14lFEY82krq89yOfLXujVr5k0evvR0QGGtVjg+bf4CM37P3Dl/Xnn8pK60mP6A3LRkm+NdVgfXZyCEXjv/kPzl0+m0YvUUM2n1jdWj/rfNNUPrMofG6moaldoyOkuNulbQdqi2LNJu7bK5R3xz296pTDt/RTwe7fHjjkYQOPFmG76df4bacQDLypLdtq5Y65VWi7/8jhCCXpu/rDDK2vG/2TH5qp6k4HFSdERklqrjqpRxgg//NPGX46k1Gs8QcdNDPb1iqS2hHElZuje4RLNSZRPnlvXWTbZxbSdANKb7n/x5+Z5YqipyFYyyJL8r8R3O4BUxbm3+cvKWW1XtF8mb2MFn/9hi6FuBN4BACAFAr81fOT3M7Ltv5jk84gBAQyU18JJNKqPlqF7JpyUYrhk3ZcuZtOa0S3TasoESWKJxv4iY098NGTnfyPdRS5JyHzn+OnvJpQeCtpMTFKxH/r/OnnXYL0MgB7lEFGZ34E7Rk27m21Trv2/IRycetVtQl3p+04LdIUUCnPmAEFLppfkLoFSk2Mz5z5D+/fv3/2j0NI8srWN+paI+13nn3Pf79VcZYxQvb1ukxGfX5OWHtugP79/s3Y+WBVTIle0HD5TKXL99337ar3///oPfesc86clzJQBAqSiwmf7Frx5tb7NTbL3oc4cHnT4RIfSa6bX5+2oLPj39hH8Gr0kOAE2cCr8DI/8KqNR1oxBCrxbM35dCxKu65X46PL8BAAquHzweUq7rFiGEXjmYvwghpBuYvwghpBuYvwghpBuYvwghpBuYvwghpBuYvwghpBuYvwghpBuYvwghpBuYvwghpBuYvwghpBuYvwghpBuYvwghpBuERII/hoMQQjpAVFdXy2T4gzgIIdTTiKamprKyMl0343UkF/GTA60DMniqf2akBvzs4bEk8LZPJf5CEWpDoZAHR3v87OGxLiots4Of6Fa7e26dSzK7JxuGnhMBADKZLD8/X9ctee1kXlz3t39+o1gBAABVJ+0tCZLsY2wxMygp60k/b4ReS1IZdZ2JEUGS/Uzsdz0s5z3hN6w4JQ9sj624ksrp2dah7lOff1MqlUVFRQqFQret0QWlTCTl14tFPfm7bAppju3Cz9ZcYWg8Vv7Q999mJgRpNuVaXHrTE5/aWodc1igW8UQi4Svwi3JKpVwgEmXnJ813cLEsrRP34JqlUkm9SMRrEtxPDx5uZL8lqbC259beQ5QK+Z2Ii/8yoRBGZ/94UMp94jsuLbt/+fTBw/Gl0tfwk9wbtc5/EIvFVVVVUukTj27+mWT8Gye8P/6XzaEYQU+tUspOsZ07yqj9b3Qy030Iytml4dnVHTxLizw7K3rqWZIgyaWPOvwt5h7VKCz8++KFTyxNCCPXns3fptjEW3Pc3aZcuvSVtSlBOvwj8xcAFE3cK6EuhJmbRSGzs2/nJsadM4d2nPIu5L1mH+Teqc38M6FQWFNT83rNiBDWuWx3/88b5r94PN/AmVRUQeex6rvuizYxEk8smb0juEh7AZ9+ysf2HQdv2/L6p1ifKPHBnXHmJEGSI6I7+Ln7l0P4uCDXPb+6ocNlvKrTvjY9nr9qCpkk4LbDPzd/lUz649Wudl/6xSTxuhicEpZFHdiwyT6qSIZ94Fee9vxfgUDAZDJfpxkRsrJUqqtDemrN8x3Gs6t9AjITC7tMHs69s39OX2yW1djmS66+Os8oyGWgvZ9tNp31dCvksen+j5Ktk5Mj2T31q8ri0v0XbPudjyvraCHm78vDLEra6Ok86mp4UCXnKQ7T6qNNVs3ZerG8R8fUUHd0cP1FWVmZSIQngJ4NJ4dKMY++22X+1iQfNVi02TlZKGsTmqKGmuhiWgSd+ypvd25Z0jQ7iz6Yvz2ugV1+p6j0IavxKccUGhJtJn5jcKnwKU4jIJ3qffnLK+XEheR2echdm0ndeyI8PPcpugvU7OW7knM7Oo0lbqj1OZla2FUFEg7v0m7nkfqhXeZvZZzjkjEzLRNoL2KIh+sfFjDBLviuvIPjTLGo0SnQdVt8PqP9sm6urXiv7/k3KMYE5u+LJuLX2N9yG37pZhCT/2K6rJKHpyaPnmuX80IqQy9Pr8rf0pRpg0z697VetP0RLStj/mS7QYNMBw0yHzMtJl2iUKg7lCU7BpkMGmQ64A1K38lBgekNcqk8z9Zl0ECTN/rZrj6RU9Xc72SVpi9Vlexv3Gfs7fRGrSEX+rFhVgP6m46eHvdYyvE74Kc3yHTQINO3hrh6FMsVLZ3Xe1GDBpmqV9eXMmCgqeqfeuOiMzp4AYJ0v+NTpq25ls14no/ZJT+TQaamA00ofUmSMPK+pZ2/FX+fsRhAMSbIs0tCk13iAr60NBlkajqQYjzEzsWcWi9/xuGKClrkOBN1DX1IkjCmDDQ1HWRqOsjUdG7E45LmPlZz/rqYFqftsrZ8w8R0kKnJGxTjz7wi77HEbdapVErlHFcfu34mpoNMTQeamPSzvmJNZTYquj+Q0mX+KhRyETPuG5J8w8R0kKnpAIpxH68knljadmso5XJZbKRjX/VrNOlnTH7r6EgYG/dRzUtRz8xWSiUiv1sOrcVI8rvz5wlj4z6kxbw7aS3fwkqFJK/o/iIb4wGmpoNMTQcYkx953i+Vy5tXynO5aqV6K/uRJGHje4XOFlBvE8YmAyjGBGm5OCKjpJtfZTW+f34z6I/rPTUyhbqpV+UvgKRRYLvC+quxl+dsC72d1yAHUEilEWYek+cE+KeLNRJU/Oha1ORpgV6Rhe57vX735kq53Itbz32+MPSudtdTGGnm/9nU9vkLAJBm4vzx517rtgaZ+tBVl0ncPW0/apRfUKlWfoof+kcuW9Bl/7fhgefhyQZ7k4q53XnxbZVR7812MO4ofwEA7kU5ESRJUMw+tHe3KGSJlcChhn9sQb7n7H+1vKF7J2Yy04K+OEN20f8lScLcZqyzfwAPQFzvH+P9jik53P9+WVPz5lXKWGUP5lyw/eDcBbMyAABWbfFhr7NvmZA/RxZxuxsYneevVMT3CnEgSNMxHtcCawFAlPQgfLqdaR8jB5MifuvlLhKG4UWzfhSrBSEZJQAgpFv4uwwyNn7j3IU55y+uDL33gA8AAGL6HgejAab2v0bnVQJAY8lR93MESQ45d2H2hYvr7z7KVx10yRojoq8MNrdeGvEguxEAICXO7TNL8r9OV1zKmjT2QkUVI3utnRFh5b7qis2njhdmxhY/uO8zkCQHuN6KrOnexTg1vn9+M2iqeWm3nox6DMFtxuerdq5XOn/lwiavXU6jFkfElrfuwMKqanK508qT2RWtrZYVRCbNneG2Y0/UrQIBAICoKS0g/oRjXrvo6zx/L/z7S2+bJF7LI+LGnI3DzlMitKYAPGX+chMu7B4378XkL6f84RJny07z1/QT12DvKp5qS0nEAisPI+KMq2FWVfc+00+Xv2fGhz/mNE8/pZc+Wu5EEvY34hvU700Tr5z0d3zTzMWugt/y3JqSlPlOZoSRszOvm+fsO81fcVryjWEWlP9cuHNPYziqMCPgIwr5ro1/YPNULSEt4m0zyjvW/mEtG6j6/khL08EWzu51rU9szAsmSOPPnW/Ft4yvVsb+hyT/6+B5XePSB0bu9c+MzSb7J2Rr7BThd2wI0nLOrdQCjQBm15X+5WpEkOS/HdzsSppAqaikZxwICtqXlEPraLd8Cpi/vQNR04zDUe87r3z+Xlq8M6Nc89FG3rWTniOXRCaWtOzUsoLIpLmjHfa6V9R3MdTaef5eHP1jvOYo2vPlryDd7/iUeX+E5tc+/4HhU+Tv2WVhmRXNj/RQ/rYd/22Xv7I8auLPVuR/3KMzGjTemPqiXR7n3iDJ8XE13WpaZ/kr5BXudXcYZHRma37b1y0q3WVL6W9uvTaxQrWATw1725TyjnVAVMvuX5P6jaXpYAsnV4128bIDCdJ4uPOdpJbXyUj4mCSHOlz1b528wrW9QPa3sNl0v1LzLFhVXsj7JDn0cvCN6taPWHP+2vyaWsx/1uGhjtX4/vnNoGWuvK5LIl3qZeMPHeevXBh34ebI74PvZLdciSAriEyau/Ca94P6rjpUPZm/8sI7Fj+Pm3c+tez55/f1yvyVC+6m3PgfSQ6xdV7g67/i2jX1n8+VkdYW/UiSuJ7XraZ1lr/l1ISZ9hTC6JxtndaTpIH+JoSxxdSAB+p+orDOxMvsDRObtVH5lQAAvJt3vIZQjN/xTqnUnHkgqDlymRxs4bQjqagGAIDtG+BKkMYjbqQzW97XxuxFJNnPxOyrS96tL/PatUXu54aQJOHk51ramo3q/LX0vEjnvKCrJgod5o4abZj4YipDL80/In+hKely6Dft89cgMDC9w2sFNPVk/oK08M7vPy/8OzBH9Nxz43tl/soawhOvfUySw31jYiprClisfBYrn8UqaPlvQzfPN3WSv7S8mB9syY7yFyKCTQjSfLJ3UkHzI4KcAII0HmRm/T8np6+dHIaamYy9lVXYqH0MVZvuRZDGb1qc1XNy+trJ/j8mlIkRtBKBRnhyH/1AkgMtbf5MKctvfpmtf1w+T9p6CkGdvza+HlW8FzPxvtB/zqgZJxJfwDAXeqn+Efkr4t8295+6NDK5tO34w6uXvwBlXlsX/LzHj//cc+NfhfxVArQcLT/d+IMoJSt8AkkS7nepDdqhplnbs+okf9llD+aft+gof7kOLhTC5MxPoTnqYYPy2H+bmQz1SKnsvCXFYYSxydjADGZnxUp3GJOEhY3B/cr2y7Se9cLzN+vq5hE/788QvE4XsvZOvTJ/F2x7VKIRX9KaatvNl2bvTaO2nv3o6fxND4zWX3g7skC93RpquDcvPCzraH3s+06zvlzpXPy8N6nSef5K6/I3XXFcl1rVpAB46vHfkpLUpfYmhI2PZzVfo245tyjha3u7o8Uv4fxbU5V1gOvbFHJ8WLnmCxcKcn41Mf6X1XljWvNhE+PBdxdsBpEkQVrNCrp3t64ur64ur64un8Wq1vy+rLg30sFqIEkSpM3yiLR7zcUK2Jw6cUv7+Z6eloSJ5fSbjzRvhiMXc31CL38XGJumsQe92PyVN+U6/rbkgGu6GC9/e+X1xvx1GjE90D2Ro+o/yaW8YPOQWd9cu3iPrdH5lObcjp8x/3nzN+6oQ/v8Xfex09EQrSM7eUVy+sql3g4RdRIFAEBeYsqVkCclbEXIzoXjNgY852UC3cxf84uHMyq63CgdKs8JG2ltQtgGxAhAJhHGpN7+4aKfd/MlA53lr1VAKL95jxKyrkT7DrWgfO5zN7CqAQBAIS5j5ux1u/itf0pld6cAdz7/jFv5eK3rGcLI3aqIXi0FAKjnVNldt+9vbDHnxuPi5mLsutLgBzdGWTkvDghY1fw3w8Gkn4nZoqgcavMeUsek+SZdH2vrskSj2A+25EBLm18TqGUtF/JUpf54zvwt2wtb7xeVC6UAAGJ28MM7M2wuk7ma08qUtTWFWy68oPyVCfKD7TfsMIsr5+Hk31dfb8zfC19867n7RDRJJlAoCadPB86ZffvqDUZzInJvUxIolJjtv1z+8GPntTujKJQEintF+1vaCLnVvpQECuXub3Oc3hnmuvNUHIWS6Opd0XwGuz7aJmn1eOOhn3kcdc/PY8oAgJeRbXQy4Os3z4xffvdWMlvz0joJi+NpGKC/Pvi4UQKFkuDsllXQScjREw8brPnLr+svhw49ykmgJCQcv+k34qwpQZ5bHxdPSbjnnFlUoT7crI9IStzibkWQ5iPdrpnmlteIFdBU6RITPd+BJMgzk32C3cq53RmAbqi6EO7Z39h4RnDCqYibizwu70wpqhErAEAsYXpF3P7J0YIgbeaGhF0srQelora20CzE72srkiDtV0TeDW++wZGQW3kl9c6PZ8z7OgdREhIoMWEGV68aBEaH1gmfPTIk+YUZVvcSjONi17ieIcgz33rdOJqQQElICGt7P6XyotRTAeffsnRaH5VASUjY5ev87gXP43dTW2/1KWE75tg8IAAAIABJREFUXz8/0Nhpx2O6Zs+8hJq4wokcaON8NJcDACCuPeNh1d/E5WhuteZ956i5MQvPkf9y9LAtat3XimnJWwMuf2R1fuXNSEpCAiXca4S9t2k6tUz9TokePU6iJMQfuu0/2oIkLBxX3I40TkiwTCrsYMziqSi4xXftD+29eKewm/PWUM8iytvJy8t7tfP30uKdDx8U0G8H5vj65vj650XlaSZh4wPfHF+tv6ja9pchixs5cdolc8Nj65o/e8KMG3mqx29E0Su4cgAQFJc1lyxMzeNrbaOGqtq7t9RVZXfVuW2kxR35bfb5bt0qu6g8xzdH6y83tJRRp/7ICdLzclsW3Sqv5UoVIGZFapSPr22UdO9AX1BzLVddSXBJZVXzUblUxk3QqD+CKQClgseruqXx4KM23zbC7MKC1vYXlFIbxd1qkYxeVRyY236D5DzktyvLp7cpU8ZqM9erLnPBees+Rm6+7W7n6X/NiLBy2pbOBABgpn5jbT7Q1DOk7S6lVCrOexsRdu5knuYNlBRcfo3mlg8pY2tMR5PQSvLatzwgr+op78GkRcyvvm77+1nfeyz8BZVegmjqiFL5ih67SBoEtits2s1/6JXqCuJtDdd6pOGvFbwapMLAsIuDKaZfXvL0ZrY82nD9pvvnlhQ9l/C4JikAgFRw9cbZPsZm472CQlpP6NV7XHP+xMJ8ok/8A5HOep53TGad8L7PEmDXt9foVb8/X5oydQClX1+yb1/KGzPvxBT09m95pUIulT/HTQ/Qi6VUKCS1iRONjPpRTAaYqP/6G5PzkmqlitYuiUIh51fGjCXJ/m2KUX5NY2kW63m4O/U6vSp/EULoHwTzFyGEdAPzFyGEdAPzFyGEdAPzFyGEdAPzFyGEdAPzFyGEdAPzFyGEdAPzFyGEdAPzFyGEdAPzFyGEdAPzFyGEdAPzFyGEdAPzFyGEdAPzFyGEdAPzFyGEdAPzFyGEdAPzFyGEdAPzFyGEdAPzFyGEdAPzFyGEdAPzFyGEdAPzFyGEdAPzFyGEdAPzFyGEdAPzFyGEdAPzFyGEdAPzFyGEdAPzFyGEdAPzFyGEdAPzFyGEdAPzFyGEdAPzFyGEdAPzFyGEdAPzFyGEdAPzFyGEdAPzFyGEdAPzFyGEdAPzFyGEdAPzFyGEdAPzFyGEdAPzFyGEdAPzFyGEdAPzFyGEdAPzFyGEdAPzFyGEdAPzFyGEdAPzFyGEdAPzt3fgpnmecAmu5ElBqQw4MdU8qkbXLUIIPS8ip52srCyRSNT50+RiSX2DVKbsmUb+YyhlEonkGTebUiFnPb5pZueQVCpQPSJgFpw7tvRifJVM8TIaiRDqIR30f8vKyp6YvwoFl16blET3POnz2Yxbjxpl3V6xXCItz6UnJbX8sfndrqs3kIlr85LuupNWLoGJ3Gd4npJfnGzy1w6rsLym1gel9DQvyuFjoVk8KUYwQr3WM+avRJJ9O3ntwkufvEMSY253O3+VSt4dq7iF31tPnBewdWvQT19a9CFcja5VsrpXXW8gYCefWblg5NCxe12fIX8VMtYdiz/2k1F1WgvEtTHnDP84djmX08WRCkLolfWM+QsAAKVRyfNGPFf+1sTe+nKA+derYu6WNAHwPTee69uH/OjLiPTuVddL1NPi9s+d+Uz5WxV1esn0DUFlgvaLRNXxx9b+YnmnWIGjQAj1TjrJ3wZPAzPiHdsVDuVSAAAZI6s8PLwoNoH1zx6CEJSlHF+29FnyN9t09NBlJikNHS8Vxlsun7zOthyHgRHqnXSSv5yzU4yId+1Wu1R16+m91TPnbwrl/wZOdaM9cSNLHjiO/XK+U2H3R+ERQjr0dPmrVEhEMqFQqvrLv504p+P8VcrE0pZiwiaZTPPYWKmUSWRNQqlQWGvxnRHxf3YrHCuaC8vk3Wu+XCps0SSWSMSyDo7GFRKNIvL2BZRyiaiptR5Rm0qUCqlIKBQKhfes5/xnm4f6IYmqvFimVD6pqiaRdmNa81cpF7eUkkifMICgjD02fMCbe5I7e/2ZJhP+N+VMbiclFNmeP47+gJhoRMNhCoReMURr7DRnrlb+ygTConspS/53ZugXLpMmuYwd6fTFx2fefbdd/jYJqXlFx6db/Pcr10mTXMeNtH/nf5dPXSmgsZujVcAJNL81e5LrpEkXhr1JEv1N/u8zp0mTXCdNcp00KTxR/szxIKgpfOx1bOwklXF64/VXz59lklCpWUbKq8rO9N07RlXmmx9WbL8UmFErlDQvVwg5lfkxl7YtnDP5W1WZiaPmrjX1SeIIJUoAABn9sefWSZMmTRo97O1/9f3VQ6kQlqbesdyzZPzIT4cMnm6eUta6oRpZtATHFd9NUdUzZb6BiW86WyBtbXBZyvFlS3eeDUiKdlk/fdqkSZMmjpu8cJ1hGJUr6WAIgXF55SeDFroyO9sGTK+NI/ttCJA8uUTxjUPjh71BvDnH5/U62ECoFyAqmjGZ6k96m/wVCVM8Iyd8bvbpZB+XR3IARV1RKWWNy0dvt81fiTDPP3rcMJtvFlz3zgUA4BSWUdY7vfcvcuq2vGrtlb6I8QcR03//qoUn/Gub60zzs1o56r/LnbJay/DpIRbbZy8/HK5+ZfWZIWeXDZ+11SO5uWdan3xp34S3x54ILZCo819SHuO0eOZy+7hiSZtvhJJLq78bstGjPNHN2vh4SHZ9w0P3+eOHzjS/r17exE66cnj+okUHvDKVSgAQU6Pt5k6cZXkzV9TyBVSWcnzZjz+v/n3zDqdUgRgAJBzqhb8WG+y9VMhtP4ZQZP/TR4P/iux0KzC9No7sN9W6rJMilcmmx3dvPB1S20kZhJAudD7+oGDn5G2bbk28d8EknNPSQ20//svLz9856+zAoR6+ReKWetj3kmd8bU4Q5xxoWmt4EflbF7t32m8XcjkaDwkLgw0326Y0/1NcHm49c9GWa5mac7e44af0P5lwIEeiCkVhaWqoi7l3GoPX2gEtj9m5ePFf3hnCNmMidUH7p78zYYnded881VlCTuF1j/MhmaqxXBkrM3Dzwhm7L9/jqfuicnqq5y9ff7XDOZ7dHK2CspTjy6YsOuFT0XrcwI5z2rVkxemHFcJ2r7Dw7A8vIn8RQq+qTvNXJkr1DB092OjDRXcfVbUGa7v8FT/wiJw8hBy2+n5Fg0ZoVRX+Oc3+DYL82pTRdg0vIn/FxS4bZ02atdAtU+NBUXV+WX3zP2rDzTb9tPFsMavNWHam2696//noZEoHh+zxtgYGBgYG834Y/t9vOs7fr9dEdtiNlPKS3ff8+PMfwZms5hxXCNilKZGxufT/b+/M45o48z8+veyx3bau222391pbW8u2ttVqbWu1eGMr1CNtPait2mrtpfZnrW4Z7lNuIig3eCNRERFRBFQw3OFMSCCE3OS+j0kyvz8SIEA4tQb0+359/tCZJ995MknemTzzzCDtHoBwdP5tEP9yk1Y+99BnyYPOieZnrH/tPsKR/g8GAGDsM6h/1arTXqkPIOgr665RhT0/kPv6VyfP9j76DIJOeCJsyisxU6d2ZUr4xId970HQv/1I672FWzL/waQUsjI2/2vic1OnTp265Js/rrF7r1fTErcvefbxf02e8upUO156+rEH7kO+PdPzdUIj/bF0ztSpU6dO35FGpVKphalffrzQsX/XJhpxR6i4J/ctnvHln2TOYFPBRuhf7OKulx6c+Ct5sJ1QH/je5Hf8awdrAgDAWGVw/yqz9yUjQ/pXI8v68/DTCDptW41EM5y5qLd0/plZ33Dy11fvu+++e+99fVMCu+v3P65sTti28P2vY5iSQc5OqcozfnvvqXs9Im5ou5/fIOMPG9Mcl1Fyjv++4N21aEW/oW57RuhfHC/aO+GhjzNYAxa01Bx8a/InYY2OvxQAABjj9PUvhmEdHR16vR7HcdyoLYnPnox4vUAoaRL0fMj7jT9oiuPP/fd+FFlU2KHofR5Jq6E2d/JUfTZyC/yrl4skKq39zC1p5ZF18ye/uSPHpls1I3WH26wvQ6iivnOZNZ2dSosFx3ElvXjn0hdcvg5vFvYcDo/GvwZxYew3sxf8kN8s773CpJLKtUbbPhmxf/Hy3c89sTqSMtDF4KWRq/7r7seA6y8AYHzSy79Go5HP52s03S7AWi6XLv23L+JyglSrsrkOM1RkXHzvGRR5/lSxzbYY83KZ2+sByHOpcWT7S9j0LSm5/37xQDQF780t8C+DtH9P+gWZrpd6pPl/vrjIn277n5ZK8p4zx414o/fos6wtPTihCjPhOC6sy/l21sQVXlls++t7u/0rZ9Qwur86BvUvrqXmRyya4x55gaq365FB0nAiLbuOK7fuupH7F2/P/mbWtC25fAcGNohLvb9wR7NoQ8zck7cXXjh7vKDRwSXMAAA4lR7/YhgmEAhUql4HqwaJKGlX2r8fCZzzRVmT0YKbMfaN6m8/jPobgiJI1JrfLxe04TiO4zLJcb8Tz/7D95n5Z4IvSHAcx/Uq8pmrHlNiF/zeaD9HAcfxW+LfzsL9c9w+3xl9qcdlGtbFAM/5O3N6NiduTvy/Tz/84pekMtsyLafmaGxAYF6T9SoMNfuGL+HVN97/+TxdasZxHMdErVeTfvWc+eqsHzKrNeUBvx7vLt+esnb2YxsG8i9uEDcn/Pr54s93nGmW2mzLbz4avy8hr1rWdWwtoxX+vOCj/v79cPGuawzHl16bDA1xhCUbg0v6XjJnkFw/5L1hR1y1cIhzb8JLATMnP4o8s+7iSO66BgDAbcDmX4vFwmaz7Y58uzFLmLwTXkef+0fEh6tOEFYfc52XOPPdA1OeQWesL04/3FDbNR9AL+gsyC1Z/rj/hFdTCISThM8z3n4v7Ue/6lq7gWNeed2+7ScJhMPTJ6HIBP/nZ6QTCCcJhNzMKtVIr77QVyXPW7Ju+1aCG6EL9zVb90Zeoff6/tBx684l/vj+9GXWJh6bfwlMv8xRdhkRU7dTTv06z/XjBW6rCQQCYe3W7WFpx5L3rV30wfxFKzf+74IA4zef9SIQCISlbz898f4XZxEIBMKGbWGnavsdTmLi1qr8iB0LPyesIRAIBMLaTVv9MvPbxbbbRqpEReiSuZMnPf7KjE9+SrmuNZrNelVJ0vb570x5/J9T5i31uSpzZFKLWVh5ZsfWn4lFdLtjYIxfezJg128nbwj0Q409yK9Fzn7lCeTl76/3HQUCAMDJ2PxLo9FsY76OwJQqWpOQQhFQKAJKg7iVKaVTBUxR/wtnjbzGrmYUAaVZJtH0+nGsV6jozYKeBraIeIqRX36sk7WyhDJhK6WHZnaf7VkxSOndTVpYMo2x72p2W6NtdX1Lq0iPm1SdrOYGCoUuNOAWvbqTQelNfVO7UOm4x1oJrbnB2qqB1ipW93z3mAzStq4CNK7MZMEtZpOUQ+taxpQNcA22BdM3XiDu8vYmd9gEremkH/JeHZdH7ftUBthRDFoThS4c5CwkAABOAcFxvLm52WKBuwOMYSwWKumPb3yJLKkBt1jSf576x1kO3HYSAMY7CIvFMhjg2AgAAOB2gzga8wUAAAD+cuDvHwMAADgH8C8AAIBzAP8CAAA4B/AvAACAcxjMvywWS6/XG41GFoslk8nMZrNCoWAymQaDQa/Xt7a2qlQqs9kskUjYbLbRaNTpdDQaTavVmkwmoVDI5/MxDNNqtc3NzTqdzmg0crlckUhkMpk0Gg2dTtfr9QaDob29XS6X9ynOYDDUarW1OIfDsRanUqlardZ6nZ5AILAWp1Kp1uIcDkcsFptMJrVazWAw+hSXy+Xt7e32xU0mk1gsHn5xiURiNpvtizOZTIVC0ac4nU7XaDQmk0kkEnG5XGvx5uZma3E+ny8UCk0mk1arpdFo1uJsNttaXKVStba29ikuk8lYLJbRaOxfHMMwnU7X1NQ0eHGpVNpd3GAwGAyGtrY2oxHu2gMATmYw/+p0Og6Hw+PxZDIZj8cTCoUcDkcul3O5XC6Xq1Ao2Gy2QCDg8/kSiYTH43E4HLVa3dHRwefzOzs7RSIRn8+3XlbHZrN5PJ5YLLbaraOjQ6lUcjgcLpcrk8m4XK5QKORyud3FlUrl4MU7OzutxdVqtbW4RCIZvLj13xwOR6lUdnR0WBtbi3fXsS/e0dGhVqute0AikfD5fIFAwGazlUqltZPW3nYXt3bSvrhYLLYWt+4BPp8vEokGL65QKLqLczgcoVDYvf85HI5KpbIvbr97rcWFQqF1D6hUKmtxqVRq9XKf4jDjGwCcDoKbVQPFYlJqlAK5lGMxKU1GOY/TYjLKLSalUsZVKfjWhQIew2yUWzCFTMLWqjtxs9Kol4qETDOmMGMKcWe7QSfBzSqdRiQVscyYwmyUC/mtJoPMYlKqlQJFv+IKR8Wl4o60tOSIiIjY2Jie4kJmT3Fxh604j2EydhWXcW3F2bTu4mqlwGJSmowyIY9hNsrNmEIq7tBpRLhZZdBJxF3FRUKmUS/BzUqtulMq7rBgCrNRLuAxrHVUCn5P8e6eSzm24gaZkN9qKy5i9RTvbO8q3mbUS3GTUqvulEnY/Ysr5bw+xeVSjsa+OCY3YwqJiKW3FteKu4t3Ctowa3GV0FrcZJTzufSu4jxr8UFedwgEcnuC4Eb2uMiHH8xEEORfT/7T6T2BQCCQWxLwLwQCgTgn4F8IBAJxTsC/EAgE4pyAfyEQCMQ5Af/+JTGrqPTKUw0dDNzI5pMTTlfWOb1LEAhkrAX8+5eEluMVlpJcz2LgRjavjOi3e9WhElAwBALpFfDvrQ/n+LfLN+29wWV0LxHXR/+xfimpscPpfYNAIGMn4N9bHWb88olrTgtopl7L21tP//DF8h1lAmd3DwKBjJmMW/8a2vWadovhtmzdwDJqmGb90EevFs2Ng6unzI8s6b8Kk1Sn7HbbGHJEqnf+zoRAIGMh49a/rMzApGyprP12bF14IeNYWh29ZaiWjKbEb95w2XRNx3K0tpV64c8t7mtz61vMzt6ZEAhkLGS8+ldW5L0lPEl0W/yrrkvxjfC/MaR/xee83OasDs02D3BUrqRm7fpi7o5Eklzn/P0JgUCcnnHpXx3rUuwPs+ftCL8N/jWKK7P9Viz45sch/Ssq9l/y5tyg4huWgdooyo78/rn71qAWAdPp+xMCgTg948y/EyZMcFvquujD/z47ccKjL0xbuOgTt6Wubkvd9+0/yu/7kPqylD++WerqttTVbalryIUaB2VFpafCN7t1tVm9i0g6HEgRda2tDHFb6rpk/nuvPv3ww0+99MG8eW5LXd2WLtz8E5HpoIf0yuTNM97+NKuxZkD/GpvLErfMXfn9jZYmp+9PCATi9Iwz/06aNLGVdr2Vmh217sMPv9xXWVPSSrveSivjcamYXWODoDTx58WEX/xLaq630q63UsPWPDl19XfRbXZtdEJy1Lb3t4YcolCtbSI9Hnpi2gfzTzZ0nWdT1LXSrrfS8o75rHZd4JldeLmVdr2Vdr2jvdHgoIfU0vivp3t8X8NsHvhZtFRlbJ/94Yqs6koYAoZAIOPMv13jvzeOblu4cMsA4w/6topwj3c/21ku7FnIowQvnjzjj5NF3Qen3It7NizzaTb0zGpQcUl/fP5eREFt74INJcSNn3425PhDVc4+j5ddt9e3Uwdu01KVsX327OXHqipMg5WCQCB3Re5A/2Kq8z+//9LG5Mv2C1Wswr0LnvbYEdOusS3hF/+55oOVh8sr1F1LcF1LW1XqhbKG3gWH6V9qafzX092/q2IOMrbQUpWxffZH7qdqquD4FwKB3IH+NXKjPp349Oc7/Q+nx3QnOXqvuwvyNuFHMsvWTCO8HPPN7PlLXL0iYw6nx5S1tg2w6WH6l1GVumXGdLcTDYOM/zaVHtz88cqtZPogYxQQCORuyR3oX0PNHzMemzR/3TZf79/65NDJE1xpT0sNpyTn0G++v62e8fRj0z//zst7z7na/mYcpn/ZkqtBy96aG3ClbED/ykoz/s/DY3sIXQjzHyAQyB3q3/effcXrbPVwi6tqqi6knzqeEPDlK2+6b86p6TOAMFz/4tLzvsvnfB6YNdD8X0XzyR2Ej35LOaOA+b8QCOSO8a+gPK+kKFtiZONGNiY5s+3dZ1b7H5P3riCiFJbkHxV2/fdy8LeXuL0uKVYyzgd/v2BzDEnZ64F9/atsryg5cbDDQSfbWtI2T3v16yKtw+vfGM15e7e4b8hvYgw8QAGBQO6ijFP/NhaGrHz1i91ckfUeY43XitLzc6/bGuuZ1VFLp3y8IpdqV0FadeXIvoTinptAXg74ZHlUbq+tqBoLojdtCD3eW9z0uqzf5nqsvVBLwY1s3NjObElPSbzouJ+GC+gbz80JLuq/CpNUJ+5csjH8pNzhAyEQyN2XcepftuR6hMd7M39Kz26kFFZcOnLkYFCDuKexQVCWuuODdz7dkJGT20gpbKQUpvzPY3PYCZldwRKvmQ8/O/1b/1gy5bK1TWnmtjXLCeepfTetajy287MPNgTEllcX1lfmHw386Rp/4HvxkP1e/feqo20NWK/lbdTjW9at2lMhHOw5QiCQuyrj1b+4kU0/vcPzi2UrPZZ9s/2HK4x+D1FUXDyw09Nj2UqPZSs9lv18uLBPA8GVkN1BkXF+61Z2tVn/9Z6B7g/JLt7/26ZlKz2WrSF4nGoY4kZovNM/uq3bWsKi92yrInD3xpW5/cwOgUDu5oxj/47llB/e7hsZWNlGx41sdlHo//Z4Hr7R8JduEQKBjLuAf/+SYMpmavnxFm4rbmSLajMK6hqd3iUIBDLWAv6FQCAQ5wT8C4FAIM4J+BcCgUCcE/AvBAKBOCfgXwgEAnFOwL8QCATinIB/IRAIxDkB/0IgEIhzguAAAACAMwD/AgAAOAfwLwAAgHMA/wIAADgHRK1WO7sPAAAAdyNIe3u7wWBwdjcAAADuOhAcx1taWjAMc3ZP7jr04vasyO1xJSIcx3HcnHcmFEHRR8MPeDVKMYuT+waMKcwm/f40LwRFn005d0GgHejdcfK3/+4+SdUZzbe1c8BNYBv/ZTAYWq3WuV25q9Dx6lP+XBt0pbNrgTD84H4ERRHUf9axK5Xj86XQ65QNXD4bBDASzGYTW8BukKj0A7fBsLbvw/wQFEW8QjfeaJWYHDfTydgZ/mvCSTWKQWoBYwmbfy0WC5fLValUzu2NM8DY1YwjyfU1otsoDTUj7etVX8QUS+2WiVpLPVMjETTwo6xr9cMYEFLIeDl1lQmVlcVS5x8tG4ziC5WVgXlZb4YkBLV1wsd/eKhKa6vjblz/PCbU7Vx1+8DtLBZzTU3efGIo4hX5Q1W7fMC3qknUfC5s1y/pV1iaARwNjCl65j9gGCYQCJRKpRN74wQ0osStKU8+EPjlYcnt2qSyOmnLJytTO/qtYJQmIwERa4roiqGL6K+X504PQBEUdbnM+ws6OTL0xs6ThRcWxwUiXgfBv8NGWVxR/ktaKIIO4V8cxzGN+MDpWGR/Rnyb2DhIO6O86kjwhh/DrnMUzv9aBoai1/wzo9HI5/PvrhkRRvnJ3ZnPPBz2c/7NHftr5WVkVgtnsI+GFVl1+soZ7mEUYd8VXPL7UUEvHMjJGdavR6y29uLsUBRB0SXkYej61iA+kktamkMROFqnkXH+PLIf/DtSSgtih/avxUyry5saGrHgfEWzfohTNUZFVain+550ih4Ogcc8fef/mkwmFoul1989nyCLTqHhcVQKw80dLgg4yZmVhbQh91vHiZ9WzN+cItT2+hTxmy5Ojwx6NOFylVo/tMJxHMdxzKgXKhUdCoVkmA+4eVS0TbFh98ZdYTpaCf4dHcPxL7U07amwiIW5Na164zCkilUmrH/T7Y96zW17ZwCjxMH1F0wmU6fT3f6uDBOL2WLCzEPK0mIy6/TYMBriuNms1ZkcN7RYjHrT0APDFktHae3O33MvDeVfc2v+t4uW/Xy8TncLRpstRsyoNgw0c8ViwIwDPa1Rbc3Marz4epgfAv7FcRzHMcyoMhj1ZstN7uFhHf+OlIb0D16b71txl40ljkPGlX/1qgYyp+BkU0p8dbtW01zPJ5M5ZDK3rlGhsWvURuaQyZzclOJF67KyqpQ4juv4QjKZQybzGWxt9yEBpldTyRwymUM+csll+cUqVR+PGVjVvKuFFG/PonrcJGGJa8gcMplTUdEptj85ppSTyZxr+Y07loU+NftE3Ekmmcwhkzk1FLmjQRwzPS94gYtrdFnbzRyZCMUcModD5jT+kX7gca/Ms32/IPTtXO7VVtr3CaErzlfXKyW1XGt7TqWgk6cb8Y9SvU5O4XDIjdeXJIQhKIpEnTnNsRVskmn0XRu38y+HzueRu9rUihUqB/PpTCIxv7sNmS8S6G5i0p1O1lOqu2/K/l9MWIfAro1A5mAmF6Zq6FNKYD8eZJbKOqu4nBsdrKDj4UhQ/K7qDrVBRbE9X269WK7q9WpYNDpFo121Wnnf76Yu/1ZUy8Q1Xc0q+ULuyF8pO5r2z3v9ba+ym6gA3A7GlX+F9P99deLd50LnehQkpRdt2XZ6vSdpw7rsL5afirnYwbWN3wqTPEmenlluH8X9Y+aprCoJo7gpOTx33RfHZ00J/+S7G41y29ta2dkW5kny9Mxa+HbEo2/n9POv+Oj2HLe3Q19793xmESVyb/5WT5KnJ2nhG1E7U9q53fPDqHWe1s3NjXv+2dhFHqc8PUmenqRfdtczHTwBddXRPbNdPc82Cm7m8LewlORJInmkxj8VgCIO/CvKzDmzJC4QQYPeST+16Vjq3LQja7NJhOSIh0MiPa9SmSM8NS7m1+0mkTxJpE8PRf3dF0WCDqwkkTxJJE8SKYDSLuz6NrL5F41cXXB6YWDY7GMkz6xj78eG/PPA4bAmgdZkpzqdrLClclN8yNRUkieJtOZwyuSI2LX5Vws6daNQsEjAOFqQ9kA8+i6MAAANF0lEQVRIwioSyZNEck+O+6c/iqDotAJOr3YqbmrtVY+owNmHu55LeJp/dU213TFiJ78l89rJKb5+MzNtT3BVcvSDEUci6uhM29PUV9YUbz1DWn/qyLQAFAmK33yZfPxa1lPE1PWpkQjq80IiKUvYY1gup94n77BLaPSCo1mepIzXfLwnZRYWCHt9NZcWxCJo4FtpR1enHZqddPirbNKXyREPBUesK25u04x6Vr7gyKa3HlqVfBfOZxpfjCv/4rhRrTmwPvyldzN+ia6t5+vMOG4xmWpOXP7sk5TQMyK797WBcvrKh65Z0cTrB2NLMso1Jrk87acDU1fklzD72EeT73/sxff7+xfHcbzcl/jE80kbvK5fqJBaldtIyvr4ldRD1X2OYvQVx/JXLBly/EF2NeGn6Ut+usaQDtpsWHAZpYti/Bz5F8dxvORiLIKiiH/EwlOXzwtVmAVXcinLotG/RaVHtQx6An1gastPTQlGhxh/QFEkOmPflYpqLY5j2uKK3DdC0EnJl+q6xyIx1Y3KvLfCwuedLsiX4DiOq5Wi1Avp/wlCp6ZdaxzxeInqxOlDj/uErC7lWEUq6WTG5iQ+7u8zIaNK1t1KJzxyLhXxCltfXFWjxHEcF/JoezLD7vNGF+VQ2bZGysNZBx7yRh8PTc/uOqOpFJYvCvJ7MCA6oK3XlGwMk/sc8kL8Ql+ODJ9zhPS/Oj7Wfv7fKPpITFoEXW5r1Fm/5mDwI6HR64sbW9UYjsuJiX6IT8AsErnV7idUaUEsgqJISMyKM8X5AqXRgmv49cuj0Uci0/ZTxaO9MlVwZNNbD70f0DbKhwO3CaStCw7Hdrwwlv1r0mgztsV/8NW1WnmPRo2dnZEb4xf+XEGTdy/DmvOvLXTZv/o3chXPiOM4jmG8ZlZRpUjW95kN7t8DL7yTc5bdY1W9qn7983E+F/qMrA3Tv4qylJ3vfnpr/Ctpr1h+IGhQ/wbNOl50TWn7HWvQq0PSvJDgg3spHE3/BwyD4fk3ekNlq6pLox1tlR6xKBKZXaS07XeJgLotOfiBkMzDdoeBam7NioQQBA3dxxrhDwMd8/ek6Ae9YuNEdsuUjRvCgyYkXGV1LWltOD89xBeJOFdp980jaTjzoI/3xP2JmbbH6uisthwqNY8h6BE3ztoZEni/f9B3tXbLcNyEGSIzvBAUfTL+aGKrTG/GLXpxEZWax2SztNb9rTpzMhzxCZyZdb2u6wdH/mk/BPV9Lelckd1xaWlBLIIGzThRTFbbOmc06vaneyHBCbtr2KOdigT+HR8g+i667wIx5v17yG1r75MVWsVp3yMvzD2b39QtFqw5/9rCmYlBuQLtEJ/owf0b/8ZHRfV2S27Ov+qqo3tmf/RlVj3v5k+/DcO/YSvO13Y76Db5t/f5t37+1VfWF7zni04+dp1u/+NaxdydEfswij52hj6yPpnlGaSDj/n4Ph0Tv7epex4eJpZJ6fLuKSaSlFNJk7zRtws4vV5jcfksH+97A8NWk/l9y2rF6ZePvRId/Up0+ERv74H9G04orGebHB2zyymL/VAkIOyza6zuIwWNWtIikbQr1Pbvyf7n326Zf9cfhQkQY5xxNv7g2L+49lpS7luzSOfquo8rsOb8awvdbeffBuV2+hdnXgpf8vrc0GuMm/9gjEv/Ysq8q8efRdF7vL3v9/F5oH9ONY2iY0xyxgM+Pvf7+NyLosiB7NMchdF+WoKauSc99mEUvcfb0RaDwj+7bhuBsFjM1KuJCIre6+PzQFiybyNPO/jxr/X8m8M+tRXc5+39UEjk7oYhZmf/Jf61UPzfe+2joJrRPRq4bdwR/rVoihNypn9wJq+h++06Rv2Lc4p/+XTZlqRy7U3f72h8+ld1sTTrRRR96UQZc/QnlxxiEYnp/5dOfDMu6skA33sis3MlXb/ntSyvDOLfUPSty/2Oc+3BtKfy4h/2QSdFJwa1dL++o/Uvq/Dv3qiz/Ksjx81wcYtpHN3rDNw+7gj/quVZXhmzV18u7+j+SDvZv5gO49FFjrbdWeCz4aOV4VT1zR4BO9+/BiWZSSvp1Fh/fw9//GGWL4ok5FX1ucxPK86jNZWP8KJZvaqzgEavV9u9dnphZsHxyX6+D0Sdq7SNqEnTspMneaNIZk1fnSnZWc20Fg2O47i8teTdyAAERddW288aGK1/1dQvgtAJgeGby/n2z9OIqcrpNLJI1f3y/wX+VRWHED5aH87QwU0Nxzrj0b8Jn2wsa+7poEVKp/7kepDg12D3br3N/jXWnb3itvx0Tp3NbFIB9wixUexoe+rWUxvedN1xgTlUx4bA6f6VsmtXJRB/qufrR+Bfs4hb53kwBAkk7qq3v4xZU1l29qWolCThyAbGOxlX50SFf5zf3OvmHXr6dxHB9/skZNpOcxpp1ef+E+yHhKYmcu2nMcjOnYp/Mv7UJQWO43hd5enXQ1AERTdS7HeP1b+BX12lnqipLZXYHj60f3Ft7qkwxMf/neOFVXYthMySD2Lj91AE3bvolvtXyy3as/6r4LNUuA3d2Gc8+jd60gvE7XF064Qjg6bd65NE1yUFBSz73/SG6qxLs+ferH/P/RDc37+rn4754Whn74aWzpqGr5cl7c5kW2f9lySdP1Yx0E0k5dT4bS/NCKwfYPUwGaV/feN+qmgb3fQLGaPov+EBSGDcIQGuV4kOnk95K/Vcgdh2Mmkw//pnnpB37Q2jprQq781w/yeikwk3uDiO40bF5er8eftjVhW1yEc4/UzPqZgXF4IExriTKmi2Zbry6tyZgb4TUq+yumdvacWZeUkIij6fnB3WIsFxHNdyYvOOvoJG7Gi0OVXOrfCIDr4XRV9OvnhDY+181c6zqa/6+tzv7784J28hMT28xeZ5DBPvPTC4f3GVqPX7BK+/Be//6kodTYPjOM5vvrTsUPSbx4qr7A7YB/Svb+y2G60jvimUXnApeu/m35PqxaOZTA3cZsajfw/OJeSHB55ZMJPo4kKc9mb0h79QmBxt12et40+XOBeXuJefC3no4aAXXo51cSG6rK3k9islZTd85xLn4hL70lOBDzwS/PK0OBeXg6s2VbXa1vNC5x56/gn0wUdCZ63Nz2vS4TjOyTr7xrTwx+73feLZlH2JTPvPhllvKEu54Doz4rU3iC4uxIBzcgeXX3WjEV38c/nb2044vJHNkBw/F+dCJL4etf/vft4IGvBiXJwLMX7F6ZIqm+K4gQcT/hPii6A+jwWHu54vb1ZhuKx2TWzM0wEogvr+IyxyS3mHYhS/TTEtg5LzoK/3k5HEaTFR05JPHGRIdWYLjuMqTfPW6Kh/BfggqN9TkdGry7i4BaPRrrhG7n/MF0VQ/2djYv2ZtjImg5Ypafg+IuSeoAgXItElLvrZ6NS9FS0do7hhjKB2wYEwBEXv9Q6aTCS6EIkuxNgXgv1dSJUNvcc3jFp5vfDGYm+fx8KiXIhEl5iIJ6KzSTyRtHubZj1X0rbvgN+9PgEvxBBdiMQp+4MXX6jJyjt4j7f3o0FRi7NKKQZlQVH2nHjiG3FRk3xRxNvvn/ujphGJLnG5Vx31TipiRp1NeCgwZHIM0YVIfDXM3/UyvU3ZPS7AC048ODnEF0F9/h68/5NccoPSiMsohNhY6ys1MSxiE5klG8ErhbErM3127jzfoIRb+I8LEEo/amtrx7Z/D7ltrWZaLCaTLX3m7JtN5u5Vtgxwc4f+Lc12Lc12D7edTR94o9a15kHW9tv48a3/+jGLM1Q7Rw+1mE0WS5909xHHcXPvVRbr9sxmu8aj2Kxt4/0qdz2ffvUtFovJfmHvQo46OZr+mPvtikGeoH0nHW7U0q+Opefflv4NbBn4LhD9Cw61E0b/Smk6GVE7XWOLO8G944Vx9fePjVp6Vceu+cEff1lSyFJpDON7fMugEh0JWJNUdtvuOwzc4eT4zAu51O++psAYZlz5l0/d5X7U3f2Yu/sx99/La9l3w222AAC4YxlX/gUAALiDAP8CAAA4B/AvAACAcwD/AgAAOAfwLwDcCVhnr5nNZpPJZP2v0Wi0LjSZTNaFwFgD/AsAdwJyudxoNHZ2dnK5XJ1Op1QqGQyGQqHQ6/V8Pp/P599Nf1R33AD+BYA7AYFAwOFwxGKxXC7ncrk8Hk+n0/H5fC6XK5VKpVIpl8s1m8f3lPk7D/AvANwJmM1mmUxmNpstFotKpbL+OQUMw5RKpcVisVgsCoVi9JcZAn8N4F8AAADnAP4FAABwDuBfAAAA5wD+BQAAcA7gXwAAAOcA/gUAAHAO4F8AAADnAP4FAABwDuBfAAAA5wD+BQAAcA7gXwAAAOcA/gUAAHAO4F8AAADnAP4FAABwDuBfAAAA5wD+BQAAcA7gXwAAAOcA/gUAAHAO4F8AAADnAP4FAABwDuBfAAAA5wD+BQAAcA7gXwAAAOcA/gUAAHAO4F8AAADnAP4FAABwDuBfAAAA5wD+BQAAcA7/D0sOVolZbpyrAAAAAElFTkSuQmCC" alt="" width="312" height="224" />

五、模块的分类
　a：标准库（内置）

　b：开源模块

　c：自定义模块

　　1、标准库

　　a、time和datetime

　　在Python中，通常有这几种方式来表示时间：1）时间戳 2）格式化的时间字符串 3）元组（struct_time）共九个元素。由于Python的time模块实现主要调用C库，所以各个平台可能有所不同。

　　UTC（Coordinated Universal Time，世界协调时）亦即格林威治天文时间，世界标准时间。在中国为UTC+8。DST（Daylight Saving Time）即夏令时。

　　时间戳（timestamp）的方式：通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”，返回的是float类型。返回时间戳方式的函数主要有time()，clock()等。

　　元组（struct_time）方式：struct_time元组共有9个元素，返回struct_time的函数主要有gmtime()，localtime()，strptime()。下面列出这种方式元组中的几个元素：

　　1）time.localtime([secs])：将一个时间戳转换为当前时区的struct_time。secs参数未提供，则以当前时间为准。

 >>> time.localtime()
 time.struct_time(tm_year=2011, tm_mon=5, tm_mday=5, tm_hour=14, tm_min=14, tm_sec=50, tm_wday=3, tm_yday=125, tm_isdst=0)
 >>> time.localtime(1304575584.1361799)
 time.struct_time(tm_year=2011, tm_mon=5, tm_mday=5, tm_hour=14, tm_min=6, tm_sec=24, tm_wday=3, tm_yday=125, tm_isdst=0)

　　2）time.gmtime([secs])：和localtime()方法类似，gmtime()方法是将一个时间戳转换为UTC时区（0时区）的struct_time。

 >>>time.gmtime()
 time.struct_time(tm_year=2011, tm_mon=5, tm_mday=5, tm_hour=6, tm_min=19, tm_sec=48, tm_wday=3, tm_yday=125, tm_isdst=0)

　　3）time.time()：返回当前时间的时间戳。

 >>> time.time()
 1304575584.1361799

　　4）time.mktime(t)：将一个struct_time转化为时间戳。

 >>> time.mktime(time.localtime())
 1304576839.0

　　5）time.sleep(secs)：线程推迟指定的时间运行。单位为秒。

　　6）time.clock()：这个需要注意，在不同的系统上含义不同。 在UNIX系统上，它返回的是“进程时间”，它是用秒表示的浮点数（时间戳）。而在WINDOWS中，第一次调用，返回的是进程运行的实际时间。而第二次 之后的调用是自第一次调用以后到现在的运行时间。（实际上是以WIN32上QueryPerformanceCounter()为基础，它比毫秒表示更为 精确）

 import time
 if __name__ == '__main__':
     time.sleep(1)
     print "clock1:%s" % time.clock()
     time.sleep(1)
     print "clock2:%s" % time.clock()
     time.sleep(1)
     print "clock3:%s" % time.clock()

　　执行结果：

 clock1:3.35238137808e-006
 clock2:1.00004944763
 clock3:2.00012040636

　　其中第一个clock()输出的是程序运行时间
　　第二、三个clock()输出的都是与第一个clock的时间间隔

　　7）time.asctime([t])：把一个表示时间的元组或者struct_time表示为这种形式：'Sun Jun 20 23:21:05 1993'。如果没有参数，将会将time.localtime()作为参数传入。

 >>> time.asctime()
 'Thu May 5 14:55:43 2011'

　　8）time.ctime([secs])：把一个时间戳（按秒计算的浮点数）转化为time.asctime()的形式。如果参数未给或者为None的时候，将会默认time.time()为参数。它的作用相当于time.asctime(time.localtime(secs))。

 >>> time.ctime()
 'Thu May 5 14:58:09 2011'
 >>> time.ctime(time.time())
 'Thu May 5 14:58:39 2011'
 >>> time.ctime(1304579615)
 'Thu May 5 15:13:35 2011'

　　9）time.strftime(format[, t])： 把一个代表时间的元组或者struct_time（如由time.localtime()和time.gmtime()返回）转化为格式化的时间字符串。 如果t未指定，将传入time.localtime()。如果元组中任何一个元素越界，ValueError的错误将会被抛出。

 >>> time.strftime("%Y-%m-%d %X", time.localtime())
 '2011-05-05 16:37:06'

　　10）time.strptime(string[, format])：把一个格式化时间字符串转化为struct_time。实际上它和strftime()是逆操作。

 >>> time.strptime('2011-05-05 16:37:06', '%Y-%m-%d %X')
 time.struct_time(tm_year=2011, tm_mon=5, tm_mday=5, tm_hour=16, tm_min=37, tm_sec=6, tm_wday=3, tm_yday=125, tm_isdst=-1)

　　在这个函数中，format默认为："%a %b %d %H:%M:%S %Y"。

　　最后，我们来对time模块进行一个总结。根据之前描述，在Python中共有三种表达方式：1）timestamp 2）tuple或者struct_time 3）格式化字符串。

　　时间转换关系

　　aaarticlea/png;base64,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" alt="" width="328" height="344" />

 #_*_coding:utf-8_*_
 import time
 # print(time.clock()) #返回处理器时间,3.3开始已废弃 , 改成了time.process_time()测量处理器运算时间,不包括sleep时间,不稳定,mac上测不出来
 # print(time.altzone)  #返回与utc时间的时间差,以秒计算\
 # print(time.asctime()) #返回时间格式"Fri Aug 19 11:14:16 2016",
 # print(time.localtime()) #返回本地时间 的struct time对象格式
 # print(time.gmtime(time.time()-800000)) #返回utc时间的struc时间对象格式          当你没插入值的时候，，默认传入你当前时间，返回标准时间第一时区
 
 # print(time.asctime(time.localtime())) #返回时间格式"Fri Aug 19 11:14:16 2016",
 #print(time.ctime()) #返回Fri Aug 19 12:38:29 2016 格式, 同上
 
 # 日期字符串 转成  时间戳
 # string_2_struct = time.strptime("2016/05/22","%Y/%m/%d") #将 日期字符串 转成 struct时间对象格式
 # print(string_2_struct)
 # struct_2_stamp = time.mktime(string_2_struct) #将struct时间对象转成时间戳
 # print(struct_2_stamp)
 
 #将时间戳转为字符串格式
 # print(time.gmtime(time.time()-86640)) #将utc时间戳转换成struct_time格式
 # print(time.strftime("%Y-%m-%d %H:%M:%S",time.gmtime()) ) #将utc struct_time格式转成指定的字符串格式
 
 #时间加减
 import datetime
 # print(datetime.datetime.now()) #返回 2016-08-19 12:47:03.941925
 #print(datetime.date.fromtimestamp(time.time()) )  # 时间戳直接转成日期格式 2016-08-19
 # print(datetime.datetime.now() )  获取当前时间
 # print(datetime.datetime.now() + datetime.timedelta(3)) #当前时间+3天
 # print(datetime.datetime.now() + datetime.timedelta(-3)) #当前时间-3天
 # print(datetime.datetime.now() + datetime.timedelta(hours=3)) #当前时间+3小时
 # print(datetime.datetime.now() + datetime.timedelta(minutes=30)) #当前时间+30分
 # c_time  = datetime.datetime.now()
 # print(c_time.replace(minute=3,hour=2)) #时间替换
 ####################格式参照####################
 %a    本地（locale）简化星期名称
 %A    本地完整星期名称
 %b    本地简化月份名称
 %B    本地完整月份名称
 %c    本地相应的日期和时间表示
 %d    一个月中的第几天（01 - 31）
 %H    一天中的第几个小时（24小时制，00 - 23）
 %I    第几个小时（12小时制，01 - 12）
 %j    一年中的第几天（001 - 366）
 %m    月份（01 - 12）
 %M    分钟数（00 - 59）
 %p    本地am或者pm的相应符    一
 %S    秒（01 - 61）    二
 %U    一年中的星期数。（00 - 53星期天是一个星期的开始。）第一个星期天之前的所有天数都放在第0周。    三
 %w    一个星期中的第几天（0 - 6，0是星期天）    三
 %W    和%U基本相同，不同的是%W以星期一为一个星期的开始。
 %x    本地相应日期
 %X    本地相应时间
 %y    去掉世纪的年份（00 - 99）
 %Y    完整的年份
 %Z    时区的名字（如果不存在为空字符）
 %%    ‘%’字符

　　##执行结果：

 3.9473128470428115e-07
 -32400
 Tue Aug 23 15:21:55 2016
 time.struct_time(tm_year=2016, tm_mon=8, tm_mday=23, tm_hour=15, tm_min=21, tm_sec=55, tm_wday=1, tm_yday=236, tm_isdst=0)
 time.struct_time(tm_year=2016, tm_mon=8, tm_mday=14, tm_hour=1, tm_min=8, tm_sec=35, tm_wday=6, tm_yday=227, tm_isdst=0)
 Tue Aug 23 15:21:55 2016
 Tue Aug 23 15:21:55 2016
 time.struct_time(tm_year=2016, tm_mon=5, tm_mday=22, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=6, tm_yday=143, tm_isdst=-1)
 1463846400.0
 time.struct_time(tm_year=2016, tm_mon=8, tm_mday=22, tm_hour=7, tm_min=17, tm_sec=55, tm_wday=0, tm_yday=235, tm_isdst=0)
 2016-08-23 07:21:55
 2016-08-23 15:21:55.438771
 2016-08-23
 2016-08-23 15:21:55.438771
 2016-08-26 15:21:55.438771
 2016-08-20 15:21:55.438771
 2016-08-23 18:21:55.438771
 2016-08-23 15:51:55.438771
 2016-08-23 02:03:55.438771

执行结果：一一对应

　　b、random模块

 #!/usr/bin/env python
 #_*_encoding: utf-8_*_
 import random
 print (random.random())  #0.6445010863311293
 #random.random()用于生成一个0到1的随机符点数: 0 <= n < 1.0
 print (random.randint(1,7)) #
 #random.randint()的函数原型为：random.randint(a, b)，用于生成一个指定范围内的整数。
 # 其中参数a是下限，参数b是上限，生成的随机数n: a <= n <= b
 print (random.randrange(1,10)) #
 #random.randrange的函数原型为：random.randrange([start], stop[, step])，
 # 从指定范围内，按指定基数递增的集合中 获取一个随机数。如：random.randrange(10, 100, 2)，
 # 结果相当于从[10, 12, 14, 16, ... 96, 98]序列中获取一个随机数。
 # random.randrange(10, 100, 2)在结果上与 random.choice(range(10, 100, 2) 等效。
 print(random.choice('liukuni')) #i
 #random.choice从序列中获取一个随机元素。
 # 其函数原型为：random.choice(sequence)。参数sequence表示一个有序类型。
 # 这里要说明一下：sequence在python不是一种特定的类型，而是泛指一系列的类型。
 # list, tuple, 字符串都属于sequence。有关sequence可以查看python手册数据模型这一章。
 # 下面是使用choice的一些例子：
 print(random.choice("学习Python"))#学
 print(random.choice(["JGood","is","a","handsome","boy"]))  #List
 print(random.choice(("Tuple","List","Dict")))   #List
 print(random.sample([1,2,3,4,5],3))    #[1, 2, 5]
 #random.sample的函数原型为：random.sample(sequence, k)，从指定序列中随机获取指定长度的片断。sample函数不会修改原有序列。

　　实际应用

 #!/usr/bin/env python
 # encoding: utf-8
 import random
 import string
 #随机整数：
 print( random.randint(0,99))  #
 
 #随机选取0到100间的偶数：
 print(random.randrange(0, 101, 2)) #
 
 #随机浮点数：
 print( random.random()) #0.2746445568079129
 print(random.uniform(1, 10)) #9.887001463194844
 
 #随机字符：
 print(random.choice('abcdefg&#%^*f')) #f
 
 #多个字符中选取特定数量的字符：
 print(random.sample('abcdefghij',3)) #['f', 'h', 'd']
 
 #随机选取字符串：
 print( random.choice ( ['apple', 'pear', 'peach', 'orange', 'lemon'] )) #apple
 #洗牌#
 items = [1,2,3,4,5,6,7]
 print(items) #[1, 2, 3, 4, 5, 6, 7]
 random.shuffle(items)
 print(items) #[1, 4, 7, 2, 5, 3, 6]

　　生产随机验证码

 import random
 checkcode = ''
 for i in range(4):
     current = random.randrange(0,4)
     if current != i:
         temp = chr(random.randint(65,90))
     else:
         temp = random.randint(0,9)
     checkcode += str(temp)
 print (checkcode)

　　c、os模块

　　提供对操作系统进行调用的接口

 os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径
 os.chdir("dirname")  改变当前脚本工作目录；相当于shell下cd
 os.curdir  返回当前目录: ('.')
 os.pardir  获取当前目录的父目录字符串名：('..')
 os.makedirs('dirname1/dirname2')    可生成多层递归目录
 os.removedirs('dirname1')    若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
 os.mkdir('dirname')    生成单级目录；相当于shell中mkdir dirname
 os.rmdir('dirname')    删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
 os.listdir('dirname')    列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
 os.remove()  删除一个文件
 os.rename("oldname","newname")  重命名文件/目录
 os.stat('path/filename')  获取文件/目录信息
 os.sep    输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
 os.linesep    输出当前平台使用的行终止符，win下为"\r\n",Linux下为"\n"
 os.pathsep    输出用于分割文件路径的字符串
 os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
 os.system("bash command")  运行shell命令，直接显示
 os.environ  获取系统环境变量
 os.path.abspath(path)  返回path规范化的绝对路径
 os.path.split(path)  将path分割成目录和文件名二元组返回
 os.path.dirname(path)  返回path的目录。其实就是os.path.split(path)的第一个元素
 os.path.basename(path)  返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
 os.path.exists(path)  如果path存在，返回True；如果path不存在，返回False
 os.path.isabs(path)  如果path是绝对路径，返回True
 os.path.isfile(path)  如果path是一个存在的文件，返回True。否则返回False
 os.path.isdir(path)  如果path是一个存在的目录，则返回True。否则返回False
 os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
 os.path.getatime(path)  返回path所指向的文件或者目录的最后存取时间
 os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间

　　d、sys模块

 sys.argv           命令行参数List，第一个元素是程序本身路径，读取参数
 sys.exit(n)        退出程序，正常退出时exit(0)
 sys.version        获取Python解释程序的版本信息
 sys.maxint         最大的Int值
 sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
 sys.platform       返回操作系统平台名称
 sys.stdout.write('please:')
 val = sys.stdin.readline()[:-1]

 　　e、shutil

　　高级的 文件、文件夹、压缩包 处理模块

　　1、shutil.copyfileobj(fsrc, fdst[, length])
　　将文件内容拷贝到另一个文件中，可以部分内容

　　 aaarticlea/png;base64,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" alt="" width="318" height="132" />

　　2、shutil.copyfile(src, dst)
　　拷贝文件

　　aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAfUAAABGCAIAAABaA5opAAAgAElEQVR4nO2dd1wT5//A79tl9+/Xfr/92qXVqr8uR1u1rmqtq466FRWVihpRq6KWujWXBJKwR9gj7A1hz7AhMgNhz4QNSUgYIWSQkPv9QYAAYShYFJ/36/7glXty3D13977PfZ4RqLOzk8fjlZWVIQAAAACYRUDA7wAAADArAX4HAACA2QnwOwAAAMxOgN8BAABgdgL8DgAAALMT4HcAAACYnQC/AwAAwOwE+B0AAABmJ8DvAAAAMDsBfgcAAIDZCfA7AAAAzE6A3wEAAGB2AvwOAAAAsxPgdwAAAJidAL8DAADA7AT4HQAAAGYnwO8AAAAwOwF+BwAAgNkJ8DsAAADMToDfAQAEQSRVzBLfwlpmr1yubnVLY4lvZUubvE/xT+/YC02fSNSRU14SVt3KVbdaIu4uZpVFN7T3/NM79rIA/A54sREy01NKWwXivuEfdxeUl/owGG4MVpVEWM4q9StkuDHK8wW9UrWGltSiHQzfxThcyMxJ5PdKR2wM6XL3MnzX3PtRLj2tXSabhOMFnErPQoYbg0HrUMzEI0HRK+OnMxhujELfkoYGWTejnOHGKPQpqamSTGWz8h4xN5nBcGMUB1c01Us6c8sYbozCwPI6plRd8T5xbd3jo0YGn1r54surS4QjVsuaW0pu2hstco1wqKgpHblWDTJJd2V9mRuDEVTFqpiZZ4K0ta0hmsFwY5QnNXGZ7S1JJQw3RklsPZctU5bobi7Opz+u4EypoqcL4HfAC4yQmR7shCGEFnMEMtXP2c1pmubEt2EYQns71tJ1nE3ew8IQ2uRqaUe7TM12Wisi1hvqvwbDX7oEWNWKe+QIgiDd3Bq/olqWTN7JzdhPNHgdhheRA23rpZIB+ws4Vd6FjIx2uXyUwjmVyec8rF7FYDZF5ZNrOyYR9isa6wrcGAyPSrbgKSpiOH1yaWl52Ho0GoL1PzQKDW7JOWCChmDM+0aOZi1Pv9ne3u7MguDVaDQEExdaR3iz0ncaoyEY9wnJy4Gjpry0hxeX4vo5DL9FMN4SmhbFQxAEkfeKWA1VYdXsVmkHLT/kexh+m2iyPTwjlqf8lkwqrK4vC6xklo0yvqS7LSkzdIut8X8sHbQyqpK4EzteJGzPq2K4FVcktnSKnv7QlXQL6sgxrktgGIJJB8ISTWmUH4kwBOPXBaXGdSrLcIuj3CxumvjGPw+Kf6Z+l4s62BW0IrWvZs8pQk5VYW5KUbN4pndkltBWFp/GqG7rVifVqSJkpjtjLt8NzG8ZLndEwnMKsPivPgzBhGXukYaRbnOJ+hAML3T2N6sRCtTkXwReviYf4GDI3MWM2dMvdwG32irE5j2c48WsIscI6/f1MRAMbwjPts8vcC1QLkaBVm9iMT9H5Cbx1SgeaaX9bIz9FwxDTlGp7X0KRFxawXArGPr68CX/uhMagjGvWgS4sad29Sn6ejpq7zugIRjzOs70F/84wzB7CIZfwxms9IsNUCfiyW1Wxm0t07VFQzDmbYLVbwHR94NsIRiegzfcREkObxv9BTmbU37LBg3pExZ7RSvlLhVVVD7WcbX8nBTwMJN2y9sIguH/NbM+kThUFQ60xHNkow/NbVGZahSPiPlp2SFL8DBEtNwUTa/o6esScDNKx6rVAovEyN1WMGRgtpZCS+3sfdqD7z+gnjwGda85GoL151q6nqFQjpLNIRj+wNzmdEpxbtdQQW4xxYH4p4l3Sn3X2Fv7R3hGfpd2t5Umkh3M9eGrhwmPp3XTT05vZ3NJapBPWEJBo9oneG9HY1FKEJlMJpPJpne1T2ppEKhPfRe8yIiaChLCfchKglJLmtXeEKKGvLhQ7+D08laBWm331OdEU7z7N/JIc+muO+Tsuul/mRbWhP59/ugDrxz2SLtXF0dtNsG/AZut94txKkk6YGr41nhyR7q5j4+YEObAMGQfapqdRy4oIBcUGAVZL3T00aR4LMWZLzbBvIoh/uDt85Mx7jWY+KN3sFZoqPbA8hsJeyS3SzQypYMgiIAaRnodA0Mw8WaNXK4QxCeHnVX5oupyJtRvNRGGYMyrVp6ESnURvELR217bv28DC8OzqKF5VDmZrIuW4bUAjXlD32Z/ZJJbUew6NHqqckcUEhE3OtF9Hhr7LtHhWEySXU7ESjS6X+4RauSOyHu7cgrDfoBhCG+y2Dehf58dHidf8bb+muxzyMv5/3BGnxlh3zey+MmN/DUe+74R6deAoQo54eu5y8PdoGZ03kfGbS2B3YwhGLfEJdidI+NwmS5x6mtVOzT4kIfjIgMYwpusCEgKbVHz4Ozp5mdXqtZqAaWmoUaNKOR8TplhgN1/0IT51l430pIeRHguUid3BEEQRMhKtjHSu2FJKZ/ZIP4Z+V3Uxoo3OfL7T/P/+/XamfZ7L5secP+3ue9+tfWKe6k6wYuaGFF2t7S1tbVPHtj648JFa15Gv4uaChI8CTcvoLROaWtra2vv37Du0AWsP3204kXFLhc2Lnrn4z2Y0CKuOsF30P2I9/7U1tbWPrblu7n/s0LnGfhdWBP697HdhKjKtpG3rKBKj2z6PtZsvV9aAq/RO9LpY7zhco8AS6awS/1LhCA2wuE/BtgvXQI1KaE7rQ3mYOF/23qdoIRgSnndsio9I8JbMLyIHBvc1h4Xaf8+zuxQYlFu91DAXpIfSaxol6pNwbTSUeFh2qGJMZ0TZGgUCo6JLRrCYF6nVIxe29fXU1SWZxfp/LqVh3ZoqHZoyOlg18UwZo6+6+3ComxVuShkXey8gyaYN/RtD0Xn0ztrzbxMX9c3+TVkKnJHkD5JYy1tlzH2XaKTVgIji1MOu5u8TbDYHak2ckcQRN7Oqya6Gr1FMF7lFarp773aFH4db/gVOeBSfIpHQ1tlbervaPTbRPPfo3Lj6iuJHuZzLd3vMhrqBnwu6OIkFKT5qo3IxB35penaoZEPMooKJsi5SCqqaKfM0JCF68nsUY9CuaiRzXKihh11sdroG6odGqrh5fKtEfyJreuFzBoab/impby4xyEriYT51gGY/HJqacpxW+OPrRxRGcU5aoN0ISvZ+uFFHax73kwa/hnmZwT1dMdTXz0rv8sEfDazvH4S3hA30Fyvr3//zQUbta2zO8ct2lUcbnBs3cvod36uzaXjv581oBQrYxyG04lfFi05bU6tGBlMdj4211wzb87/bPzbJ7d5/Eu3mXJj41frpt/vwprQv7dvuuCS3jjyDUKQn+a/0MJhh396kkBcVxn1q4npSo9on9aeHjXxNYIgSEtj0mFj/BxzFzOmsEeO5CTYfGSAWeCVltbRK1MgLQ0J+4j6n9h529RJxH0Iwk5bQ9B/FW16q0asLmB/esbxu0LRx6pJOmIKv2bicjK/tf8zaW+DQ7DrEhh+TR+/O75+QF2KXiknMtxpjonLHzGMEpm4MMd7Cc50WwgttXsqeyfv6W7wpDi+b+5xOam0VNyRmu7xFcFqf3RO5hjnVSrpSMkN+AFHWOwVHc1DBO1Ndn74Nw0t91LLWVJEIuZTs/xW443WBSXF8RFE2v44N3gejPvSMch9mpO54/m9p53lGGH/X5zh2qCUhE4EQRB+W51TlMu3RjBkbLs/sVglipe21uXd9HBc7BBiVNRQyau0oDgutXS7nl1dMfYdIGTFmd7U1kH7loxvnWfJM/S7uLUkUHfrs/J7R0VOnJNh2KhnstodKY13uquLtQormqCiX1q/8xMNDm8/+zAwf/D2akhzMLxz1ym+tHXUO20nI9gMfe0eOalyosjkGfmdnXhn58qNDymV3FH71haWFH81oahIKJUhSGVJol5UQhB7TLkjXY0Yb+P3rVyO0Vh8qRxBkLay0KVE/VfQJjcrhYL2hoeexLetXO8Vt/Uow3W2X3SUTliAXmKuYx6LJe+bLsmP7XeFTMazdERDGNw7nnkql6VCIq17aI6GYOw7BA+yMoTsE0sbnMMjr2XUcBFE1ivJygn/M2aKckcQRNYpYNlFxNzLqeMhiFjUlZQZ8VfimHJH5JI6Zs5xB8J/yWEG5TwEQXp72mKTyB/AuPl2/i4t4prqrCMOxIWe0V4N/ZuQtnArLMNCLkZGwGlFodXs6ZP8OH6XVlTStCzRkIHtvriSuoFP+c3Fj7yMIBj+xDnYlDko+J4KFoMQneZcxREgCI/D9EiJMaSPJ3cEQRCES3PQPXcERUpmz1QI/6L6XVSbQbHWvTUpv0+el9bvhWStrbs0jWPLpt53Q5Vn43d20PmlK44ap9R2TLHVVpCb5P2xjfug3BEEQYQFp40Jn9l6W9dyUuI9P7R218ysE8j6NS4pryp0K8h3zk87ZaX/BuxwqZIrHjfv0sWucC1vnUwPybH93iftzjuIRkMY3NuuqaUqDzS5TBIbRuhv4bxR9WRH/iyRd3ewHIOdPyKH9su9/7PSithNBoZrguL9q6utg5w/doswquQjCIIgfcIeHq0k3zk/1ygxdLMR4QuHcDv2eJ0lZZLu8oaa6MbJ9Jofx++iwrKUw0ZoCDbdHJyZPZiFFNR7xLm+B8OQledF5dvS08OlOVzT2KVpEMGcIcE/J36XCTs51cWsUR1ku9vZ1SW1I8+jTMDO9nmgdWzrZP3ew60pzI6nq29eVeF593sHi9XQ1DS9DkYQ5In9ziunpuaXtXZN1B3hmfidHYRaOm8nOqGGN0W9d+VrmNrtSK/hSFVbXTlBcTGGpbxuGTswLvpAUKR1Tq4Tne5EpzvR005Z6b+BgSEYhoj2B9ysXndKL5XKVUJ4cWlFATmfPlCejvc3f83MF1vS3D6R4sfze3v+MSIagjFz9J1IKsluuUySHGUCwZg38Zbo+qlVxTQi7y6roG628NQdlDuCIIiUy69yik/xbOjg8KpMQsNPRVIHainHKDF0sxEMwTCEJcw1t9vk5rYpukwlhO8TdLelFw/Vqk1a/Ck3m2+8qD4TK368/Ew7r8EvLex8WIxBTsXQg1PY6Ev1+AiG37Lx+buYh0wRLs2+X/A1M9Mj72n93ivkl1IdB3H19o7MK8pLqVZ5Exzyu7yHz3wcpCzq5heSzhwUuUzYVp0R6GhjSCTcxQQ1DX7cza1MD3S0JhAI9w0oAydGzK+nxzg6Olrjb536+eN3Pvtm55/GA3vgG0YtG342erjMnKj+lcb3zp/U3IuOnuhxPN1+l3CrsmJ9BnbROyqjfKyub511eYmUwer0ic2s4qo88cWtpWmR3o6O2IuPbHzjWR2szPiB6nQMSy9uVq315qKkcK+BleG0spZuBBE1MRJDPZWf+SUW1LdLEQRB+FUpUf6Ojo6Ojugz675euuaILtZKWcg/uaipY7i+eeUJ4X79ax+e+mG3ns2ws62WSfqdUxgRNLjLQTQmv0ftGNJ+umNvfb9g0R+uRc2TGBAzLtziO7F0mkjaf5gCTpUXI9+RTlddbroSVnhQ/ggLR4UPX5LK65ryr0bR84aNd+1OSou6GDFQxpP0KgYDwTBkGpM5MPC1sZbuRKeHtYyMNMbJv/f1dcYkh6PCIy5FpSUN1bhCKuWYOqAhDO5di+DwqWZgpo/eHlYN/UFaRQ2CIAgi7xUx60tG1KpFavxpF5M1PqNqNTqRmFNGq6DjMqtqh7Yoa+PXuScMlAn222FvAsEwpG+5Oayg/7+IejpyK+kepdW5HSP624zbvqoOIaecGGABwYTvvGJ9OVOXcmOShc6+ndomCU0Tl30GPI3fe4X8slhrM/RfJ1D9/HHi+J4fvv5dS3Ofvcpm+v2+ePktr1Qf84d3LqFQKBRKW1NTY7eGHnlA8dL2+izv20f3rF62ZN3VIb9LeSya560ju1Yt+3rjjUG/C5oKwy1QKBQKderQjh8XffDZih0nlbuAukO0TRkexHTW5QabolAo1Jmju9YuXvTjP+x3Cbc6i0K4ekZj397TKBQKhTp2XAt1wzg8r25EI4CEU0GLNr998ezp/f0FT+/dp3HmCj44a9Dx3VVJ7iaobcsXfrj20GWcgzte768rWv0V8fvJ89cfkNNLBhwvKI9zNjz767fzP3hv4crtt91SKvkIIiiLcSBob/762x9X7Tis5xBd2CxCEARpormaPUChUCjUoU1LPp23eM2uo38oq/O+M3Vk5r0h1d7wLgqFQp3c8f3nHy7Xnha/C1kZoX4WaJ0rl7T7//H+gyduEY0ji9hdakdEIkiD95nvPv9tGsJ3BEFaGoo9C5TSIQTZfOnkeyokrN8je2wM5mBhiGiHZ4mGN6V2ZjIK0vmTGMVaEfImDgPBxDV+uQV9ygA+Jhh+BQN/6ZsyQnmOeclHTcfsPzMahULWUhe/Ho1+FYf/KarmuRpiIpUIi6uVx2VDS/7Ty/pr16D+WtUK8FljCkNY/GK3iBC+6pdkHYKW9LKq4gkfVN0tYQmuEIz7wIR8MaOm/5ZnN5XdJ6PfMbXZHZkxvGKzcTEBaw3hyfld3t7REphE2WJBmGftDxfWT0fytz3b/ebuHfv1fApnJIB/cr/LxZzCyHu7t6BcMgdOkJjfQDXT2LFp5fe3Y4fOj7i1JFB3/cdf7P7TAPuIGMtEEARBejtqqGaa65YdtsgbCr94FUkEzWF+RxAEQdpKY/VPqPp9CA4jDH186STzM4KKeLNT6/5Zvwsaae53TuzfcvSR54AGuTT7a9tXbtaxSVEN4iXsPI+72vu3ncD505T5qe6aVC+0xpb9x2+70RqG+l7VRmFOrF66fPMeLdiMkqPsOSSoTDC7uGHLAV2nFJUovjnVGLXxuyN3vHOHbnx+stHNB4ZkWpO6JNUT5WdaIu7+tmzddPidU+hx9+SeY3pOtIaBlwVmrOHFbXM3a9km1qo3fJn9vm8+OWGV3zANQ0cqixP+io64EKFc9EvbBAPaTow0/lAfhqypj0XD0jdNdfG78biNYZmkar76PpGD9PsdbWPc2je4hX6/Q4aOx8KH/u+FiAhUeMBaQ/hfGKOfH08m56uQCuotvUz+hcUtcA31f86SiSJhR0Jm+OChXaWmeirbUZH2tjpjDzRkYPFTKKNR5StiUVsMzWejqbVGSllU67iXldLvhKVu0WEDl0C/3yEccZ6dx6kI1YoN1fByWoLH/cc+AF3ZMdYmpaKOgpoih7xMdKTvKuI0yh1R+n3dtkv2GVPO9TwNT+53Ka8mUv/3b29GDzsLMkFzpvejE9e9GwY/EreWBOr+NPebwyY57Sol26vTjE9+ueqS/9D5nXV+l3Afk68f3LBd1yaTPfRhSfBDje8W773pSR98tEnYeR73jv926jY5d3gIxs60u7FjwwFdZ9pgnqYtjXRu8/cbdKwSh/cKbaHiT65fdRQTVDQkZ0G53529B/544EvnKyXJT7Z7YOMeVqp6KoaYEb8LmZ6XV20+YxpfPTwTxPTQ/H7+Wr2QErY6wTMst38199j0+H0clH438bz9ONs2L89+YLlONljuEXLW03qOY1qJVDZe/5lx/G6bUjm8rEIhiE+JuBiRmjhxpkUhl7XFUr0WYrDzySGWNc9PamZilH7HGS5wCSWq1KppcuxJF9N1ngF73N02RZeO9zoyjt8JNjvjyobPvyBjc2rI1BiD7PLiseNncVdrdC5VJyJCJ9hnk43Nd2TKo4KyhOmYz+AF9LusqyHDWvPbNRdJgXRVX8oE/DpadPbQS9cY7asvgd8ldVRL1LaNB+76qr5uCmsfB1jd0XcOYwxuXMKMMtT69ZdjGMqogdjdJf73Dm3cdt6CWqcUfFsa6dzmQ+eN41kjirLC7h9ZuWy44JHmVKPzB3frWsczuxEEQfgpdhZelCTWGJfsjPi9knxi5Q/apMfMkabONFz/zdwVYwi+wfvMd5/vN0hjtY+TpH9CJOVVha70Id3Y5+XdcCW8g4MhGF7iFqIdHqETMbS4NkqlrYU3oun0MSabVPIkfp80CrmcF58Z9jMGu8InxuK5lntfj4hPKx5Wq2Yp8YetYQiG3zY0Xes7rFZvp2YmtArKKun6mdW142z1yfz+hIh46cWJ+1xtPjEwX0XJiGqbereA9mz3m7u37LnuQZ9qc9FT8RT5d1k3t8jv7tGdqz/bq2dnZ2fn6jNc9AO8vH5vzXC4tm317iuuuRPcfs1JFhd+WXPgb5+C0Se/O8/t2p7VW6/Ypyv3eky/d2c5nN+2YP1Fq6Q6lU8F5X53fh8I4fkp9hZelOTasSKSmfC7MAH98zfLf9G+R7CyG86tg19+/D603/QxS80rNT9cd/kX36K8SlumpU+OgFPlUZB2ytp8o1/IuYjIi5HKZa8y/25PrBWpH8rUWUfOp9vlluQLx7D89PtdIe/rl7vx5pDY5y0to4q8V8SsYxgmRewjWW0LHqpV7SDftWYwhMUvcYsI5av7pkzU2Fxhl5vvW17HUpufe6Z+RxAEEZWWp54wN4CM7I8mVzRNbcYaBGlNtb28d7cWIXZmejg9Zf8ZcUdzquOlSxfOnNi1Yv5H8/bq2Tp5+CVVDbvfX16/s+IMz65ZcfR28ERNZVXh8MmVK0/BEdVqVlZS7mp8/5P2QMvF2H5Hyvyu7Vs60u8I0hILa+w5qOuc0dSabG85nt5nxO+NgZd/WrRg6dajp1GX1GGXwGpTt8NM1yPffLoHP00BPK82+05c9KXIlIg2iUQlnT5W/r2rtdyFnmebm2sb5fIWDguhTfZTM+N56uYXm2a/K2TCRr/MsI1Y64MxGSnPc+COIL1iQX5R0qXImPtpBbkq536s/LtMIqyoLbLNzbWlJV31JkGw/lxL8s28qqLRh/nM/Y6IuJXGQSQINljqFevHmZrgu+get07sOXw/YNTkyP8MU+v/LuvmFAbrX7p04cyJ/b8s3XTVTlXxL6/fm1KtL29euVfXs2CCNvMGqvHZDasP3w0oHj38QczwvrFv1S+XSMnKWhnT76I8F53ffth23Zk24tpuSTE6f3CXrrUf2WR8vc+c39dd9syfcFjCCJiuh79Z/YddVqPa2cKmBzElyPh/cTBk4vk3LcsmN9d2YMH6W33h7H8uPOJSZOTg4t4s653A7+Ki0ly7XKZN0Ph+V/S1M+3zSotGXjgKubDRN8F7sZHLmZjCMpXivd1NlLz8iNGjjJ9H+ricqkdOaAhnuMA5BK9Sq5apVJSnzTJ3imqt3kvPThrdXDTM7/LOLnZSIcM2NRk1vt+l3VUNVYFVjfVDupa3d7RQC3Ntc4siarnD3iU6WPaRjhAMz3UMNKqa0oO0i+45o3p/cr/3CrtYWSMnJZEJOHRPvf3b1u4xzBqsj3/Y7z1tbfUlJeomO/rH/d5THPTo6Nr1WsT4xlHrJOy6urpa5e0oLKPAx37Zc8EyefQhNlGNzuz89RQholLpxjH93hCNOfbTOk2DiLKRohRU+N3Ze+Dg5qNXnKNozeNodCb83pFm8Pt332uYJFarmZKdnZ9f39U1xqA/ZqD2z2v3myWwRvZ2flIEnEq3/DybnJxRS7ImCf8mBoaI9ofCwi9GRV1WWQwr2sVyBYIgjbV0x5Im7lg/6jTkd2FBSbKGmdGGQDp+fL8rFG15nq9i7S2HtTAq5MJGX6r3YmMX7YxhXSEVfb0NxUGLDYjH85/GHzKxoDzext7FfXrHLct7RTV1RepqNQufEPKLEQxhCf+1dtcaXqs3k2kBTSIEQcSirryqQkodT/0hDfk90rOx2T8xeI+t6+GgqJPj+r23neUYTl7pnRAzeKDyrsyCmC1ENASb/hL8OEslTJe2VZmH2EAw/AU5xKZuKgNPu+iet88e1jQIr5khvT+533vYzDBY40bcyGqU8WqoRieWag91oJm83ztrMqy0f1x90lX1opcJmEm2WhvU+729NM7w1JpfLngPJjZ6mPkZ/vaUhlFFp9HvgqailGBra9+otCq1ucNBeAXejw5u2KVtnjBiRlIJOy82KCA8bWCAl5AVbfTHkT1nzKNH9IoXtyRanj2igbKgDqqxLY10bvNvmriw8mGXXHt1IO7Qhg0auMAiNTvVkmp8fuMPJ+GAAvUdZ5TMSPtqR76V5opVu+CwUu6Im6g1n2zullbPHuuJ1J5jtH/x9ht+dLZoCiF8Z715iN1iZz/t8Mg/o6JGLPttDeZg1eRnVKGGEd6xS6SP1YtG6XeTgwmJh80w33mmUgWK6HHzMwpFX1mK7atYc3jo5lD09fHiqN6LsDaHaczh2u+TdNWZepo87fwEMkFrBmYV9No7/16r4z1thpdLmmrzLnlZf+tOGV2r54L91pvBo/MzqrSxa/R9LH+OKFI/Ikjpd/1PSc6HKQE7rK01E0upNRPkZwScKtMA0jLP6KDBe6S3LSGTsgKNhnDmW8Oy6UP3qYRZnYmyJUD6xhtDM1Kn0EtLwslwvHtG56ZD1sy1lDyx36U8ZiR6y6f7H3irBvFyUUdphNWfRw8a5w56RNhY4Hr2e7V+15j//TGXoeR0L7csAnNk2Y86lgxld0KZgF2eZHtXZ+vXcxdvQVkGRBQOryJpCz3gzqF1m//yqxUiCIL0tJUnhzt7xqrT+7T5XVAcjNP4EoI+WXOcGKO2G/kgPfXpDtcP7dh51jSyeFDxnXV5Ya4YK79I1YPhFgUTtPYcPvbIN3dQ8R2szGA86tSxmybhpUMvJG1ppHObly7bfsYsqqBRedm1V6eT9Tbv2H7gkc8Ysy8IHtvctiRPoPeeTKvjG7f+8/3faxP0z27YqnXLMqayTagM4rurk/1JOGxoQcN4v8bAjLm2Z8NBy8TaKYTwbaUPqbHEsrYudUOVxsq/q0INI7xjFpUskY3XvgrDEAxDVl6eLX2KifLvCkVfZozJK1jcsYF5bxUKeXVl6Do0/DrO+UpOjrXqkp1lGu/5BRp+E28JP03rXa+gNRG36iMImvPveYddap9iC2q32lPHzL6ZmObdqOacj5V/V6WNXaPvab42KE/9M0vpdxiCYQhvvDo4Na1j4vw7r6UM50Wc7xxgNTgBMSJiMTN1bDzveYQAAAcaSURBVI0hA7Nfw7OUjQTyHlZzITqIvAhN+MIx1KSa+/RPPQkn38fwyoXbZlTmTAXvyFP4XdZel0rY9d7ibRo6N7GkAcxNDG9fvqJnGKdsC5R2sRlBsN7h5e/NXbDvjruy6VUm5FWlOj+6fmDZ+58sPvDIh5Kv1Hlvez3N+drhnWsP6fVvz9rKlOSEx1rgzn2/68yVB0Yjx6YikraaOIs/923fpmNAIpFI1haWHr5hxcMetj2cqsehJBKJZPLwyqHVC+ct230JTyKRSJ4hI2YykPJr6XEeJBKJZHxPZ++PCxf8uO8KgUQikVyCYlWt2U73ebDvEwh6++vdNzwKJ3BbT31OiL3u6TPnr94gKivJGH/3tpltZNGIZ4eQRQuwvnLp8o2HaGXBhw+uXb50zY4yXIttaaRzm3/4dsOO83fuE4z7Sz44e+LEsQOwX0rlWC8U/BSvQGrqGHrvqc+NDnAmkfCX9yyfv3DVgcsPTEgkEokUQqscPcNTW0lMsAeJRCIZ6Oz45tOFazV00aYkEokUlj2iHVTIzKB4O5JIJJL++V8XzV244ZQe1oxEIpG8k8s5I37JqSPf31jvwPYj1x7pm/UfEg5767phkJp550fAjLl/4pyOXWx551Ri+DGZhN/FgX74tzHuTh29ane1PtNlDhYDwTBk6KRJb+lvgH0cbfQKBoZMKHHqnsZ9fTxLB/S/MJglvskpHQiCIHJ5b2gAWqkz9Qv2HYKPz1MpRC7uqgyBtbau+OiL80Hjv5FOE5Pwe19LS9kdB8PlbglJ6h7dovY651BLCIYhHHGea4QFqwNBEF5rpYEXHtI33xSSXajmW9LK6swzFuh3TW01U0qHuiKL+JmlaZrezj87OJ+mZpOys0k06gVvu3nGlut9qLbFDVNoqpVw8n2s9K5i7dJn0u5P074q6WzOCkTbRqeFEK4O8dcDA6+h0B0R8eqSnQbW6aGJvvQOBEF6O5vzAvEDH9/HWyYOdfjoba/P9jcYWHcLZx7EaGqtLYgPZow1p6+gqSjKRlkebeaUPvJ66aqnh5OujgZL8sgc9uonbimJd8WoKXnP1HVYSwO/Ks3f7OrV++YeSZNrduGVxXuZDG7ugbV/xqgp1JRwiyLdDAdLGnvGlY5qSRjIv1PiU7wt7w8UNfMd2+0IgvBzKFFpWWOMakIEZbHOxndHH7hV6KhZFBCkMcPFHFZTSzZRRcOnPOsspFjq31JTUt8vWznzzTA68v2NYb3BUo6JrMn1O27P9fzz7GliTBHvGRhe6XfjAH++RP1Pcour/yIZvAGb7I0rr5CpmSi4vNDvByzmX7DhhtjKloEUPbfY/zMMDKFNDyZmW2WPXCyzwtah0RAMv4LFHS8QIQii6JMX5kdfjR5nidWjFk9qTgN19HVzGDaan++0V9eDa/oZGN9kvNwnLVdtZruvp6wyZa8hbq6F572CltGv0YKuJvcYh/kw7t9Wnn8VtPZfpZKuRp9Yp/+F9T+zdtdJHV2xqX+FuP0fDEMwPN85UCWERxCkt4Vd45o0rErv0fKpIzOGT0ZXfbq/5TWCjX/hTPdhBb+v/cLQGIs/te43df0jR8CvTInwsgpKKWriNOSk0PIrxmtZfbFhxhIxBvfcUqqnPYivzPP+Do99BW28OybDNEuNi62S/L7GYV+BYQjt7typNoTnBMTGXItKS+hSDNm/u8Z8PFkPLDH/yNglmbg9P+T2aS2U2g66z4AeQatftM2HMO4/5k5nU9TV6uPkv4KcPoZhCDZa7paYrCYYlzRxKm2i4vFZKr2MZMKq2gLcJCr2TkZezBR/3nYiuurpkS73CPbkGQ7dEQQBfn8xEDUXJlLwZ7es+HTBugOX0QEJ447OZ4XePfzD219u1LiGM/ekFrLGTb2/8DBjiU7xJdP/C97CWoeE+BsxMdcmXKLT4jvV9X9/vumT9jTSvIwfPbyqfvjFs0EubmoqxkdHT6JW4/UzSwpfwMiEV54QGe77PMgdAX5/MRAy032tH+oOYOabXDFOTqa7KsnD4oGurq4ulhxbOHuDd8BUkIu7quNsHg3NEgiYhQC/AwAAwOwE+B0AAABmJ8DvAAAAMDsBfgcAAIDZCfA7AAAAzE6A3wGAl5G+vj4EQXp7e/l8/vh/A15cgN8BgJeOvr4+Ho8nFos5HE5DQwOfzx/r7171ky8AXgyA3wGAlw65XN7a2trU1MTlckUikdq/e3p6Wltb2Wz2xJsDPK8AvwMALyNSqZTD4cjl8tF/c7nc/r8lEgmXO96PXQOec4DfAQAAYHYC/A4AAACzE+B3AAAAmJ0AvwMAAMDsBPgdAAAAZifA7wAAADA7AX4HAACA2QnwOwAAAMxOgN8BAABgdgL8DgAAALMT4HcAAACYnQC/AwAAwOwE+B0AAABmJ8DvAAAAMDsBfgcAAIDZyf8Dy6t0IjFsRNcAAAAASUVORK5CYII=" alt="" width="316" height="44" />

　　3、shutil.copymode(src, dst)
　　仅拷贝权限。内容、组、用户均不变

 def copymode(src, dst):
     """Copy mode bits from src to dst"""
     if hasattr(os, 'chmod'):
         st = os.stat(src)
         mode = stat.S_IMODE(st.st_mode)
         os.chmod(dst, mode)

　　4、shutil.copystat(src, dst)
　　拷贝状态的信息，包括：mode bits, atime, mtime, flags（要求拷贝的文件必须存在）

　　aaarticlea/png;base64,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" alt="" width="333" height="24" />

　　修改了修改时间，和访问时间

　　5、shutil.copy(src, dst)
　　拷贝文件和权限

 def copy(src, dst):
     """Copy data and mode bits ("cp src dst").
 
     The destination may be a directory.
 
     """
     if os.path.isdir(dst):
         dst = os.path.join(dst, os.path.basename(src))
     copyfile(src, dst)
     copymode(src, dst)

　　6、shutil.copy2(src, dst)
　　拷贝文件和状态信息

 def copy2(src, dst):
     """Copy data and all stat info ("cp -p src dst").
 
     The destination may be a directory.
 
     """
     if os.path.isdir(dst):
         dst = os.path.join(dst, os.path.basename(src))
     copyfile(src, dst)
     copystat(src, dst)

　　7、shutil.ignore_patterns(*patterns)
　　     shutil.copytree(src, dst, symlinks=False, ignore=None)
　　递归的去拷贝文件

　　例如：copytree(source, destination, ignore=ignore_patterns('*.pyc', 'tmp*'))

　　aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAkAAAAAjCAIAAADzByK8AAAfdUlEQVR4nO2dd1wUV/f/ZxH5GR990vSbx15j14jRCKiJvXeNLfYuBk1sicFk72wDlia9izTpvYgU6b33uvRepcPuzszvj91lCwussgZI5vPav+4c7p6duTPvOeeee4EwXLhw4cKFaxwKGm0HcOHChQsXrg8RDjBcuHDhwjUuhQMMFy5cuHCNS+EAw4ULFy5c41I4wHDhwoUL17gUDjBcuHDhwjUuhQMM1zhTheONiwbhjKY+4eZSqpn+LBptCtXZuqnCzMVwvgZtCtUUMNresUfHz9ET611H+jUqdQqNPk8/wL+zlGxKnUJTn63naNM8km57q+oSfqJSp9B01lgF+zTm/W5CnUKjLzP3cmmVlue4Pqpq7Xzs19JoU6gv/8jKtQlz2aJNm0I1uB5XXNjLtciwvqRMMw4v6hhVP99DOMBwjSdVON44rxuYW9uNoELtMaEmC9QBAQCI6GCe5DFfR40AAATgs0nNDcxR8nWU1NvT4ehKkgUAAtRpGm62ac4TYQABMFXzuSrjw7ttf1dn4sjpVn2xnrtBnAOn2+n6Fupl0vMe10dTVor3Hn1YBgCIaPko0GPXSz0ZACAA73iTldjGtUFYvYmmZ25RjMYLw6QLsJ663CgLZa14qXb6cVUVa01XvaAV2jDajuAaVhWON9Ye/NMjv65HmF5YS8pFffpkACCi/sPcpHv6Op8BAAFwMr6uqhdFxXc2XoWwelPCzCara872LxJ3uK+pLFQBJkKA9F+6JbUo+QIJhgCYQtd9VMBifvC5YHUW571eBxMhQJlpYEPKjDlJgiEApumZwcUj6BaX9NRQHHXphc7kF6+tSt+JOdxeSHM2+woAiKh9KvztY0frJTCAAPghIC26FRF8HURY5d7PDj7RdU+r+9t8/3BJC2DvypIMT0+e/MmkOauU1GKl1OmHqqMg1ODq6jlKJylvxF6D9tzXWpdWTZ48efLkyZ9MkpuldEotuP7vdhLXe6rC8foaFfPEklZRJLU4uBjMpACIaGdY25KR5LSYTiEAcDK+rrLnn0YvDEO6erKuwQAi0770KRRztKucYgLLAMoXWr6+nW3hwcayAPyHrjMiemGsxub8341gGaC+wCTodWudR4DhBJxeY0t1jv72K2EAmfuZlQxM6baHhDsraMAEosW9ZEZ8XugxUw0CAD8EpEYJ0wvDMAxD2RVefxw4+8Q4onjMh2HSAhiKIqyG3Aj6of9bpjDaAOsoCH5+cSmBMP3bI3CgWIIhbFZfT3d3d3ddkis4obARB9iYV4XjtTX7VT3y63tEj5SGfKOrTiDaGdS2vmtOPq9Pn0zUf5zXWM/859ELYzF73N1IE8AgAGP11KW7TIQpX2j5BvZ115WFKMCkzzRtjOtHhpnetsyEV7JAfYFx0Nuetvy8gHUwZZah88tGFuufd4rHp3LS/Q8ZwAQwCMBqU67b6skAi3spJWVt+RQns6+A9pmI3IyugfTCMAzDUHal19N9px8bRxR3fnznRyJpphB7arJd7m/7WADrLMmIdjLzrZHAtC3vjfa5xV+uO/SXX83Qd1hblg/1tOK/EmB1QTZu4Yn57aPth0SqcLy+Zs55veSyNtHrWUox0f1C38+7ob0bxaKCjebS9B/nNTWysOEerYxnetpfmoREd/ayPpbXwwtB8u6QKVMto4slsma2ZrlxZp7EAYzd1pF+hUKbbh2Tx0K6utsdnMmf018a17PZI8JMb1Vd/Bmq1lKnxCI28q611siBOtvA+WXjCLsdm2qNTPbfrmV1Kap4VOcUGjxDXDbovlLNqJKoPqYu/WcHAxnOwBADsFo7b9tlOo6UnOpmFM1M9tr1XOdMRF5W91BveCiSbHxyy60/PcZ4IlGqAKvNdr2/42MBrD4j0kXzN+9qSWxRhMXs7e3rY4l/v+DrXwywTGuSlVdg7rgAWKzahq+3/eKRNzD8wlAWm9XL5r5IIgi7l8VmoRLEXs0JxzTV5AyCIkcTYCi7PkKRCCaaRoqbzhIR0t2bdZ0EIDAYwDAMQ5gsVi+bO+rZbFYvSwqYQVHBblE2m9XL/kfSC8N6ajzevlqoYX4uomg0HwidJYZeVjO17H5Lq2wZ3rrOKcBhFcwbGGIAhrJ59wWGYSjC7mOzmMiw9wiSbHxi876rYzwIGzcAq8/w0Xu064lkAJNY/16AZb68dAtojQ+AxdLWL972q2d+fe/wthKqNMFuphoZMhxVgKFofoSJDIAlARiL2evuBn9CpV5LSztPJA4CMFwj0ruaHJKjDkHDYnQB1lQSd+OFJkHLXhKA5aYHHDaAN/v4XLO1XTZYCvGDhCYbH9+09+rYLkgcLYB1V+bH2+t5VIk0d5XlxL4y9BKlVGdJjNmNldNX75AUYDVJjtq/HSeJnwET0FgHWL67e2BwcKm0u60Lop7Y+NWSnzSHBViaxZmtyn+Nbh4hlrZh8bTj+ikVbcPbSiZG4EItGgGAUQUYys5znwjDkCQAQ9mdVW8VyJTPvHLaujMujW2AtTZX6tprfWMdMZ6qkTEMay0x87eYAANodAHWkP27s5EMDCBJANZRrO1uMcPM27A4187XbrlUAYahKWOfYBIDrL060/SMXL8+X7BgN9AD1x0r+CZ8gPXUZLn+Ks81/XKp4s+ulTyj7sq0V/fWyslN/HLZ5ntu/QDrKk+0ubtGTm7i9FVbH3jwKNWQ5U8+KCcnJzdxoqwMASLITJCdyPNgyQ+nzNKEXKxNdlHdwzk4caLsV98eIgbUDvOrpA2wlmT7344u4rm4YN/PFrFN4i2LfMGFjf2nc9GRx3aJAmO1Kdrk9u55cnITZZVuaAeV5Ls//nEdz/b7uwZvBRbeNITpXNo6h3dw2y/mkRUYVh+q+dOW2dy2ZT9p+Oe0YRiGZdle27dSTk5uouwE0dMpt+cPpyTeBGO65bntSzknUlaGsFvVLaUWw7AaP9V98l/JycnJyR0g+WYMmCRINjykuJDX3Zq7NknlXYOcpgSd7fJzeZbyv7pk1QzMDfarwuHKqtkKD7wKRhyANSee0qVPJZPlSDCBk28B8EQyWY73uZze0SaGZk1mL+mfUfhmciZhaX1sROxXFHhNpVLkBPrkfLZENvRnbNCGyC0kkhyZLEeCuWkfmNTvxic0tfsFIp2ifX3V6ibkKTSv1wi7a+wCrKekKuYEiSRHJk2A6Sssg9xrM38xIPWfhGkGVvcyxVV4Y33llanK+nxLOQ2jnQHZvNHYxyhLuil4VPCjp7fU2noviXeUbnY0JO/93rZ6an0inJeSSHJkkizMuSKwDIl/ReQdA13EPB26UzKCj+sKeKX9UjmhVPzd3pRH9jAb6Pwi+0DbCt490llq6vtyPpksRyJN4OYD4Qkkfv/f+8S/FaVZR1iU+xYNszsJxaVorb3UAYbV+Py+e82ZZx6pY3ceTCKAtVdnmV6Zs+KiTTGToyZGot4xgsxXS9bTYvhmHIDNm3/hl193r96sHs1kMpnM9rIUu7tKizfedeXCCkURdn12MOXs14oqfIBhKIqwa9P94TPLtvzaDzAMRREWk8lkMquSPZ6dWrn9kXs51wUmi8UWneFCETaLyWQyW7Jea55TWPc3A6wlyeG3Iwvn7LxpGF7LZDKZzHwf8qWN638iij5omuOs7u+fP3//fcvoOiaTyWTWhhvd2jV3weEndkm8IYoibFa284NjqxUUFeXljx596pDYwGQymcyaEJ1LP8zectcwrEzANMPu9v7lC47/5ZrajPAy3aw062u3n5E80prZvIQ3irBZnPOZYnF++96z6n6Zzf3nU+B09tslGh3fNH+XqltKmp/qvtOPDMPyW8vdH21f+eXy62bRJfzceLXX4+2rN980jy56x+ktVmf3+nmyh9VD80Ru6So3FaWlm3+2Sy5r41hGqW1eNUv2uG4sY5DbrsLh8srZF/RTpRCAoWwEYSIIE0GC/XWmUQFk8OZtW3c3r1HMvE6R3/80qBNgcCGt8x0TYSLIay/aZDIsSyJdz+rrFYZYkBftP2QYMnqbwWT1IQgTQfzcYM7UOsEtT6BvlMVmMxGkj83yciFCAJ5oGpHH82GgGwibmRZmPImqppKPoNhYBhiGomhHa42Dtx4EAAGGJ5DUFpl6vGpGmB31IeE2EIA/07MUZVhnfXC4rSwJnmtqp1OGMBGkprqAaA0IMGmhpaNxJbfbmqpc1RdECGgrOMYkIN15xbEXdYmQmtGewOwKBKksz3xiSVxo5WpaibDev/gUQREWgjARhFGUeMeMCGmYnw0vqOZdDhaCir6stBTpepvLkuBvHAOdaxEmghTkRV4yATIwab1rqJfwm11xXuRlU3iC1su7CSV1CMJEkNys0NNGAAKAYOJO5d8fKIJw3cjKeHPcEEBado9TyxsE3BD5YQ3FURcs6Zt8Et62oCj2UQDm+3TPaqUrRuFFY3YaTAKA9TUx/NSPriFGCN5YaHdtjrvqvlVXHfghWE9ttuv91VPnrb3xqozNfxw2F0ZonFu4QdmlPwrDmvLfqp0TBhiGYVhjTiDlrBDA+lWf7k08s0rCFGJ7fpDOecW/F2AlQfRrCmtPPnbN7a9MRYv8KRc2zNktHIY1x1nd23v0PPAu4JewogiS6/77afmNVzUC+ZslNEYYXNs6c/6hJ/aJTfzRiyLZjiqHV2++IxiHoXXB9HNKJ382jeBfjiy7m1Rj88gKsfdzxouLO/adGzaFWOP7dM+a06rPbl+z8Htb0IagKIYlGx1RmLf7L++M/lOWbHRw454b5tGMDkEExmvvlJ9zSC00X+DHJ+hs/2aXsm1yRZegZbSa4ooZx3TixCMshrp+8bTjUgEYX2EBOtOpw6UQm+IOaFBliYZweVcX7xmGokigF20yCcgAV88+lsA2VQUqFNIEopF6Dav/RkFRJC/CZAIMIOOIgbRBUcTXlThMChFld1WHKcDkqZbRhSiGjW2AYRjW01bn7KMHAQBRddd5pJbxBm5TQyntJRGiPVfwzuDf9czWxFSvVYC2xNLHtaWfE2hdTQHRmggB7Y2vYlM4be3VXiEvIKC22ua1bxvW0cgwcNWF1Iz2vsmtwXoLimMv6uh87xqfOjLnyxlJd82Jw6QQu6ucgu0XAPoPntFh7bw3QxQtyou8ZEIkAKMzodkCIXSTf4TbeiJ9l29CDA8CKIo2lMTfsdaEtGwfpJQPTBLmZwadMBwuhdhRrONuMUPb4a+s6lYMwz4ewBSvGI7hHKJEACv2I+5dct6uXLi9p640wYIqCrDtSzfSYoSemS1FkZo/LVx/x/kfDLCWZIffDiltv24YwU8VYS0JLx/snyt/9pkXf0A3x1nd26u0V8UqtkkYLGhjlPHNHUoHH/OjsMZIg2tbj12lv2GImOY4qhxetem2vmAmEc2yv33g4I8kT94LbradupWbl/iUzXsA7I+9a6bJ7FZ1TanlIRRF2Gw2m0/Uaq9H21acAf5ZDSJuJujsXDv7oBo/CKty+1lh8Tm1sAKRLfnQWDWl5f87OgjByu2lFoHxJQnAQv3on5IBZBiS0MMU3E8RLfD6L5UEAfhqtkAQ1hi9jQzLEI3otWwhYzT3JgwIxuGieUHJAMZm9Xm4wpOoFvoNnBM+XgBGX275NkYgZmhuLFW3IULU5xsFANZUz6DZAAJNf5NPRqVgLx21vqHWEADzzF8ZcQ+0p+UF7yIS51s6mVRhddW5qi8ABNTW2r3xa2tPzg7aqWZ0IChXkkU2Q0gSgJUWxd00AxDd6moMQzDWQpvy1TxMIADkXQSCsK5y6wCbOUT6br/EWKEopsEr1Fle0+bXlPKB+1NKArDc9IDD+trHQzPTujkNOMAGVW9jse/jbwjTFq2lRAsfQYUKlgcp4vgXAKwl2f7JIcXtNwwjGwWbURRB2IjgWsHmOMt7exT3qFjGDUyWN0YZ39qhePBRP8EaIw2ubT1+XTOoRMSyIUznwpYZm24LzYWh9cEaZ5VOqnCDsGx7tRdu3oPx670ApnhJ/23h4CM42eDAht03LGJLRdMMibq71s4iCBAsQXvrmp3KdqmV3SKWcRpKy78iHNWJFXfrVThcXjlb8aH3yOfABCQBwIoe0mmTAFgfUvGOKZxDaozeQSVPAIDgktXB6j/UoGdGloWBDAwrhdcJLhxGUJQtLq81PMAQVkeW60QKdUd0/8vBuAHYCsuwOIF2cQDrymOEHwDET/Wt7mcKX/i+5phE92VEIqRtfjiG+9yoq8579oII6Vgej2MUMeIv6xIhAL40tlNNY4TGuioa2T3LHekrjgQAawmJ81IExBlWnvoM4Xuiq8I20HYukUgwcvkjm0+wuKSAvZqAAMNzbQKsyvizwiiKIigqdp3P8ACrS7/3ymCBQ6hrdTevg48GsNOq7qnDPUdHTxIWcaBtlRmGJyCCjIyMjMz0r9eJkgzDsH8zwEre0K9u/ObkE/f8YQyLfMFP3357HviKe2AVePx+au13V/qziIMCDMtxUjm8Skk4BMMwNMv+1n5uEJZlpz4Uv94LYKe5RRziVe31cOuKzwmcoSEsAgGCoAO0EC7Aqlzvblz8qXhLCIKgI9piAYZFU75dNO24gVRDsOEB1hS7X50iy5nSh0U/3BoQIYBhKIoWRJrJkWD+n7jlDrFeajiAIb19WVcBkTOfJObbASwDw/+PRj8g5m1o1PQeAGO2JqZ6rSCK+YEyMHfuENI2P8QDWEdTqbG7LgR0lGx9dePdlhKJEACQmvEWB9+nrrqLrFzNR7zEZniAdVc5BdvPH8Rn7nUxchYAGIZhaGNZkspLTf6fmLiTRaeGhTQcwOqcAhxWASDiA29UcBsXO0X41A5RGyWJUk1PbNpz2TBs7AZg71NGj6II0l2X7/VgDQQRZGSmzhWaAMP+3QDTuLrxmx9/GxZghT5DAuzpqbXfXVEfHmC5TvfEAAzDsu1v7T/wI8krM2YYfkkbYIrXzWMYHYg48YP0Slfl7xYpKtumlHcOYjnIV0RT1i3aLt0QTBKA7VOnyAKwPqS8pY+NcN+XRT4D/4zT3vDcFJ7QDz+TiAJxP02SFCIq+o3sju6Mi9wIrIDTOKaWFL8HwPpaE1M9VxCJn+pb3ctoHeQMC/y63qaIeLelRNoaQ6srbi++VFNboqsLAd2FOlY7rXS+d4kXrkn+EEkOsBlWnvrFHcP7zBOKogjaGZPot1uTxxgt2wfi8oeYBBHYgFGBImitna8tJwIzZbRwBudIB0aq2Zjn14esA0NRFO2py/d8sGbKnIFFHP9KgLUk2T8+qLj9hlFU49CGTbGWKnsU996zihs4cpuiTW7tUDzwqL+efqgU4sUtiseeuaaJBiz1IRpnlU6qqNy8OzS/pA6wGxZxA1KIouICTEwKcThFU9Yt3v5QCoX0/ZIghVj4QIM2CQDIOaOp70P+pRiKYWhD5CYACAAQjCM+bA5sgP5RKcRcRvh+IhHSMt0dVSGuMxH1FpfEX9ElQgBAQGeTra92nOsSXhy2Pyh35HkuCVKIzcGxXgpEImTo+CjzQ54ZKIahnaVmvtazAYAGYZhERRyikn4KMdX05Ka9Y5xfEgCsvZrh+cd523LR9t76fM8/96+6wifY3wywutTUAFNTcXVHf38RR0ngoCFYc7yfv693DDdl0BRrqbLn6HngN/CJVeD59NThA49sE4WKOMQBjBuA6YkGYBiGYdn2t/cvh7aomEUO+UgQA7A0C4uAxEThaXAJAIZVez7culzxhqU4giXo6gbk9adLKl2Uv1ukqGwvjmBxGhoBjMEq6bFy+8srZl2QYhZRDMCK/GaoU86n9S8FazKxVv8PCUCGIYnCRRwYhmEF3lMppCsClfRFUeaTYGN67YA9lhoiNwEAEY21B6ybEwMwlN2d7SJLpvw8EHdcSQ1gXQ3FlmegSdPmnXpROpJ+RPQ+AOsrr0y9/ZwI0fQ3+2aK7mnQUesbaj3X/JWhQHUHdxoMAEjNaE9gagQj7hKHZ7pWp+OlsEePGIC1FOv5mK1yeO3EXQrVnZIRfESLCNGtrsUyRF9Xm/JpHibyzqGevGvdXJ78i43xgAoODOssNfe1nk3U3P86JWHAakkxAKvP+PWVgaJ3XOigQJM6wFJNT26+qeo2hteAYZgkAOtrYvipHVkNR4keaCtPtrr3YQDrrkixvbNr7Q6dBAG7rrKEF7eWfyYeYJ2MKNOrexSOGKXwWgbnl/QAVhZmeGcTBK08pOKYM3RHg8VgzfHWNrbm3gKPmkIfcO7bb8/DIghrija5vePYZbXXAmX0kQbXtioe/s0hWWjU5jrdP7JqwbFnLqlix2l9iMaZJ5Rh+IXVvSYdXX/qkR3/tk8Xwy+JAIZhSQb7N8zZRwrIEnlGJ+reMwsWWs4cr7V19YxDGuGFIq+dcRo3TcKHXM4cTZZftP2hV2GDdIKwgQAL9dP8guzk0NHD/4JC32lqZAiADSEVbUL7rhfco1EmGr1NZ/KXMxdFmU8iwZBRWLbo8sS82wAQJAMYwmZ5ucByZM83gzouLYB1NRRbnYEgCJo0ff4p69IR9CSs9wEYhnXWB4W/hAD4TN/qF6GEQUdmQehemsE2/yyhZ0F7tUfwCwgASMfyRFxVRyND31UXAmChNCbAMHEAKyuOv2OmfzggPZf/Swq1vUwhAGZaeRkwBLnU9DrK4zv6i9vx/OXMzeXJv9hoQpovf04sE571avQOdZGXGGC5Ga+PGpjejCsqHdR3KQOsxk91748PDMKGqN4aE5IMYI+/gSbPWHbBtgzlqacu3/PB9q+FFjK3MuJ0jv7fMgW1WMEsMNpcGEE/9L+V32vG8Vu7K5JtlVfOWrtDO57TX2dpvIfOsd23bu2HCATC3A379JOE3ehkRJlcU1y144l3NYqiaG1KmLPm0wF703M6a8t7wwGYfw3X3YE/i9P+LtObckpx4ym1oDoxluVhRsqbIAiC/rflgnbYMNtTtyTZPT40b9aOm0ZRjdy+ivwpF2+e/dNbdCFzrKXKnjnrL5D8CrmG+R5PT8vPE4y+MIwLsJkQgaB4XSuohGOZ43T/6GqCmOkvvrLs7QMihuEXhtUFko6uV/xJ83VuG4qiaJol0dIniL83PdexFNMTmxbsUnVLqRnsPHJU7fnwh+WfL79hEVfSybGsdL+/6ejvLwfsxlHpeve7xZ+uvOuQVtnFsaxwurXukKpzZvUwM87RFPlFNw3SpBSEFQfMpVMhAM6ltLUwMUaczXQ18vrgsuY+oYJDRqz151QSBADknNHcx0YxDG2M3kklyxKN1KqZQv+jJN/zEzIJAgAiunqzETYnWYQ16JoAGRgQ3HLFzoKxct0IAMiQyHfyMQRhZ4YZyZAp2wZNRKMowmqrDNlAJEKAPFXdJxj78HkO5ruqENV1BMKk6fNPWUvvXyp3t9U68QAWK+BeU0Opug0RApprhLeY6mqptPZ6TgAA0jLdE1WBYhja1xyT5LGMSFtp7e8lmgXv4BTTL7B0Nq3CsPYqlyArTjG9v1SGRSvDxM+cAMAKez+HWqylKvNPB+0Zlh66wv8Xq7Uy/am9FgEATiIRxTC0q8I20HYekb7TJz5aEGqNuSR3EwgACBj/FJZTyB0VndEJvrs0RRYyC6gh87GTIQSAgmdMUDPWUBx92Yo+3yHYuUp87h3FMLS9UMPF/CsAIKK5SnJJ+QgnwGr8VPedemDwdkxnDzEMk2gOrKM6y+bewn3A+MlagbqxqXMFgy/sXWni82O8Y58uWHfLqRLDsJ7qTKd7q3nNs9Zs1eaHXN0VybbKq3jHPl++5RePjJwEN/UHYuIvjurTvYl7ufYLN58YEH3VJjk/3SmmxG3JzosvMgQN23L81c9+LcZyxqaz9BCBWKw83Eh5s4zMzO8v6gzHL44YgepXFfq7m7Nb2TxmkHKjQp+/zn3bb7nxCu31gP+owUshvnppcG3bLJ7pptt6oUM9b7Ls7QMih+UXhnHSiEu4ve787ZVA9JVmfvqHxQNPz/KrJpGDb01d7flw64ov+o0PUoNzB3kQV7oof7f4037Lo9qD7sIhrHL7yyv2/ektrSisOGAundZfxLUhuKypT+z+UIUPNGifCNabGb9NHbiVVIHXfyjkgfWKMjCsFFEvft8pDMNQlJnr1m8pS6ZsixZ/0ljMXjcXMKBz8n81rE0/uAixq77I8ubMJX9GfGgHwuouqYw+BvhOfvrc/E56K8Z8l5bus1qgfbaJja7QAO3MKQ47IGAgo2a4zT9b3HOgt7gk4epztW9sA33bMAxrT8kJ2g10f3CVQgUHV60MYz+Lfk9mDqAXT81BMV6Kgj5rWt+KLxG9FE15ZHcTsaNinu3rl4PutYZh9ZmPnYz6jRc6hDgNQq+cNP9DBgP6Bzqnw3OzPqwIEa32fbb/kbbr0GmXMSJpbuaLS7pqjDC4tvWYuCpEUaEoyq3iQ7NCQpIyhyrfGN+KpsgfU5Mawv7lYrZUBKkfkBq/cP0DhKKpZqeuw0Ou/BxLwgE2NoWiCJLj8vD4mo1X6a+LhygxxzAMy3l19+AKaJOy0duE4ODojAxJwq/xq2iK/HF1v+JGnGEjEtpZV2B5azaOL1wCSrM4e4OkH1owPuiF4QAbo2qKMr61c64sT5tu6YaUDm7d8Fbn4vezZGVlZb8+TR509yhcuHhivqsOpexdeEaKk19jRSiKshGEJcGHPcaW0OH6AOEAw4UL1z9GbUlZQbtgWJZEGvaz0s7XbjxM8+AaQjjAcOHChQvXuBQOMFy4cOHCNS6FAwwXLly4cI1L/X9sbwtTYewNDAAAAABJRU5ErkJggg==" alt="" width="424" height="25" />

　　8、 shutil.rmtree(path[, ignore_errors[, onerror]])
　　递归的去删除文件

　　aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAaAAAAAiCAIAAACWW5ppAAAaiUlEQVR4nO2dd1wTZx/AT+uuA4Q4Wlu1vmqrtu4K7l21otaqVavVvo66lfpqa2ubS8giYQ8RkamACgiCskSQpRBmmNnrBGRkzwsj7x8JkEAQLFiszefz/YfL7+5+ee7yvWcegFYDmTFjxsw7CdDvGZgxY8bMG8IsODNmzLyzmAVnxoyZdxaz4MyYMfPOYhacGTNm3lnMgjPzpmhRMpVyTpO6w3Y+rGBLZWyJjAOrebCSI5OzJTK2Ss1v6e+EzfSEZpinlLElMrZMwW2EeSo5WyJjy+QcDawPaFFzYSlNpeD3e6pas+DMvCGaFQxm+LGTbkGFHIbh9iZlDtbPdTwIAsgbJEa2e4THxxgQQDqdLSyuVvR/2mZeTQvMZLHi7JBIAMRP94mI5KeddEMCoMPH3sGhtXqjiehxARcXnQpJV74FjutLwTWruGoJs7G/v9JroObCMoZcxjHXHfqWZgWDduvICdfADnbTwryMxz6ziCAAooZibhKfBH/mgQdAcDAGuzerkCvt/8z/7cB8jZItkrGkSp6pAL64tsApCAmA4EAUYbbXLadUXwAEB6BQH1274cpq15mI/sD/4qJTQelqVT9/oz4RHL9ZxZLXFVIzQ9wO/foM7l9t85uVLIWgQipittWZjS8hTyOjS+rKRXXlouJbHleP7cGE1vZzzu8WajYr5Mjq3edDc3OVxpdGU5NyzIc0CkQNx7r/XBB/xsdlnM5umQUcs93eAtTispgHTgCeNDshp/OnLQpqaWHYbCQ4EIWb6RtAKIrbikTq7ObC6vALYlYXXnfcb4t/TNd07KP4W+kTwVXwcnDfjx45fLDVp1/2t+Dgioq4q3s/sZy35Vwc19RTSJCW5Lx3geUYS8vRo0cOGzJhvllwfQpPQ/U8u/Kn64lpgg4fqcpuRXpOxaKGYwPcWRRybsh8Z8xQLHZfltlubwUtMIvHe7gDiTQtOJjz8sXT027gQJTj3IDYtPqi0PtOA1HoyT5Gdbd2pAUl4fbf2nwfUslq7r8v1WdNVDE9zv2bcW9KcDCvSclSK0xWm40RZqS47v7svQHjFm5yiC96ZXBF6f3L39m89YKDObCCo1G9xRka0CzPCj2xZNcVt3y2ceNUw1NRY1Z4kUbiAjzYZfU1j4/6kKyx7pcpxTXK/k+7r+HJpUyBjNPUr2m0wFyZlCmSc3vmF760vtglGAmAoEnBNUvLs9NuvOdAnB8QmyOnlhSGzgGxM2+ERdZ3eWeqeI/vXd1sc8SVpey3u7fPBKfiP4k4u+xNCU6YWfTE3TMqvwfBVPpj3ImFU9fsvfL4xasz+YcIrurenYhbybll/Z9J93DZtw4vn7XLsXP1DS7wun1tls+9CH6lSgPlpd9c6u7xy7tpN0irzjyOAgd6P6hU9+CR/KbgCOuS96KwHwQnsntwezfLKgvT/QAQ7EJw7Bcvkg45udreT4VgvqS+2Dfc8XO/0FfYTauBtJpyZhry5NzFuNR+q8T9MwTXDCWk3rp0uUeC6zn/DME1FXu53nC/848QnDKGtP6LTSfd8liMN36ut5imFw9sUeCA/hWcml1NvTcX3SPBtcAsPu/hNyA4DIsZ0kUN7q8hot53OfjJoqMenH5qgvSL4PjNKo5a0knqMK9JyVLKO94TLSoOP8sLd3p5TwWn5qglNImY3d1Do48F16RgyISVcjm3Dy9Ps4JRGHj41OUz3QquSUaTCGmqnrTi3xiNmb9vmLfypH8cT9IHR9MoWEIJS/mPmx+nYpMfuw9CgUB/Co4Piyvi4pwBNK4HguNLGygeweBYN9cLOYm7u+qD+2vUZWU67Zq5cH8ooy9/Fz2nZ4KDeY3Syvpqip6aUkEDXSmmqg3GRwwEx22U0UT64BJhHa09DOY1ymjCanJxZugNwvUXreXeouaohGX1rITsR0TXiDx9sJoLiyvqqym8nCCnfVMtPl1yNiilNYcysaDDfBReo4wu1n1aHHod+V+7P0JqurmufSI4nkZC1X3Z/LAL+w5vvRKRrtVALUqmvKG0vppSX10uFbOaNFCTnC6t0/3JUIordbuIhHRYyVEJKwTVlPrqUomI1agb+VWx5IKy+moKNfrK/qWIj7464peU1frdy2XSNndz1aJKYTWlvpqS6b1n/Y+HfZ7kajVQs4IhrdedvUIu5XQSPVclrBC2Xk2hgNF1Bx9XJShvjxQyX9kVyMtxWrXg43W4+NSGXt2UPKWUKRAzHsV7fIL38+CV1cmYAgmjXqxHJOc1mRwf1/DVxpH1Uo6m/cryVTJmg+GnhsjYUgmjwWDHRtOn6Bo1R6w7eEHwEDQKAEHAM+q5kN52CpnpCRN8pdQgDQmjQdplz12Lim0icwlTYtDD1azmiMSMekF5SdZNAAQBNHZCQFyBWJ9Gg4Sp6JRGi5JOo4TPxTktSsmuruprwWnKGKl/HJg+96fbfXXA16N7wbWouUp+SqbLjrHWVgiEFcJ6rNUHU6csO47537chjPaS1Qlu5qJLadVPs/yP2FpbIRBW1mM/+HzJvgBKpd5x0vySOyeXWo5+HzHF9nS74JTshDD7hZZjRoybucS+TXA1qckEOwTCCmFtaTl6+NBBg0eMtkQgrBAIKwTi8y0/OJcYWamoKOLSToQVwnrs2DEjho2f83cJLifN/chXCCuEtcWY94cOmrv1SkRao5TGf0L6385ZVhYjhw+ZteuST7mCx46/+tPK94cPmb3r4q+Ov+9ZbW1pMXLYl9+dDk8I9Tq1cY61pcXIKV+fJ2VXcbUaSFsZCB62QSCsENYWo4cPGTJk+GiLtu++5n8+kXzd2eH0qP99sxxhhbAeM3rY4PeWHfZ58hwWV7IeXDm47j9WY0YMHbTopOddjuEPQE6X1Eb7Hlq/yEp3NcfM3f9rVEaeXNbRg81ymrg20nPPynn66z5m3g/IR8/y5fLOxtQlk3f/3JKZyw4GZ+coX7sYDY+T7xbsNQPnMAgFAkhfHC2DGOr6CRFvRSQg8JhBKNTs6NSCOnZHx6k4AnGhZwjpQ0e8FZGAIBIsMKiB7uFRUJlAyW/WQFq4/PZd98l41EAQBED0KEe8NRE/ygE1AAQBNMYi8vZJZ+IEDGoACA7D4a39Yguk7NcbIniZuN3JcRyRgCASxmBAAAQBNGYskYBo5WJFp3tMxXopICM9kcPx+pjRGPRQn2iyiN7ZhmpJJSMnYEDrMa2JhNEOIACCg7D4jRkl+jA1R8B+sN4RjyASrB3xoxxAAAQHOmDb0pjq5YVlGKcBc+uq0y+4Y//jE/MMZr0BwTFekD1Pr525Ch/TL91w3QkO5ouZj9z2frz4hA+ktwD1RQHp0NhRH82cg05rr3aq+E8izi796ONt5+w3Ld+MzoP5Wg2k4qdE2NvOnL/vNr09sqHsLn6fkeC0GkiroZQ/vLTPUHDtFBVH2e+d3cMmKpUajzxg87cJro1nSfi9NvO3Xr4d8cz/xLnTJ4KzS0XPXO03T/p44+GbmWVaDdSQQTq7YdKQ4YuPE0LZcOnz64c3fjRo2Iwtv4fGi+DSbO+D67fvwsdmGrXI4LSIC5vt7LprosJp4SfXz15x2OvR/STH3ccu/ZlYUlmf9NseG8T07648olTqw5RM5r0LO5ctP+oWThPqdnwSenzDF8OWXrgRyTVs3ioZ9LBTW75cccr3Pluki0wOPLhy1tAVl2/FvjA5CxTOjTj95Yw9l5IolN7fl3xy8BxnBwAEAZTDGILnnxVl9UpIy4pb7ol/DwXOjkmniQymZ8McSend6U64EXj8kbyyOgWk1UDPHnt/SkQNBMFvMoqr5Pp2blaCy3gcCCD9A+oYKrg86BbRwgEEPKOyRaxGDT85hmCBcThaRJf2bnpqYiSq+yaqml2XFwiA6DEk0uVKvlYDNau58dH4MQ7gIAfM0UIWbBCsUTBCbyMHoLEfhCRxYb5WA2kUzOgovCUWBThgx0VndXaxSkoNCUV210Tlq0Wl92OcLV09cUy+VsN+U4Kzmfxlu0D+VroTnLyEGfPLttnnnxq1TVj1FcG4b+ceDcltL1D+k4izs8ZMmX/WyFBljNTfv5/6xckwctvGd1RwZeTAE19v3vDtkbO3A11yayGtBtIywpxPrlx37NdEGqTVC27x5rPOuXWQVgPRo87vXTjvMCaErYG0GogWcXq33bpLgQ+FhoftqeCKU/A7ltrtPXHsSHBUSIUA0mogbamP/e5F23/zyOXpwnjwc/z36zcccgrV202/75Ogg8tmrDoekklufcby4Cz0NyvXH/eO1NtNH5l849tFn6w9E0UuMPE0huM9N3/x0Za+FRx61PXIRzW0tl97ZpL7VAIIuN99WENv26ipit/lih+GcvuDWiEycNOzRLcPcCCA9POtpil0NT5G5EwiZgDS+XcaTaqGGJnXx+PQgPu9NCGrES7x9sePdAi6KzKSy1+gB4LjK7lRC5HI9xy8fF4a1K9V3PhINACihmFC4trr3TylOPUAEhyO9fauaQ9uUrLyUz2HoTFWAfGsTjdwTwTXomQwS8O/cCDMufeED/9LBVfKfnhp64wt3vklcsOlgnIKlO/pdrddRl0MMvzLBDdl8OL99g+ppo/WkEE6u2HjgT8CGRpIqxOc3Rr7m7G6GRV9ILgPhq67QHrG7SqmIP6PTUt2nQjJ6liMxb47Vk1b/HNADKSzA5wXe2n1/D3nosgdJxIWeGy0mWz72934ms7T03VN1N0XE4qLez8soBcc0s+DVy4x2G5KcLyUh66TcOAg76iUOobG8Dj0yJkk7AAQ/Ca7tE6uSzIX6U4YBYI7n5UJFLzHD4hWGBBAOl+h0WSKbHsidtS1mDzJazZOO9Gt4FpgTlQYEgBRw/3ijewD85QlIYNBcJAD5iiF07qRK+fHrkCBw7CeBDZd2L7AkycXp59xcvo0LJn7VwSnm/iG/tAz+I5+tscbE5ztlCWnfavfRsFp2AJ6GGrV2MnTp1++X1ADFdZWl8hMLYo2C44ceOLrpStOekd3nALW9sXftOCW2jlEPpZ2FaNK8j+wbMP286FPMmugQkNSiJtspwDrLnmS+brIeJ9vF6/bdSkyI6tDZBJ21cJJwFdX/SlVnXMojLFf8unifTczn8l7fV++huDUz696Ei1AcE50Wl51ZY2I3g7n4VYn7FAQBEKT2WK9LzIeOY/DgkBIEktY4BlAGI0GARCc+/B5FTt2IwGzPDlf2Osl4t0KrlmZ/iMSOQCFWpKUZ5SwkMqjRS5AIgG0w8j7Wa3xfFhe5O5PsMKi3sNgV6fod6mVvWpcslvBNcsqi9JvDCWQtj0taD17OYUZZ4dEAjjizNiMGhH9pZgh7m1p0KFc91OrP1vv9LCXpfrX6NEoqoyfFvhfxITx1tYWI8ZNnvlLdMHLKopYanTxzIIjB5742k4/imqSNy64nfpRVNO8uO2wY+7EYe9bWltPGI/ozC6UX9ELSKuBtPygq5tmjRs+cmwXkXsJt8trTJyiyGvjoo/XoONS6l53CLITryG42uR9bvjhIDgYi0OQHCeYJCqVJ9ELjp/rP5mAHoD0D6yMXkvEjECjBoAg4B7pn+hhgcMcLaL1sgNO2xPBVT2wQSIBEByCI5hO2Nlp2qPnRruoOJSnPhNIjuNJ+JFoEHDAjo1MqxHRayWmR127Exynvu7JT6SOZx9HxA4DQQCFGoTFTyA5TvW+dqagoleloS6hJv6y5z+LLkT27STWnvI68+DkJaxHF9dOGDdhnNWH02bs9UoSSzoMMpgF97YLzva73+Lbxhy6gh90ddMs24Po1Arq6xVCPm7bouVHr0Wzhb0tz9cQXH3KQTfCCBCcHZfFEfdgslXd473O2KFI559j/UfjcCtveIx0QA9A3vw2BD0cG3RXyOxlB5y2J4KriVuhq8E9ed3+Sr5aVugW4DjRyXG8I2YwCmPh9yBXbKJN3bNBhg70fRO1ueZpisPW6UuPxvDfyom+LSquSlCmNH6mwTXZCVdtJk3/7IBfZlvJ/s2Ca1Zw1GK6xkTO777gGiUMtYxldE/3RHDVdx13L7DddflBYVnnPjKNmK5WtP5OXoSi7D632fdHcmmFiUgRTa3oaqZIku/2hesP4TOolb2cE/AagoPJaG+iJQgCIQllAnbHhFWsWhFNqOA3t1Uq4YrAW46WDiAAggAqKIwVt80JO0S3RMk7mmxKFq+LCcEpmVVCmqh1XVqzOuskCgmgUIPvZnR+vViLklktpIkNFrFp5IxqIUNu2O8JcyW8uK8cMYNRmLF+cRWd5ieaEBzMb1Iwq0WvGCPuc8HxGsru4HZPXWkf0C8dcNpuBSfjZUdf+eZaKavDdrgqPfbPDXMOefBb8+654ATlEcT902yOe/MMIltUhUWRZ3eaFlxxSfTFfV8s+zmi7SC8KvKjOC9SqYlS6zPBNclp4ur8qqpScWvr5pW8IcGlR13cstXuVOjz0taNHMrtawlJEZBRWA8EB1OeEnbY2n6NjkgUdLjFFfTn153in8e/1EcWpaA2LbTZTop7IuoYScvyxCcUpNR3cZaa2DPrP9v6Z1Tiy94tzXkdwVXci3CbiAEBt7B7L6gqo9YxV0oJn+JEOJJfITDoOM5OcEFgdUa7/0xU7H/LcQwaBEBw+L2nr+7Y6iGdBacuCgRAh3OVbTPbS6/7OQAgapD3/TzjM7aoWdU5/oNxjr/S9MHNKnZBsttQrCeeyzKyIcwRcaJtkeBIgs/1l90LrkVBp2b7jSa5oZhdXZo+FlyLilKecPnH+au9yW/rYnu4Jvshev2nP/u/rKW3P9lgXmNVaqrLgS9P+VW1Tdblpdw5tcSk4PZP+fzorfYOBRU3Mezs6rkrLj0WsloLgi0oveN1dPa4afOP+SbV1dCMq2Z0TjrpxKYFXxPvq1SQVgM1K8jkjJs3/FNM5dxXguOyEsCjiwBgxuqfbiaou3+nVUmu//HNm/tacJrSbK8D67btITxI171Xq1GSGH47OC2NbHRwuDAZs81mxysFp4G0JdfObpu19hQqvoSqap2F0CStbEjDgTeDn1bS2iOLPY5umrHhAjGlnKZuj6yoT0H95heaw6R3eQo46ebOxRsOE3pZietGcK53HtTQ1G3bWbHLPQmDUODs6NTcWmaj7mqqOQJh+nkXx4m+MZkCYzUwomYQMQNAcMTdtCopl/fsxjgcGgDRhwv6oANOq4HSYrCDUCDgEZkn57VooEY5/VYYcgguPNVgWUVTxZ3xOPQAFGpJErlKqndci4pV9TJ5L+gwITiJA7cJjkNJcQdQDiOvxzwTMNu+dQvMrqlK2IVEjXK6eauu4w2sltLu3kXrVjKUKflamC+uK3INxnzsHd31Ykp29YuEb5BIAEec9TC7t011mCelPfC/8NWai/1WfdN2L7iX2Qm/zHvPYsrCg9gcdi7EIUMcMkRLzgo4amezxiNHlze/UU5lZwQiN1pOm386llcolHC1GqhFxVHUpWfePbcB8cmSK8Evq6j6IpPml9w5ufyzeauvBuoOyMwJDXfZtfv8f3eMtJz44bwt3ztRjEtEwYwLOrNq8dofAnLJEIdckhwU7var8ctCeLCkoo5DhthPn4bY71wwc8N5t0I2GeIU1tUa6xLmqASlNRwyxE5L8Ttpt2CO3WXPIjYZ4uTXvqw0EFle5rX/rh4CAO9NXH0YndnpCdkKVyUoq+WQIXb07V/s5s1af/p6JMQhQ3yKSGS02LZRWsmKu/rjylU7L3gUNDBU0or8oCPbNyw9RrrNbqArRGU5foe3rl9+wj2cJzbaUZDlfG6zzfbzmAQKGeKQswOQIRGBZQ26TzmKupKXHDLEvuP5/bLpi/fg78RBHDLEL5GaWKEFaTVQXQp49KtpX3z3c+jjNF3hF4bZ7/nxvN+TzA5Dn7WJvx1YM2Xe91ci09J1kfkhp7cf+jkk67ni1XdVPvG7ld//EfEQknP/0nwRrlREz8sImElyAJDX0RX5DN3CKTVHIKJFx7p+hNetcCjgGazZggpCl14jjkajBgbFpfPLIAEVYsVtdSFOIl1zZFKlHZ5PcM7vrviRIOpQfqVICWkZkdMImAFINyybruiTtzNS700hYQAQ3J9bwW+gZiS6DsU7bs827kWF+Yws30nO+PdRqMHhKZCACjVUsqgRC9DYj9xuBtYa3G9qjrgwCABBAES/jwsJb6iEBFRIUMmoyrzkAQ4jusxNMvVUU7Kqi0InEhzedySeLqzkVBdFPHCxcPU8lmdi0KAF5sklVKiO8jw/dBYSCYDYD93vRDVQq0WMv1og/CZBdo7f8V3rTsf1U++bju4GGUSFlXfO2+z/Ixi1ctKHE1v5ZPGaY/e5bXlX8smkI62fzlyy6pf7+VoNpILSHvy2vHWXOet34gvbtCXNp9w5s6Z1l1krNiFjU2m5QV5/dlntqqeEOu3Tx9tu2xdS1CGsmHL/173tGbbx5XdnvCsMjylMT/E4tMxE5OztJ7CZBhMpX2S4/LZ94qT5m89fi27o8hGUm+71k13noy3cdiXIqC7GSUSe3aT7dM05p7DUR7+f/kr351p7V9+IwNN7F06c9OHESV/uxtxNEhufhRFz8cg6/ZG3XyZlcdp+JBkxv+5e2/nstgfcH6V1OV+k+p7rj2u/aAvefTk6r4sX570IJ+xbMactct/VHk7irYm137L72PXUdMlfaKjCBZ63fOY6kya1siH5GUvM1TY8vRDgMd1g+095pS/lhjvmOfl7zjIImOT/ILPjmmVdZEXYPY9Zrj7ObLpcDWnhXIyP23SnsOheT/Fth3pvskt7JtuyTI8RNamyLzkR2xN2cZp2q73upkfNlZaGTzL8Xq1M8XA/mFveZQ5KVlVRWFvwJ15eJu2m1UAKUXloFLHT8Z0X+L/qdW+voFlZyUx3RP2w0af/Gqc6zP90xswbodh3x09obGppCfwPeVWnmb6iWcmqygvyvLjqSnRBvydjFpyZN0Wx746zrr4U7r/63XD/QsTM+NA/174NdtOaBWfGjCm4IgGV31DJ6wECxT/tjXX/JsyCM2OmE3AuxsdthqvT5B5wqZxj+v+3mXkLMAvOjBkz7yxmwZkxY+ad5f8eIxcqLxmIWgAAAABJRU5ErkJggg==" alt="" width="319" height="26" />

　　9、shutil.move(src, dst)
　　递归的去移动文件

　　10、shutil.make_archive(base_name, format,...)

　　创建压缩包并返回文件路径，例如：zip、tar

　　base_name： 压缩包的文件名，也可以是压缩包的路径。只是文件名时，则保存至当前目录，否则保存至指定路径，
　　　　如：www                        =>保存至当前路径
　　　　如：/Users/wupeiqi/www =>保存至/Users/wupeiqi/

　　format： 压缩包种类，“zip”, “tar”, “bztar”，“gztar”

　　root_dir： 要压缩的文件夹路径（默认当前目录）

　　owner： 用户，默认当前用户

　　group： 组，默认当前组

　　logger： 用于记录日志，通常是logging.Logger对象

 #将 /Users/wupeiqi/Downloads/test 下的文件打包放置当前程序目录
 import shutil
 ret = shutil.make_archive("wwwwwwwwww", 'gztar', root_dir='/Users/wupeiqi/Downloads/test')
 #将 /Users/wupeiqi/Downloads/test 下的文件打包放置 /Users/wupeiqi/目录
 import shutil
 ret = shutil.make_archive("/Users/wupeiqi/wwwwwwwwww", 'gztar', root_dir='/Users/wupeiqi/Downloads/test')

　　shutil 对压缩包的处理是调用 ZipFile 和 TarFile 两个模块来进行的，详细：

　　①、zipfile

 import zipfile
 # 压缩
 z = zipfile.ZipFile('laxi.zip', 'w')
 z.write('a.log')
 z.write('data.data')
 z.close()
 # 解压
 z = zipfile.ZipFile('laxi.zip', 'r')
 z.extractall()
 z.close()

　　②、tarfile

 import tarfile
 # 压缩
 tar = tarfile.open('your.tar','w')
 tar.add('/Users/wupeiqi/PycharmProjects/bbs2.zip', arcname='bbs2.zip')
 tar.add('/Users/wupeiqi/PycharmProjects/cmdb.zip', arcname='cmdb.zip')
 tar.close()
 # 解压
 tar = tarfile.open('your.tar','r')
 tar.extractall()  # 可设置解压地址
 tar.close()

　　③、ZipFile

 class ZipFile(object):
     """ Class with methods to open, read, write, close, list zip files.
 
     z = ZipFile(file, mode="r", compression=ZIP_STORED, allowZip64=False)
 
     file: Either the path to the file, or a file-like object.
           If it is a path, the file will be opened and closed by ZipFile.
     mode: The mode can be either read "r", write "w" or append "a".
     compression: ZIP_STORED (no compression) or ZIP_DEFLATED (requires zlib).
     allowZip64: if True ZipFile will create files with ZIP64 extensions when
                 needed, otherwise it will raise an exception when this would
                 be necessary.
 
     """
 
     fp = None                   # Set here since __del__ checks it
 
     def __init__(self, file, mode="r", compression=ZIP_STORED, allowZip64=False):
         """Open the ZIP file with mode read "r", write "w" or append "a"."""
         if mode not in ("r", "w", "a"):
             raise RuntimeError('ZipFile() requires mode "r", "w", or "a"')
 
         if compression == ZIP_STORED:
             pass
         elif compression == ZIP_DEFLATED:
             if not zlib:
                 raise RuntimeError,\
                       "Compression requires the (missing) zlib module"
         else:
             raise RuntimeError, "That compression method is not supported"
 
         self._allowZip64 = allowZip64
         self._didModify = False
         self.debug = 0  # Level of printing: 0 through 3
         self.NameToInfo = {}    # Find file info given name
         self.filelist = []      # List of ZipInfo instances for archive
         self.compression = compression  # Method of compression
         self.mode = key = mode.replace('b', '')[0]
         self.pwd = None
         self._comment = ''
 
         # Check if we were passed a file-like object
         if isinstance(file, basestring):
             self._filePassed = 0
             self.filename = file
             modeDict = {'r' : 'rb', 'w': 'wb', 'a' : 'r+b'}
             try:
                 self.fp = open(file, modeDict[mode])
             except IOError:
                 if mode == 'a':
                     mode = key = 'w'
                     self.fp = open(file, modeDict[mode])
                 else:
                     raise
         else:
             self._filePassed = 1
             self.fp = file
             self.filename = getattr(file, 'name', None)
 
         try:
             if key == 'r':
                 self._RealGetContents()
             elif key == 'w':
                 # set the modified flag so central directory gets written
                 # even if no files are added to the archive
                 self._didModify = True
             elif key == 'a':
                 try:
                     # See if file is a zip file
                     self._RealGetContents()
                     # seek to start of directory and overwrite
                     self.fp.seek(self.start_dir, 0)
                 except BadZipfile:
                     # file is not a zip file, just append
                     self.fp.seek(0, 2)
 
                     # set the modified flag so central directory gets written
                     # even if no files are added to the archive
                     self._didModify = True
             else:
                 raise RuntimeError('Mode must be "r", "w" or "a"')
         except:
             fp = self.fp
             self.fp = None
             if not self._filePassed:
                 fp.close()
             raise
 
     def __enter__(self):
         return self
 
     def __exit__(self, type, value, traceback):
         self.close()
 
     def _RealGetContents(self):
         """Read in the table of contents for the ZIP file."""
         fp = self.fp
         try:
             endrec = _EndRecData(fp)
         except IOError:
             raise BadZipfile("File is not a zip file")
         if not endrec:
             raise BadZipfile, "File is not a zip file"
         if self.debug > 1:
             print endrec
         size_cd = endrec[_ECD_SIZE]             # bytes in central directory
         offset_cd = endrec[_ECD_OFFSET]         # offset of central directory
         self._comment = endrec[_ECD_COMMENT]    # archive comment
 
         # "concat" is zero, unless zip was concatenated to another file
         concat = endrec[_ECD_LOCATION] - size_cd - offset_cd
         if endrec[_ECD_SIGNATURE] == stringEndArchive64:
             # If Zip64 extension structures are present, account for them
             concat -= (sizeEndCentDir64 + sizeEndCentDir64Locator)
 
         if self.debug > 2:
             inferred = concat + offset_cd
             print "given, inferred, offset", offset_cd, inferred, concat
         # self.start_dir:  Position of start of central directory
         self.start_dir = offset_cd + concat
         fp.seek(self.start_dir, 0)
         data = fp.read(size_cd)
         fp = cStringIO.StringIO(data)
         total = 0
         while total < size_cd:
             centdir = fp.read(sizeCentralDir)
             if len(centdir) != sizeCentralDir:
                 raise BadZipfile("Truncated central directory")
             centdir = struct.unpack(structCentralDir, centdir)
             if centdir[_CD_SIGNATURE] != stringCentralDir:
                 raise BadZipfile("Bad magic number for central directory")
             if self.debug > 2:
                 print centdir
             filename = fp.read(centdir[_CD_FILENAME_LENGTH])
             # Create ZipInfo instance to store file information
             x = ZipInfo(filename)
             x.extra = fp.read(centdir[_CD_EXTRA_FIELD_LENGTH])
             x.comment = fp.read(centdir[_CD_COMMENT_LENGTH])
             x.header_offset = centdir[_CD_LOCAL_HEADER_OFFSET]
             (x.create_version, x.create_system, x.extract_version, x.reserved,
                 x.flag_bits, x.compress_type, t, d,
                 x.CRC, x.compress_size, x.file_size) = centdir[1:12]
             x.volume, x.internal_attr, x.external_attr = centdir[15:18]
             # Convert date/time code to (year, month, day, hour, min, sec)
             x._raw_time = t
             x.date_time = ( (d>>9)+1980, (d>>5)&0xF, d&0x1F,
                                      t>>11, (t>>5)&0x3F, (t&0x1F) * 2 )
 
             x._decodeExtra()
             x.header_offset = x.header_offset + concat
             x.filename = x._decodeFilename()
             self.filelist.append(x)
             self.NameToInfo[x.filename] = x
 
             # update total bytes read from central directory
             total = (total + sizeCentralDir + centdir[_CD_FILENAME_LENGTH]
                      + centdir[_CD_EXTRA_FIELD_LENGTH]
                      + centdir[_CD_COMMENT_LENGTH])
 
             if self.debug > 2:
                 print "total", total
 
     def namelist(self):
         """Return a list of file names in the archive."""
         l = []
         for data in self.filelist:
             l.append(data.filename)
         return l
 
     def infolist(self):
         """Return a list of class ZipInfo instances for files in the
         archive."""
         return self.filelist
 
     def printdir(self):
         """Print a table of contents for the zip file."""
         print "%-46s %19s %12s" % ("File Name", "Modified    ", "Size")
         for zinfo in self.filelist:
             date = "%d-%02d-%02d %02d:%02d:%02d" % zinfo.date_time[:6]
             print "%-46s %s %12d" % (zinfo.filename, date, zinfo.file_size)
 
     def testzip(self):
         """Read all the files and check the CRC."""
         chunk_size = 2 ** 20
         for zinfo in self.filelist:
             try:
                 # Read by chunks, to avoid an OverflowError or a
                 # MemoryError with very large embedded files.
                 with self.open(zinfo.filename, "r") as f:
                     while f.read(chunk_size):     # Check CRC-32
                         pass
             except BadZipfile:
                 return zinfo.filename
 
     def getinfo(self, name):
         """Return the instance of ZipInfo given 'name'."""
         info = self.NameToInfo.get(name)
         if info is None:
             raise KeyError(
                 'There is no item named %r in the archive' % name)
 
         return info
 
     def setpassword(self, pwd):
         """Set default password for encrypted files."""
         self.pwd = pwd
 
     @property
     def comment(self):
         """The comment text associated with the ZIP file."""
         return self._comment
 
     @comment.setter
     def comment(self, comment):
         # check for valid comment length
         if len(comment) > ZIP_MAX_COMMENT:
             import warnings
             warnings.warn('Archive comment is too long; truncating to %d bytes'
                           % ZIP_MAX_COMMENT, stacklevel=2)
             comment = comment[:ZIP_MAX_COMMENT]
         self._comment = comment
         self._didModify = True
 
     def read(self, name, pwd=None):
         """Return file bytes (as a string) for name."""
         return self.open(name, "r", pwd).read()
 
     def open(self, name, mode="r", pwd=None):
         """Return file-like object for 'name'."""
         if mode not in ("r", "U", "rU"):
             raise RuntimeError, 'open() requires mode "r", "U", or "rU"'
         if not self.fp:
             raise RuntimeError, \
                   "Attempt to read ZIP archive that was already closed"
 
         # Only open a new file for instances where we were not
         # given a file object in the constructor
         if self._filePassed:
             zef_file = self.fp
             should_close = False
         else:
             zef_file = open(self.filename, 'rb')
             should_close = True
 
         try:
             # Make sure we have an info object
             if isinstance(name, ZipInfo):
                 # 'name' is already an info object
                 zinfo = name
             else:
                 # Get info object for name
                 zinfo = self.getinfo(name)
 
             zef_file.seek(zinfo.header_offset, 0)
 
             # Skip the file header:
             fheader = zef_file.read(sizeFileHeader)
             if len(fheader) != sizeFileHeader:
                 raise BadZipfile("Truncated file header")
             fheader = struct.unpack(structFileHeader, fheader)
             if fheader[_FH_SIGNATURE] != stringFileHeader:
                 raise BadZipfile("Bad magic number for file header")
 
             fname = zef_file.read(fheader[_FH_FILENAME_LENGTH])
             if fheader[_FH_EXTRA_FIELD_LENGTH]:
                 zef_file.read(fheader[_FH_EXTRA_FIELD_LENGTH])
 
             if fname != zinfo.orig_filename:
                 raise BadZipfile, \
                         'File name in directory "%s" and header "%s" differ.' % (
                             zinfo.orig_filename, fname)
 
             # check for encrypted flag & handle password
             is_encrypted = zinfo.flag_bits & 0x1
             zd = None
             if is_encrypted:
                 if not pwd:
                     pwd = self.pwd
                 if not pwd:
                     raise RuntimeError, "File %s is encrypted, " \
                         "password required for extraction" % name
 
                 zd = _ZipDecrypter(pwd)
                 # The first 12 bytes in the cypher stream is an encryption header
                 #  used to strengthen the algorithm. The first 11 bytes are
                 #  completely random, while the 12th contains the MSB of the CRC,
                 #  or the MSB of the file time depending on the header type
                 #  and is used to check the correctness of the password.
                 bytes = zef_file.read(12)
                 h = map(zd, bytes[0:12])
                 if zinfo.flag_bits & 0x8:
                     # compare against the file type from extended local headers
                     check_byte = (zinfo._raw_time >> 8) & 0xff
                 else:
                     # compare against the CRC otherwise
                     check_byte = (zinfo.CRC >> 24) & 0xff
                 if ord(h[11]) != check_byte:
                     raise RuntimeError("Bad password for file", name)
 
             return ZipExtFile(zef_file, mode, zinfo, zd,
                     close_fileobj=should_close)
         except:
             if should_close:
                 zef_file.close()
             raise
 
     def extract(self, member, path=None, pwd=None):
         """Extract a member from the archive to the current working directory,
            using its full name. Its file information is extracted as accurately
            as possible. `member' may be a filename or a ZipInfo object. You can
            specify a different directory using `path'.
         """
         if not isinstance(member, ZipInfo):
             member = self.getinfo(member)
 
         if path is None:
             path = os.getcwd()
 
         return self._extract_member(member, path, pwd)
 
     def extractall(self, path=None, members=None, pwd=None):
         """Extract all members from the archive to the current working
            directory. `path' specifies a different directory to extract to.
            `members' is optional and must be a subset of the list returned
            by namelist().
         """
         if members is None:
             members = self.namelist()
 
         for zipinfo in members:
             self.extract(zipinfo, path, pwd)
 
     def _extract_member(self, member, targetpath, pwd):
         """Extract the ZipInfo object 'member' to a physical
            file on the path targetpath.
         """
         # build the destination pathname, replacing
         # forward slashes to platform specific separators.
         arcname = member.filename.replace('/', os.path.sep)
 
         if os.path.altsep:
             arcname = arcname.replace(os.path.altsep, os.path.sep)
         # interpret absolute pathname as relative, remove drive letter or
         # UNC path, redundant separators, "." and ".." components.
         arcname = os.path.splitdrive(arcname)[1]
         arcname = os.path.sep.join(x for x in arcname.split(os.path.sep)
                     if x not in ('', os.path.curdir, os.path.pardir))
         if os.path.sep == '\\':
             # filter illegal characters on Windows
             illegal = ':<>|"?*'
             if isinstance(arcname, unicode):
                 table = {ord(c): ord('_') for c in illegal}
             else:
                 table = string.maketrans(illegal, '_' * len(illegal))
             arcname = arcname.translate(table)
             # remove trailing dots
             arcname = (x.rstrip('.') for x in arcname.split(os.path.sep))
             arcname = os.path.sep.join(x for x in arcname if x)
 
         targetpath = os.path.join(targetpath, arcname)
         targetpath = os.path.normpath(targetpath)
 
         # Create all upper directories if necessary.
         upperdirs = os.path.dirname(targetpath)
         if upperdirs and not os.path.exists(upperdirs):
             os.makedirs(upperdirs)
 
         if member.filename[-1] == '/':
             if not os.path.isdir(targetpath):
                 os.mkdir(targetpath)
             return targetpath
 
         with self.open(member, pwd=pwd) as source, \
              file(targetpath, "wb") as target:
             shutil.copyfileobj(source, target)
 
         return targetpath
 
     def _writecheck(self, zinfo):
         """Check for errors before writing a file to the archive."""
         if zinfo.filename in self.NameToInfo:
             import warnings
             warnings.warn('Duplicate name: %r' % zinfo.filename, stacklevel=3)
         if self.mode not in ("w", "a"):
             raise RuntimeError, 'write() requires mode "w" or "a"'
         if not self.fp:
             raise RuntimeError, \
                   "Attempt to write ZIP archive that was already closed"
         if zinfo.compress_type == ZIP_DEFLATED and not zlib:
             raise RuntimeError, \
                   "Compression requires the (missing) zlib module"
         if zinfo.compress_type not in (ZIP_STORED, ZIP_DEFLATED):
             raise RuntimeError, \
                   "That compression method is not supported"
         if not self._allowZip64:
             requires_zip64 = None
             if len(self.filelist) >= ZIP_FILECOUNT_LIMIT:
                 requires_zip64 = "Files count"
             elif zinfo.file_size > ZIP64_LIMIT:
                 requires_zip64 = "Filesize"
             elif zinfo.header_offset > ZIP64_LIMIT:
                 requires_zip64 = "Zipfile size"
             if requires_zip64:
                 raise LargeZipFile(requires_zip64 +
                                    " would require ZIP64 extensions")
 
     def write(self, filename, arcname=None, compress_type=None):
         """Put the bytes from filename into the archive under the name
         arcname."""
         if not self.fp:
             raise RuntimeError(
                   "Attempt to write to ZIP archive that was already closed")
 
         st = os.stat(filename)
         isdir = stat.S_ISDIR(st.st_mode)
         mtime = time.localtime(st.st_mtime)
         date_time = mtime[0:6]
         # Create ZipInfo instance to store file information
         if arcname is None:
             arcname = filename
         arcname = os.path.normpath(os.path.splitdrive(arcname)[1])
         while arcname[0] in (os.sep, os.altsep):
             arcname = arcname[1:]
         if isdir:
             arcname += '/'
         zinfo = ZipInfo(arcname, date_time)
         zinfo.external_attr = (st[0] & 0xFFFF) << 16L      # Unix attributes
         if compress_type is None:
             zinfo.compress_type = self.compression
         else:
             zinfo.compress_type = compress_type
 
         zinfo.file_size = st.st_size
         zinfo.flag_bits = 0x00
         zinfo.header_offset = self.fp.tell()    # Start of header bytes
 
         self._writecheck(zinfo)
         self._didModify = True
 
         if isdir:
             zinfo.file_size = 0
             zinfo.compress_size = 0
             zinfo.CRC = 0
             zinfo.external_attr |= 0x10  # MS-DOS directory flag
             self.filelist.append(zinfo)
             self.NameToInfo[zinfo.filename] = zinfo
             self.fp.write(zinfo.FileHeader(False))
             return
 
         with open(filename, "rb") as fp:
             # Must overwrite CRC and sizes with correct data later
             zinfo.CRC = CRC = 0
             zinfo.compress_size = compress_size = 0
             # Compressed size can be larger than uncompressed size
             zip64 = self._allowZip64 and \
                     zinfo.file_size * 1.05 > ZIP64_LIMIT
             self.fp.write(zinfo.FileHeader(zip64))
             if zinfo.compress_type == ZIP_DEFLATED:
                 cmpr = zlib.compressobj(zlib.Z_DEFAULT_COMPRESSION,
                      zlib.DEFLATED, -15)
             else:
                 cmpr = None
             file_size = 0
             while 1:
                 buf = fp.read(1024 * 8)
                 if not buf:
                     break
                 file_size = file_size + len(buf)
                 CRC = crc32(buf, CRC) & 0xffffffff
                 if cmpr:
                     buf = cmpr.compress(buf)
                     compress_size = compress_size + len(buf)
                 self.fp.write(buf)
         if cmpr:
             buf = cmpr.flush()
             compress_size = compress_size + len(buf)
             self.fp.write(buf)
             zinfo.compress_size = compress_size
         else:
             zinfo.compress_size = file_size
         zinfo.CRC = CRC
         zinfo.file_size = file_size
         if not zip64 and self._allowZip64:
             if file_size > ZIP64_LIMIT:
                 raise RuntimeError('File size has increased during compressing')
             if compress_size > ZIP64_LIMIT:
                 raise RuntimeError('Compressed size larger than uncompressed size')
         # Seek backwards and write file header (which will now include
         # correct CRC and file sizes)
         position = self.fp.tell()       # Preserve current position in file
         self.fp.seek(zinfo.header_offset, 0)
         self.fp.write(zinfo.FileHeader(zip64))
         self.fp.seek(position, 0)
         self.filelist.append(zinfo)
         self.NameToInfo[zinfo.filename] = zinfo
 
     def writestr(self, zinfo_or_arcname, bytes, compress_type=None):
         """Write a file into the archive.  The contents is the string
         'bytes'.  'zinfo_or_arcname' is either a ZipInfo instance or
         the name of the file in the archive."""
         if not isinstance(zinfo_or_arcname, ZipInfo):
             zinfo = ZipInfo(filename=zinfo_or_arcname,
                             date_time=time.localtime(time.time())[:6])
 
             zinfo.compress_type = self.compression
             if zinfo.filename[-1] == '/':
                 zinfo.external_attr = 0o40775 << 16   # drwxrwxr-x
                 zinfo.external_attr |= 0x10           # MS-DOS directory flag
             else:
                 zinfo.external_attr = 0o600 << 16     # ?rw-------
         else:
             zinfo = zinfo_or_arcname
 
         if not self.fp:
             raise RuntimeError(
                   "Attempt to write to ZIP archive that was already closed")
 
         if compress_type is not None:
             zinfo.compress_type = compress_type
 
         zinfo.file_size = len(bytes)            # Uncompressed size
         zinfo.header_offset = self.fp.tell()    # Start of header bytes
         self._writecheck(zinfo)
         self._didModify = True
         zinfo.CRC = crc32(bytes) & 0xffffffff       # CRC-32 checksum
         if zinfo.compress_type == ZIP_DEFLATED:
             co = zlib.compressobj(zlib.Z_DEFAULT_COMPRESSION,
                  zlib.DEFLATED, -15)
             bytes = co.compress(bytes) + co.flush()
             zinfo.compress_size = len(bytes)    # Compressed size
         else:
             zinfo.compress_size = zinfo.file_size
         zip64 = zinfo.file_size > ZIP64_LIMIT or \
                 zinfo.compress_size > ZIP64_LIMIT
         if zip64 and not self._allowZip64:
             raise LargeZipFile("Filesize would require ZIP64 extensions")
         self.fp.write(zinfo.FileHeader(zip64))
         self.fp.write(bytes)
         if zinfo.flag_bits & 0x08:
             # Write CRC and file sizes after the file data
             fmt = '<LQQ' if zip64 else '<LLL'
             self.fp.write(struct.pack(fmt, zinfo.CRC, zinfo.compress_size,
                   zinfo.file_size))
         self.fp.flush()
         self.filelist.append(zinfo)
         self.NameToInfo[zinfo.filename] = zinfo
 
     def __del__(self):
         """Call the "close()" method in case the user forgot."""
         self.close()
 
     def close(self):
         """Close the file, and for mode "w" and "a" write the ending
         records."""
         if self.fp is None:
             return
 
         try:
             if self.mode in ("w", "a") and self._didModify: # write ending records
                 pos1 = self.fp.tell()
                 for zinfo in self.filelist:         # write central directory
                     dt = zinfo.date_time
                     dosdate = (dt[0] - 1980) << 9 | dt[1] << 5 | dt[2]
                     dostime = dt[3] << 11 | dt[4] << 5 | (dt[5] // 2)
                     extra = []
                     if zinfo.file_size > ZIP64_LIMIT \
                             or zinfo.compress_size > ZIP64_LIMIT:
                         extra.append(zinfo.file_size)
                         extra.append(zinfo.compress_size)
                         file_size = 0xffffffff
                         compress_size = 0xffffffff
                     else:
                         file_size = zinfo.file_size
                         compress_size = zinfo.compress_size
 
                     if zinfo.header_offset > ZIP64_LIMIT:
                         extra.append(zinfo.header_offset)
                         header_offset = 0xffffffffL
                     else:
                         header_offset = zinfo.header_offset
 
                     extra_data = zinfo.extra
                     if extra:
                         # Append a ZIP64 field to the extra's
                         extra_data = struct.pack(
                                 '<HH' + 'Q'*len(extra),
                                 1, 8*len(extra), *extra) + extra_data
 
                         extract_version = max(45, zinfo.extract_version)
                         create_version = max(45, zinfo.create_version)
                     else:
                         extract_version = zinfo.extract_version
                         create_version = zinfo.create_version
 
                     try:
                         filename, flag_bits = zinfo._encodeFilenameFlags()
                         centdir = struct.pack(structCentralDir,
                         stringCentralDir, create_version,
                         zinfo.create_system, extract_version, zinfo.reserved,
                         flag_bits, zinfo.compress_type, dostime, dosdate,
                         zinfo.CRC, compress_size, file_size,
                         len(filename), len(extra_data), len(zinfo.comment),
                         0, zinfo.internal_attr, zinfo.external_attr,
                         header_offset)
                     except DeprecationWarning:
                         print >>sys.stderr, (structCentralDir,
                         stringCentralDir, create_version,
                         zinfo.create_system, extract_version, zinfo.reserved,
                         zinfo.flag_bits, zinfo.compress_type, dostime, dosdate,
                         zinfo.CRC, compress_size, file_size,
                         len(zinfo.filename), len(extra_data), len(zinfo.comment),
                         0, zinfo.internal_attr, zinfo.external_attr,
                         header_offset)
                         raise
                     self.fp.write(centdir)
                     self.fp.write(filename)
                     self.fp.write(extra_data)
                     self.fp.write(zinfo.comment)
 
                 pos2 = self.fp.tell()
                 # Write end-of-zip-archive record
                 centDirCount = len(self.filelist)
                 centDirSize = pos2 - pos1
                 centDirOffset = pos1
                 requires_zip64 = None
                 if centDirCount > ZIP_FILECOUNT_LIMIT:
                     requires_zip64 = "Files count"
                 elif centDirOffset > ZIP64_LIMIT:
                     requires_zip64 = "Central directory offset"
                 elif centDirSize > ZIP64_LIMIT:
                     requires_zip64 = "Central directory size"
                 if requires_zip64:
                     # Need to write the ZIP64 end-of-archive records
                     if not self._allowZip64:
                         raise LargeZipFile(requires_zip64 +
                                            " would require ZIP64 extensions")
                     zip64endrec = struct.pack(
                             structEndArchive64, stringEndArchive64,
                             44, 45, 45, 0, 0, centDirCount, centDirCount,
                             centDirSize, centDirOffset)
                     self.fp.write(zip64endrec)
 
                     zip64locrec = struct.pack(
                             structEndArchive64Locator,
                             stringEndArchive64Locator, 0, pos2, 1)
                     self.fp.write(zip64locrec)
                     centDirCount = min(centDirCount, 0xFFFF)
                     centDirSize = min(centDirSize, 0xFFFFFFFF)
                     centDirOffset = min(centDirOffset, 0xFFFFFFFF)
 
                 endrec = struct.pack(structEndArchive, stringEndArchive,
                                     0, 0, centDirCount, centDirCount,
                                     centDirSize, centDirOffset, len(self._comment))
                 self.fp.write(endrec)
                 self.fp.write(self._comment)
                 self.fp.flush()
         finally:
             fp = self.fp
             self.fp = None
             if not self._filePassed:
                 fp.close()

　　④、TarFile

 class TarFile(object):
     """The TarFile Class provides an interface to tar archives.
     """
 
     debug = 0                   # May be set from 0 (no msgs) to 3 (all msgs)
 
     dereference = False         # If true, add content of linked file to the
                                 # tar file, else the link.
 
     ignore_zeros = False        # If true, skips empty or invalid blocks and
                                 # continues processing.
 
     errorlevel = 1              # If 0, fatal errors only appear in debug
                                 # messages (if debug >= 0). If > 0, errors
                                 # are passed to the caller as exceptions.
 
     format = DEFAULT_FORMAT     # The format to use when creating an archive.
 
     encoding = ENCODING         # Encoding for 8-bit character strings.
 
     errors = None               # Error handler for unicode conversion.
 
     tarinfo = TarInfo           # The default TarInfo class to use.
 
     fileobject = ExFileObject   # The default ExFileObject class to use.
 
     def __init__(self, name=None, mode="r", fileobj=None, format=None,
             tarinfo=None, dereference=None, ignore_zeros=None, encoding=None,
             errors=None, pax_headers=None, debug=None, errorlevel=None):
         """Open an (uncompressed) tar archive `name'. `mode' is either 'r' to
            read from an existing archive, 'a' to append data to an existing
            file or 'w' to create a new file overwriting an existing one. `mode'
            defaults to 'r'.
            If `fileobj' is given, it is used for reading or writing data. If it
            can be determined, `mode' is overridden by `fileobj's mode.
            `fileobj' is not closed, when TarFile is closed.
         """
         modes = {"r": "rb", "a": "r+b", "w": "wb"}
         if mode not in modes:
             raise ValueError("mode must be 'r', 'a' or 'w'")
         self.mode = mode
         self._mode = modes[mode]
 
         if not fileobj:
             if self.mode == "a" and not os.path.exists(name):
                 # Create nonexistent files in append mode.
                 self.mode = "w"
                 self._mode = "wb"
             fileobj = bltn_open(name, self._mode)
             self._extfileobj = False
         else:
             if name is None and hasattr(fileobj, "name"):
                 name = fileobj.name
             if hasattr(fileobj, "mode"):
                 self._mode = fileobj.mode
             self._extfileobj = True
         self.name = os.path.abspath(name) if name else None
         self.fileobj = fileobj
 
         # Init attributes.
         if format is not None:
             self.format = format
         if tarinfo is not None:
             self.tarinfo = tarinfo
         if dereference is not None:
             self.dereference = dereference
         if ignore_zeros is not None:
             self.ignore_zeros = ignore_zeros
         if encoding is not None:
             self.encoding = encoding
 
         if errors is not None:
             self.errors = errors
         elif mode == "r":
             self.errors = "utf-8"
         else:
             self.errors = "strict"
 
         if pax_headers is not None and self.format == PAX_FORMAT:
             self.pax_headers = pax_headers
         else:
             self.pax_headers = {}
 
         if debug is not None:
             self.debug = debug
         if errorlevel is not None:
             self.errorlevel = errorlevel
 
         # Init datastructures.
         self.closed = False
         self.members = []       # list of members as TarInfo objects
         self._loaded = False    # flag if all members have been read
         self.offset = self.fileobj.tell()
                                 # current position in the archive file
         self.inodes = {}        # dictionary caching the inodes of
                                 # archive members already added
 
         try:
             if self.mode == "r":
                 self.firstmember = None
                 self.firstmember = self.next()
 
             if self.mode == "a":
                 # Move to the end of the archive,
                 # before the first empty block.
                 while True:
                     self.fileobj.seek(self.offset)
                     try:
                         tarinfo = self.tarinfo.fromtarfile(self)
                         self.members.append(tarinfo)
                     except EOFHeaderError:
                         self.fileobj.seek(self.offset)
                         break
                     except HeaderError, e:
                         raise ReadError(str(e))
 
             if self.mode in "aw":
                 self._loaded = True
 
                 if self.pax_headers:
                     buf = self.tarinfo.create_pax_global_header(self.pax_headers.copy())
                     self.fileobj.write(buf)
                     self.offset += len(buf)
         except:
             if not self._extfileobj:
                 self.fileobj.close()
             self.closed = True
             raise
 
     def _getposix(self):
         return self.format == USTAR_FORMAT
     def _setposix(self, value):
         import warnings
         warnings.warn("use the format attribute instead", DeprecationWarning,
                       2)
         if value:
             self.format = USTAR_FORMAT
         else:
             self.format = GNU_FORMAT
     posix = property(_getposix, _setposix)
 
     #--------------------------------------------------------------------------
     # Below are the classmethods which act as alternate constructors to the
     # TarFile class. The open() method is the only one that is needed for
     # public use; it is the "super"-constructor and is able to select an
     # adequate "sub"-constructor for a particular compression using the mapping
     # from OPEN_METH.
     #
     # This concept allows one to subclass TarFile without losing the comfort of
     # the super-constructor. A sub-constructor is registered and made available
     # by adding it to the mapping in OPEN_METH.
 
     @classmethod
     def open(cls, name=None, mode="r", fileobj=None, bufsize=RECORDSIZE, **kwargs):
         """Open a tar archive for reading, writing or appending. Return
            an appropriate TarFile class.
 
            mode:
            'r' or 'r:*' open for reading with transparent compression
            'r:'         open for reading exclusively uncompressed
            'r:gz'       open for reading with gzip compression
            'r:bz2'      open for reading with bzip2 compression
            'a' or 'a:'  open for appending, creating the file if necessary
            'w' or 'w:'  open for writing without compression
            'w:gz'       open for writing with gzip compression
            'w:bz2'      open for writing with bzip2 compression
 
            'r|*'        open a stream of tar blocks with transparent compression
            'r|'         open an uncompressed stream of tar blocks for reading
            'r|gz'       open a gzip compressed stream of tar blocks
            'r|bz2'      open a bzip2 compressed stream of tar blocks
            'w|'         open an uncompressed stream for writing
            'w|gz'       open a gzip compressed stream for writing
            'w|bz2'      open a bzip2 compressed stream for writing
         """
 
         if not name and not fileobj:
             raise ValueError("nothing to open")
 
         if mode in ("r", "r:*"):
             # Find out which *open() is appropriate for opening the file.
             for comptype in cls.OPEN_METH:
                 func = getattr(cls, cls.OPEN_METH[comptype])
                 if fileobj is not None:
                     saved_pos = fileobj.tell()
                 try:
                     return func(name, "r", fileobj, **kwargs)
                 except (ReadError, CompressionError), e:
                     if fileobj is not None:
                         fileobj.seek(saved_pos)
                     continue
             raise ReadError("file could not be opened successfully")
 
         elif ":" in mode:
             filemode, comptype = mode.split(":", 1)
             filemode = filemode or "r"
             comptype = comptype or "tar"
 
             # Select the *open() function according to
             # given compression.
             if comptype in cls.OPEN_METH:
                 func = getattr(cls, cls.OPEN_METH[comptype])
             else:
                 raise CompressionError("unknown compression type %r" % comptype)
             return func(name, filemode, fileobj, **kwargs)
 
         elif "|" in mode:
             filemode, comptype = mode.split("|", 1)
             filemode = filemode or "r"
             comptype = comptype or "tar"
 
             if filemode not in ("r", "w"):
                 raise ValueError("mode must be 'r' or 'w'")
 
             stream = _Stream(name, filemode, comptype, fileobj, bufsize)
             try:
                 t = cls(name, filemode, stream, **kwargs)
             except:
                 stream.close()
                 raise
             t._extfileobj = False
             return t
 
         elif mode in ("a", "w"):
             return cls.taropen(name, mode, fileobj, **kwargs)
 
         raise ValueError("undiscernible mode")
 
     @classmethod
     def taropen(cls, name, mode="r", fileobj=None, **kwargs):
         """Open uncompressed tar archive name for reading or writing.
         """
         if mode not in ("r", "a", "w"):
             raise ValueError("mode must be 'r', 'a' or 'w'")
         return cls(name, mode, fileobj, **kwargs)
 
     @classmethod
     def gzopen(cls, name, mode="r", fileobj=None, compresslevel=9, **kwargs):
         """Open gzip compressed tar archive name for reading or writing.
            Appending is not allowed.
         """
         if mode not in ("r", "w"):
             raise ValueError("mode must be 'r' or 'w'")
 
         try:
             import gzip
             gzip.GzipFile
         except (ImportError, AttributeError):
             raise CompressionError("gzip module is not available")
 
         try:
             fileobj = gzip.GzipFile(name, mode, compresslevel, fileobj)
         except OSError:
             if fileobj is not None and mode == 'r':
                 raise ReadError("not a gzip file")
             raise
 
         try:
             t = cls.taropen(name, mode, fileobj, **kwargs)
         except IOError:
             fileobj.close()
             if mode == 'r':
                 raise ReadError("not a gzip file")
             raise
         except:
             fileobj.close()
             raise
         t._extfileobj = False
         return t
 
     @classmethod
     def bz2open(cls, name, mode="r", fileobj=None, compresslevel=9, **kwargs):
         """Open bzip2 compressed tar archive name for reading or writing.
            Appending is not allowed.
         """
         if mode not in ("r", "w"):
             raise ValueError("mode must be 'r' or 'w'.")
 
         try:
             import bz2
         except ImportError:
             raise CompressionError("bz2 module is not available")
 
         if fileobj is not None:
             fileobj = _BZ2Proxy(fileobj, mode)
         else:
             fileobj = bz2.BZ2File(name, mode, compresslevel=compresslevel)
 
         try:
             t = cls.taropen(name, mode, fileobj, **kwargs)
         except (IOError, EOFError):
             fileobj.close()
             if mode == 'r':
                 raise ReadError("not a bzip2 file")
             raise
         except:
             fileobj.close()
             raise
         t._extfileobj = False
         return t
 
     # All *open() methods are registered here.
     OPEN_METH = {
         "tar": "taropen",   # uncompressed tar
         "gz":  "gzopen",    # gzip compressed tar
         "bz2": "bz2open"    # bzip2 compressed tar
     }
 
     #--------------------------------------------------------------------------
     # The public methods which TarFile provides:
 
     def close(self):
         """Close the TarFile. In write-mode, two finishing zero blocks are
            appended to the archive.
         """
         if self.closed:
             return
 
         if self.mode in "aw":
             self.fileobj.write(NUL * (BLOCKSIZE * 2))
             self.offset += (BLOCKSIZE * 2)
             # fill up the end with zero-blocks
             # (like option -b20 for tar does)
             blocks, remainder = divmod(self.offset, RECORDSIZE)
             if remainder > 0:
                 self.fileobj.write(NUL * (RECORDSIZE - remainder))
 
         if not self._extfileobj:
             self.fileobj.close()
         self.closed = True
 
     def getmember(self, name):
         """Return a TarInfo object for member `name'. If `name' can not be
            found in the archive, KeyError is raised. If a member occurs more
            than once in the archive, its last occurrence is assumed to be the
            most up-to-date version.
         """
         tarinfo = self._getmember(name)
         if tarinfo is None:
             raise KeyError("filename %r not found" % name)
         return tarinfo
 
     def getmembers(self):
         """Return the members of the archive as a list of TarInfo objects. The
            list has the same order as the members in the archive.
         """
         self._check()
         if not self._loaded:    # if we want to obtain a list of
             self._load()        # all members, we first have to
                                 # scan the whole archive.
         return self.members
 
     def getnames(self):
         """Return the members of the archive as a list of their names. It has
            the same order as the list returned by getmembers().
         """
         return [tarinfo.name for tarinfo in self.getmembers()]
 
     def gettarinfo(self, name=None, arcname=None, fileobj=None):
         """Create a TarInfo object for either the file `name' or the file
            object `fileobj' (using os.fstat on its file descriptor). You can
            modify some of the TarInfo's attributes before you add it using
            addfile(). If given, `arcname' specifies an alternative name for the
            file in the archive.
         """
         self._check("aw")
 
         # When fileobj is given, replace name by
         # fileobj's real name.
         if fileobj is not None:
             name = fileobj.name
 
         # Building the name of the member in the archive.
         # Backward slashes are converted to forward slashes,
         # Absolute paths are turned to relative paths.
         if arcname is None:
             arcname = name
         drv, arcname = os.path.splitdrive(arcname)
         arcname = arcname.replace(os.sep, "/")
         arcname = arcname.lstrip("/")
 
         # Now, fill the TarInfo object with
         # information specific for the file.
         tarinfo = self.tarinfo()
         tarinfo.tarfile = self
 
         # Use os.stat or os.lstat, depending on platform
         # and if symlinks shall be resolved.
         if fileobj is None:
             if hasattr(os, "lstat") and not self.dereference:
                 statres = os.lstat(name)
             else:
                 statres = os.stat(name)
         else:
             statres = os.fstat(fileobj.fileno())
         linkname = ""
 
         stmd = statres.st_mode
         if stat.S_ISREG(stmd):
             inode = (statres.st_ino, statres.st_dev)
             if not self.dereference and statres.st_nlink > 1 and \
                     inode in self.inodes and arcname != self.inodes[inode]:
                 # Is it a hardlink to an already
                 # archived file?
                 type = LNKTYPE
                 linkname = self.inodes[inode]
             else:
                 # The inode is added only if its valid.
                 # For win32 it is always 0.
                 type = REGTYPE
                 if inode[0]:
                     self.inodes[inode] = arcname
         elif stat.S_ISDIR(stmd):
             type = DIRTYPE
         elif stat.S_ISFIFO(stmd):
             type = FIFOTYPE
         elif stat.S_ISLNK(stmd):
             type = SYMTYPE
             linkname = os.readlink(name)
         elif stat.S_ISCHR(stmd):
             type = CHRTYPE
         elif stat.S_ISBLK(stmd):
             type = BLKTYPE
         else:
             return None
 
         # Fill the TarInfo object with all
         # information we can get.
         tarinfo.name = arcname
         tarinfo.mode = stmd
         tarinfo.uid = statres.st_uid
         tarinfo.gid = statres.st_gid
         if type == REGTYPE:
             tarinfo.size = statres.st_size
         else:
             tarinfo.size = 0L
         tarinfo.mtime = statres.st_mtime
         tarinfo.type = type
         tarinfo.linkname = linkname
         if pwd:
             try:
                 tarinfo.uname = pwd.getpwuid(tarinfo.uid)[0]
             except KeyError:
                 pass
         if grp:
             try:
                 tarinfo.gname = grp.getgrgid(tarinfo.gid)[0]
             except KeyError:
                 pass
 
         if type in (CHRTYPE, BLKTYPE):
             if hasattr(os, "major") and hasattr(os, "minor"):
                 tarinfo.devmajor = os.major(statres.st_rdev)
                 tarinfo.devminor = os.minor(statres.st_rdev)
         return tarinfo
 
     def list(self, verbose=True):
         """Print a table of contents to sys.stdout. If `verbose' is False, only
            the names of the members are printed. If it is True, an `ls -l'-like
            output is produced.
         """
         self._check()
 
         for tarinfo in self:
             if verbose:
                 print filemode(tarinfo.mode),
                 print "%s/%s" % (tarinfo.uname or tarinfo.uid,
                                  tarinfo.gname or tarinfo.gid),
                 if tarinfo.ischr() or tarinfo.isblk():
                     print "%10s" % ("%d,%d" \
                                     % (tarinfo.devmajor, tarinfo.devminor)),
                 else:
                     print "%10d" % tarinfo.size,
                 print "%d-%02d-%02d %02d:%02d:%02d" \
                       % time.localtime(tarinfo.mtime)[:6],
 
             print tarinfo.name + ("/" if tarinfo.isdir() else ""),
 
             if verbose:
                 if tarinfo.issym():
                     print "->", tarinfo.linkname,
                 if tarinfo.islnk():
                     print "link to", tarinfo.linkname,
             print
 
     def add(self, name, arcname=None, recursive=True, exclude=None, filter=None):
         """Add the file `name' to the archive. `name' may be any type of file
            (directory, fifo, symbolic link, etc.). If given, `arcname'
            specifies an alternative name for the file in the archive.
            Directories are added recursively by default. This can be avoided by
            setting `recursive' to False. `exclude' is a function that should
            return True for each filename to be excluded. `filter' is a function
            that expects a TarInfo object argument and returns the changed
            TarInfo object, if it returns None the TarInfo object will be
            excluded from the archive.
         """
         self._check("aw")
 
         if arcname is None:
             arcname = name
 
         # Exclude pathnames.
         if exclude is not None:
             import warnings
             warnings.warn("use the filter argument instead",
                     DeprecationWarning, 2)
             if exclude(name):
                 self._dbg(2, "tarfile: Excluded %r" % name)
                 return
 
         # Skip if somebody tries to archive the archive...
         if self.name is not None and os.path.abspath(name) == self.name:
             self._dbg(2, "tarfile: Skipped %r" % name)
             return
 
         self._dbg(1, name)
 
         # Create a TarInfo object from the file.
         tarinfo = self.gettarinfo(name, arcname)
 
         if tarinfo is None:
             self._dbg(1, "tarfile: Unsupported type %r" % name)
             return
 
         # Change or exclude the TarInfo object.
         if filter is not None:
             tarinfo = filter(tarinfo)
             if tarinfo is None:
                 self._dbg(2, "tarfile: Excluded %r" % name)
                 return
 
         # Append the tar header and data to the archive.
         if tarinfo.isreg():
             with bltn_open(name, "rb") as f:
                 self.addfile(tarinfo, f)
 
         elif tarinfo.isdir():
             self.addfile(tarinfo)
             if recursive:
                 for f in os.listdir(name):
                     self.add(os.path.join(name, f), os.path.join(arcname, f),
                             recursive, exclude, filter)
 
         else:
             self.addfile(tarinfo)
 
     def addfile(self, tarinfo, fileobj=None):
         """Add the TarInfo object `tarinfo' to the archive. If `fileobj' is
            given, tarinfo.size bytes are read from it and added to the archive.
            You can create TarInfo objects using gettarinfo().
            On Windows platforms, `fileobj' should always be opened with mode
            'rb' to avoid irritation about the file size.
         """
         self._check("aw")
 
         tarinfo = copy.copy(tarinfo)
 
         buf = tarinfo.tobuf(self.format, self.encoding, self.errors)
         self.fileobj.write(buf)
         self.offset += len(buf)
 
         # If there's data to follow, append it.
         if fileobj is not None:
             copyfileobj(fileobj, self.fileobj, tarinfo.size)
             blocks, remainder = divmod(tarinfo.size, BLOCKSIZE)
             if remainder > 0:
                 self.fileobj.write(NUL * (BLOCKSIZE - remainder))
                 blocks += 1
             self.offset += blocks * BLOCKSIZE
 
         self.members.append(tarinfo)
 
     def extractall(self, path=".", members=None):
         """Extract all members from the archive to the current working
            directory and set owner, modification time and permissions on
            directories afterwards. `path' specifies a different directory
            to extract to. `members' is optional and must be a subset of the
            list returned by getmembers().
         """
         directories = []
 
         if members is None:
             members = self
 
         for tarinfo in members:
             if tarinfo.isdir():
                 # Extract directories with a safe mode.
                 directories.append(tarinfo)
                 tarinfo = copy.copy(tarinfo)
                 tarinfo.mode = 0700
             self.extract(tarinfo, path)
 
         # Reverse sort directories.
         directories.sort(key=operator.attrgetter('name'))
         directories.reverse()
 
         # Set correct owner, mtime and filemode on directories.
         for tarinfo in directories:
             dirpath = os.path.join(path, tarinfo.name)
             try:
                 self.chown(tarinfo, dirpath)
                 self.utime(tarinfo, dirpath)
                 self.chmod(tarinfo, dirpath)
             except ExtractError, e:
                 if self.errorlevel > 1:
                     raise
                 else:
                     self._dbg(1, "tarfile: %s" % e)
 
     def extract(self, member, path=""):
         """Extract a member from the archive to the current working directory,
            using its full name. Its file information is extracted as accurately
            as possible. `member' may be a filename or a TarInfo object. You can
            specify a different directory using `path'.
         """
         self._check("r")
 
         if isinstance(member, basestring):
             tarinfo = self.getmember(member)
         else:
             tarinfo = member
 
         # Prepare the link target for makelink().
         if tarinfo.islnk():
             tarinfo._link_target = os.path.join(path, tarinfo.linkname)
 
         try:
             self._extract_member(tarinfo, os.path.join(path, tarinfo.name))
         except EnvironmentError, e:
             if self.errorlevel > 0:
                 raise
             else:
                 if e.filename is None:
                     self._dbg(1, "tarfile: %s" % e.strerror)
                 else:
                     self._dbg(1, "tarfile: %s %r" % (e.strerror, e.filename))
         except ExtractError, e:
             if self.errorlevel > 1:
                 raise
             else:
                 self._dbg(1, "tarfile: %s" % e)
 
     def extractfile(self, member):
         """Extract a member from the archive as a file object. `member' may be
            a filename or a TarInfo object. If `member' is a regular file, a
            file-like object is returned. If `member' is a link, a file-like
            object is constructed from the link's target. If `member' is none of
            the above, None is returned.
            The file-like object is read-only and provides the following
            methods: read(), readline(), readlines(), seek() and tell()
         """
         self._check("r")
 
         if isinstance(member, basestring):
             tarinfo = self.getmember(member)
         else:
             tarinfo = member
 
         if tarinfo.isreg():
             return self.fileobject(self, tarinfo)
 
         elif tarinfo.type not in SUPPORTED_TYPES:
             # If a member's type is unknown, it is treated as a
             # regular file.
             return self.fileobject(self, tarinfo)
 
         elif tarinfo.islnk() or tarinfo.issym():
             if isinstance(self.fileobj, _Stream):
                 # A small but ugly workaround for the case that someone tries
                 # to extract a (sym)link as a file-object from a non-seekable
                 # stream of tar blocks.
                 raise StreamError("cannot extract (sym)link as file object")
             else:
                 # A (sym)link's file object is its target's file object.
                 return self.extractfile(self._find_link_target(tarinfo))
         else:
             # If there's no data associated with the member (directory, chrdev,
             # blkdev, etc.), return None instead of a file object.
             return None
 
     def _extract_member(self, tarinfo, targetpath):
         """Extract the TarInfo object tarinfo to a physical
            file called targetpath.
         """
         # Fetch the TarInfo object for the given name
         # and build the destination pathname, replacing
         # forward slashes to platform specific separators.
         targetpath = targetpath.rstrip("/")
         targetpath = targetpath.replace("/", os.sep)
 
         # Create all upper directories.
         upperdirs = os.path.dirname(targetpath)
         if upperdirs and not os.path.exists(upperdirs):
             # Create directories that are not part of the archive with
             # default permissions.
             os.makedirs(upperdirs)
 
         if tarinfo.islnk() or tarinfo.issym():
             self._dbg(1, "%s -> %s" % (tarinfo.name, tarinfo.linkname))
         else:
             self._dbg(1, tarinfo.name)
 
         if tarinfo.isreg():
             self.makefile(tarinfo, targetpath)
         elif tarinfo.isdir():
             self.makedir(tarinfo, targetpath)
         elif tarinfo.isfifo():
             self.makefifo(tarinfo, targetpath)
         elif tarinfo.ischr() or tarinfo.isblk():
             self.makedev(tarinfo, targetpath)
         elif tarinfo.islnk() or tarinfo.issym():
             self.makelink(tarinfo, targetpath)
         elif tarinfo.type not in SUPPORTED_TYPES:
             self.makeunknown(tarinfo, targetpath)
         else:
             self.makefile(tarinfo, targetpath)
 
         self.chown(tarinfo, targetpath)
         if not tarinfo.issym():
             self.chmod(tarinfo, targetpath)
             self.utime(tarinfo, targetpath)
 
     #--------------------------------------------------------------------------
     # Below are the different file methods. They are called via
     # _extract_member() when extract() is called. They can be replaced in a
     # subclass to implement other functionality.
 
     def makedir(self, tarinfo, targetpath):
         """Make a directory called targetpath.
         """
         try:
             # Use a safe mode for the directory, the real mode is set
             # later in _extract_member().
             os.mkdir(targetpath, 0700)
         except EnvironmentError, e:
             if e.errno != errno.EEXIST:
                 raise
 
     def makefile(self, tarinfo, targetpath):
         """Make a file called targetpath.
         """
         source = self.extractfile(tarinfo)
         try:
             with bltn_open(targetpath, "wb") as target:
                 copyfileobj(source, target)
         finally:
             source.close()
 
     def makeunknown(self, tarinfo, targetpath):
         """Make a file from a TarInfo object with an unknown type
            at targetpath.
         """
         self.makefile(tarinfo, targetpath)
         self._dbg(1, "tarfile: Unknown file type %r, " \
                      "extracted as regular file." % tarinfo.type)
 
     def makefifo(self, tarinfo, targetpath):
         """Make a fifo called targetpath.
         """
         if hasattr(os, "mkfifo"):
             os.mkfifo(targetpath)
         else:
             raise ExtractError("fifo not supported by system")
 
     def makedev(self, tarinfo, targetpath):
         """Make a character or block device called targetpath.
         """
         if not hasattr(os, "mknod") or not hasattr(os, "makedev"):
             raise ExtractError("special devices not supported by system")
 
         mode = tarinfo.mode
         if tarinfo.isblk():
             mode |= stat.S_IFBLK
         else:
             mode |= stat.S_IFCHR
 
         os.mknod(targetpath, mode,
                  os.makedev(tarinfo.devmajor, tarinfo.devminor))
 
     def makelink(self, tarinfo, targetpath):
         """Make a (symbolic) link called targetpath. If it cannot be created
           (platform limitation), we try to make a copy of the referenced file
           instead of a link.
         """
         if hasattr(os, "symlink") and hasattr(os, "link"):
             # For systems that support symbolic and hard links.
             if tarinfo.issym():
                 if os.path.lexists(targetpath):
                     os.unlink(targetpath)
                 os.symlink(tarinfo.linkname, targetpath)
             else:
                 # See extract().
                 if os.path.exists(tarinfo._link_target):
                     if os.path.lexists(targetpath):
                         os.unlink(targetpath)
                     os.link(tarinfo._link_target, targetpath)
                 else:
                     self._extract_member(self._find_link_target(tarinfo), targetpath)
         else:
             try:
                 self._extract_member(self._find_link_target(tarinfo), targetpath)
             except KeyError:
                 raise ExtractError("unable to resolve link inside archive")
 
     def chown(self, tarinfo, targetpath):
         """Set owner of targetpath according to tarinfo.
         """
         if pwd and hasattr(os, "geteuid") and os.geteuid() == 0:
             # We have to be root to do so.
             try:
                 g = grp.getgrnam(tarinfo.gname)[2]
             except KeyError:
                 g = tarinfo.gid
             try:
                 u = pwd.getpwnam(tarinfo.uname)[2]
             except KeyError:
                 u = tarinfo.uid
             try:
                 if tarinfo.issym() and hasattr(os, "lchown"):
                     os.lchown(targetpath, u, g)
                 else:
                     if sys.platform != "os2emx":
                         os.chown(targetpath, u, g)
             except EnvironmentError, e:
                 raise ExtractError("could not change owner")
 
     def chmod(self, tarinfo, targetpath):
         """Set file permissions of targetpath according to tarinfo.
         """
         if hasattr(os, 'chmod'):
             try:
                 os.chmod(targetpath, tarinfo.mode)
             except EnvironmentError, e:
                 raise ExtractError("could not change mode")
 
     def utime(self, tarinfo, targetpath):
         """Set modification time of targetpath according to tarinfo.
         """
         if not hasattr(os, 'utime'):
             return
         try:
             os.utime(targetpath, (tarinfo.mtime, tarinfo.mtime))
         except EnvironmentError, e:
             raise ExtractError("could not change modification time")
 
     #--------------------------------------------------------------------------
     def next(self):
         """Return the next member of the archive as a TarInfo object, when
            TarFile is opened for reading. Return None if there is no more
            available.
         """
         self._check("ra")
         if self.firstmember is not None:
             m = self.firstmember
             self.firstmember = None
             return m
 
         # Read the next block.
         self.fileobj.seek(self.offset)
         tarinfo = None
         while True:
             try:
                 tarinfo = self.tarinfo.fromtarfile(self)
             except EOFHeaderError, e:
                 if self.ignore_zeros:
                     self._dbg(2, "0x%X: %s" % (self.offset, e))
                     self.offset += BLOCKSIZE
                     continue
             except InvalidHeaderError, e:
                 if self.ignore_zeros:
                     self._dbg(2, "0x%X: %s" % (self.offset, e))
                     self.offset += BLOCKSIZE
                     continue
                 elif self.offset == 0:
                     raise ReadError(str(e))
             except EmptyHeaderError:
                 if self.offset == 0:
                     raise ReadError("empty file")
             except TruncatedHeaderError, e:
                 if self.offset == 0:
                     raise ReadError(str(e))
             except SubsequentHeaderError, e:
                 raise ReadError(str(e))
             break
 
         if tarinfo is not None:
             self.members.append(tarinfo)
         else:
             self._loaded = True
 
         return tarinfo
 
     #--------------------------------------------------------------------------
     # Little helper methods:
 
     def _getmember(self, name, tarinfo=None, normalize=False):
         """Find an archive member by name from bottom to top.
            If tarinfo is given, it is used as the starting point.
         """
         # Ensure that all members have been loaded.
         members = self.getmembers()
 
         # Limit the member search list up to tarinfo.
         if tarinfo is not None:
             members = members[:members.index(tarinfo)]
 
         if normalize:
             name = os.path.normpath(name)
 
         for member in reversed(members):
             if normalize:
                 member_name = os.path.normpath(member.name)
             else:
                 member_name = member.name
 
             if name == member_name:
                 return member
 
     def _load(self):
         """Read through the entire archive file and look for readable
            members.
         """
         while True:
             tarinfo = self.next()
             if tarinfo is None:
                 break
         self._loaded = True
 
     def _check(self, mode=None):
         """Check if TarFile is still open, and if the operation's mode
            corresponds to TarFile's mode.
         """
         if self.closed:
             raise IOError("%s is closed" % self.__class__.__name__)
         if mode is not None and self.mode not in mode:
             raise IOError("bad operation for mode %r" % self.mode)
 
     def _find_link_target(self, tarinfo):
         """Find the target member of a symlink or hardlink member in the
            archive.
         """
         if tarinfo.issym():
             # Always search the entire archive.
             linkname = "/".join(filter(None, (os.path.dirname(tarinfo.name), tarinfo.linkname)))
             limit = None
         else:
             # Search the archive before the link, because a hard link is
             # just a reference to an already archived file.
             linkname = tarinfo.linkname
             limit = tarinfo
 
         member = self._getmember(linkname, tarinfo=limit, normalize=True)
         if member is None:
             raise KeyError("linkname %r not found" % linkname)
         return member
 
     def __iter__(self):
         """Provide an iterator object.
         """
         if self._loaded:
             return iter(self.members)
         else:
             return TarIter(self)
 
     def _dbg(self, level, msg):
         """Write debugging output to sys.stderr.
         """
         if level <= self.debug:
             print >> sys.stderr, msg
 
     def __enter__(self):
         self._check()
         return self
 
     def __exit__(self, type, value, traceback):
         if type is None:
             self.close()
         else:
             # An exception occurred. We must not call close() because
             # it would try to write end-of-archive blocks and padding.
             if not self._extfileobj:
                 self.fileobj.close()
             self.closed = True
 # class TarFile

　　f、shelve

　　shelve模块是一个简单的k,v将内存数据通过文件持久化的模块，可以持久化任何pickle可支持的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
 d.close()

　　 aaarticlea/png;base64,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" alt="" width="476" height="99" />

　　g、xml处理模块

　　xml是实现不同语言或程序之间进行数据交换的协议，跟json差不多，但json使用起来更简单，不过，古时候，在json还没诞生的黑暗年代，大家只能选择用xml呀，至今很多传统公司如金融行业的很多系统的接口还主要是xml。

　　xml的格式如下，就是通过<>节点来区别数据结构的:

 <?xml version="1.0"?>
 <data>
     <country name="Liechtenstein">
         <rank updated="yes">2</rank>
         <year>2008</year>
         <gdppc>141100</gdppc>
         <neighbor name="Austria" direction="E"/>
         <neighbor name="Switzerland" direction="W"/>
     </country>
     <country name="Singapore">
         <rank updated="yes">5</rank>
         <year>2011</year>
         <gdppc>59900</gdppc>
         <neighbor name="Malaysia" direction="N"/>
     </country>
     <country name="Panama">
         <rank updated="yes">69</rank>
         <year>2011</year>
         <gdppc>13600</gdppc>
         <neighbor name="Costa Rica" direction="W"/>
         <neighbor name="Colombia" direction="E"/>
     </country>
 </data>

　　xml协议在各个语言里的都 是支持的，在python中可以用以下模块操作xml

 import xml.etree.ElementTree as ET
 tree = ET.parse("xmltest.xml")
 root = tree.getroot()
 print(root.tag)
 #遍历xml文档
 for child in root:
     print(child.tag, child.attrib)
     for i in child:
         print(i.tag,i.text)
 #只遍历year 节点
 for node in root.iter('year'):
     print(node.tag,node.text)

　　修改和删除xml文档内容

 import xml.etree.ElementTree as ET
 tree = ET.parse("xmltest.xml")
 root = tree.getroot()

 #修改
 for node in root.iter('year'):
     new_year = int(node.text) + 1
     node.text = str(new_year)
     node.set("updated","yes")
 tree.write("xmltest.xml")

 #删除node
 for country in root.findall('country'):
    rank = int(country.find('rank').text)
    if rank > 50:
      root.remove(country)
 tree.write('output.xml')

　　自己创建xml文档

 import xml.etree.ElementTree as ET
 new_xml = ET.Element("namelist")
 name = ET.SubElement(new_xml,"name",attrib={"enrolled":"yes"})
 age = ET.SubElement(name,"age",attrib={"checked":"no"})
 sex = ET.SubElement(name,"sex")
 sex.text = ''
 name2 = ET.SubElement(new_xml,"name",attrib={"enrolled":"no"})
 age = ET.SubElement(name2,"age")
 age.text = ''
 et = ET.ElementTree(new_xml) #生成文档对象
 et.write("test.xml", encoding="utf-8",xml_declaration=True)
 ET.dump(new_xml) #打印生成的格式 

 　　h、ConfigParser模块

　　用于生成和修改常见配置文档，当前模块的名称在 python 3.x 版本中变更为 configparser。

　　来看一个好多软件的常见文档格式如下

 [DEFAULT]
 ServerAliveInterval = 45
 Compression = yes
 CompressionLevel = 9
 ForwardX11 = yes
 [bitbucket.org]
 User = hg
 [topsecret.server.com]
 Port = 50022
 ForwardX11 = no

　　如果想用python生成一个这样的文档怎么做呢？

 import configparser
 config = configparser.ConfigParser()
 config["DEFAULT"] = {'ServerAliveInterval': '',
                       'Compression': 'yes',
                      'CompressionLevel': ''}
 config['bitbucket.org'] = {}
 config['bitbucket.org']['User'] = 'hg'
 config['topsecret.server.com'] = {}
 topsecret = config['topsecret.server.com']
 topsecret['Host Port'] = ''     # mutates the parser
 topsecret['ForwardX11'] = 'no'  # same here
 config['DEFAULT']['ForwardX11'] = 'yes'
 with open('example.ini', 'w') as configfile:
    config.write(configfile)

　　写完了还可以再读出来

 >>> import configparser
 >>> config = configparser.ConfigParser()
 >>> config.sections()
 []
 >>> config.read('example.ini')
 ['example.ini']
 >>> config.sections()
 ['bitbucket.org', 'topsecret.server.com']
 >>> 'bitbucket.org' in config
 True
 >>> 'bytebong.com' in config
 False
 >>> config['bitbucket.org']['User']
 'hg'
 >>> config['DEFAULT']['Compression']
 'yes'
 >>> topsecret = config['topsecret.server.com']
 >>> topsecret['ForwardX11']
 'no'
 >>> topsecret['Port']
 ''
 >>> for key in config['bitbucket.org']: print(key)
 ...
 user
 compressionlevel
 serveraliveinterval
 compression
 forwardx11
 >>> config['bitbucket.org']['ForwardX11']
 'yes'

　　I、hashlib模块　　

　　用于加密相关的操作，3.x里代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法

 import hashlib
 m = hashlib.md5()
 m.update(b"Hello")
 m.update(b"It's me")
 print(m.digest())
 m.update(b"It's been a long time since last time we ...")

 print(m.digest()) #2进制格式hash
 print(len(m.hexdigest())) #16进制格式hash
 '''
 def digest(self, *args, **kwargs): # real signature unknown
     """ Return the digest value as a string of binary data. """
     pass

 def hexdigest(self, *args, **kwargs): # real signature unknown
     """ Return the digest value as a string of hexadecimal digits. """
     pass

 '''
 import hashlib

 # ######## md5 ########

 hash = hashlib.md5()
 hash.update('admin')
 print(hash.hexdigest())

 # ######## sha1 ########

 hash = hashlib.sha1()
 hash.update('admin')
 print(hash.hexdigest())

 # ######## sha256 ########

 hash = hashlib.sha256()
 hash.update('admin')
 print(hash.hexdigest())

 # ######## sha384 ########

 hash = hashlib.sha384()
 hash.update('admin')
 print(hash.hexdigest())

 # ######## sha512 ########

 hash = hashlib.sha512()
 hash.update('admin')
 print(hash.hexdigest())

　　python 还有一个 hmac 模块，它内部对我们创建 key 和 内容 再进行处理然后再加密

 import hmac
 h = hmac.new('wueiqi')
 h.update('hellowo')
 print h.hexdigest()

　　j、re模块

 '.'     默认匹配除\n之外的任意一个字符，若指定flag DOTALL,则匹配任意字符，包括换行
 '^'     匹配字符开头，若指定flags MULTILINE,这种也可以匹配上(r"^a","\nabc\neee",flags=re.MULTILINE)
 '$'     匹配字符结尾，或e.search("foo$","bfoo\nsdfsf",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") 是匹配不到的
 '\Z'    匹配字符结尾，同$
 '\d'    匹配数字0-9
 '\D'    匹配非数字
 '\w'    匹配[A-Za-z0-9]
 '\W'    匹配非[A-Za-z0-9]
 's'     匹配空白字符、\t、\n、\r , re.search("\s+","ab\tc1\n3").group() 结果 '\t'

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

　　H、Subprocess模块 

　　常用subprocess方法示例

#执行命令，返回命令执行状态 ， 0 or 非0
>>> retcode = subprocess.call(["ls", "-l"])

#执行命令，如果命令结果为0，就正常返回，否则抛异常
>>> subprocess.check_call(["ls", "-l"])
0

#接收字符串格式命令，返回元组形式，第1个元素是执行状态，第2个是命令结果 
>>> subprocess.getstatusoutput('ls /bin/ls')
(0, '/bin/ls')

#接收字符串格式命令，并返回结果
>>> subprocess.getoutput('ls /bin/ls')
'/bin/ls'

#执行命令，并返回结果，注意是返回结果，不是打印，下例结果返回给res
>>> res=subprocess.check_output(['ls','-l'])
>>> res
b'total 0\ndrwxr-xr-x 12 alex staff 408 Nov 2 11:05 OldBoyCRM\n'

#上面那些方法，底层都是封装的subprocess.Popen
poll()
Check if child process has terminated. Returns returncode

wait()
Wait for child process to terminate. Returns returncode attribute.

terminate() 杀掉所启动进程
communicate() 等待任务结束

stdin 标准输入

stdout 标准输出

stderr 标准错误

pid
The process ID of the child process.

#例子
>>> p = subprocess.Popen("df -h|grep disk",stdin=subprocess.PIPE,stdout=subprocess.PIPE,shell=True)
>>> p.stdout.read()
b'/dev/disk1 465Gi 64Gi 400Gi 14% 16901472 104938142 14% /\n'

 >>> subprocess.run(["ls", "-l"])  # doesn't capture output
 drwxr-xr-x   3 gy  staff   102 11  9 17:17 Applications
 drwxr-xr-x@  5 gy  staff   170 11  9 19:56 Applications (Parallels)
 drwxr-xr-x+ 19 gy  staff   646 11 21 10:19 Desktop
 drwx------+ 12 gy  staff   408 11 14 15:39 Documents
 drwx------+ 32 gy  staff  1088 11 21 10:19 Downloads
 drwx------@ 62 gy  staff  2108 11 17 10:44 Library
 >>> subprocess.run("exit 1", shell=True, check=True)
 Traceback (most recent call last):
 subprocess.CalledProcessError: Command 'exit 1' returned non-zero exit status 1
 >>> subprocess.run(["ls", "-l", "/dev/null"], stdout=subprocess.PIPE)
 CompletedProcess(args=['ls', '-l', '/dev/null'], returncode=0,
 stdout=b'crw-rw-rw- 1 root root 1, 3 Jan 23 16:23 /dev/null\n')

　　调用subprocess.run(...)是推荐的常用方法，在大多数情况下能满足需求，但如果你可能需要进行一些复杂的与系统的交互的话，你还可以用subprocess.Popen(),语法如下：

p = subprocess.Popen("find / -size +1000000 -exec ls -shl {} \;",shell=True,stdout=subprocess.PIPE) print(p.stdout.read())

可用参数：

• args：shell命令，可以是字符串或者序列类型（如：list，元组）
• bufsize：指定缓冲。0 无缓冲,1 行缓冲,其他 缓冲区大小,负值 系统缓冲
• stdin, stdout, stderr：分别表示程序的标准输入、输出、错误句柄
• preexec_fn：只在Unix平台下有效，用于指定一个可执行对象（callable object），它将在子进程运行之前被调用
• close_sfs：在windows平台下，如果close_fds被设置为True，则新创建的子进程将不会继承父进程的输入、输出、错误管道。
  所以不能将close_fds设置为True同时重定向子进程的标准输入、输出与错误(stdin, stdout, stderr)。
• shell：同上
• cwd：用于设置子进程的当前目录
• env：用于指定子进程的环境变量。如果env = None，子进程的环境变量将从父进程中继承。
• universal_newlines：不同系统的换行符不同，True -> 同意使用 \n
• startupinfo与createionflags只在windows下有效
  将被传递给底层的CreateProcess()函数，用于设置子进程的一些属性，如：主窗口的外观，进程的优先级等等

终端输入的命令分为两种：

• 输入即可得到输出，如：ifconfig
• 输入进行某环境，依赖再输入，如：python

需要交互的命令示例

 import subprocess

 obj = subprocess.Popen(["python"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
 obj.stdin.write('print 1 \n ')
 obj.stdin.write('print 2 \n ')
 obj.stdin.write('print 3 \n ')
 obj.stdin.write('print 4 \n ')

 out_error_list = obj.communicate(timeout=10)
 print out_error_list

subprocess实现sudo 自动输入密码

 import subprocess

 def mypass():
     mypass = '' #or get the password from anywhere
     return mypass

 echo = subprocess.Popen(['echo',mypass()],
                         stdout=subprocess.PIPE,
                         )

 sudo = subprocess.Popen(['sudo','-S','iptables','-L'],
                         stdin=echo.stdout,
                         stdout=subprocess.PIPE,
                         )

 end_of_pipe = sudo.stdout

 print "Password ok \n Iptables Chains %s" % end_of_pipe.read()

最常用的匹配语法

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

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

　　仅需轻轻知道的几个匹配模式

 re.I(re.IGNORECASE): 忽略大小写（括号内是完整写法，下同）
 M(MULTILINE): 多行模式，改变'^'和'$'的行为（参见上图）
 S(DOTALL): 点任意匹配模式，改变'.'的行为