python学习第六天回顾（常用模块）

一、os模块

　　python编程时，经常和文件，目录打交道，就可以用os模块来操作了，os模块包含普遍的操作系统功能，与具体的平台无关

 1     import os  #导入os模块
 2     
 3     os.name() #判断现在正在实用的平台，windows返回“NT”;linux返回“posix”
 4     os.getcwd() # 得到当前工作的目录
 5     os.listdir() #指定所有目录下所有的文件和目录
 6     os.remove() #删除指定的文件
 7     os.rmdir() #删除指定的目录
 8     os.mkdir() #创建目录，只可创建一层目录
 9     os.mkdirs() #创建多层目录
10     os.path.isfile() #判断指定对象是否为文件。是返回True,否则False
11     os.path.isdir() #判断指定对象是否为目录。是为True,否则为False
12     os.path.split() #返回路径的目录和文件名
13     os.system() #执行shell命令
14         #os.system("ls")
15     os.chdir() #改变目录到指定目录
16     os.path.getsize() #获得文件的大小，如果为目录则返回0

 1     os.path.join()    #连接目录和文件名
 2         print(os.path.join('a','E:\\b','c.txt'))
 3         print(os.path.join('a','/b','c.txt')) #/b/c.txt
 4     os.path.basename() #返回文件名
 5         print(os.path.basename('E:\\a\\a,txt'))
 6     os.path.dirname() #返回文件路径
 7         print(os.path.dirname('E:\\a\\c.txt'))
 8     os.path.normcase()  #转换path的大小写和斜杠
 9         print(os.path.normcase('c:/wIndows\\system32\\') )
10     os.path.normpath()  #规范path字符串形式  
11             print(os.path.normpath('c://windows\\System32\\../Temp/'))
12     os.path.abspath()    #返回绝对路径
13         print(os.path.abspath('a/b/c.txt'))  #返回函数内相对路径的绝对路径
14         print(os.path.abspath('/a/b/c.txt')) #返回根目录加函数内的绝对路径

二、random模块

　　python中random模块用于生成随机数。

　　下面有几个常用的函数：

 1     random.random() #随机生成一个实数，在[0,1]之间
 2     random.randint()    #随机生成一个整数，在指定的范围内
 3     random.randrange([start],stop[,step]) #在指定范围内，按指定基数递增的集合中获取一个随机数
 4         #print(random.randrange(1,10,2))
 5     random.choice(sequence)#在序列中获取一个随机元素
 6         #print(random.choice("abc"))
 7     random.sample()    #从指定序列中随机获取指定长度的片断。
 8         #print(random.sample([1,2,5,7,3,9],2))
 9     random.shuffle() #用于将一个列表中的元素打乱
10         #item=[1,"a",5,"p",9]
11         #random.shuffle(item)
12         #print(item)

 1     验证码打印功能：
 2     def v_code(n=5):
 3         res=''
 4         for i in range(n):
 5             num=random.randint(0,9)
 6             s=chr(random.randint(65,90))
 7             add=random.choice([num,s])
 8             res+=str(add)
 9         return res
10 
11     print(v_code(6))

三、shutil模块

　　#shutil---High-level file operations 是一种高层次的文件操作工具，类似于高级API，主要强大之处在于对文件的复制与删除操作。

1     shutil.copyfileobj(fsrc,fdst[,length])
2     #将文件内容拷贝到另一个文件中，若指定lenght则是指定文件在缓冲区的大小
3     import shutil
4     shutil.copyfileobj(open("a.txt","r"),open("b.txt","w"))

1     shutil.copyfile(src,dst)
2     #拷贝文件, 目标文件不需要存在，会自动创建
3     shutil.copyfile("a.txt","b.txt")

1     shutil.copymode(src,dst)
2     #仅拷贝权限。内容，组，用户均不变. 目录文件必须存在 不存在将会报错“FileNotFoundError: [WinError 2] 系统找不到指定的文件。”
3     shutil.copymode("f1.log","f2.log")

1     shutil.copystat(src,dst)
2     #仅拷贝状态的信息，包括：mode,bits,atime,mtime,flags,目标文件必须存在
3     shutil.copystat("f1,log","f2.log")

