电脑/python/官方内置模块/基本内置模块熟悉.html

<!DOCTYPE html>
<html>
<head>
<!-- 2016-07-30 六 23:05 -->
<meta  charset="utf-8">
<meta  name="viewport" content="width=device-width, initial-scale=1">
<title>基本内置模块熟悉</title>
<meta  name="generator" content="Org-mode">
<meta  name="author" content="万泽(德山书生)">
<meta  name="description" content="制作者邮箱：a358003542@gmail.com"
>
<style type="text/css">
body {
    margin-right: auto;
    margin-left: auto;
}

.title {
    display: block;
    text-align: center;
    padding: 10px;
}

.center-block {
    display: block;
    margin-left: auto;
    margin-right: auto;
}

.underline{
    text-decoration: underline;
}
   html, body {
    margin: 0;
    padding: 0;
    font-family:"Microsoft YaHei",Arial,Helvetica,sans-serif,"宋体";
    font-size: 1em;
}

#content {
    display: block;
    margin-left: auto;
    margin-right: auto;
    background:#fcfcfc;
    height:100%;
    margin-left:300px;
    max-width:800px;
    min-height:100%;
    padding:1.618em 3.236em;
}

code {
    padding: 2px 4px;
    color: #c7254e;
    background-color: #f9f2f4;
    border-radius: 4px;
}

pre {
    max-width: 100%;
    display: block;
    padding: 9.5px;
    margin: 0 0 10px;
    font-size: 13px;
    line-height: 1.42857143;
    color: #333;
    background-color: #f5f5f5;
    border: 1px solid #ccc;
    border-radius: 4px;
    overflow : auto;
}


blockquote {
    padding: 10px 20px;
    margin: 0 0 20px;
    font-size: 17.5px;
    border-left: 5px solid #eee;
}

li{
    margin-top: 0.5em;
    margin-bottom: 0.5em;
}

p{
    text-indent:2em;
    line-height:150%;
}

/* dl */
dl {
    margin-top: 0;
    margin-bottom: 20px;
}
dt {
    font-weight: 700;
    line-height: 150%;
    margin-top: 0.5em;
    margin-bottom: 0.5em;
}
dd {
    line-height: 150%;
}

@media (min-width: 768px) {
  dt {
    white-space: nowrap;
  }
}

video{
    max-width: 100%;
    margin-left: auto;
    margin-right: auto;
}

figure p{
    text-indent:0em;
}
img{
    max-width: 100%;
}

embed{
    max-width: 100%;
    margin-left: auto;
    margin-right: auto;
}

figure{
    text-align: center;
}

/*  class  */
.FRAMED{
    max-width:100%;
    border:1px solid ;
    padding: 1em;
    -webkit-box-sizing: border-box;
    -moz-box-sizing: border-box;
    box-sizing: border-box;
}

.NOTECARD{
    width: 35%;
    position:relative;
    right: -30%;
    padding: 1em;
    margin:0 auto;
    border: solid 1px;
    -webkit-box-sizing: border-box;
    -moz-box-sizing: border-box;
    box-sizing: border-box;
}

/*
table
*/
table {
    border-collapse: collapse;
    border-spacing: 0;
    margin: 16px 0;
    empty-cells: show;
    border: 1px solid #ccc;
    width: 100%;
    display: table;
}

table tr {
    border-bottom: 1px solid #ddd;
}
table th,table td{
    padding:8px;
}

table tr:nth-child(even) {
    background-color: #f1f1f1;
}


ul,ol,dl{
    line-height:24px;
    list-style-image:none;
    /* list-style:none; */
    margin:0px 0px 24px 0px;
    padding:0;
}

li{
    margin-left: 24px;
}

dd{
    margin:0;
}

#content .section ul,#content .toctree-wrapper ul,article ul{
    list-style:disc;
    line-height:24px;
    margin-bottom:24px}

#content .section ul li,#content .toctree-wrapper ul li,article ul li{
    list-style:disc;
    margin-left:24px}

#content .section ul li p:last-child,#content .toctree-wrapper ul li p:last-child,article ul li p:last-child{
                                                                                                                                  margin-bottom:0}

#content .section ul li ul,#content .toctree-wrapper ul li ul,article ul li ul{
    margin-bottom:0}

#content .section ul li li,#content .toctree-wrapper ul li li,article ul li li{
    list-style:circle}

#content .section ul li li li,#content .toctree-wrapper ul li li li,article ul li li li{
    list-style:square}

#content .section ul li ol li,#content .toctree-wrapper ul li ol li,article ul li ol li{
    list-style:decimal}

#content .section ol,#content ol,article ol{
    list-style:decimal;
    line-height:24px;
    margin-bottom:24px}

#content .section ol li,#content ol li,article ol li{
    list-style:decimal;
    margin-left:24px}

#content .section ol li p:last-child,#content ol li p:last-child,article ol li p:last-child{
                                                                                                                           margin-bottom:0}

#content .section ol li ul,#content ol li ul,article ol li ul{
    margin-bottom:0}

#content .section ol li ul li,#content ol li ul li,article ol li ul li{
    list-style:disc}

dl dt{
    font-weight:bold;
}

dl p,dl table,dl ul,dl ol{
    margin-bottom:12px !important;
}

dl dd{
    margin:0 0 12px 24px;
}

@media print{
    .codeblock,pre.src{
        white-space:pre.src-wrap}
}

@media print{
    html,body,section{
        background:none !important}

    *{
        box-shadow:none !important;
        text-shadow:none !important;
        filter:none !important;
        -ms-filter:none !important}

    a,a:visited{
          text-decoration:underline}

    pre.src,blockquote{
        page-break-inside:avoid}

    thead{
        display:table-header-group}

    tr,img{
        page-break-inside:avoid}

    img{
        max-width:100% !important}

    @page{
        margin:0.5cm}

    p,h2,h3{
        orphans:3;
        widows:3}

    h2,h3{
        page-break-after:avoid}
}

@media print{
    #postamble{
        display:none}

    #content{
        margin-left:0}
}

@media print{
    #table-of-contents{
        display:none}

    @page{
        size: auto;
        margin: 25mm 25mm 25mm 25mm;}

    body {
        margin: 0px;}
}

@media screen and (max-width: 768px){
}

@media only screen and (max-width: 480px){
}

@media screen and (max-width: 768px){
    .tablet-hide{
        display:none}
}

@media screen and (max-width: 480px){
    .mobile-hide{
        display:none}
}

@media screen and (max-width: 480px){
}

@media screen and (max-width: 768px){
    #content{
        margin-left:0;
        padding: 1em 1em;}

    #content #content{
        padding:1.618em}

    #content.shift{
        position:fixed;
        min-width:100%;
        left:85%;
        top:0;
        height:100%;
        overflow:hidden}
}

@media screen and (min-width: 1400px){
    #content{
        background:rgba(0,0,0,0.05)}

    #content{
        background:#fcfcfc}
}

@media screen and (max-width: 768px){
    #copyright{
        width:85%;
        display:none}

    #copyright.shift{
        display:block}

    img{
        width:100%;
        height:auto}
}

@media screen and (max-width: 480px){
    #content .sidebar{
        width:100%}
}


.figure p{
    color:#000;
    font:italic 85%/1 arial,sans-serif;
    padding:1em 0;
}

.rotate-90{
    -webkit-transform:rotate(90deg);
    -moz-transform:rotate(90deg);
    -ms-transform:rotate(90deg);
    -o-transform:rotate(90deg);
    transform:rotate(90deg);
}

.rotate-270{
    -webkit-transform:rotate(270deg);
    -moz-transform:rotate(270deg);
    -ms-transform:rotate(270deg);
    -o-transform:rotate(270deg);
    transform:rotate(270deg);
}

#toggle-sidebar,
#table-of-contents .close-sidebar {
    display: none;
}

@media screen and (max-width: 768px) {
    #table-of-contents {
        display: none;
        width: 60%;
    }

    #table-of-contents h2 a {
        display: block;
    }

    #table-of-contents:target {
        display: block;
    }

    #copyright, #postamble {
        display: none;
    }

    #toggle-sidebar {
        background-color: #2980B9;
        display: block;
        margin-bottom: 1.6em;
        padding: 0.6em;
        text-align: center;
    }

    #toggle-sidebar h2 {
        color: white;
        font-size: 100%;
        line-height: 50px;
        margin: 0;
        padding: 0;
    }

    #table-of-contents .close-sidebar {
       color: rgba(255, 255, 255, 0.3);
       display: inline-block;
       margin: 0px 10px 0px 45px;
       padding: 10px;
    }
}

*{
    -webkit-box-sizing:border-box;
    -moz-box-sizing:border-box;
    box-sizing:border-box;
}

figcaption,figure,footer,header,hgroup,nav{
    display:block}

ins{
    background:#ff9;
    color:#000;
    text-decoration:none}

mark{
    background:#ff0;
    color:#000;
    font-style:italic;
    font-weight:bold}

small{
    font-size:85%}

sub,sup{
    font-size:75%;
    line-height:0;
    position:relative;
    vertical-align:baseline}

sup{
    top:-0.5em}

sub{
    bottom:-0.25em}

img{
    -ms-interpolation-mode:bicubic;
    vertical-align:middle;
    max-width:100%}

svg:not(:root){
    overflow:hidden}

figure{
    margin:0}

label{
    cursor:pointer}

legend{
    border:0;
    margin-left:-7px;
    padding:0;
    white-space:normal}

#content .danger,#content .error{
    background:#fdf3f2}

legend{
    display:block;
    width:100%;
    border:0;
    padding:0;
    white-space:normal;
    margin-bottom:24px;
    font-size:150%;
    *margin-left:-7px}

label{
    display:block;
    margin:0 0 0.3125em 0;
    color:#333;
    font-size:90%}

a{
    color:#2980B9;
    text-decoration:none;
    cursor:pointer}


a:hover,a:active{
    outline:0;
}

a:hover{
    color:#3091d1}

a:visited{
    color:#9B59B6}

.left{
    text-align:left}

.center{
    text-align:center}

.right{
    text-align:right}

hr{
    display:block;
    height:1px;
    border:0;
    border-top:1px solid #e1e4e5;
    margin:24px 0;
    padding:0}

#table-of-contents li{
    list-style:none;
    margin-left: 0px;
}

#table-of-contents header{
    height:32px;
    display:inline-block;
    line-height:32px;
    padding:0 1.618em;
    display:block;
    font-weight:bold;
    text-transform:uppercase;
    font-size:80%;
    color:#2980B9;
    white-space:nowrap}

#table-of-contents ul{
    margin-bottom:0}

