Python学习记录day6-反射、常用模块

系统管理员 2022-07-14 09:38 314阅读 0赞

# Python学习记录day6-反射、常用模块 #

@(学习)\[python\]

*  Python学习记录day6-反射常用模块
 *  反射
 *  常用模块
    
     *  1 sys System-specific parameters and functions
     *  2 os Miscellaneous operating system interfaces
     *  3 hashlib Secure hashes and message digests
     *  4 re Regular expression operations
     *  5 random Generate pseudo-random numbers
     *  6 shutil High-level file operations
     *  7 shelve Python object persistence
     *  8 xml
     *  9 configparser Configuration file parser
     *  10 subprocess Subprocess management
     *  11 urllibrequest Extensible library for opening URLs

# 1.反射 #

反射：利用字符串的形式去对象（默认）中操作（寻找）成员  
`cat commons.py`

#!/usr/bin/env python
    #_*_coding:utf-8_*_
    ''' * Created on 2016/12/3 21:54. * @author: Chinge_Yang. '''
    
    def login():
        print("炫酷登录")
    
    
    def home():
        print("炫酷页面")
    
    
    def logout():
        print("欢乐退出")

`cat index.py`

#!/usr/bin/env python
    #_*_coding:utf-8_*_
    ''' * Created on 2016/12/3 21:56. * @author: Chinge_Yang. '''
    
    
    import commons
    
    def run():
        if hasattr(commons, inp):
            inp = input("请输入要访问的url：")
            func = getattr(commons, inp)
            func()
        else:
            print("404")
    
    
    if __name__ == "__main__":
        run()

以字符串方式导入模块：

obj = __import__("commons")
    obj = __import__("commons.login", fromlist = True)

实例实质：伪造Web框架的路由系统  
getattr,delattr,setattr,hasattr

# 2.常用模块 #

模块中的特殊变量：

print(__doc__)  #获取文件开头的注释，(3个引号中间的信息) 
    
    __cache__   #缓存pyc存放的位置
    
    print(__file__) #当前py文件所在的路径
    
    os.path.abspath()   #获取文件的绝对路径
    os.path.dirname()   #获取文件目录的名字
    sys.path.append(os.path.dirname(os.path.abspath(__file__))) #添加文件上层目录到python库
    
    print(admin.__packages__)   #获取admin所在的包名
    #只有执行当前文件时，当前文件的特殊变量__name__ == "__main__"

## 2.1 sys — System-specific parameters and functions ##

用于提供对Python解释器相关的操作：

sys.argv           命令行参数List，第一个元素是程序本身路径
    sys.exit(n)        退出程序，正常退出时exit(0)
    sys.version        获取Python解释程序的版本信息
    sys.maxint         最大的Int值
    sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
    sys.platform       返回操作系统平台名称
    sys.stdin          输入相关
    sys.stdout         输出相关
    sys.stderror       错误相关

**进度条案例：**

#!/usr/bin/env python
    # _*_coding:utf-8_*_
    ''' * Created on 2016/12/4 10:53. * @author: Chinge_Yang. '''
    
    import sys
    import time
    
    
    def view_bar(num, total):
        rate =  num / total
        rate_num = int(rate * 100)
        #r = '\r%d%%' % (rate_num, )
        r = '\r%s>%d%%' % (">" * num, rate_num)
        sys.stdout.write(r)
        sys.stdout.flush()
    
    
    if __name__ == '__main__':
        for i in range(0, 100):
            time.sleep(0.1)
            view_bar(i, 100)