1     shutil.copy(src,dst)
2     #拷贝文件和权限
3     import shutil
4     shutil.copy("a.txt","b.txt")
5 
6     shutil.copy2(src,dst)
7     #拷贝文件和状态信息
8     import shutil
9     shutil.copy2("a.txt","b.txt")

 1     shutil.igonre_patterns(*patterns)
 2     shutil.copytree(src,dst,symlinks=False,ignore=None)
 3     #递归的去拷贝文件夹
 4     import shutil
 5     shutil.copytree("abc","bcd",ignore=shutil.ignore_patterns("*.pyc","tmp")) #目标目录不能存在，注意对bcd目录的父级目录要有可写权限，ignore的意思是排除
 6 
 7     #拷贝软链接
 8     import shutil
 9     shutil.copytree("abc","bcd",symlinks=True,ignore=shutil.ignore_patterns("*.pyc","tmp"))
10     "通常的拷贝都把软链接拷贝成硬链接，即对软链接来说，创建新的文件"

1     shutil.rmtree(path[,ignore_errors[,onerror]])
2     #递归的去删除文件
3     import shutil
4     shutil.rmtree("abc")
5

1     shutil.move(src,dst)
2     #递归的去移动文件，类似mv命令，可以重命名
3     import shutil
4     shutil.move("abc","bcd")

 1     shutil.make_archive(base_name,format,...)
 2     #创建压缩包并返回文件路径，例如：zip, tar
 3     @ base_name:压缩包的文件名，也可以是压缩包的路径。只是文件名旱，则保存至当前目录，否则保存至指定路径
 4     #如：abc  将该文件保存在当前路径
 5     #如： /export/abc  将该文件保存在/export目录下
 6     @format:压缩包种类，"zip","tar","bztar","gztar"
 7     @root_dir:要压缩的文件目录（默认为当前目录）
 8     @owner:指定压缩用的用户权限，默认当前用户
 9     @group: 指定压缩用的组权限，默认为当前组
10     @logger:用于记录日志，通常是logging.Logger对象
11 
12

1     shutil.make_archive("data_bak", 'gztar', root_dir=r'E:\s17\day06\bbb') #r'E:\s17\day06\bbb',r告诉python解释器为原生字符串
2     #用tarfile模块来解压
3     #示例：
4     import tarfile
5     t=tarfile.open('data_bak.tar.gz','r')
6     t.extractall('extract_dir')
7     t.close()

 1     #可以用zipfile模块进行压缩解压缩
 2     import zipfile
 3 
 4     # 压缩
 5     z = zipfile.ZipFile('laxi.zip', 'w')
 6     z.write('a.log')
 7     z.write('data.data')
 8     z.close()
 9 
10     # 解压
11     z = zipfile.ZipFile('laxi.zip', 'r')
12     z.extractall(path='.')
13     z.close()

 1     #tarfile模块压缩解压缩
 2     import tarfile
 3 
 4     # 压缩
 5      t=tarfile.open('/tmp/egon.tar','w')
 6      t.add('/test1/a.py',arcname='a.bak')
 7      t.add('/test1/b.py',arcname='b.bak')
 8      t.close()
 9 
10 
11     # 解压
12      t=tarfile.open('/tmp/egon.tar','r')
13      t.extractall('/egon')
14      t.close()

四、time模块

# python中表式时间的方式：
#     时间戳：通常来说，时间戳表示的是从1970年1月1日00:00:00开始的按秒计算的偏移量
#     格式化的时间字符串：(format_time)
#     结构化的时间：（struct_time）

 1 import time
 2     # print(time.time())  #时间戳：1496551846.9015346
 3     # print(time.localtime().tm_year) #本地时区的struct_time
 4     # print(time.gmtime())#UTC时区的struct_time
 5     # print(time.strftime("%Y-%m-%d %H:%M:%S"))
 6     # print(time.strftime("%Y-%m-%d %X"))
 7     # print(time.asctime())
 8     # print(time.ctime())
 9     #时间戳---结构化的时间---格式化的时间字符串
10     #以上三者间的相互转换
11     print(time.localtime()) #当前时区的结构化时间
12     print(time.localtime(1496551846.9015346)) #时间戳转为当前时区的结构化的时间
13     print(time.gmtime())
14     #time.gmtime()与 time.localtime()一样，只不过 time.gmtime()转换的是utc时区的
15     #time.mktime() #将一个结构化的时间转换为时间戳
16     print(time.mktime(time.localtime()))
17     #time.strftime(format[,t]) 把一个代表时间的元组或结构化的时间（time.localtime(）或 time.gmtime(））转化为格式化的时间字符串
18     #若t没有指定将传入time.localtime(),若元组中有元素越界则抛出异常
19     print(time.strftime("%Y-%m-%d %H:%M:%S"))
20     print(time.strftime("%Y-%m-%d %H:%M:%S",time.localtime()))