#table-of-contents li.divide-top{
    border-top:solid 1px #404040}

#table-of-contents li.divide-bottom{
    border-bottom:solid 1px #404040}

#table-of-contents li.current{
    background:#e3e3e3}

#table-of-contents li.current a{
    color:gray;
    border-right:solid 1px #c9c9c9;
    padding:0.4045em 2.427em}

#table-of-contents li.current a:hover{
    background:#d6d6d6}

#table-of-contents li a{
    /* color:#404040; */
    padding:0.4045em 1.618em;
    position:relative;
    /* background:#fcfcfc; */
    border:none;
    /* border-bottom:solid 1px #c9c9c9; */
    /* border-top:solid 1px #c9c9c9; */
    padding-left:1.618em -4px}

#table-of-contents li.on a:hover,#table-of-contents li.current>a:hover{
    background:#fcfcfc}

#table-of-contents li ul li a{
    /* background:#c9c9c9; */
    padding:0.4045em 2.427em}

#table-of-contents li ul li ul li a{
    padding:0.4045em 3.236em}

#table-of-contents li.current ul{
    display:block}

/* #table-of-contents li ul{ */
/*     margin-bottom:0; */
/*     display:none} */

#table-of-contents .local-toc li ul{
    display:block}

#table-of-contents li ul li a{
    margin-bottom:0;
    color:#b3b3b3;
    font-weight:normal}

#table-of-contents a{
    display:inline-block;
    line-height:18px;
    padding:0.4045em 1.618em;
    display:block;
    position:relative;
    font-size:90%;
    color:#b3b3b3;
    direction: ltr;
}

#table-of-contents a:hover{
    background-color:#4e4a4a;
    cursor:pointer}

/* #text-table-of-contents { */
/*     overflow:scroll; */
/* } */

#table-of-contents{
    position:fixed;
    top:0;
    left:0;
    width:300px;
    overflow-x:hidden;
    overflow-y:scroll;
    height:100%;
    background:#343131;
    z-index:200;
    scrollbar-base-color: #1F1D1D;
    scrollbar-arrow-color: #b3b3b3;
    scrollbar-shadow-color: #1F1D1D;
    scrollbar-track-color : #343131;
}

#table-of-contents h2{
    z-index:200;
    background-color:#2980B9;
    text-align:center;
    padding:0.809em;
    display:block;
    color:#fcfcfc;
    font-size: 100%;
    margin-bottom:0.809em}

ul.nav li ul li {
    display: none;
}

ul.nav li ul li ul li {
    display: none;
}

ul.nav li.active ul li {
    display: inline;
}

ul.nav li.active ul li ul li {
    display: inline;
}

ul.nav li.active ul li a {
    background-color: #E3E3E3;
    color: #8099B0;
    border-right:solid 1px #c9c9c9 !important;
}

ul.nav li.active ul li.active a {
    background-color: #C9C9C9;
    color: black !important;
    font-weight: bold !important;
}

ul.nav li.active ul li.active ul li.active a {
    color: black !important;
    font-weight: bold !important;
    display: block !important;
}

ul.nav li.active ul li.active ul li a {
    color: #808080 !important;
    font-weight: normal !important;
    display: block !important;
}

ul.nav li.active ul li ul li a {
    display: none !important;
}


ul.nav li ul li ul li ul li {
    display: none !important; /* as long as nav is on multiple levels of ul */
    /* display: none; /* as long as nav is on multiple levels of ul *\/ */
}

ul.nav li.active > a {
    border-bottom:solid 1px #c9c9c9 !important; /* XXX Restrict it to 2nd level */
    border-right:solid 1px #c9c9c9 !important;
}

ul.nav li.active a {
    color: gray !important;
    font-weight:bold;
    background-color: white;
    border-right:solid 0px white !important;
}

ul.nav > li.active > a {
    color: black !important;
}

footer{
    color:#999}

footer p{
    margin-bottom:12px}

#copyright, #postamble{
    position:fixed;
    bottom:0;
    left:0;
    width:300px;
    color:#fcfcfc;
    background:#1f1d1d;
    border-top:solid 10px #343131;
    font-family:"Lato","proxima-nova","Helvetica Neue",Arial,sans-serif;
    font-size: 90%;
    z-index:400;
    padding:12px;
}

#postamble .author {
    font-size: 100%;
    margin-bottom: 0px;
}

#postamble .date {
    font-size: 90%;
    margin-bottom: 0px;
    color: #27AE60;
}

#postamble .creator,#postamble .validation {
    display:none;
}

#copyright a{
    color:#2980B9;
    text-decoration:none}

#copyright .rst-current-version{
    padding:12px;
    background-color:#272525;
    display:block;
    text-align:right;
    font-size:90%;
    cursor:pointer;
    color:#27AE60;
    *zoom:1}

#content img{
    max-width:100%;
    height:auto !important}

#content div.figure{
    margin-bottom:24px}

#content div.figure.align-center{
    text-align:center}

#content .section>img,#content .section>a>img{
    margin-bottom:24px}

.verse{
    border-left:5px solid #6AB0DE;
    background-color: #E7F2FA;
    padding: 6px 20px;
    font-style:italic;
}

#content .note .last,#content .attention .last,#content .caution .last,#content .danger .last,#content .error .last,#content .hint .last,#content .important .last,#content .tip .last,#content .warning .last,#content .seealso .last,#content .admonitiontodo .last{
    margin-bottom:0}

#content .admonition-title:before{
    margin-right:4px}

#content .section ol p,#content .section ul p{
    margin-bottom:12px}

#content h1 .headerlink,#content h2 .headerlink,#content h3 .headerlink,#content h4 .headerlink,#content h5 .headerlink,#content h6 .headerlink,#content dl dt .headerlink{
    display:none;
    visibility:hidden;
    font-size:14px}

#content h1 .headerlink:after,#content h2 .headerlink:after,#content h3 .headerlink:after,#content h4 .headerlink:after,#content h5 .headerlink:after,#content h6 .headerlink:after,#content dl dt .headerlink:after{
    visibility:visible;
    content:"";
    font-family:FontAwesome;
    display:inline-block}

#content h1:hover .headerlink,#content h2:hover .headerlink,#content h3:hover .headerlink,#content h4:hover .headerlink,#content h5:hover .headerlink,#content h6:hover .headerlink,#content dl dt:hover .headerlink{
    display:inline-block}

#content .sidebar{
    float:right;
    width:40%;
    display:block;
    margin:0 0 24px 24px;
    padding:24px;
    background:#f3f6f6;
    border:solid 1px #e1e4e5}

#content .sidebar p,#content .sidebar ul,#content .sidebar dl{
    font-size:90%}

#content .sidebar .last{
    margin-bottom:0}

#content .sidebar .sidebar-title{
    display:block;
    font-family:"Roboto Slab","ff-tisa-web-pro","Georgia",Arial,sans-serif;
    font-weight:bold;
    background:#e1e4e5;
    padding:6px 12px;
    margin:-24px;
    margin-bottom:24px;
    font-size:100%}

#content .footnote-reference,#content .citation-reference{
    vertical-align:super;
    font-size:90%}

span[id*='MathJax-Span']{
    color:#404040}

.math{
    text-align:center}

#footnotes{
    border-top:1px solid #e1e4e5;
    padding-top: 36px;
}

h2.footnotes{
    display:none;
}


.footnum:before, .footref:before{
    content:"[";
}

.footnum:after, .footref:after{
    content:"]";
}