更多用法：  
[https://docs.python.org/3/library/sys.html][https_docs.python.org_3_library_sys.html]

## 2.2 os — Miscellaneous operating system interfaces ##

用于提供系统级别的操作：

os.getcwd()                 获取当前工作目录，即当前python脚本工作的目录路径
    os.chdir("dirname")         改变当前脚本工作目录；相当于shell下cd
    os.curdir                   返回当前目录: ('.')
    os.pardir                   获取当前目录的父目录字符串名：('..')
    os.makedirs('dir1/dir2')    可生成多层递归目录
    os.removedirs('dirname1')   若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
    os.mkdir('dirname')         生成单级目录；相当于shell中mkdir dirname
    os.rmdir('dirname')         删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
    os.listdir('dirname')       列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
    os.remove()                 删除一个文件
    os.rename("oldname","new")  重命名文件/目录
    os.stat('path/filename')    获取文件/目录信息
    os.sep                      操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
    os.linesep                  当前平台使用的行终止符，win下为"\t\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所指向的文件或者目录的最后修改时间

更多用法：  
[https://docs.python.org/3/library/os.html?highlight=os\#module-os][https_docs.python.org_3_library_os.html_highlight_os_module-os]

## 2.3 hashlib — Secure hashes and message digests ##

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

import hashlib
    
    # ######## md5 ########
    hash = hashlib.md5()
    # help(hash.update)
    hash.update(bytes('admin', encoding='utf-8'))
    print(hash.hexdigest())
    print(hash.digest())
    
    
    ######## sha1 ########
    
    hash = hashlib.sha1()
    hash.update(bytes('admin', encoding='utf-8'))
    print(hash.hexdigest())
    
    # ######## sha256 ########
    
    hash = hashlib.sha256()
    hash.update(bytes('admin', encoding='utf-8'))
    print(hash.hexdigest())
    
    
    # ######## sha384 ########
    
    hash = hashlib.sha384()
    hash.update(bytes('admin', encoding='utf-8'))
    print(hash.hexdigest())
    
    # ######## sha512 ########
    
    hash = hashlib.sha512()
    hash.update(bytes('admin', encoding='utf-8'))
    print(hash.hexdigest())
    以上加密算法虽然依然非常厉害，但时候存在缺陷，即：通过撞库可以反解。所以，有必要对加密算法中添加自定义key再来做加密。
    
    import hashlib
    
    # ######## md5 ########
    
    hash = hashlib.md5(bytes('ygqygq2',encoding="utf-8"))
    hash.update(bytes('admin',encoding="utf-8"))
    print(hash.hexdigest())
    python内置还有一个 hmac 模块，它内部对我们创建 key 和 内容 进行进一步的处理然后再加密
    
    import hmac
    
    h = hmac.new(bytes('ygqygq2',encoding="utf-8"))
    h.update(bytes('admin',encoding="utf-8"))
    print(h.hexdigest())

更多用法：  
[https://docs.python.org/3/library/hashlib.html][https_docs.python.org_3_library_hashlib.html]

## 2.4 re — Regular expression operations ##

简介：  
就其本质而言，正则表达式（或re）是一种小型的、高度专业化的编程语言，（在Python中）它内嵌在Python中，并通过re模块实现。正则表达式模式被编译成一系列的字节码，然后由用C编写的匹配引擎执行。

*  字符：  
    . 匹配除换行符以外的任意字符  
    \\w 匹配字母或数字或下划线或汉字  
    \\s 匹配任意的空白符  
    \\d 匹配数字  
    \\b 匹配单词的开始或结束  
    ^ 匹配字符串的开始  
    $ 匹配字符串的结束
 *  次数：  
    \* 重复零次或更多次  
    \+ 重复一次或更多次  
    ? 重复零次或一次  
    \{n\} 重复n次  
    \{n,\} 重复n次或更多次  
    \{n,m\} 重复n到m次

Python提供re模块，包含所有正则表达式的功能。由于Python的字符串本身也用\\转义，所以要特别注意：

s = 'ABC\\-001' # Python的字符串
    # 对应的正则表达式字符串变成：
    # 'ABC\-001'

因此我们强烈建议使用Python的r前缀，就不用考虑转义的问题了：

s = r'ABC\-001' # Python的字符串
    # 对应的正则表达式字符串不变：
    # 'ABC\-001'

先看看如何判断正则表达式是否匹配：

>>> import re
    >>> re.match(r'^\d{3}\-\d{3,8}$', '010-12345')
    <_sre.SRE_Match object; span=(0, 9), match='010-12345'>
    >>> re.match(r'^\d{3}\-\d{3,8}$', '010 12345')
    >>>

**分组**  
除了简单地判断是否匹配之外，正则表达式还有提取子串的强大功能。用()表示的就是要提取的分组（Group）。比如：

^(\\d\{3\})-(\\d\{3,8\})$分别定义了两个组，可以直接从匹配的字符串中提取出区号和本地号码：

>>> m = re.match(r'^(\d{3})-(\d{3,8})$', '010-12345')
    >>> m
    <_sre.SRE_Match object; span=(0, 9), match='010-12345'>
    >>> m.group(0)
    '010-12345'
    >>> m.group(1)
    '010'
    >>> m.group(2)
    '12345'

如果正则表达式中定义了组，就可以在Match对象上用group()方法提取出子串来。  
注意到group(0)永远是原始字符串，group(1)、group(2)……表示第1、2、……个子串。  
提取子串非常有用。来看一个更凶残的例子：

>>> t = '19:05:30'
    >>> m = re.match(r'^(0[0-9]|1[0-9]|2[0-3]|[0-9])\:(0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|[0-9])\:(0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|[0-9])$', t)
    >>> m.groups()
    ('19', '05', '30')

这个正则表达式可以直接识别合法的时间。但是有些时候，用正则表达式也无法做到完全验证，比如识别日期：  
`'^(0[1-9]|1[0-2]|[0-9])-(0[1-9]|1[0-9]|2[0-9]|3[0-1]|[0-9])$'`  
对于’2-30’，’4-31’这样的非法日期，用正则还是识别不了，或者说写出来非常困难，这时就需要程序配合识别了。

**编译**  
当我们在Python中使用正则表达式时，re模块内部会干两件事情：  
编译正则表达式，如果正则表达式的字符串本身不合法，会报错；  
用编译后的正则表达式去匹配字符串。  
如果一个正则表达式要重复使用几千次，出于效率的考虑，我们可以预编译该正则表达式，接下来重复使用时就不需要编译这个步骤了，直接匹配：

>>> import re
    # 编译:
    >>> re_telephone = re.compile(r'^(\d{3})-(\d{3,8})$')
    # 使用：
    >>> re_telephone.match('010-12345').groups()
    ('010', '12345')
    >>> re_telephone.match('010-8086').groups()
    ('010', '8086')

**match**

# match，从起始位置开始匹配，匹配成功返回一个对象，未匹配成功返回None
    
    
     match(pattern, string, flags=0)
     # pattern： 正则模型
     # string ： 要匹配的字符串
     # falgs ： 匹配模式
         X  VERBOSE     Ignore whitespace and comments for nicer looking RE's. I IGNORECASE Perform case-insensitive matching. M MULTILINE "^" matches the beginning of lines (after a newline) as well as the string. "$" matches the end of lines (before a newline) as well as the end of the string. S DOTALL "." matches any character at all, including the newline. A ASCII For string patterns, make \w, \W, \b, \B, \d, \D match the corresponding ASCII character categories (rather than the whole Unicode categories, which is the default). For bytes patterns, this flag is the only available behaviour and needn't be specified.
    
         L  LOCALE      Make \w, \W, \b, \B, dependent on the current locale.
         U  UNICODE     For compatibility only. Ignored for string patterns (it
                        is the default), and forbidden for bytes patterns.

实例：

# 无分组
    r = re.match("h\w+", origin)
    print(r.group())     # 获取匹配到的所有结果
    print(r.groups())    # 获取模型中匹配到的分组结果
    print(r.groupdict()) # 获取模型中匹配到的分组结果
    
    # 有分组
    
    # 为何要有分组？提取匹配成功的指定内容（先匹配成功全部正则，再匹配成功的局部内容提取出来）
    
    r = re.match("h(\w+).*(?P<name>\d)$", origin)
    print(r.group())     # 获取匹配到的所有结果
    print(r.groups())    # 获取模型中匹配到的分组结果
    print(r.groupdict()) # 获取模型中匹配到的分组中所有执行了key的组

**search**

# search,浏览整个字符串去匹配第一个，未匹配成功返回None
    # search(pattern, string, flags=0)

实例：

# 无分组
    
    r = re.search("a\w+", origin)
    print(r.group())     # 获取匹配到的所有结果
    print(r.groups())    # 获取模型中匹配到的分组结果
    print(r.groupdict()) # 获取模型中匹配到的分组结果
    
    # 有分组
    
    r = re.search("a(\w+).*(?P<name>\d)$", origin)
    print(r.group())     # 获取匹配到的所有结果
    print(r.groups())    # 获取模型中匹配到的分组结果
    print(r.groupdict()) # 获取模型中匹配到的分组中所有执行了key的组

**findall**

# findall，获取非重复的匹配列表；如果有一个组则以列表形式返回，且每一个匹配均是字符串；如果模型中有多个组，则以列表形式返回，且每一个匹配均是元祖；
    # 空的匹配也会包含在结果中
    #findall(pattern, string, flags=0)

实例：

# 无分组
    r = re.findall("a\w+",origin)
    print(r)
    
    # 有分组
    origin = "hello alex bcd abcd lge acd 19"
    r = re.findall("a((\w*)c)(d)", origin)
    print(r)

**sub**

# sub，替换匹配成功的指定位置字符串
    
    sub(pattern, repl, string, count=0, flags=0)
    # pattern： 正则模型
    # repl ： 要替换的字符串或可执行对象
    # string ： 要匹配的字符串
    # count ： 指定匹配个数
    # flags ： 匹配模式

实例：

# 与分组无关
    
    origin = "hello alex bcd alex lge alex acd 19"
    r = re.sub("a\w+", "999", origin, 2)
    print(r)

**split**

# split，根据正则匹配分割字符串
    
    split(pattern, string, maxsplit=0, flags=0)
    # pattern： 正则模型
    # string ： 要匹配的字符串
    # maxsplit：指定分割个数
    # flags ： 匹配模式

实例：

# 无分组
    origin = "hello alex bcd alex lge alex acd 19"
    r = re.split("alex", origin, 1)
    print(r)
    
    # 有分组
    
    origin = "hello alex bcd alex lge alex acd 19"
    r1 = re.split("(alex)", origin, 1)
    print(r1)
    r2 = re.split("(al(ex))", origin, 1)
    print(r2)

常用正则表达式：

IP：
    ^(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){
       3}$
    手机号：
    ^1[3|4|5|8][0-9]\d{
       8}$
    邮箱：
    [a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+

更多用法：  
[https://docs.python.org/3/library/re.html][https_docs.python.org_3_library_re.html]

## 2.5 random — Generate pseudo-random numbers ##

**随机数**

import random
    print random.random()
    print random.randint(1,2)
    print random.randrange(1,10)

**生成随机验证码**

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

更多用法：  
[https://docs.python.org/3/library/random.html][https_docs.python.org_3_library_random.html]

## 2.6 shutil — High-level file operations ##

**shutil.copyfile( src, dst)** 从源src复制到dst中去。当然前提是目标地址是具备可写权限。抛出的异常信息为IOException. 如果当前的dst已存在的话就会被覆盖掉  
**shutil.move( src, dst)** 移动文件或重命名  
**shutil.copymode( src, dst)** 只是会复制其权限，其他的东西是不会被复制的  
**shutil.copystat( src, dst)** 复制权限、最后访问时间、最后修改时间  
**shutil.copy( src, dst)** 复制一个文件到一个文件或一个目录  
**shutil.copy2( src, dst)** 在copy上的基础上再复制文件最后访问时间与修改时间也复制过来了，类似于cp –p的东西  
**shutil.copy2( src, dst)** 如果两个位置的文件系统是一样的话相当于是rename操作，只是改名；如果是不在相同的文件系统的话就是做move操作  
**shutil.copytree( olddir, newdir, True/Flase)** 把olddir拷贝一份newdir，如果第3个参数是True，则复制目录时将保持文件夹下的符号连接，如果第3个参数是False，则将在复制的目录下生成物理副本来替代符号连接  
**shutil.rmtree( src )** 递归删除一个目录以及目录内的所有内容  
**shutil.make\_archive(base\_name, format\[, root\_dir\[, base\_dir\[, verbose\[, dry\_run\[, owner\[, group\[, logger\]\]\]\]\]\]\])** 创建压缩包并返回文件路径，例如：zip、tar

base_name： 压缩包的文件名，也可以是压缩包的路径。只是文件名时，则保存至当前目录，否则保存至指定路径，
    如：www                        =>保存至当前路径
    如：/Users/wupeiqi/www =>保存至/Users/wupeiqi/
    format： 压缩包种类，“zip”, “tar”, “bztar”，“gztar”
    root_dir：   要压缩的文件夹路径（默认当前目录）
    owner：  用户，默认当前用户
    group：  组，默认当前组
    logger： 用于记录日志，通常是logging.Logger对象

更多用法：  
[https://docs.python.org/3/library/shutil.html][https_docs.python.org_3_library_shutil.html]  
[https://docs.python.org/3/library/zipfile.html][https_docs.python.org_3_library_zipfile.html]

## 2.7 shelve — Python object persistence ##

shelve模块是一个简单的k,v将内存数据通过文件持久化的模块，可以持久化任何pickle可支持的python数据格式。

先把数据保存在文件中：  
`vim shelve_test.py`

#!/usr/bin/env python
    # _*_coding:utf-8_*_
    ''' * Created on 2017/2/2 17:47. * @author: Chinge_Yang. '''
    
    import shelve
    
    d = shelve.open("shelve_test")
    
    
    def stu_data(name, age):
        print("student:", name, age)
    
    
    name = ["stu1", "stu2", "stu3"]
    info = {
       "name": "test01", "age": 22}
    
    d["test"] = name
    d['func'] = stu_data
    d["info"] = info
    
    d.close()

`python shelve_test.py`

然后读取数据：  
`vim shelve_print.py`

#!/usr/bin/env python
    # _*_coding:utf-8_*_
    ''' * Created on 2017/2/2 20:00. * @author: Chinge_Yang. '''
    
    import shelve
    
    
    def stu_data(name, age):
        print("student:", name, age)
    
    
    f = shelve.open("shelve_test")
    
    print(f["test"])
    print(f["func"])
    print(f["info"])

`python shelve_print.py`

结果得到之前保存的数据：

['stu1', 'stu2', 'stu3']
    <function stu_data at 0x10e6cb158> { 'age': 22, 'name': 'test01'}

## 2.8 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 = '33'
    name2 = ET.SubElement(new_xml,"name",attrib={
       "enrolled":"no"})
    age = ET.SubElement(name2,"age")
    age.text = '19'
    
    et = ET.ElementTree(new_xml) #生成文档对象
    et.write("test.xml", encoding="utf-8",xml_declaration=True)

更多用法：  
[https://docs.python.org/3/library/xml.html][https_docs.python.org_3_library_xml.html]

## 2.9 configparser — Configuration file parser ##

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

[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': '45',
                          'Compression': 'yes',
                         'CompressionLevel': '9'}
    
    config['bitbucket.org'] = {}
    config['bitbucket.org']['User'] = 'hg'
    config['topsecret.server.com'] = {}
    topsecret = config['topsecret.server.com']
    topsecret['Host Port'] = '50022'     # 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']
    '50022'
    >>> for key in config['bitbucket.org']: print(key)
    ...
    user
    compressionlevel
    serveraliveinterval
    compression
    forwardx11
    >>> config['bitbucket.org']['ForwardX11']
    'yes'

configparser增删改查语法：

[section1]
    k1 = v1
    k2:v2
    
    [section2]
    k1 = v1

import ConfigParser
    
    config = ConfigParser.ConfigParser()
    config.read('i.cfg')
    
    # ########## 读 ##########
    #secs = config.sections()
    #print secs
    #options = config.options('group2')
    #print options
    
    #item_list = config.items('group2')
    #print item_list
    
    #val = config.get('group1','key')
    #val = config.getint('group1','key')
    
    # ########## 改写 ##########
    #sec = config.remove_section('group1')
    #config.write(open('i.cfg', "w"))
    
    #sec = config.has_section('wupeiqi')
    #sec = config.add_section('wupeiqi')
    #config.write(open('i.cfg', "w"))
    
    
    #config.set('group2','k1',11111)
    #config.write(open('i.cfg', "w"))
    
    #config.remove_option('group2','age')
    #config.write(open('i.cfg', "w"))

更多用法：  
[https://docs.python.org/3/library/configparser.html][https_docs.python.org_3_library_configparser.html]

## 2.10 subprocess — Subprocess management ##

4种执行系统命令方法：  
1. os.system(“cmd”)  
输出命令结果到屏幕，返回命令招行状态。  
2. os.popen(“cmd”).read()  
保存命令的招行结果输出。  
3. commands.getstatusoutput(“cmd”)【python2.7 for Linux】  
`status, res = commands.getstatusoutput("pwd")`  
status为命令招行状态码，res为命令执行结果。  
4. subprocess  
subprocess.run(“cmd”) 【python3.5及以上版本】  
subprocess.run(args, \*, stdin=None, input=None, stdout=None, stderr=None, shell=False, timeout=None, check=False, encoding=None, errors=None)

常用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(…)是推荐的常用方法，在大多数情况下能满足需求，但如果你可能需要进行一些复杂的与系统的交互的话，你还可以用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 = '123' #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()

更多用法：  
[https://docs.python.org/3/library/subprocess.html][https_docs.python.org_3_library_subprocess.html]

## 2.11 `urllib.request` — Extensible library for opening URLs ##

urllib提供了一系列用于操作URL的功能。

**Get**

urllib的request模块可以非常方便地抓取URL内容，也就是发送一个GET请求到指定的页面，然后返回HTTP的响应：

例如，对豆瓣的一个URLhttps://api.douban.com/v2/book/2129650进行抓取，并返回响应：

from urllib import request
    
    with request.urlopen('https://api.douban.com/v2/book/2129650') as f:
        data = f.read()
        print('Status:', f.status, f.reason)
        for k, v in f.getheaders():
            print('%s: %s' % (k, v))
        print('Data:', data.decode('utf-8'))

可以看到HTTP响应的头和JSON数据：

Status: 200 OK
    Server: nginx
    Date: Tue, 26 May 2015 10:02:27 GMT
    Content-Type: application/json; charset=utf-8
    Content-Length: 2049
    Connection: close
    Expires: Sun, 1 Jan 2006 01:00:00 GMT
    Pragma: no-cache
    Cache-Control: must-revalidate, no-cache, private
    X-DAE-Node: pidl1
    Data: {
       "rating":{
       "max":10,"numRaters":16,"average":"7.4","min":0},"subtitle":"","author":["廖雪峰编著"],"pubdate":"2007-6","tags":[{
       "count":20,"name":"spring","title":"spring"}...}

如果我们要想模拟浏览器发送GET请求，就需要使用Request对象，通过往Request对象添加HTTP头，我们就可以把请求伪装成浏览器。例如，模拟iPhone 6去请求豆瓣首页：

from urllib import request
    
    req = request.Request('http://www.douban.com/')
    req.add_header('User-Agent', 'Mozilla/6.0 (iPhone; CPU iPhone OS 8_0 like Mac OS X) AppleWebKit/536.26 (KHTML, like Gecko) Version/8.0 Mobile/10A5376e Safari/8536.25')
    with request.urlopen(req) as f:
        print('Status:', f.status, f.reason)
        for k, v in f.getheaders():
            print('%s: %s' % (k, v))
        print('Data:', f.read().decode('utf-8'))

这样豆瓣会返回适合iPhone的移动版网页：

...
        <meta name="viewport" content="width=device-width, user-scalable=no, initial-scale=1.0, minimum-scale=1.0, maximum-scale=1.0">
        <meta name="format-detection" content="telephone=no">
        <link rel="apple-touch-icon" sizes="57x57" href="http://img4.douban.com/pics/cardkit/launcher/57.png" />
    ...

**Post**

如果要以POST发送一个请求，只需要把参数data以bytes形式传入。  
我们模拟一个微博登录，先读取登录的邮箱和口令，然后按照weibo.cn的登录页的格式以username=xxx&password=xxx的编码传入：

from urllib import request, parse
    
    print('Login to weibo.cn...')
    email = input('Email: ')
    passwd = input('Password: ')
    login_data = parse.urlencode([
        ('username', email),
        ('password', passwd),
        ('entry', 'mweibo'),
        ('client_id', ''),
        ('savestate', '1'),
        ('ec', ''),
        ('pagerefer', 'https://passport.weibo.cn/signin/welcome?entry=mweibo&r=http%3A%2F%2Fm.weibo.cn%2F')
    ])
    
    req = request.Request('https://passport.weibo.cn/sso/login')
    req.add_header('Origin', 'https://passport.weibo.cn')
    req.add_header('User-Agent', 'Mozilla/6.0 (iPhone; CPU iPhone OS 8_0 like Mac OS X) AppleWebKit/536.26 (KHTML, like Gecko) Version/8.0 Mobile/10A5376e Safari/8536.25')
    req.add_header('Referer', 'https://passport.weibo.cn/signin/login?entry=mweibo&res=wel&wm=3349&r=http%3A%2F%2Fm.weibo.cn%2F')
    
    with request.urlopen(req, data=login_data.encode('utf-8')) as f:
        print('Status:', f.status, f.reason)
        for k, v in f.getheaders():
            print('%s: %s' % (k, v))
        print('Data:', f.read().decode('utf-8'))

如果登录成功，我们获得的响应如下：

Status: 200 OK
    Server: nginx/1.2.0
    ...
    Set-Cookie: SSOLoginState=1432620126; path=/; domain=weibo.cn
    ...
    Data: {
       "retcode":20000000,"msg":"","data":{
       ...,"uid":"1658384301"}}

如果登录失败，我们获得的响应如下：

...
    Data: {
       "retcode":50011015,"msg":"\u7528\u6237\u540d\u6216\u5bc6\u7801\u9519\u8bef","data":{
       "username":"example@python.org","errline":536}}

**Handler**

如果还需要更复杂的控制，比如通过一个Proxy去访问网站，我们需要利用ProxyHandler来处理，示例代码如下：

proxy_handler = urllib.request.ProxyHandler({
       'http': 'http://www.example.com:3128/'})
    proxy_auth_handler = urllib.request.ProxyBasicAuthHandler()
    proxy_auth_handler.add_password('realm', 'host', 'username', 'password')
    opener = urllib.request.build_opener(proxy_handler, proxy_auth_handler)
    with opener.open('http://www.example.com/login.html') as f:
        pass

**小结**

> urllib提供的功能就是利用程序去执行各种HTTP请求。如果要模拟浏览器完成特定功能，需要把请求伪装成浏览器。伪装的方法是先监控浏览器发出的请求，再根据浏览器的请求头来伪装，User-Agent头就是用来标识浏览器的。

更多用法：  
[https://docs.python.org/3.5/library/urllib.request.html][https_docs.python.org_3.5_library_urllib.request.html]  
参考教程：  
[http://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/001432688314740a0aed473a39f47b09c8c7274c9ab6aee000][http_www.liaoxuefeng.com_wiki_0014316089557264a6b348958f449949df42a6d3a2e542c000_001432688314740a0aed473a39f47b09c8c7274c9ab6aee000]

[https_docs.python.org_3_library_sys.html]: https://docs.python.org/3/library/sys.html
[https_docs.python.org_3_library_os.html_highlight_os_module-os]: https://docs.python.org/3/library/os.html?highlight=os#module-os
[https_docs.python.org_3_library_hashlib.html]: https://docs.python.org/3/library/hashlib.html
[https_docs.python.org_3_library_re.html]: https://docs.python.org/3/library/re.html
[https_docs.python.org_3_library_random.html]: https://docs.python.org/3/library/random.html
[https_docs.python.org_3_library_shutil.html]: https://docs.python.org/3/library/shutil.html
[https_docs.python.org_3_library_zipfile.html]: https://docs.python.org/3/library/zipfile.html
[https_docs.python.org_3_library_xml.html]: https://docs.python.org/3/library/xml.html
[https_docs.python.org_3_library_configparser.html]: https://docs.python.org/3/library/configparser.html
[https_docs.python.org_3_library_subprocess.html]: https://docs.python.org/3/library/subprocess.html
[https_docs.python.org_3.5_library_urllib.request.html]: https://docs.python.org/3.5/library/urllib.request.html
[http_www.liaoxuefeng.com_wiki_0014316089557264a6b348958f449949df42a6d3a2e542c000_001432688314740a0aed473a39f47b09c8c7274c9ab6aee000]: http://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/001432688314740a0aed473a39f47b09c8c7274c9ab6aee000