五、sys模块

　　import sys #导入sys模块

 1     sys.argv   #命令行参数List，第一个元素是程序本身路径
 2     #示例：
 3     #test.py
 4     import sys
 5     a=sys.argv[0]
 6     print(a)
 7     #在终端执行文件，会打印出文件所在的路径
 8     test.py #执行文件
 9     #返回结果为：
10     #test.py的路径
11     #test.py
12     import sys
13     a=sys.argv[1]
14     print(a)
15     ##在终端执行文件，会打印出文件后的内容
16     test.py abc  #执行该命令
17     #返回结果为：
18     #abc

1     sys.exit(n) #退出程序，正常退出时exit(0)
2     sys.version #获取python解释器的版本信息
3     sys.maxint #最大的Int值
4     sys.path #返回模块的搜索路径，初始化时使用pythonpath环境变量的值
5     sys.platform #返回操作系统平台名称

1     #打印进度条示例：
2     import sys,time
3 
4     for i in range(50):
5         sys.stdout.write('%s\r' %('#'*i))#从控制台写入内容
6         sys.stdout.flush() #刷新出控制台写入的内容
7         time.sleep(0.1) #停0.1秒
8     """在pycharm中不会达到效果，可以在终端运行"""

六、json与pickle模块

　　@eval内置方法可以将一个字符串转成python对象，不过，eval方法是有局限性的，对于普通的数据类型，json.loads和eval都能用，但遇到特殊类型的时候，eval就不能用了。所以eval只适合执行一个字符串表达式，并返回表达式的值。

1     示例：
2     import json
3     x="[a,b,null,true,1]"
4     print(eval(x)) #报错，无法解析null类型，（python没有null类型，而是None,而json就可以支持null类型）
5     print(json.loads(x))
6

 1     #什么是序列化：
 2     #将对象（变量）从内存中变成可存储或传输的过程称之为序列化。
 3     #序列化的作用：
 4     #@持久保存状态
 5         #一个软件/程序的执行就在处理一系列状态的变化，在编程语言中，"状态"会以各种各样有结构的数据类型（变量）的形式被保存在内存中。
 6         #内存是无法持久的保存数据的，若程序支行过程中，断电或程序被重启，内存中的数据将被清空，即之前在内存中存在的数据没有了，数据将会丢失。
 7         #若在（断电或程序重启）此之前，将内存中的数据保存到文件中，以便于下次程序执行时能从文件中加载之前的数据，然后执行，即序列化
 8     #@跨平台数据交互
 9         #序列化，不仅可以把内存中的数据写入到硬盘中，还可以通过网络传输到别的机器上，如果收发的双方约定好实用一种序列化的格式，则可以在不同平台/语言中，实现跨平台的数据交互。
10     #反之，将文件中的内容重新读到内存中，则称为反序列化。

1     序列化之JSON

 1     @#json是支持跨平台的序列化。
 2         #若我们需要在不同的程序语言中传递数据（对象），则必须把对象序列化成标准格式，更好的方法是序列化为json格式，因为json表示出来的是一个字符串，可以被所有的语言读取，也可以方便的存储到硬盘或通过网络传输。
　　　　　　JSON不仅是标准格式，而且还可直接在WEB页面中读取，非常方便。
 3 
 4     JSON和PYTHON内置数据类型如下所示：
 5         JSON类型                PYTHON类型
 6         {}                            dict
 7         []                              list
 8         "string"                     str
 9         123.123                    int或float
10         true/false                   True/False
11         null                            None

1     JSON序列化的过程：
2         
3         内存中的数据--->  格式JSON ---> 字符串 ----> 保存到文件或基于网络传输
4 
5     JSON反序列化的过程：
6     
7         文件或基于网络传输的数据 ----> 字符串 ----> 转化为JSON ---->  写入到内存中

 1     #JSON序列化示例：
 2      import json
 3 
 4     dic={"name":"jack","age":19,"sex":"male"}
 5     print(type(dic)) #<class dict>
 6     
 7     res = json.dumps(dic)
 8     print(type(res)) #<class str>
 9 