.footpara {
    color: #999;
    font-size: 90%;
    font-family:"Lato","proxima-nova","Helvetica Neue",Arial,sans-serif;
    padding-bottom: 8px;
    padding-left: 16px;
    padding-right: 16px;
    padding-top: 8px;
    line-height: 1.25em;
    /* display: inline; */
}
.highlight .hll { background-color: #ffffcc }
.highlight  { background: #f8f8f8; }
.highlight .c { color: #8f5902; font-style: italic } /* Comment */
.highlight .err { color: #a40000; border: 1px solid #ef2929 } /* Error */
.highlight .g { color: #000000 } /* Generic */
.highlight .k { color: #204a87; font-weight: bold } /* Keyword */
.highlight .l { color: #000000 } /* Literal */
.highlight .n { color: #000000 } /* Name */
.highlight .o { color: #ce5c00; font-weight: bold } /* Operator */
.highlight .x { color: #000000 } /* Other */
.highlight .p { color: #000000; font-weight: bold } /* Punctuation */
.highlight .ch { color: #8f5902; font-style: italic } /* Comment.Hashbang */
.highlight .cm { color: #8f5902; font-style: italic } /* Comment.Multiline */
.highlight .cp { color: #8f5902; font-style: italic } /* Comment.Preproc */
.highlight .cpf { color: #8f5902; font-style: italic } /* Comment.PreprocFile */
.highlight .c1 { color: #8f5902; font-style: italic } /* Comment.Single */
.highlight .cs { color: #8f5902; font-style: italic } /* Comment.Special */
.highlight .gd { color: #a40000 } /* Generic.Deleted */
.highlight .ge { color: #000000; font-style: italic } /* Generic.Emph */
.highlight .gr { color: #ef2929 } /* Generic.Error */
.highlight .gh { color: #000080; font-weight: bold } /* Generic.Heading */
.highlight .gi { color: #00A000 } /* Generic.Inserted */
.highlight .go { color: #000000; font-style: italic } /* Generic.Output */
.highlight .gp { color: #8f5902 } /* Generic.Prompt */
.highlight .gs { color: #000000; font-weight: bold } /* Generic.Strong */
.highlight .gu { color: #800080; font-weight: bold } /* Generic.Subheading */
.highlight .gt { color: #a40000; font-weight: bold } /* Generic.Traceback */
.highlight .kc { color: #204a87; font-weight: bold } /* Keyword.Constant */
.highlight .kd { color: #204a87; font-weight: bold } /* Keyword.Declaration */
.highlight .kn { color: #204a87; font-weight: bold } /* Keyword.Namespace */
.highlight .kp { color: #204a87; font-weight: bold } /* Keyword.Pseudo */
.highlight .kr { color: #204a87; font-weight: bold } /* Keyword.Reserved */
.highlight .kt { color: #204a87; font-weight: bold } /* Keyword.Type */
.highlight .ld { color: #000000 } /* Literal.Date */
.highlight .m { color: #0000cf; font-weight: bold } /* Literal.Number */
.highlight .s { color: #4e9a06 } /* Literal.String */
.highlight .na { color: #c4a000 } /* Name.Attribute */
.highlight .nb { color: #204a87 } /* Name.Builtin */
.highlight .nc { color: #000000 } /* Name.Class */
.highlight .no { color: #000000 } /* Name.Constant */
.highlight .nd { color: #5c35cc; font-weight: bold } /* Name.Decorator */
.highlight .ni { color: #ce5c00 } /* Name.Entity */
.highlight .ne { color: #cc0000; font-weight: bold } /* Name.Exception */
.highlight .nf { color: #000000 } /* Name.Function */
.highlight .nl { color: #f57900 } /* Name.Label */
.highlight .nn { color: #000000 } /* Name.Namespace */
.highlight .nx { color: #000000 } /* Name.Other */
.highlight .py { color: #000000 } /* Name.Property */
.highlight .nt { color: #204a87; font-weight: bold } /* Name.Tag */
.highlight .nv { color: #000000 } /* Name.Variable */
.highlight .ow { color: #204a87; font-weight: bold } /* Operator.Word */
.highlight .w { color: #f8f8f8; text-decoration: underline } /* Text.Whitespace */
.highlight .mb { color: #0000cf; font-weight: bold } /* Literal.Number.Bin */
.highlight .mf { color: #0000cf; font-weight: bold } /* Literal.Number.Float */
.highlight .mh { color: #0000cf; font-weight: bold } /* Literal.Number.Hex */
.highlight .mi { color: #0000cf; font-weight: bold } /* Literal.Number.Integer */
.highlight .mo { color: #0000cf; font-weight: bold } /* Literal.Number.Oct */
.highlight .sb { color: #4e9a06 } /* Literal.String.Backtick */
.highlight .sc { color: #4e9a06 } /* Literal.String.Char */
.highlight .sd { color: #8f5902; font-style: italic } /* Literal.String.Doc */
.highlight .s2 { color: #4e9a06 } /* Literal.String.Double */
.highlight .se { color: #4e9a06 } /* Literal.String.Escape */
.highlight .sh { color: #4e9a06 } /* Literal.String.Heredoc */
.highlight .si { color: #4e9a06 } /* Literal.String.Interpol */
.highlight .sx { color: #4e9a06 } /* Literal.String.Other */
.highlight .sr { color: #4e9a06 } /* Literal.String.Regex */
.highlight .s1 { color: #4e9a06 } /* Literal.String.Single */
.highlight .ss { color: #4e9a06 } /* Literal.String.Symbol */
.highlight .bp { color: #3465a4 } /* Name.Builtin.Pseudo */
.highlight .vc { color: #000000 } /* Name.Variable.Class */
.highlight .vg { color: #000000 } /* Name.Variable.Global */
.highlight .vi { color: #000000 } /* Name.Variable.Instance */
.highlight .il { color: #0000cf; font-weight: bold } /* Literal.Number.Integer.Long */
</style>
<script type="text/x-mathjax-config">
    MathJax.Hub.Config({
        displayAlign: "center",
        displayIndent: "0em",

        "HTML-CSS": { scale: 100,
                        linebreaks: { automatic: "false" },
                        webFont: "TeX"
                       },
        SVG: {scale: 100,
              linebreaks: { automatic: "false" },
              font: "TeX"},
        NativeMML: {scale: 100},
        TeX: { equationNumbers: {autoNumber: "AMS"},
               MultLineWidth: "85%",
               TagSide: "right",
               TagIndent: ".8em"
             }
});
</script>
<script type="text/javascript"
        src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS_HTML"></script>
</head>
<body>
<div id="content">
<header>
<h1 class="title">基本内置模块熟悉</h1>
</header><nav id="table-of-contents">
<h2>Table of Contents</h2>
<div id="text-table-of-contents">
<ul>
<li><a href="#orgheadline3">1. pickle模块</a>
<ul>
<li><a href="#orgheadline1">1.1. 将对象存入文件</a></li>
<li><a href="#orgheadline2">1.2. 从文件中取出对象</a></li>
</ul>
</li>
<li><a href="#orgheadline6">2. shelve模块</a>
<ul>
<li><a href="#orgheadline4">2.1. 存入多个对象</a></li>
<li><a href="#orgheadline5">2.2. 读取这些对象</a></li>
</ul>
</li>
<li><a href="#orgheadline15">3. sys模块</a>
<ul>
<li><a href="#orgheadline7">3.1. sys.argv</a></li>
<li><a href="#orgheadline8">3.2. exit函数</a></li>
<li><a href="#orgheadline9">3.3. sys.platform</a></li>
<li><a href="#orgheadline10">3.4. sys.path</a></li>
<li><a href="#orgheadline11">3.5. 标准输入输出错误输出文件</a></li>
<li><a href="#orgheadline12">3.6. sys.version</a></li>
<li><a href="#orgheadline13">3.7. sys.maxsize</a></li>
<li><a href="#orgheadline14">3.8. sys.stdin.isatty()</a></li>
</ul>
</li>
<li><a href="#orgheadline17">4. fileinput模块</a>
<ul>
<li><a href="#orgheadline16">4.1. input函数</a></li>
</ul>
</li>
<li><a href="#orgheadline30">5. os.path模块</a>
<ul>
<li><a href="#orgheadline18">5.1. abspath函数</a></li>
<li><a href="#orgheadline19">5.2. dirname函数</a></li>
<li><a href="#orgheadline20">5.3. basename函数</a></li>
<li><a href="#orgheadline21">5.4. split函数</a></li>
<li><a href="#orgheadline22">5.5. splitext函数</a></li>
<li><a href="#orgheadline23">5.6. join函数</a></li>
<li><a href="#orgheadline24">5.7. expanduser函数</a></li>
<li><a href="#orgheadline25">5.8. exists函数</a></li>
<li><a href="#orgheadline26">5.9. isfile和isdir还有islink}</a></li>
<li><a href="#orgheadline27">5.10. samefile函数</a></li>
<li><a href="#orgheadline28">5.11. getmtime函数</a></li>
<li><a href="#orgheadline29">5.12. getctime函数</a></li>
</ul>
</li>
<li><a href="#orgheadline31">6. glob模块</a></li>
<li><a href="#orgheadline36">7. subprocess模块</a>
<ul>
<li><a href="#orgheadline32">7.1. call函数</a></li>
<li><a href="#orgheadline33">7.2. getoutput函数</a></li>
<li><a href="#orgheadline34">7.3. getstatusoutput函数</a></li>
<li><a href="#orgheadline35">7.4. Popen类</a></li>
</ul>
</li>
<li><a href="#orgheadline50">8. os模块</a>
<ul>
<li><a href="#orgheadline37">8.1. getcwd函数</a></li>
<li><a href="#orgheadline38">8.2. mkdir函数</a></li>
<li><a href="#orgheadline39">8.3. chdir函数</a></li>
<li><a href="#orgheadline40">8.4. remove函数</a></li>
<li><a href="#orgheadline41">8.5. rename函数</a></li>
<li><a href="#orgheadline42">8.6. repalce函数</a></li>
<li><a href="#orgheadline43">8.7. rmdir函数</a></li>
<li><a href="#orgheadline44">8.8. listdir命令</a></li>
<li><a href="#orgheadline45">8.9. walk函数</a></li>
<li><a href="#orgheadline46">8.10. environ函数</a></li>
<li><a href="#orgheadline47">8.11. getpid函数</a></li>
<li><a href="#orgheadline48">8.12. stat函数</a></li>
<li><a href="#orgheadline49">8.13. 给进程发送信号</a></li>
</ul>
</li>
<li><a href="#orgheadline57">9. shutil模块</a>
<ul>
<li><a href="#orgheadline51">9.1. 复制文件</a></li>
<li><a href="#orgheadline52">9.2. 复制文件夹</a></li>
<li><a href="#orgheadline53">9.3. 删除整个目录</a></li>
<li><a href="#orgheadline54">9.4. 移动文件夹</a></li>
<li><a href="#orgheadline55">9.5. chown函数</a></li>
<li><a href="#orgheadline56">9.6. which函数</a></li>
</ul>
</li>
<li><a href="#orgheadline63">10. tarfile和zipfile模块</a>
<ul>
<li><a href="#orgheadline59">10.1. 制作gz压缩文件</a>
<ul>
<li><a href="#orgheadline58">10.1.1. TarFile的add方法</a></li>
</ul>
</li>
<li><a href="#orgheadline60">10.2. 解压缩gz压缩文件</a></li>
<li><a href="#orgheadline61">10.3. 提取egg文件中的内容</a></li>
<li><a href="#orgheadline62">10.4. 制作zip压缩文件</a></li>
</ul>
</li>
<li><a href="#orgheadline66">11. itertools模块</a>
<ul>
<li><a href="#orgheadline64">11.1. repeat函数</a></li>
<li><a href="#orgheadline65">11.2. starmap函数</a></li>
</ul>
</li>
<li><a href="#orgheadline70">12. multiprocessing模块</a>
<ul>
<li><a href="#orgheadline68">12.1. Pool类</a>
<ul>
<li><a href="#orgheadline67">12.1.1. starmap方法</a></li>
</ul>
</li>
<li><a href="#orgheadline69">12.2. ThreadPool类</a></li>
</ul>
</li>
</ul>
</div>
</nav>


<div class="outline-2">
<h2 id="orgheadline3">pickle模块</h2>
<div class="outline-text-2" id="text-1">
<p>
pickle模块可以将某一个复杂的对象永久存入一个文件中，以后再导入这个文件，这样自动将这个复杂的对象导入进来了。
</p>
</div>

<div class="outline-3">
<h3 id="orgheadline1">将对象存入文件</h3>
<div class="outline-text-3" id="text-1-1">
<div class="highlight"><pre><span></span><span class="kn">import</span> <span class="nn">pickle</span>

<span class="k">class</span> <span class="nc">Test</span><span class="p">:</span>
    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">a</span><span class="o">=</span><span class="mi">0</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">b</span><span class="o">=</span><span class="mi">0</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">c</span><span class="o">=</span><span class="mi">1</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">d</span><span class="o">=</span><span class="mi">1</span>

    <span class="k">def</span> <span class="nf">__str__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="nb">str</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">__dict__</span><span class="p">)</span>

<span class="k">if</span> <span class="n">__name__</span> <span class="o">==</span> <span class="s1">&#39;__main__&#39;</span><span class="p">:</span>
    <span class="n">test001</span><span class="o">=</span><span class="n">Test</span><span class="p">()</span>
    <span class="k">print</span><span class="p">(</span><span class="n">test001</span><span class="p">)</span>
    <span class="n">testfile</span><span class="o">=</span><span class="nb">open</span><span class="p">(</span><span class="s1">&#39;data.pkl&#39;</span><span class="p">,</span><span class="s1">&#39;wb&#39;</span><span class="p">)</span>
    <span class="n">pickle</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">test001</span><span class="p">,</span><span class="n">testfile</span><span class="p">)</span>
    <span class="n">testfile</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>
</pre></div>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline2">从文件中取出对象</h3>
<div class="outline-text-3" id="text-1-2">
<p>
值得一提的是从文件中取出对象，原来的类的定义还是必须存在，也就是声明一次在内存中的，否则会出错。
</p>
<div class="highlight"><pre><span></span><span class="kn">import</span> <span class="nn">pickle</span>

<span class="k">class</span> <span class="nc">Test</span><span class="p">:</span>
    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">a</span><span class="o">=</span><span class="mi">0</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">b</span><span class="o">=</span><span class="mi">0</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">c</span><span class="o">=</span><span class="mi">1</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">d</span><span class="o">=</span><span class="mi">1</span>

    <span class="k">def</span> <span class="nf">__str__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="nb">str</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">__dict__</span><span class="p">)</span>

<span class="k">if</span> <span class="n">__name__</span> <span class="o">==</span> <span class="s1">&#39;__main__&#39;</span><span class="p">:</span>
    <span class="n">testfile</span><span class="o">=</span><span class="nb">open</span><span class="p">(</span><span class="s1">&#39;data.pkl&#39;</span><span class="p">,</span><span class="s1">&#39;rb&#39;</span><span class="p">)</span>
    <span class="n">test001</span><span class="o">=</span><span class="n">pickle</span><span class="o">.</span><span class="n">load</span><span class="p">(</span><span class="n">testfile</span><span class="p">)</span>
    <span class="k">print</span><span class="p">(</span><span class="n">test001</span><span class="p">)</span>
    <span class="n">testfile</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>
</pre></div>

<p>
pickle模块的基本使用就是用dump函数将某个对象存入某个文件中，然后这个文件以后可以用load函数来加载，然后之前的那个对象会自动返回出来。
</p>
</div>
</div>
</div>


<div class="outline-2">
<h2 id="orgheadline6">shelve模块</h2>
<div class="outline-text-2" id="text-2">
<p>
shelve模块是基于pickle模块的，也就是只有pickle模块支持的对象它才支持。 之前提及pickle模块只能针对一个对象，如果你有多个对象要处理，可以考虑使用shelve模块，而shelve模块就好像是自动将这些对象用字典的形式包装起来了。除此之外shelve模块的使用更加简便了。
</p>
</div>

<div class="outline-3">
<h3 id="orgheadline4">存入多个对象</h3>
<div class="outline-text-3" id="text-2-1">
<div class="highlight"><pre><span></span><span class="kn">import</span> <span class="nn">shelve</span>
<span class="kn">from</span> <span class="nn">Hero</span> <span class="kn">import</span> <span class="n">Garen</span>

<span class="k">if</span> <span class="n">__name__</span> <span class="o">==</span> <span class="s1">&#39;__main__&#39;</span><span class="p">:</span>
    <span class="n">garen1</span><span class="o">=</span><span class="n">Garen</span><span class="p">()</span>
    <span class="n">garen2</span><span class="o">=</span><span class="n">Garen</span><span class="p">(</span><span class="s1">&#39;red&#39;</span><span class="p">)</span>
    <span class="n">garen3</span><span class="o">=</span><span class="n">Garen</span><span class="p">(</span><span class="s1">&#39;yellow&#39;</span><span class="p">)</span>
    <span class="n">db</span><span class="o">=</span><span class="n">shelve</span><span class="o">.</span><span class="n">open</span><span class="p">(</span><span class="s1">&#39;test.db&#39;</span><span class="p">)</span>
    <span class="k">for</span> <span class="p">(</span><span class="n">key</span><span class="p">,</span><span class="n">item</span><span class="p">)</span> <span class="ow">in</span> <span class="p">[(</span><span class="s1">&#39;garen1&#39;</span><span class="p">,</span><span class="n">garen1</span><span class="p">),(</span><span class="s1">&#39;garen2&#39;</span><span class="p">,</span><span class="n">garen2</span><span class="p">),(</span><span class="s1">&#39;garen3&#39;</span><span class="p">,</span><span class="n">garen3</span><span class="p">)]:</span>
        <span class="n">db</span><span class="p">[</span><span class="n">key</span><span class="p">]</span><span class="o">=</span><span class="n">item</span>
    <span class="n">db</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>
</pre></div>


<p>
我们看到整个过程的代码变得非常的简洁了，然后一个个对象是以字典的形式存入进去的。
</p>
</div>
</div>

<div class="outline-3">
<h3 id="orgheadline5">读取这些对象</h3>
<div class="outline-text-3" id="text-2-2">
<p>
读取这些对象的代码也很简洁，就是用shelve模块的open函数打开数据库文件，open函数会自动返回一个字典对象，这个字典对象里面的数据就对应着之前存入的键值和对象。
</p>

<p>
同时通过这个例子我发现，如果自己定义的类，将他们提取出来放入另外一个文件，那么shelve模块读取文件时候是不需要再引入之前的定义。这一点值得我们注意，因为shelve模块内部也采用的是pickle的机制，所以可以猜测之前pickle的那个例子类的定义写在写入文件代码的里面，所以不能载入数据库；而如果将这些类的定义放入一个文件，然后这些类以模块或说模块载入的形式引入，那么读取这些对象就可以以一种更优雅的形式实现。如下所示：
</p>
<div class="highlight"><pre><span></span><span class="kn">import</span> <span class="nn">shelve</span>

<span class="k">if</span> <span class="n">__name__</span> <span class="o">==</span> <span class="s1">&#39;__main__&#39;</span><span class="p">:</span>
    <span class="n">db</span><span class="o">=</span><span class="n">shelve</span><span class="o">.</span><span class="n">open</span><span class="p">(</span><span class="s1">&#39;test.db&#39;</span><span class="p">)</span>
    <span class="k">for</span> <span class="n">key</span> <span class="ow">in</span> <span class="nb">sorted</span><span class="p">(</span><span class="n">db</span><span class="p">):</span>
        <span class="k">print</span><span class="p">(</span><span class="n">db</span><span class="p">[</span><span class="n">key</span><span class="p">])</span>
    <span class="n">db</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>
</pre></div>

<p>
我们看到就作为简单的程序或者原型程序的数据库，shelve模块已经很好用而且够用了。
</p>
</div>
</div>
</div>


<div class="outline-2">
<h2 id="orgheadline15">sys模块</h2>
<div class="outline-text-2" id="text-3">
<p>
sys模块有一些功能很常用，其实在前面我们就看到过一些了。
</p>
</div>

<div class="outline-3">
<h3 id="orgheadline7">sys.argv</h3>
<div class="outline-text-3" id="text-3-1">
<p>
在刚开始说明python执行脚本参数传递的问题时就已经讲了sys.argv这个变量。这是一个由字符串组成的列表。
</p>
<div class="highlight"><pre><span></span><span class="kn">import</span> <span class="nn">sys</span>
<span class="k">print</span><span class="p">(</span><span class="n">sys</span><span class="o">.</span><span class="n">argv</span><span class="p">)</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">sys</span><span class="o">.</span><span class="n">argv</span><span class="p">)):</span>
    <span class="k">print</span><span class="p">(</span><span class="n">sys</span><span class="o">.</span><span class="n">argv</span><span class="p">[</span><span class="n">i</span><span class="p">])</span>
</pre></div>


<p>
比如新建上面的一个test.py文件，然后执行：
</p>
<pre>
python3 test.py test1 test2
['test.py', 'test1', 'test2']
test.py
test1
test2
</pre>


<p>
我们可以看到 <code>sys.argv[0]</code> 就是这个脚本的文件名，然后后面依次是各个参数。
</p>
</div>
</div>

<div class="outline-3">
<h3 id="orgheadline8">exit函数</h3>
<div class="outline-text-3" id="text-3-2">
<p>
这个我们在编写GUI程序的时候经常看到，在其他脚本程序中也很常用。如果不带参数的话那么直接退出程序，还可以带一个字符串参数，返回错误提示信息，或者带一个数字，这里的详细讨论略过。
</p>

<div class="highlight"><pre><span></span>&gt;&gt;&gt; import sys
&gt;&gt;&gt; sys.exit<span class="o">(</span><span class="s1">&#39;出错了&#39;</span><span class="o">)</span>
出错了
</pre></div>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline9">sys.platform</h3>
<div class="outline-text-3" id="text-3-3">
<p>
返回当前脚本执行的操作系统环境。
</p>

<p>
Linux 返回字符串值：linux；Windows返回win32；Mac OS X 返回darwin。
</p>
</div>
</div>

<div class="outline-3">
<h3 id="orgheadline10">sys.path</h3>
<div class="outline-text-3" id="text-3-4">
<p>
一连串字符串列表，是python脚本模块的搜索路径，所以我们自定义的python模块，只需要在sys.path这个列表上新加一个字符串路径即可。
</p>
</div>
</div>

<div class="outline-3">
<h3 id="orgheadline11">标准输入输出错误输出文件</h3>
<div class="outline-text-3" id="text-3-5">
<p>
sys.stdin，sys.stdout，sys.stderr这三个文件对象对应的就是linux系统所谓的标准输入标准输出和错误输出文件流对象。
</p>
</div>
</div>

<div class="outline-3">
<h3 id="orgheadline12">sys.version</h3>
<div class="outline-text-3" id="text-3-6">
<p>
sys.version输出当前python的版本信息和编译环境的详细信息。
</p>

<p>
<code>sys.version_info[0]</code> 返回当前python主版本的标识，比如python3就返回数字3。
</p>
</div>
</div>

<div class="outline-3">
<h3 id="orgheadline13">sys.maxsize</h3>
<div class="outline-text-3" id="text-3-7">
<p>
返回当前计算环境下整数(int)类型的最大值，32位系统是 \(2**31-1\) 。
</p>
<pre>
&gt;&gt;&gt; 2**31-1
2147483647
&gt;&gt;&gt; import sys
&gt;&gt;&gt; sys.maxsize
2147483647
</pre>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline14">sys.stdin.isatty()</h3>
<div class="outline-text-3" id="text-3-8">
<p>
测试输入流是不是终端。如果是终端，则返回True。
</p>


<div class="NOTECARD">
<p>
更多内容请参见 <a href="https://docs.python.org/3/library/sys.html">官方文档</a> 。
</p>

</div>
</div>
</div>
</div>

<div class="outline-2">
<h2 id="orgheadline17">fileinput模块</h2>
<div class="outline-text-2" id="text-4">
<p>
fileinput模块提供了便捷的多文件处理方案。
</p>
</div>

<div class="outline-3">
<h3 id="orgheadline16">input函数</h3>
<div class="outline-text-3" id="text-4-1">
<pre>
fileinput.input(files=None, inplace=False)
</pre>

<p>
input函数最常用的两个参数如上所示，如果不带参数，那么就是默认的命令行的 <code>sys.argv[1:]</code> 接受到的一系列文件。如果命令行也没有输入文件参数，那么就是默认的sys.stdin标准输入。特定的文件输入用 <code>files</code> 来指定，参数为文件名字符值的列表。
</p>

<p>
<code>inplace</code> 默认是False，也就是原文件没有被修改，如果设置为True，那么对于line的一些操作是会原地修改原文件的。具体请看下面的例子：
</p>
<div class="highlight"><pre><span></span><span class="n">allfile</span> <span class="o">=</span> <span class="p">[</span><span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">path</span><span class="p">,</span><span class="n">f</span><span class="p">)</span> <span class="k">for</span> <span class="n">path</span><span class="p">,</span><span class="n">dirs</span><span class="p">,</span><span class="n">files</span> <span class="ow">in</span> <span class="n">os</span><span class="o">.</span><span class="n">walk</span><span class="p">(</span><span class="s1">&#39;.&#39;</span><span class="p">)</span>
        <span class="k">if</span> <span class="n">files</span> <span class="k">for</span> <span class="n">f</span> <span class="ow">in</span> <span class="n">files</span><span class="p">]</span>
<span class="k">def</span> <span class="nf">process</span><span class="p">(</span><span class="n">line</span><span class="p">):</span>
    <span class="k">return</span> <span class="n">line</span><span class="o">.</span><span class="n">replace</span><span class="p">(</span><span class="s1">&#39;skeleton&#39;</span><span class="p">,</span><span class="n">project_name</span><span class="p">)</span>
<span class="k">with</span> <span class="n">fileinput</span><span class="o">.</span><span class="n">input</span><span class="p">(</span><span class="n">files</span><span class="o">=</span><span class="n">allfile</span><span class="p">,</span><span class="n">inplace</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span> <span class="k">as</span> <span class="n">f</span><span class="p">:</span>
    <span class="k">for</span> <span class="n">line</span> <span class="ow">in</span> <span class="n">f</span><span class="p">:</span>
        <span class="k">print</span><span class="p">(</span><span class="n">process</span><span class="p">(</span><span class="n">line</span><span class="p">),</span><span class="n">end</span><span class="o">=</span><span class="s1">&#39;&#39;</span><span class="p">)</span>
</pre></div>

<p>
上面代码第一行使用用os.walk来生成本文件夹下所有的文件名路径。然后作为参数输入给files，这里一般定义一个process函数来处理每一行，然后返回处理后的值。用print函数打印具体的处理的效果。如果这里inpalce没有设置为True那么结果只是打印在终端上，设置为True之后，原文件对应行将被修改。inplace参数很有用。 （<a href="http://ruslanspivak.com/2010/10/20/in-place-file-rewrite-with-fileinput/">参考网站</a> ，在你确认操作结果的情况下慎重使用。）
</p>
</div>
</div>
</div>


<div class="outline-2">
<h2 id="orgheadline30">os.path模块</h2>
<div class="outline-text-2" id="text-5">
<p>
前面提到sys.argv只能返回当前python脚本的文件名，而我们常常需要这个python脚本在系统中的具体位置。前面如os.getcwd等也能获得当前python脚本的所在目录，不过os.path模块的一个优点就是跨平台特性支持很好，也就是一般我们通过其他方式获得的path路径都会用这个模块的函数辅助处理一下。
</p>

<p>
我们来看下面的例子：
</p>
<div class="highlight"><pre><span></span><span class="kn">import</span> <span class="nn">os</span>

<span class="k">print</span><span class="p">(</span><span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">abspath</span><span class="p">(</span><span class="n">__file__</span><span class="p">))</span>
<span class="k">print</span><span class="p">(</span><span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">dirname</span><span class="p">(</span><span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">abspath</span><span class="p">(</span><span class="n">__file__</span><span class="p">)))</span>

<span class="k">print</span><span class="p">(</span><span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">basename</span><span class="p">(</span><span class="n">__file__</span><span class="p">))</span>
<span class="k">print</span><span class="p">(</span><span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">basename</span><span class="p">(</span><span class="n">os</span><span class="o">.</span><span class="n">environ</span><span class="p">[</span><span class="s1">&#39;HOME&#39;</span><span class="p">]))</span>
</pre></div>

<pre>
/home/wanze/桌面/test.py
/home/wanze/桌面
test.py
wanze
</pre>


<p>
其中 <code>__file__</code> 表示当前脚本文件所在的路径。
</p>
</div>

<div class="outline-3">
<h3 id="orgheadline18">abspath函数</h3>
<div class="outline-text-3" id="text-5-1">
<p>
abspath函数接受一个path路径值然后返回一个正规的普适的路径地址。具体效果类似于执行了: <code>normpath(join(os.getcwd(), path))</code> 。
</p>

<p>
再看下面的例子演示了空字符串默认当前工作目录，然后也接受绝对路径等。
</p>
<pre>
&gt;&gt;&gt; import os
&gt;&gt;&gt; os.path.abspath('')
'/home/wanze'
&gt;&gt;&gt; os.path.abspath('test')
'/home/wanze/test'
&gt;&gt;&gt; os.path.abspath('/test')
'/test'
&gt;&gt;&gt; os.path.abspath('test/')
'/home/wanze/test'
</pre>

<p>
我们看到如果abspath接收的是空字符串，其定位是当前脚本的工作目录，那么是引用的模块里面的 <code>os.path.abspath('')</code> ，具体对应的也是当前脚本的工作目录。然后os.path.abspath(".")返回的是当前脚本工作目录。
</p>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline19">dirname函数</h3>
<div class="outline-text-3" id="text-5-2">
<p>
dirname函数接受一个路径值然后返回这个路径除开最后一个元素的前面的路径值。比如上面的例子，路径指向文件，那么dirname函数返回的是除开这个文件名的前面的路径；而如果接受的路径指向目录，那么返回的是除开最后一个文件夹名的前面的路径值。
</p>
</div>
</div>

<div class="outline-3">
<h3 id="orgheadline20">basename函数</h3>
<div class="outline-text-3" id="text-5-3">
<p>
如上面例子所示，basename函数接受一个路径值然后返回路径的最后一个元素，如果路径指向文件，那么返回的是文件名；如果路径指向目录，那么返回的是最后那个目录的文件夹名。比如下面实现了从绝对路径提取出文件名的功能。
</p>
<pre>
&gt;&gt;&gt; import os.path
&gt;&gt;&gt; string = '/home/wanze/test.txt'
&gt;&gt;&gt; fileName,fileExtension = os.path.splitext(os.path.basename(string))
&gt;&gt;&gt; fileName
'test'
</pre>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline21">split函数</h3>
<div class="outline-text-3" id="text-5-4">
<p>
将路径path字符串分割，可以视作dirname和basename的组合。
</p>
<pre>
&gt;&gt;&gt; os.path.split('/usr/local/bin/test.txt')
('/usr/local/bin', 'test.txt')
&gt;&gt;&gt; os.path.dirname('/usr/local/bin/test.txt')
'/usr/local/bin'
&gt;&gt;&gt; os.path.basename('/usr/local/bin/test.txt')
'test.txt'
</pre>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline22">splitext函数</h3>
<div class="outline-text-3" id="text-5-5">
<p>
将某个路径path的后缀分开，这里主要是针对文件名为输入的时候，那么第一个为该文件的名字，输出数组的第二个值是该文件的后缀。这个函数在提取文件名后缀和前面的名字的时候很有用，方便组合出新的文件名。
</p>
<pre>
&gt;&gt;&gt; import os
&gt;&gt;&gt; fileName, fileExtension = os.path.splitext('/path/to/somefile.ext')
&gt;&gt;&gt; fileName
'/path/to/somefile'
&gt;&gt;&gt; fileExtension
'.ext'
</pre>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline23">join函数</h3>
<div class="outline-text-3" id="text-5-6">
<p>
用于连接多个路径值合并成一个新的路径值，同样相对于简单的字符串拼接，用这个函数处理路径组合具有操作系统普适性和灵活性。
</p>
<pre>
&gt;&gt;&gt; os.path.join(os.path.expanduser('~'),'test','lib')
'/home/wanze/test/lib'
</pre>

<p>
上面join函数多个参数生成的新path在windows下又是不同的输出的。
</p>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline24">expanduser函数</h3>
<div class="outline-text-3" id="text-5-7">
<pre>
&gt;&gt;&gt; import os
&gt;&gt;&gt; os.path.expanduser('~')
'/home/wanze'
&gt;&gt;&gt; os.path.expanduser('~/pymf')
'/home/wanze/pymf'
&gt;&gt;&gt; os.path.join(os.path.expanduser('~'),'pymf','mymodule')
'/home/wanze/pymf/mymodule'
</pre>

<p>
"~" 这个符号可以在这里使用，从而展开为以/home/wanze为基础的绝对路径，兼容大部分系统（在windows下也可以使用。）
</p>

<p>
同时我们看到join函数可以接受很多不定量的参数，然后将他们组合成为一个新的路径，而且不用你费心是 <code>/</code> 还是 <code>\</code> ，你不需要写这些了，用join函数自然料理好一切。
</p>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline25">exists函数</h3>
<div class="outline-text-3" id="text-5-8">
<p>
os.path.exists(path)：测试路径或文件等是否存在。如果存在返回True，否则返回False。
</p>
</div>
</div>

<div class="outline-3">
<h3 id="orgheadline26">isfile和isdir还有islink}</h3>
<div class="outline-text-3" id="text-5-9">
<p>
os.path.isfile(path)：接受一个字符串路径变量，如果是文件那么返回True，否则返回False（也就是文件不存在或者不是文件是文件夹等情况都会返回False）。
</p>

<p>
类似的有isdir和islink函数。
</p>
</div>
</div>

<div class="outline-3">
<h3 id="orgheadline27">samefile函数</h3>
<div class="outline-text-3" id="text-5-10">
<p>
os.path.samefile(path1,path2)：如果两个文件或路径相同则返回True，否则返回False。
</p>
</div>
</div>

<div class="outline-3">
<h3 id="orgheadline28">getmtime函数</h3>
<div class="outline-text-3" id="text-5-11">
<p>
os.path.getmtime(path)
</p>

<p>
返回文件的最后修改时间，返回值是多少多少秒，可用time模块的ctime或localtime函数将其转换成 <code>time.struct_time</code> 对象，然后使用strftime来进行更好的格式输出。
</p>
</div>
</div>

<div class="outline-3">
<h3 id="orgheadline29">getctime函数</h3>
<div class="outline-text-3" id="text-5-12">
<p>
类似getmtime，返回文件的最后创建时间。在unix系统中是指最后文件的元信息更改的时间。
</p>

<div class="NOTECARD">
<p>
更多内容请参见 <a href="https://docs.python.org/3/library/os.path.html">官方文档</a> 。
</p>

</div>
</div>
</div>
</div>


<div class="outline-2">
<h2 id="orgheadline31">glob模块</h2>
<div class="outline-text-2" id="text-6">
<p>
glob模块用法很简单，初步学习就是一个glob函数，接受一个pathname路径值，然后返回这个路径下某些文件名组成的列表。支持 <code>* ?</code> 符号表达。
</p>


<p>
意思是任意数量的字符或者任意的一个字符，然后 <code>[?]</code> 明确表示问号。
</p>
<pre>
&gt;&gt;&gt; import glob
&gt;&gt;&gt; glob.glob('*.py')
['re_subst.py', 're_sub.py', 'test2.py']
</pre>
</div>
</div>


<div class="outline-2">
<h2 id="orgheadline36">subprocess模块</h2>
<div class="outline-text-2" id="text-7">
<p>
我想大家都注意到了现在的计算机都是多任务的，这种多任务的实现机制就是所谓的多个进程同时运行，因为计算机只有一个CPU（现在多核的越来越普及了，它们内部的工作原理我没了解过。）所有计算机一次只能处理一个进程，而这种多进程的实现有点类似你人脑（当然不排除某些极个别现象），你不能一边看电影一边写作业，但是可以写一会作业然后再看一会电影（当然不推荐这么做、），计算机的多进程实现机制也和这个类似，就是一会干这个进程，一会儿做那个进程。
</p>

<p>
计算机的一个进程里面还可以分为很多个线程，这个较为复杂，就不谈了。比如你编写的一个脚本程序，系统就会给它分配一个进程号之类的，然后cpu有时就会转过头来执行它一下（计算机各个进程之间的切换很快的，所以才会给我们一种多任务的错觉。）而你的脚本程序里面还可以再开出其他的子进程出来， python的subprocess模块主要负责这方面的工作。
</p>
</div>

<div class="outline-3">
<h3 id="orgheadline32">call函数</h3>
<div class="outline-text-3" id="text-7-1">
<div class="highlight"><pre><span></span><span class="kn">import</span> <span class="nn">subprocess</span>

<span class="n">subprocess</span><span class="o">.</span><span class="n">call</span><span class="p">([</span><span class="s2">&quot;echo&quot;</span><span class="p">,</span> <span class="s2">&quot;hello world&quot;</span><span class="p">])</span>
<span class="n">subprocess</span><span class="o">.</span><span class="n">call</span><span class="p">([</span><span class="s2">&quot;echo&quot;</span><span class="p">,</span> <span class="s2">&quot;$HOME&quot;</span><span class="p">])</span>
<span class="n">subprocess</span><span class="o">.</span><span class="n">call</span><span class="p">(</span><span class="s1">&#39;echo $HOME&#39;</span><span class="p">,</span><span class="n">shell</span><span class="o">=</span><span class="bp">True</span><span class="p">)</span>
</pre></div>

<pre>
hello world
$HOME
/home/wanze
</pre>


<p>
其中使用shell=True选项后用法较简单较直观，但网上提及安全性和兼容性可能有问题，他们推荐一般不适用shell=True这个选项。（<a href="http://stackoverflow.com/questions/3172470/actual-meaning-of-shell-true-in-subprocess">参考网站</a>）
</p>

<p>
如果不使用shell=True这个选项的，比如这里 <code>$HOME</code> 这个系统变量就无法正确翻译过来，如果实在需要home路径，需要使用os.path的expanduser函数。
</p>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline33">getoutput函数</h3>
<div class="outline-text-3" id="text-7-2">
<p>
取出某个进程命令的输出，返回的是字符串形式。
</p>
<pre>
import subprocess

name=subprocess.getoutput('whoami')
print(name)
</pre>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline34">getstatusoutput函数</h3>
<div class="outline-text-3" id="text-7-3">
<p>
某个进程执行的状态。
</p>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline35">Popen类</h3>
<div class="outline-text-3" id="text-7-4">
<p>
根据Popen类创建一个进程管理实例，可以进行进程的沟通，暂停，关闭等等操作。前面的函数的实现是基于Popen类的，这是较高级的课题，这里暂时略过。
</p>

<div class="NOTECARD">
<p>
更多内容请参见 <a href="https://docs.python.org/3/library/subprocess.html">官方文档</a> 。
</p>

</div>
</div>
</div>
</div>


<div class="outline-2">
<h2 id="orgheadline50">os模块</h2>
<div class="outline-text-2" id="text-8">
</div><div class="outline-3">
<h3 id="orgheadline37">getcwd函数</h3>
<div class="outline-text-3" id="text-8-1">
<p>
不管你在终端运行python还是运行某个python脚本，总有一个变量存储着当前工作目录的位置。你可以通过getcwd命令来查看当前工作目录。
</p>

<pre>
import os
print(os.getcwd())
</pre>

<p>
如果是终端调用python就是你终端的当前工作目录所在，你可以用pwd命令来查看。如下所示：
</p>
<pre>
=&gt;pwd
/home/wanze
=&gt;python3
&gt;&gt;&gt; import os
&gt;&gt;&gt; print(os.getcwd())
/home/wanze
</pre>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline38">mkdir函数</h3>
<div class="outline-text-3" id="text-8-2">
<p>
新建一个文件夹。
</p>
<pre>
os.mkdir(str)
</pre>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline39">chdir函数</h3>
<div class="outline-text-3" id="text-8-3">
<p>
os模块里有一个chdir函数来更改当前工作目录所在地。
</p>

<p>
可以使用 <code>.</code> 和 <code>..</code> 语法，也可以使用简单的"test"调转到test文件夹。
</p>
<pre>
&gt;&gt;&gt; os.chdir('/home/wanze/pymf')
&gt;&gt;&gt; print(os.getcwd())
/home/wanze/pymf
</pre>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline40">remove函数</h3>
<div class="outline-text-3" id="text-8-4">
<pre>
os.remove(path)
</pre>

<p>
支持相对路径表达。如果路径是目录将会抛出一个OSError异常。
</p>
</div>
</div>

<div class="outline-3">
<h3 id="orgheadline41">rename函数</h3>
<div class="outline-text-3" id="text-8-5">
<pre>
os.rename(src, dst)
</pre>

<p>
第一个参数是目标文件或目录，第二个参数是要替换成为的名字。这个命令一方面可以重命名文件，此外可以移动文件。
</p>

<p>
支持相对路径语法表达，rename在windows下不一定替换原文件，repalce一定替换文件。
</p>
</div>
</div>

<div class="outline-3">
<h3 id="orgheadline42">repalce函数</h3>
<div class="outline-text-3" id="text-8-6">
<pre>
os.replace(src, dst)
</pre>

<p>
rename在windows下不一定替换原文件，repalce一定替换文件。
</p>

<p>
支持相对路径语法表达。
</p>
</div>
</div>

<div class="outline-3">
<h3 id="orgheadline43">rmdir函数</h3>
<div class="outline-text-3" id="text-8-7">
<pre>
os.rmdir(path)
</pre>

<p>
支持相对路径语法表达，只能删除空目录。如果要删除整个目录，请使用 <code>shutil.rmtree(path)</code> 。
</p>
</div>
</div>

<div class="outline-3">
<h3 id="orgheadline44">listdir命令</h3>
<div class="outline-text-3" id="text-8-8">
<pre>
os.listdir(path='.')
</pre>

<p>
相当于简单的ls命令，将返回一个字符串列表，其内包含本path下所有的文件和文件夹名（包括链接文件）。
</p>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline45">walk函数</h3>
<div class="outline-text-3" id="text-8-9">
<pre>
os.walk('.')
</pre>


<p>
产生一个生成器对象，具体数值含义如下：（dirpath, dirnames, filenames），其中dirpath和filenames可以合并出本目录下所有文件的具体文件名路径，而dirpath和dirnames可以合并出本目录下所有目录的具体路径名。
</p>

<p>
根据这个os.walk函数我写了一个 <code>gen_file</code> 函数，其是一个生成器函数，会遍历目录树，并返回本目录下的文件信息。具体代码如下所示:
</p>

<div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">gen_file</span><span class="p">(</span><span class="n">startpath</span><span class="o">=</span><span class="s1">&#39;.&#39;</span><span class="p">,</span><span class="n">filetype</span><span class="o">=</span><span class="s2">&quot;&quot;</span><span class="p">):</span>
    <span class="sd">&#39;&#39;&#39;利用os.walk 遍历某个目录，收集其内的文件，返回</span>
<span class="sd">    (文件路径列表, 本路径下的文件列表)</span>
<span class="sd">    比如:</span>
<span class="sd">    ([&#39;shortly&#39;], [&#39;shortly.py&#39;])</span>
<span class="sd">([&#39;shortly&#39;, &#39;templates&#39;], [&#39;shortly.py&#39;])</span>
<span class="sd">([&#39;shortly&#39;, &#39;static&#39;], [&#39;shortly.py&#39;])</span>

<span class="sd">    第一个可选参数 startpath  默认值 &#39;.&#39;</span>
<span class="sd">    第二个参数  filetype  正则表达式模板 默认值是&quot;&quot; 其作用是只选择某些文件</span>
<span class="sd">    如果是空值，则所有的文件都将被选中。比如 &quot;html$|pdf$&quot; 将只选中 html和pdf文件。</span>
<span class="sd">    &#39;&#39;&#39;</span>
    <span class="k">for</span> <span class="n">root</span><span class="p">,</span> <span class="n">dirs</span><span class="p">,</span> <span class="n">files</span> <span class="ow">in</span> <span class="n">os</span><span class="o">.</span><span class="n">walk</span><span class="p">(</span><span class="n">startpath</span><span class="p">):</span>
        <span class="n">filelist</span> <span class="o">=</span> <span class="p">[]</span>
        <span class="k">for</span> <span class="n">f</span> <span class="ow">in</span> <span class="n">files</span><span class="p">:</span>
            <span class="n">fileName</span><span class="p">,</span><span class="n">fileExt</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">splitext</span><span class="p">(</span><span class="n">f</span><span class="p">)</span>
            <span class="k">if</span> <span class="n">filetype</span><span class="p">:</span>
                <span class="k">if</span> <span class="n">re</span><span class="o">.</span><span class="n">search</span><span class="p">(</span><span class="n">filetype</span><span class="p">,</span><span class="n">fileExt</span><span class="p">):</span>
                    <span class="n">filelist</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">f</span><span class="p">)</span>
            <span class="k">else</span><span class="p">:</span>
                <span class="n">filelist</span> <span class="o">=</span> <span class="n">files</span>
        <span class="k">if</span> <span class="n">filelist</span><span class="p">:</span><span class="c1">#空文件夹不加入</span>
            <span class="n">dirlist</span> <span class="o">=</span> <span class="n">root</span><span class="o">.</span><span class="n">split</span><span class="p">(</span><span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">sep</span><span class="p">)</span>
            <span class="n">dirlist</span> <span class="o">=</span> <span class="n">dirlist</span><span class="p">[</span><span class="mi">1</span><span class="p">:]</span>
            <span class="k">if</span> <span class="n">dirlist</span><span class="p">:</span>
                <span class="k">yield</span> <span class="p">(</span><span class="n">dirlist</span><span class="p">,</span> <span class="n">filelist</span><span class="p">)</span>
            <span class="k">else</span><span class="p">:</span>
                <span class="k">yield</span> <span class="p">([</span><span class="s1">&#39;.&#39;</span><span class="p">],</span> <span class="n">filelist</span><span class="p">)</span>
</pre></div>


<p>
这个函数可以帮助你管理本目录下（可以通过正则表达式过滤）你感兴趣的文件，都刷一边。然后继续必要的操作，比如查找等等之类的。
</p>
</div>
</div>

<div class="outline-3">
<h3 id="orgheadline46">environ函数</h3>
<div class="outline-text-3" id="text-8-10">
<p>
os.environ，返回一个字典值，这个字典值里面存储着当前shell的一些变量和值。比如系统中“HOME”所具体的路径名是：
</p>
<pre>
import os
print(os.environ['HOME'])
</pre>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline47">getpid函数</h3>
<div class="outline-text-3" id="text-8-11">
<p>
os.getpid函数，返回当前运行的进程的pid。
</p>
</div>
</div>

<div class="outline-3">
<h3 id="orgheadline48">stat函数</h3>
<div class="outline-text-3" id="text-8-12">
<p>
返回文件的一些信息。比如 <code>st_size</code> 是文件的大小，单位是字节。此外还有:
</p>

<dl class="org-dl">
<dt><code>st_mtime</code></dt><dd>最后文件修改的时间。</dd>

<dt><code>st_ctime</code></dt><dd>最后文件创建的时间，在windows下是严格的最初文件创建时间，在unix下是最后文件metadata的改变时间。</dd>
</dl>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline49">给进程发送信号</h3>
<div class="outline-text-3" id="text-8-13">
<p>
可以通过os模块的kill函数来给某个进程发送某个信号。
</p>
<pre>
os.kill(pid, sig)
</pre>


<p>
函数第一个参数是进程的pid，第二个参数是具体发送的信号。比如:
</p>
<pre>
os.kill(pid, signal.SIGSTOP)
</pre>

<p>
就是暂停某个进程，然后
</p>

<pre>
os.kill(pid, signal.SIGCONT)
</pre>

<p>
是继续某个进程。 然后 <code>killpg</code> 函数能够对某个进程包括其子进程发送某个信号，参考了 <a href="http://kernelcheck.blogspot.com/2009/07/pausestop-process-in-python.html">这个网页</a> 。
</p>

<p>
除此之外还有 <code>SIGINT</code> （正常终止进程信号）和 <code>SIGKILL</code> （强制终止进程信号） 等等，更多信号请参看关于unix信号那块，比如 <a href="http://en.wikipedia.org/wiki/Unix_signal">这个wiki页面</a> 。
</p>


<div class="NOTECARD">
<p>
更多os模块内容请参见 <a href="https://docs.python.org/3.4/library/os.html">官方文档</a> 。
</p>

</div>
</div>
</div>
</div>

<div class="outline-2">
<h2 id="orgheadline57">shutil模块</h2>
<div class="outline-text-2" id="text-9">
<p>
相当于os模块的补充，shutil模块进一步提供了一些系统级别的文件或文件夹的复制，删除，移动等等操作。
</p>
</div>

<div class="outline-3">
<h3 id="orgheadline51">复制文件</h3>
<div class="outline-text-3" id="text-9-1">
<pre>
shutil.copyfile(src, dst)
shutil.copy(src, dst)
shutil.copy2(src, dst)
</pre>

<p>
其中 <code>copyfile</code> 的src和dst两个参量都是完整文件路径名，第一个参量是待复制的文件，第二个参量是复制后的文件名；而 <code>copy</code> 函数的第一个参量是待复制的文件，但是第二个参量是目标文件夹路径； <code>copy2</code> 函数和copy函数类似，不同的是它能尝试保留文件的所有元信息metadata（模块开头有说明是理论上但不尽然）。
</p>
</div>
</div>

<div class="outline-3">
<h3 id="orgheadline52">复制文件夹</h3>
<div class="outline-text-3" id="text-9-2">
<pre>
shutil.copytree(src, dst)
</pre>

<p>
<code>copytree</code> 函数第一个参量是待复制的文件夹路径名，第二个参量是目标文件夹路径名，其将被创建不应该存在。
</p>
</div>
</div>

<div class="outline-3">
<h3 id="orgheadline53">删除整个目录</h3>
<div class="outline-text-3" id="text-9-3">
<pre>
shutil.rmtree(path)
</pre>

<p>
<code>rmtree</code> 函数用于删除整个文件夹，path就是目标文件夹的路径名。
</p>
</div>
</div>

<div class="outline-3">
<h3 id="orgheadline54">移动文件夹</h3>
<div class="outline-text-3" id="text-9-4">
<pre>
shutil.move(src,dst)
</pre>

<p>
<code>move</code> 函数把一个文件或者一个文件夹移动到一个文件夹内。
</p>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline55">chown函数</h3>
<div class="outline-text-3" id="text-9-5">
<pre>
shutil.chown(path, user=None, group=None)
</pre>

<p>
<code>chown</code> 函数类似的linux系统下的chown函数，这个函数基于os.chown函数，不过接口更友好。
</p>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline56">which函数</h3>
<div class="outline-text-3" id="text-9-6">
<pre>
shutil.which(cmd)
</pre>

<p>
<code>which</code> 函数类似的linux系统下的which函数。
</p>


<div class="NOTECARD">
<p>
更多shutil模块内容请参见 <a href="https://docs.python.org/3.4/library/shutil.html">官方文档</a> 。
</p>

</div>
</div>
</div>
</div>


<div class="outline-2">
<h2 id="orgheadline63">tarfile和zipfile模块</h2>
<div class="outline-text-2" id="text-10">
<p>
tarfile是gzip，bz2和lzma压缩文件读写的解决方案，zipfile模块是zip压缩文件的解决方案， <em>值得一提的是pip管理的egg文件也可以通过zipfile模块来管理</em> 。
</p>
</div>

<div class="outline-3">
<h3 id="orgheadline59">制作gz压缩文件</h3>
<div class="outline-text-3" id="text-10-1">
<p>
请看下面的例子：
</p>
<div class="highlight"><pre><span></span><span class="kn">import</span> <span class="nn">tarfile</span>
<span class="k">with</span> <span class="n">tarfile</span><span class="o">.</span><span class="n">open</span><span class="p">(</span><span class="s2">&quot;skeleton.tar.gz&quot;</span><span class="p">,</span> <span class="s2">&quot;w:gz&quot;</span><span class="p">)</span> <span class="k">as</span> <span class="n">tar</span><span class="p">:</span>
    <span class="k">for</span> <span class="n">name</span> <span class="ow">in</span> <span class="p">[</span><span class="s2">&quot;setup.py&quot;</span><span class="p">,</span><span class="s2">&quot;LICENSE&quot;</span><span class="p">,</span><span class="s2">&quot;README.md&quot;</span><span class="p">,</span><span class="s2">&quot;skeleton&quot;</span><span class="p">,</span> <span class="s2">&quot;docs&quot;</span><span class="p">]:</span>
        <span class="n">tar</span><span class="o">.</span><span class="n">add</span><span class="p">(</span><span class="n">name</span><span class="p">)</span>
</pre></div>

<p>
这里首先用tarfile模块的 <code>open</code> 函数来返回一个TarFile对象，其中第一个参数是你的压缩文件的名字，第二个参数是处理模式。
</p>

<p>
模式可接受的参数如下：
</p>

<dl class="org-dl">
<dt>r</dt><dd>默认值是r，就是只读某个压缩文件。类似有 <code>r:gz</code> ， <code>r:bz2</code> 和 <code>r:xz</code> ，这里的意思就是具体设置好要读的压缩文件的格式（gzip，bzip2和lzma）。</dd>
<dt>w</dt><dd>类似的还有 <code>w:gz</code>  ， <code>w:bz2</code> ， <code>w:xz</code> 。这里 <code>w</code> 或者 <code>w:</code> 官方文档的说明是（Open for uncompressed writing），我对这个无压缩方式写不是很理解。</dd>
<dt>a</dt><dd>还有 <code>a:</code> ， Open for appending with no compression. 文件如果不存在将被创建。</dd>
</dl>
</div>

<div class="outline-4">
<h4 id="orgheadline58">TarFile的add方法</h4>
<div class="outline-text-4" id="text-10-1-1">
<p>
然后接下来就是往压缩文件里面添加内容（文件或者整个目录），具体就是用创建的TarFile对象的add方法，如上例子所示。
</p>
</div>
</div>
</div>

<div class="outline-3">
<h3 id="orgheadline60">解压缩gz压缩文件</h3>
<div class="outline-text-3" id="text-10-2">
<p>
最简单的例子如下所示：
</p>
<div class="highlight"><pre><span></span><span class="k">with</span> <span class="n">tarfile</span><span class="o">.</span><span class="n">open</span><span class="p">(</span><span class="s2">&quot;skeleton.tar.gz&quot;</span><span class="p">)</span> <span class="k">as</span> <span class="n">tar</span><span class="p">:</span>
    <span class="n">tar</span><span class="o">.</span><span class="n">extractall</span><span class="p">()</span>
</pre></div>

<p>
用tarfile模块的open函数打开那个压缩文件，用返回的TarFile对象的extractall方法解压缩这个文件，注意用os.chdir来控制当前工作目录。
</p>


<div class="NOTECARD">
<p>
更多tarfile模块内容请参见 <a href="https://docs.python.org/3.4/library/tarfile.html">官方文档</a> 。
</p>

</div>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline61">提取egg文件中的内容</h3>
<div class="outline-text-3" id="text-10-3">
<p>
简单的例子如下所示：
</p>
<div class="highlight"><pre><span></span><span class="nb">zip</span><span class="o">=</span><span class="n">zipfile</span><span class="o">.</span><span class="n">ZipFile</span><span class="p">(</span><span class="s2">&quot;test.egg&quot;</span><span class="p">)</span>
<span class="nb">zip</span><span class="o">.</span><span class="n">extract</span><span class="p">(</span><span class="s1">&#39;test.txt&#39;</span><span class="p">)</span>
</pre></div>

<p>
这里用zipfile模块的ZipFile构造函数创建了一个ZipFile对象，然后用ZipFile的 <code>extract</code> 方法提取出了test.txt文件在当前工作目录。
</p>

<p>
相关的 <code>extractall</code> 方法将会提取出压缩文件中所有的内容。
</p>
</div>
</div>

<div class="outline-3">
<h3 id="orgheadline62">制作zip压缩文件</h3>
<div class="outline-text-3" id="text-10-4">
<p>
简单的示例如下：
</p>
<div class="highlight"><pre><span></span><span class="k">with</span> <span class="n">zipfile</span><span class="o">.</span><span class="n">ZipFile</span><span class="p">(</span><span class="s1">&#39;test.zip&#39;</span><span class="p">,</span><span class="s1">&#39;w&#39;</span><span class="p">)</span> <span class="k">as</span> <span class="nb">zip</span><span class="p">:</span>
    <span class="nb">zip</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="s1">&#39;test2.png&#39;</span><span class="p">)</span>
</pre></div>

<p>
首先用zipfile模块的ZipFile构造函数创建一个ZipFile对象，这里mode需要使用 'w'，然后使用ZipFile对象的write方法来添加内容。你可以猜到如果模式是 'a' 的话write方法是给这个压缩文件添加内容（a模式同文件操作含义如果原压缩文件不存在也是可以创建的）。
</p>


<div class="NOTECARD">
<p>
更多zipfile模块内容请参见 <a href="https://docs.python.org/3.4/library/zipfile.html">官方文档</a> 。
</p>

</div>
</div>
</div>
</div>


<div class="outline-2">
<h2 id="orgheadline66">itertools模块</h2>
<div class="outline-text-2" id="text-11">
</div><div class="outline-3">
<h3 id="orgheadline64">repeat函数</h3>
<div class="outline-text-3" id="text-11-1">
<p>
其定义函数如下：
</p>
<div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">repeat</span><span class="p">(</span><span class="nb">object</span><span class="p">,</span> <span class="n">times</span><span class="o">=</span><span class="bp">None</span><span class="p">):</span>
    <span class="c1"># repeat(10, 3) --&gt; 10 10 10</span>
    <span class="k">if</span> <span class="n">times</span> <span class="ow">is</span> <span class="bp">None</span><span class="p">:</span>
        <span class="k">while</span> <span class="bp">True</span><span class="p">:</span>
            <span class="k">yield</span> <span class="nb">object</span>
    <span class="k">else</span><span class="p">:</span>
        <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">times</span><span class="p">):</span>
            <span class="k">yield</span> <span class="nb">object</span>
</pre></div>

<p>
也就是返回一个可迭代对象，这么封装最大的一个用处是用于填充map函数或者zip函数的某个常数值。因为你填写repeat(5)之后将一个返回一个可迭代对象，不停的返回数字5而不需要你考虑长度问题。
</p>
</div>
</div>

<div class="outline-3">
<h3 id="orgheadline65">starmap函数</h3>
<div class="outline-text-3" id="text-11-2">
<p>
starmap函数具体定义如下所示：
</p>
<div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">starmap</span><span class="p">(</span><span class="n">function</span><span class="p">,</span> <span class="n">iterable</span><span class="p">):</span>
    <span class="c1"># starmap(pow, [(2,5), (3,2), (10,3)]) --&gt; 32 9 1000</span>
    <span class="k">for</span> <span class="n">args</span> <span class="ow">in</span> <span class="n">iterable</span><span class="p">:</span>
        <span class="k">yield</span> <span class="n">function</span><span class="p">(</span><span class="o">*</span><span class="n">args</span><span class="p">)</span>
</pre></div>

<p>
其接受一个可迭代对象，然后逐个将可迭代对象中的元素解包之后送入函数当参数（最后当然函数也执行了）。
</p>
</div>
</div>
</div>


<div class="outline-2">
<h2 id="orgheadline70">multiprocessing模块</h2>
<div class="outline-text-2" id="text-12">
<p>
multiprocessing为python提供了多进程（或者多线程）的解决方案。
</p>
</div>

<div class="outline-3">
<h3 id="orgheadline68">Pool类</h3>
<div class="outline-text-3" id="text-12-1">
<pre>
from multiprocessing import Pool

def f(x):
    return x*x

if __name__ == '__main__':
    with Pool(5) as p:
        print(p.map(f, [1, 2, 3]))
</pre>

<p>
这里Pool的第一个参数是可选项 <code>processes</code> ，如果不设置，则默认的是 <code>os.cpu_count()</code> ，即当前系统的cpu数。
</p>

<p>
一般cpu密集型的任务推荐使用多进程处理，当然前提是你有多个cpu的情况下，如果你并没有相关硬件条件，追求时髦动用多进程还不如用单进程，集中精力用好的算法办好一件事。不过不同进程（不同程序）之间的通信还是很有用的。
</p>

<p>
这里的map是Pool对象的 <code>map</code> 方法，其除了接受第一个列表参数，然后用多进程分别处理这些列表中的元素之外，并不能在额外接受其他参数了。如果你想要接受一些参数，推荐使用 <code>starmap</code> 方法。
</p>
</div>

<div class="outline-4">
<h4 id="orgheadline67">starmap方法</h4>
<div class="outline-text-4" id="text-12-1-1">
<p>
starmap类似map方法，不过其接受的是一系列的函数参数。值得注意的是python的itertools模块里面提供的starmap，repeat还有python语言的zip和map函数等在此处有时会很有用，可能是你感兴趣的。
</p>
<div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">multiprocessing</span> <span class="kn">import</span> <span class="n">Pool</span>

<span class="k">def</span> <span class="nf">f</span><span class="p">(</span><span class="n">x</span><span class="p">,</span><span class="n">y</span><span class="p">):</span>
    <span class="k">return</span> <span class="p">(</span><span class="n">x</span><span class="o">*</span><span class="n">x</span><span class="o">+</span><span class="n">y</span><span class="o">*</span><span class="n">y</span><span class="p">)</span>

<span class="k">if</span> <span class="n">__name__</span> <span class="o">==</span> <span class="s1">&#39;__main__&#39;</span><span class="p">:</span>
    <span class="k">with</span> <span class="n">Pool</span><span class="p">(</span><span class="mi">5</span><span class="p">)</span> <span class="k">as</span> <span class="n">p</span><span class="p">:</span>
        <span class="k">print</span><span class="p">(</span><span class="n">p</span><span class="o">.</span><span class="n">starmap</span><span class="p">(</span><span class="n">f</span><span class="p">,</span> <span class="p">[(</span><span class="mi">1</span><span class="p">,</span><span class="mi">1</span><span class="p">),(</span><span class="mi">2</span><span class="p">,</span><span class="mi">2</span><span class="p">),(</span><span class="mi">3</span><span class="p">,</span><span class="mi">3</span><span class="p">)]))</span>
</pre></div>


<p>
在看一个有可选参数的情况：
</p>
<div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">multiprocessing.dummy</span> <span class="kn">import</span> <span class="n">Pool</span> <span class="k">as</span> <span class="n">ThreadPool</span>
<span class="kn">from</span> <span class="nn">itertools</span> <span class="kn">import</span> <span class="n">repeat</span>

<span class="n">urls</span> <span class="o">=</span> <span class="n">get_all_urls</span><span class="p">(</span><span class="n">base_url</span><span class="p">,</span><span class="n">model_url</span><span class="p">)</span>

<span class="k">with</span> <span class="n">ThreadPool</span><span class="p">(</span><span class="mi">6</span><span class="p">)</span> <span class="k">as</span> <span class="n">tp</span><span class="p">:</span>
    <span class="n">imgs</span> <span class="o">=</span> <span class="n">tp</span><span class="o">.</span><span class="n">starmap</span><span class="p">(</span><span class="n">get_url_imgs</span><span class="p">,</span><span class="nb">zip</span><span class="p">(</span><span class="n">urls</span><span class="p">,</span><span class="n">repeat</span><span class="p">(</span><span class="n">inclass</span><span class="p">))</span>
</pre></div>


<p>
这里的 <code>get_url_imgs</code> 除了接受第一个url参数之外，还接受一个可选参数inclass，这里通过repeat封装之后将这两个参数用zip函数封装即能达到这样的执行效果：
</p>

<pre>
get_url_imgs(url,inclass)
get_url_imgs(url,inclass)
get_url_imgs(url,inclass)
.....
</pre>

<p>
然后这些都是多线程运行的。
</p>
</div>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline69">ThreadPool类</h3>
<div class="outline-text-3" id="text-12-2">
<p>
一般和网络相关的I/O密集型任务推荐使用多线程处理，但也不是线程设置得越多越好，一般设置为当前CPU数*2+2左右，再多并没有起到提速效果，有时反而会降低速度。
</p>

<p>
multiprocessing还有一个dummy子模块，其提供了和multiprocessing一样的API [<sup><a id="fnr.1" class="footref" href="#fn.1">1</a></sup> ，不同的是multiprocessing作用于进程，而dummy子模块是作用于线程的。
</p>


<pre>
from multiprocessing.dummy import Pool as ThreadPool

with ThreadPool(6) as tp:
    imgs = tp.map(partial_get_url_imgs,urls)
</pre>
</div>
</div>
</div>
<div id="footnotes">
<h2 class="footnotes">Footnotes: </h2>
<div id="text-footnotes">

<div class="footdef"><sup><a id="fn.1" class="footnum" href="#fnr.1">1</a></sup> <div class="footpara">请参看这个 <a href="http://segmentfault.com/blog/caspar/1190000000414339b">网页</a> 。</div></div>


</div>
</div></div>
</body>
</html>