10     #json.dump的应用
11     f=open("序列化对象","w")
12     f.write(res)
13     f.close()
14     ###等价于下面的代码 
15     json.dump(dic,f)
16         #dic即上面dict类型的内容，f即上面open的内容也可以写成json.dump(dic,open("a.txt","w"))

1     json反序列化：
2     
3     import json
4     f=open("序列化对象"，“r”)
5     data=json.loads(f.read()) #data为字典类型
6     #等价于下面的
7      data=json.load(f)
8         #即 data=json.load(open("a.txt","r")

1     ####注意：#####
2     #@  JSON 不认单引号
3     #@  无论数据是怎样创建的，只要满足JSON适用的格式，就可以用json.loads读出数据，并非一定要先json.dumps数据才能loads
4 
5 ###########################

1     序列化之pickle

1     Pickle序列化过程：
2     内存中结构化的数据---->转为pickle格式---->bytes类型---->保存到文件或基于网络传输
3 
4     Pickle反序列化过程：
5     读取文件或网络传输的数据--->bytes类型--->格式pickle--->以结构化的数据写入到内存中
6 
7     #在json序列化的过程中是以字符串的类型进行保存的，而pickle是以字节类型进行保存的，所以在读取/写入文件时应该以二进制的方式打开。

 1     #Pickle序列化示例：
 2     import pickle
 3     dic={"name":"jack","age":19}
 4     print(type(dic)) #<class dict>
 5     
 6     res=pickle.dumps(dic)
 7     print(type(res)) #<class bytes>
 8     
 9     f=open("filename","wb")
10     f.write(res)
11     f.close()
12     #以上操作等价于：
13     pcikle.dump(dic,f)  <==> pickle.dump(dic,open("filename","wb"))
14 
15     #pickle反序列化示例：
16     import pickle
17     f=open("filename","rb")
18     data=pickle.loads(f.read())
19     #以上操作相当于    pickle.load(f)
20     print(data["age"])

1     #在json中不支持python的函数类型，而pickle是支持的
2     #示例：
3     import json,pickle
4     def func():
5         print('from func')
6 
7     json.dumps(func)# 报错，json不支持python的函数类型
8     f=pickle.dumps(func)
9     print(f)

1     #pickle的序列化只能用于python，并且可能不同版本的python彼此都不兼容，因此，只能用pickle保存那些不重要的数据，不能成功地反序列化也没关系

七、shelve模块

　　#shelve模块比pickle模块简单，只有一个open函数，返回类似字典的形象，可读可写；key必须是字符串，而值可以是python所支持的数据类型

1     import shelve
2 
3     f=shelve.open(r'sheve.txt')
4     # f['stu1_info']={'name':'egon','age':18,'hobby':['piao','smoking','drinking']}
5     # f['stu2_info']={'name':'gangdan','age':53}
6     # f['school_info']={'website':'http://www.pypy.org','city':'beijing'}
7 
8     print(f['stu1_info']['hobby'])
9     f.close()

八、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数据

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

 1     # print(root.iter('year')) #全文搜索
 2     # print(root.find('country')) #在root的子节点找，只找一个
 3     # print(root.findall('country')) #在root的子节点找，找所有
 4 
 5 
 6 
 7     import xml.etree.ElementTree as ET
 8 
 9     tree = ET.parse("a")    #用ET.parse解析xml文件a的内容
10     root = tree.getroot()    #获取根节点
11 
12     for i in root.iter('year'):    #root.iter()找到的内容生成可迭代对象
13         print(i.tag,i.text,i.attrib)    #i元素内有tag,txt,attrib属性
14

1     #遍历xml文档
2     for child in root:
3     　　print('========>',child.tag,child.attrib,child.attrib['name'])
4     　　for i in child:
5     　　　　print(i.tag,i.attrib,i.text)

 1     import xml.etree.ElementTree as ET
 2  
 3     tree = ET.parse("xmltest.xml")
 4     root = tree.getroot()
 5  
 6     #修改
 7     for node in root.iter('year'):
 8         new_year=int(node.text)+1
 9         node.text=str(new_year)
10         node.set('updated','yes')
11         node.set('version','1.0')
12     tree.write('test.xml')
13  
14  
15     #删除node
16     for country in root.findall('country'):
17        rank = int(country.find('rank').text)
18        if rank > 50:
19          root.remove(country)
20  
21     tree.write('output.xml')
22 
23     #在country内添加（append）节点year2
24     import xml.etree.ElementTree as ET
25     tree = ET.parse("a.xml")
26     root=tree.getroot()
27     for country in root.findall('country'):
28         for year in country.findall('year'):
29             if int(year.text) > 2000:
30                 year2=ET.Element('year2')
31                 year2.text='新年'
32                 year2.attrib={'update':'yes'}
33                 country.append(year2) #往country节点下添加子节点
34 
35     tree.write('a.xml.swap')

    创建xml文件

    #在country内添加（append）节点year2
    import xml.etree.ElementTree as ET
    tree = ET.parse("a.xml")
    root=tree.getroot()
    for country in root.findall('country'):
        for year in country.findall('year'):
            if int(year.text) > 2000:
                year2=ET.Element('year2')
                year2.text='新年'
                year2.attrib={'update':'yes'}
                country.append(year2) #往country节点下添加子节点

    tree.write('a.xml.swap')

九、configparser模块

# 注释1
; 注释2

[section1]
k1 = v1
k2:v2
user=egon
age=18
is_admin=true
salary=31

[section2]
k1 = v1

配置文件：

    读取配置文件内容
    import configparser

    config=configparser.ConfigParser()
    config.read('a.cfg')

    #查看所有的标题
    res=config.sections() #['section1', 'section2']
    print(res)

    #查看标题section1下所有key=value的key
    options=config.options('section1')
    print(options) #['k1', 'k2', 'user', 'age', 'is_admin', 'salary']

    #查看标题section1下所有key=value的(key,value)格式
    item_list=config.items('section1')
    print(item_list) #[('k1', 'v1'), ('k2', 'v2'), ('user', 'egon'), ('age', '18'), ('is_admin', 'true'), ('salary', '31')]

    #查看标题section1下user的值=>字符串格式
    val=config.get('section1','user')
    print(val) #egon

    #查看标题section1下age的值=>整数格式
    val1=config.getint('section1','age')
    print(val1) #18

    #查看标题section1下is_admin的值=>布尔值格式
    val2=config.getboolean('section1','is_admin')
    print(val2) #True

    #查看标题section1下salary的值=>浮点型格式
    val3=config.getfloat('section1','salary')
    print(val3) #31.0

    修改配置文件：
    
    import configparser

    config=configparser.ConfigParser()
    config.read('a.cfg')


    #删除整个标题section2
    config.remove_section('section2')

    #删除标题section1下的某个k1和k2
    config.remove_option('section1','k1')
    config.remove_option('section1','k2')

    #判断是否存在某个标题
    print(config.has_section('section1'))

    #判断标题section1下是否有user
    print(config.has_option('section1',''))


    #添加一个标题
    config.add_section('egon')

    #在标题egon下添加name=egon,age=18的配置
    config.set('egon','name','egon')
    config.set('egon','age',18) #报错,必须是字符串


    #最后将修改的内容写入文件,完成最终的修改
    config.write(open('a.cfg','w'))

[PHP]
engine = On
short_open_tag = Off
asp_tags = Off
precision = 14
output_buffering = 4096
zlib.output_compression = Off
implicit_flush = Off
unserialize_callback_func =
serialize_precision = 17
disable_functions =
disable_classes =
zend.enable_gc = On
expose_php = On
max_execution_time = 30
max_input_time = 60
memory_limit = 128M
error_reporting = E_ALL & ~E_DEPRECATED & ~E_STRICT
display_errors = Off
display_startup_errors = Off
log_errors = On
log_errors_max_len = 1024
ignore_repeated_errors = Off
ignore_repeated_source = Off
report_memleaks = On
track_errors = Off
html_errors = On
variables_order = "GPCS"
request_order = "GP"
register_argc_argv = Off
auto_globals_jit = On
post_max_size = 8M
auto_prepend_file =
auto_append_file =
default_mimetype = "text/html"
doc_root =
user_dir =
enable_dl = Off
file_uploads = On
upload_max_filesize = 2M
max_file_uploads = 20
allow_url_fopen = On
allow_url_include = Off
default_socket_timeout = 60
[CLI Server]
cli_server.color = On
[Date]
[filter]
[iconv]
[intl]
[sqlite]
[sqlite3]
[Pcre]
[Pdo]
[Pdo_mysql]
pdo_mysql.cache_size = 2000
pdo_mysql.default_socket=
[Phar]
[mail function]
SMTP = localhost
smtp_port = 25
sendmail_path = /usr/sbin/sendmail -t -i
mail.add_x_header = On
[SQL]
sql.safe_mode = Off
[ODBC]
odbc.allow_persistent = On
odbc.check_persistent = On
odbc.max_persistent = -1
odbc.max_links = -1
odbc.defaultlrl = 4096
odbc.defaultbinmode = 1
[Interbase]
ibase.allow_persistent = 1
ibase.max_persistent = -1
ibase.max_links = -1
ibase.timestampformat = "%Y-%m-%d %H:%M:%S"
ibase.dateformat = "%Y-%m-%d"
ibase.timeformat = "%H:%M:%S"
[MySQL]
mysql.allow_local_infile = On
mysql.allow_persistent = On
mysql.cache_size = 2000
mysql.max_persistent = -1
mysql.max_links = -1
mysql.default_port =
mysql.default_socket =
mysql.default_host =
mysql.default_user =
mysql.default_password =
mysql.connect_timeout = 60
mysql.trace_mode = Off
[MySQLi]
mysqli.max_persistent = -1
mysqli.allow_persistent = On
mysqli.max_links = -1
mysqli.cache_size = 2000
mysqli.default_port = 3306
mysqli.default_socket =
mysqli.default_host =
mysqli.default_user =
mysqli.default_pw =
mysqli.reconnect = Off
[mysqlnd]
mysqlnd.collect_statistics = On
mysqlnd.collect_memory_statistics = Off
[OCI8]
[PostgreSQL]
pgsql.allow_persistent = On
pgsql.auto_reset_persistent = Off
pgsql.max_persistent = -1
pgsql.max_links = -1
pgsql.ignore_notice = 0
pgsql.log_notice = 0
[Sybase-CT]
sybct.allow_persistent = On
sybct.max_persistent = -1
sybct.max_links = -1
sybct.min_server_severity = 10
sybct.min_client_severity = 10
[bcmath]
bcmath.scale = 0
[browscap]
[Session]
session.save_handler = files
session.use_cookies = 1
session.use_only_cookies = 1
session.name = PHPSESSID
session.auto_start = 0
session.cookie_lifetime = 0
session.cookie_path = /
session.cookie_domain =
session.cookie_httponly =
session.serialize_handler = php
session.gc_probability = 1
session.gc_divisor = 1000
session.gc_maxlifetime = 1440
session.bug_compat_42 = Off
session.bug_compat_warn = Off
session.referer_check =
session.cache_limiter = nocache
session.cache_expire = 180
session.use_trans_sid = 0
session.hash_function = 0
session.hash_bits_per_character = 5
url_rewriter.tags = "a=href,area=href,frame=src,input=src,form=fakeentry"
[MSSQL]
mssql.allow_persistent = On
mssql.max_persistent = -1
mssql.max_links = -1
mssql.min_error_severity = 10
mssql.min_message_severity = 10
mssql.compatability_mode = Off
mssql.secure_connection = Off
[Assertion]
[mbstring]
[gd]
[exif]
[Tidy]
tidy.clean_output = Off
[soap]
soap.wsdl_cache_enabled=1
soap.wsdl_cache_dir="/tmp"
soap.wsdl_cache_ttl=86400
soap.wsdl_cache_limit = 5
[sysvshm]
[ldap]
ldap.max_links = -1
[mcrypt]
[dba]

php.ini文件的格式也是如翠

php.ini配置文件

    #一个简单的ini文件，test.ini

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

    获取所有节点

　　import configparser
　　config=configparser.ConfigParser()
　　config.read('test.ini',encoding='utf-8')
　　res=config.sections()
　　print(res)

　　'''
　　打印结果:
　　['bitbucket.org', 'topsecret.server.com']
　　'''

    #获取指定节点下所有的键值对
    
    import configparser
    config=configparser.ConfigParser()
    config.read('test.ini',encoding='utf-8')
    res=config.items('bitbucket.org')　　#items()获取键值对
    print(res)

    '''
    打印结果:(包含DEFAULT以及bitbucket.org这俩标题下所有的items)
　　[('serveraliveinterval', '45'), ('compression', 'yes'), ('compressionlevel', '9'), ('forwardx11', 'yes'), ('user', 'hg')]
    '''

    #获取指定节点下所有的键
    import configparser
    config=configparser.ConfigParser()
    config.read('test.ini',encoding='utf-8')
    res=config.options('bitbucket.org')　　#options（）获取bitucket.org下的所有的键
    print(res)

    '''
    打印结果:(包含DEFAULT以及bitbucket.org这俩标题下所有的键)
    ['user', 'serveraliveinterval', 'compression', 'compressionlevel', 'forwardx11']'''

    #获取指定节点下指定key的值

    import configparser
    config=configparser.ConfigParser()
    config.read('test.ini',encoding='utf-8')
    res1=config.get('bitbucket.org','user')

    res2=config.getint('topsecret.server.com','port')
    res3=config.getfloat('topsecret.server.com','port')
    res4=config.getboolean('topsecret.server.com','ForwardX11')

    print(res1)
    print(res2)
    print(res3)
    print(res4)

    '''
    打印结果:
    hg
    50022.0
    False
    '''

    #检查、删除、添加节点
    import configparser
    config=configparser.ConfigParser()
    config.read('test.ini',encoding='utf-8')

    #检查
    has_sec=config.has_section('bitbucket.org')
    print(has_sec) #打印True

    #添加节点
    config.add_section('egon') #已经存在则报错
    config['egon']['username']='gangdan'
    config['egon']['age']='18'
    config.write(open('test.ini','w'))

    #删除节点
    config.remove_section('egon')
    config.write(open('test.ini','w'))

    #检查、删除、设置指定组内的键值对
    import configparser
    config=configparser.ConfigParser()
    config.read('test.ini',encoding='utf-8')

    #检查
    has_sec=config.has_option('bitbucket.org','user')         #bitbucket.org下有一个键user
    print(has_sec) #打印True

    #删除
    config.remove_option('DEFAULT','forwardx11')
    config.write(open('test.ini','w'))

    #设置
    config.set('bitbucket.org','user','gangdang')
    config.write(open('test.ini','w'))

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)

基于上述方法添加一个ini文档

十、hashlib模块


1     #hash:一种算法，3.x代替了md5和sha模块，主要提供SHA1,SHA224,SHA256,SHA384,SHA512,MD5算法
2 
3     三个特点：
4         @ 内容相同则hash运算结果相同，内容稍微改变则hash值随之改变
5         @ 不可逆推
6         @相同算法，不论校验的数据有多长，得到的哈希值长度是固定的。

 1     import hashlib
 2  
 3     m=hashlib.md5()# m=hashlib.sha256()
 4  
 5     m.update('hello'.encode('utf8'))
 6     print(m.hexdigest())      #5d41402abc4b2a76b9719d911017c592
 7  
 8     m.update('alvin'.encode('utf8'))
 9  
10     print(m.hexdigest())      #92a7e713c30abbb0319fa07da2a5c4af
11  
12     m2=hashlib.md5()
13     m2.update('helloalvin'.encode('utf8'))
14     print(m2.hexdigest())     #92a7e713c30abbb0319fa07da2a5c4af
15 
16     '''
17     注意：把一段很长的数据update多次，与一次update这段长数据，得到的结果一样
18     但是update多次为校验大文件提供了可能。
19     '''

1     以上算法，可以通过撞库来反解，可以在加密算法中添加自定义的key来做加密。
2     import hashlib
3  
4 # ######## 256 ########
5  
6     hash = hashlib.sha256('898oaFs09f'.encode('utf8'))
7     hash.update('alvin'.encode('utf8'))
8     print(hash.hexdigest())#e79e68f070cdedcfe63eaf1a2e92c83b4cfb1b5c6bc452d214c1b7e77cdfd1c7

import hashlib
passwds=[
    'alex3714',
    'alex1313',
    'alex94139413',
    'alex123456',
    '123456alex',
    'a123lex',
    ]
def make_passwd_dic(passwds):
    dic={}
    for passwd in passwds:
        m=hashlib.md5()
        m.update(passwd.encode('utf-8'))
        dic[passwd]=m.hexdigest()
    return dic

def break_code(cryptograph,passwd_dic):
    for k,v in passwd_dic.items():
        if v == cryptograph:
            print('密码是===>\033[46m%s\033[0m' %k)

cryptograph='aee949757a2e698417463d47acac93df'
break_code(cryptograph,make_passwd_dic(passwds))

模拟撞库解密

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

1      import hmac
2      h = hmac.new('alvin'.encode('utf8'))
3      h.update('hello'.encode('utf8'))
4      print (h.hexdigest())#320df9832eab4c038b6c1d7ed73a5940

十一、suprocess模块

import  subprocess

'''
sh-3.2# ls /Users/egon/Desktop |grep txt$
mysql.txt
tt.txt
事物.txt
'''

res1=subprocess.Popen('ls /Users/jieli/Desktop',shell=True,stdout=subprocess.PIPE)
res=subprocess.Popen('grep txt$',shell=True,stdin=res1.stdout,
                 stdout=subprocess.PIPE)

print(res.stdout.read().decode('utf-8'))


#等同于上面,但是上面的优势在于,一个数据流可以和另外一个数据流交互,可以通过爬虫得到结果然后交给grep
res1=subprocess.Popen('ls /Users/jieli/Desktop |grep txt$',shell=True,stdout=subprocess.PIPE)
print(res1.stdout.read().decode('utf-8'))


#windows下:
# dir | findstr 'test*'
# dir | findstr 'txt$'
import subprocess
res1=subprocess.Popen(r'dir C:\Users\Administrator\PycharmProjects\test\a',shell=True,stdout=subprocess.PIPE)
res=subprocess.Popen('findstr test*',shell=True,stdin=res1.stdout,
                 stdout=subprocess.PIPE)

print(res.stdout.read().decode('gbk')) #subprocess使用当前系统默认编码，得到结果为bytes类型，在windows下需要用gbk解码

十二、logging模块


    #用于便捷记录日志且线程安全的模块

import logging
'''
一:如果不指定filename,则默认打印到终端
二:指定日志级别:
    指定方式:
        1:level=10
        2:level=logging.ERROR

    日志级别种类:
        CRITICAL = 50
        FATAL = CRITICAL
        ERROR = 40
        WARNING = 30
        WARN = WARNING
        INFO = 20
        DEBUG = 10
        NOTSET = 0

三:指定日志级别为ERROR,则只有ERROR及其以上级别的日志会被打印
'''


logging.basicConfig(filename='access.log',
                    format='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',
                    datefmt='%Y-%m-%d %H:%M:%S %p',
                    level=10)

logging.debug('debug')　　#logging.debug()内可以写成("内容为：%s" % abc) abc指的是一个变量
logging.info('info')
logging.warning('warning')
logging.error('error')
logging.critical('critical')
logging.log(10,'log') #如果level=40,则只有logging.critical和loggin.error的日志会被打印

1     #可以logging.basicConfig()函数中通过具体参数来更改logging模块默认行为，可用参数有：
2     filename:用指定的文件名创建FiledHandler，这样日志会被存储在指定的文件中。
3     filemod:文件打开方式，在指定了filename时使用这个参数，默认为"a"可以指定为"w".
4     format:指定handler使用的日志显示格式
5     datefmt：指定日志格式。
6     level:设置日志级别
7     stream:用指定的stream创建StreamHandler.可以指定输出到sys.stderr,sys.stdout或者文件，默认为sys.stderr。若同进列出了filename和stream两个参数，则stream参数会被忽略。

 1     #日志格式

%(name)s	Logger的名字，并非用户名（python解释器所属的用户）
%(levelno)s	数字形式的日志级别
%(levelname)s	文本形式的日志级别
%(pathname)s	调用日志输出函数的模块的完整路径名，可能没有
%(filename)s	调用日志输出函数的模块的文件名
%(module)s	调用日志输出函数的模块名
%(funcName)s	调用日志输出函数的函数名
%(lineno)d	调用日志输出函数的语句所在的代码行
%(created)f	当前时间，用unix标准的表示时间的浮点数表示
%(relativeCreated)d	输出日志信息时的，自Logger创建以来的毫秒数
%(asctime)s	字符串形式的当前时间。默认格式为"2003-07-08 16:49:45,896".逗号后为毫秒
%(thread)d	线程ID。可能没有
%(threadName)s	线程名。可能没有
%(process)d	进程ID。可能没有
%(message)s	用户输出的消息

posted @ 2017-06-08 00:27 冠彭阅读(134) 评论(0) 收藏举报

刷新页面返回顶部

wtnyihg

python学习第六天回顾（常用模块）

公告