模块

configparser
#对配置文件进行解析
  1. import configparser
  3. config = configparser.ConfigParser() #这是生成一个实例
  4. config["DEFAULT"] = {'ServerAliveInterval': '45', #serveraliveinterval = 45
  5. 'Compression': 'yes', #compression = yes
  6. 'CompressionLevel': '9'} #生成 compressionlevel = 9
  8. #config["DEFAULT"]生成[DEFAULT],
  10. config['bitbucket.org'] = {} #生成 [bitbucket.org]
  11. config['bitbucket.org']['User'] = 'hg' #生成 user = hg
  12. config['topsecret.server.com'] = {} #生成 [topsecret.server.com]
  13. topsecret = config['topsecret.server.com'] #创建别名
  14. topsecret['Host Port'] = '50022' #生成 host port = 50022
  15. topsecret['ForwardX11'] = 'no' #生成 forwardx11 = no
  16. config['DEFAULT']['ForwardX11'] = 'yes' #在[DEFAULT]下生成 forwardx11 = yes
  18. with open('example.ini', 'w') as configfile: #写入
  19. config.write(configfile)

 

re模块-正则

在线正则测试     http://tool.oschina.net/regex    

 
头疼去吧
  1. print(re.findall(r"\-?\d+\.?\d*","1-12*(60+(-40.35/5)-(-4*2))")) #匹配出所有数字
  2. # #['1', '-12', '60', '-40.35', '5', '-4', '2']
  3. print(re.findall(r"\-?\d+\.\d+|(\-?\d+)","1-12*(60+(-40.35/5)-(-4*2))")) #匹配所有整数
  4. #|管道符左边是匹配所有小数,右边是匹配所有整数,()特性是先执行取结果,右边的执行匹配显示,左边匹配就抛弃
  5. #['1', '-12', '60', '', '5', '-4', '2']
 
 

re.findall遍历匹配

#可以获取字符串中所有匹配的字符串，返回一个列表
  1. import re
  2. #如下匹配的字符串
  4. 预定义字符集匹配
  5. print(re.findall("a","abc\n121b3\ta_ef * | - ="))      #匹配所有a字符,a可变成任意字符或数字或空格符(\n或\t)
  6. #['a', 'a']
  7. print(re.findall("^a","abc\n121b3\t a_ef * | - =a"))       #^a匹配以a开头的 a$匹配以a结尾的
  8. #['a']
  9. print(re.findall("\w","abc123a_ef * | - ="))         #\w匹配字母数字下划线,不匹配特殊字符和空格
  10. #['a', 'b', 'c', '1', '2', '3', 'a', '_', 'e', 'f']
  11. print(re.findall("\W","abc123a_ef * | - ="))         #\W匹配非字母数字下划线,匹配特殊字符和空格
  12. #[' ', '*', ' ', '|', ' ', '-', ' ', '=']
  13. print(re.findall("\s","abc\n123\ta_ef * | - ="))        #\s匹配任意空白字符 等同于[\n\t\r\f]
  14. #['\n', '\t', ' ', ' ', ' ', ' ']
  15. print(re.findall("\S","abc\n123\ta_ef * | - ="))         #\S 匹配任意非空白字符
  16. #['a', 'b', 'c', '1', '2', '3', 'a', '_', 'e', 'f', '*', '|', '-', '=']
  18. print(re.findall("\d","abc\n123\ta_ef * | - ="))         #\d匹配任意数字0-9
  19. #['1', '2', '3']
  20. print(re.findall("\D","ta_ef- ="))       #\D匹配非数字字符
  21. #['t', 'a', '_', 'e', 'f', '-', ' ', '=']
  22. print(re.findall(r'a\\c',"a\\c a\c a\\\\c"))          #r原生显示\\
    #['a\\c', 'a\\c']
  26. 括号匹配
  27. print(re.findall("com(?:aa|bb)","acomaavabbcombb ab a")) #(aa|bb)匹配aa或bb com(?:aa|bb)匹配comaa和combb #如果不加?:匹配aa或bb
  28. #['comaa', 'combb']
  29. print(re.findall("a[-\n]c","abc a-ca_c a\tc a\nc="))     #[]匹配[]中包含的任意一个字符
  30. #['a-c', 'a\nc']
  31. print(re.findall("a[-\n]c","abc a-c a c a_c a\tc a\nc=")) #[^]匹配[]中不包含的任意一个字符
  32. #['abc', 'a c', 'a_c', 'a\tc']
  33. print(re.findall("ab{2}","abvabb ab a")) #{}指定匹配abb {2,5}匹配2-5次 {,5}匹配0-5次 {,5} 匹配5-n次
  34. #['abb']
  36. 特殊符号匹配
  37. ^ 匹配开头 $匹配结尾 \转意字符
  38. print(re.findall("comaa|combb","acomaavabbcombb ab a")) # | comaa|combb 匹配comaa和combb
  39. #['comaa', 'combb']
  40. print(re.findall("a.c","abc a|c a c a_c a\tc a\nc=")) #"."匹配任意单个字符 不能匹配\n
  41. #['abc', 'a|c', 'a c', 'a_c', 'a\tc']
  42. print(re.findall("a.c","abc a|c a c a_c a\tc a\nc=",re.S)) #"."和re.s匹配任意单个字符且能匹配\n
  43. #['abc', 'a|c', 'a c', 'a_c', 'a\tc', 'a\nc']
  44. print(re.findall("ab*","a ab abb abbb")) # * 匹配0或n个前一个位的字符
  45. #['a', 'ab', 'abb', 'abbb']
  46. print(re.findall("ab+","a ab abb abbb")) # + 匹配1或n个前一个位的字符
  47. #['ab', 'abb', 'abbb']
  48. print(re.findall("ab?","a ab abb abbb")) #?匹配0或1个b
  49. #['a', 'ab', 'ab', 'ab']
  51. 贪婪和非贪婪匹配
  52. *?,+?,??,{m,n}?    前面的*,+,?等都是贪婪匹配，也就是尽可能匹配，后面加?号使其变成惰性匹配
  53. print(re.findall("a.*c","aa123cabbbc")) #.* 贪婪匹配 匹配a开头c结尾
  54. #['aa123cabbbc']
  55. print(re.findall("a.*?c","aa123cabbbc")) #a.*?c 非贪婪匹配,匹配最短满足条件的
  56. #['aa123c', 'abbbc']
    1. a = re.findall(r"a(\d+?)",'a23b')    #非贪婪匹配
    2. print(a)
    3. b = re.findall(r"a(\d+)",'a23b')     #贪婪匹配
    4. print(b)
    5. 执行结果：
    6. ['2']
    7. ['23']
     
  60.  
 

complie()

#编辑正则表达式模式,返回一个对象的模式（可以把那些常用的正则表达式编译成正则表达式对象，这样可以提高一点效率。）
re.compile(pattern,flags=0)
  1. re.compile(pattern,flags=0)
  3. pattern: 编译时用的表达式字符串。
  5. flags 编译标志位，用于修改正则表达式的匹配方式，如：是否区分大小写，多行匹配等。常用的flags有：
  6. 标志
  7. re.S(DOTALL)        #使.匹配包括换行在内的所有字符
  8. re.I（IGNORECASE）  #使匹配对大小写不敏感
  9. re.L（LOCALE）      #做本地化识别（locale-aware)匹配，法语等
  10. re.M(MULTILINE)     #多行匹配，影响^和$
  11. re.X(VERBOSE)       #该标志通过给予更灵活的格式以便将正则表达式写得更易于理解
  12. re.U                #根据Unicode字符集解析字符，这个标志影响\w,\W,\b,\B
 
 

match object对象

re.match     只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None
re.search   匹配整个字符串，直到找到一个匹配
  1. #match和search一旦匹配成功，就是一个match object对象
  3.  
  4. start() 返回匹配开始的位置
  5. end() 返回匹配结束的位置
  6. span() 返回一个元组包含匹配 (开始,结束) 的位置
  7. group() 返回被 RE 匹配的字符串,()内输入数字可以一次输入多个分组，对应组号匹配的字符串
  8. a = "123abc456"
  9. print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(0)) #123abc456,返回整体
  10. print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(1)) #123
  11. print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(2)) #abc
  12. print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(3)) #456
  13. #group(0) 列出所有匹配， group(1) 列出第一个括号匹配部分，
  14. #group(2) 列出第二个括号匹配部分，group(3) 列出第三个括号匹配部分。
 

re.split 

分隔操作,分割后返回列表
  1. print(re.split("[ba]","a2bcd")) #用b和a当分隔符
  2. #['', '2', 'cd']
  3. print(re.split('\d+','one1two2three3four4five5')) #用数字当分割符
  4. #['one', 'two', 'three', 'four', 'five', '']
 

re.sub 替换

  1. print(re.sub("^g","G","guolm is man, guolm")) #不加^ 匹配所有
  2. #Guolm is man, guolm
  4. print(re.sub("(\w+)(\s)(\w+)(\s)(\w+)$",r"\5\2\3\4\1","alex make love"))
  5. #位置替换 \w+匹配多个字母数字下划线,\s是空格 5-1是索引位置
  6. #love make alex
  7.  
  8. print(re.sub("(\w+)(\W+)(\w+)(\W+)(\w+)",r"\5\2\3\4\1","alex ' \ + = make ---/\ love")) #\W匹配非字母数字下划线
  9. #love ' \ + = make ---/\ alex
  10.  
 

re.subn 替换,并返回次数

  1. print(re.subn('[1-3]','A','12456ab13cdef')) #包含1至3的数字替换成A 并显示替换次数
  2. #('AA456abAAcdef', 4)
  3. print(re.subn("g.t","have",'I get A, I got B ,I gut C')) #包含g.t 替换成have 并返回替换次数
  4. #('I have A, I have B ,I have C', 3)
 

finditer

搜索string，返回一个顺序访问每一个匹配结果（Match对象）的迭代器。找到 RE 匹配的所有子串，并把它们作为一个迭代器返回

  1. iter = re.finditer(r'\d+','12 drumm44ers drumming, 11 ... 10 ...')
  2. for i in iter:
  3. print(i)
  4. print(i.group())
  5. print(i.span())
  6. # 12
  7. # (0, 2)
  8. # <_sre.SRE_Match object; span=(8, 10), match='44'>
  9. # 44
  10. # (8, 10)
  11. # <_sre.SRE_Match object; span=(24, 26), match='11'>
  12. # 11
  13. # (24, 26)
  14. # <_sre.SRE_Match object; span=(31, 33), match='10'>
  15. # 10
  16. # (31, 33)
 

hashlib

  1. import hashlib
  3. #定义一个hash容器 把数据传入进去
  4. m=hashlib.md5()
  5. #m=hashlib.md5("bbbass".encode("utf-8")) #密码加严,先增加一段字符串
  6. m.update("aaaaaass".encode("utf-8"))
  7. print(m.hexdigest())
  8. #f34ec82a17a5ff16f0083fecaf445512
  10. #效果相同,sha256比md5更安全(没用)
  11. ma=hashlib.sha256()
  12. ma.update("aaaaaass".encode("utf-8"))
  13. print(ma.hexdigest())
  14. #d359e7a0615170c1404f4c49ad54be2ddd4e2a4fff8833c2d548dc9536d7a2a4
  16. #定义一个hash容器 把db文件内容数据传入进去
  17. with open(r"E:\install\pycharm\guolm\a.txt","rb") as f:
  18. for line in f:
  19. m.update(line)
  20. md5_num=m.hexdigest()
  21. print(md5_num)
  22. #b9384ce6cab40771cbd807b3c7bdd4f7
 
loggin模块分5个级别    debug()    info()    warnging()    error()    critical()
  1. import logging
  2. logging.basicConfig(filename='example.log',
  3. level=logging.WARNING,
  4. format='%(asctime)s %(message)s',
  5. datefmt='%m/%d/%Y %H:%M:%S %p')
  6. #filename='example.log' 指定写入日志文件
  7. #level=logging.WARNING(日志级别必须大写),日志级别达到WARNING级别写入db文件(文件默认生成)
  8. #format='%(asctime)s %(message)s'日志格式, asctime当前时间, message当前内容
  9. #datefmt='%m/%d/%Y %H:%M:%S %p' 日期格式
  10.  
  11. logging.debug('This message should go to the log file')
  12. logging.info('So should this')
  13. logging.warning('And this, too')
  14. logging.error("wrong password more than 3 times")
  15. logging.critical("server is down")
  17. #db文件显示
  18. 06/07/2017 01:01:54 AM And this, too06/07/2017 01:01:54 AM wrong password more than 3 times
  19. 06/07/2017 01:01:54 AM server is down
  20.  
 
 

日志格式

%(name)s

Logger的名字

%(levelno)s

数字形式的日志级别

%(levelname)s

文本形式的日志级别

%(pathname)s

谁调用日志输出该函数的模块的完整路径名，可能没有

%(filename)s

谁调用日志输出该函数的模块的文件名(aa.py)

%(module)s

谁调用日志输出该函数的模块名(aa)

%(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

用户输出的消息
 

 

如果想同时把log打印在屏幕和文件日志里，就需要了解一点复杂的知识 了


Python 使用logging模块记录日志涉及四个主要类，使用官方文档中的概括最为合适：

logger提供了应用程序可以直接使用的接口；

handler将(logger创建的)日志记录发送到合适的目的输出(输出到文件内或屏幕)

filter提供了细度设备来决定输出哪条日志记录(日志内容哪些输出,哪些不输出)

formatter决定日志记录的最终输出格式(日志格式)

logger
每个程序在输出信息之前都要获得一个Logger。Logger通常对应了程序的模块名，比如聊天工具的图形界面模块可以这样获得它的Logger：
LOG=logging.getLogger(”chat.gui”)
而核心模块可以这样：
LOG=logging.getLogger(”chat.kernel”)

Logger.setLevel(lel):指定最低的日志级别，低于lel的级别将被忽略。debug是最低的内置级别，critical为最高
Logger.addFilter(filt)、Logger.removeFilter(filt):添加或删除指定的filter
Logger.addHandler(hdlr)、Logger.removeHandler(hdlr)：增加或删除指定的handler
Logger.debug()、Logger.info()、Logger.warning()、Logger.error()、Logger.critical()：可以设置的日志级别

 

handler

handler对象负责发送相关的信息到指定目的地。Python的日志系统有多种Handler可以使用。有些Handler可以把信息输出到控制台，有些Logger可以把信息输出到文件，还有些 Handler可以把信息发送到网络上。如果觉得不够用，还可以编写自己的Handler。可以通过addHandler()方法添加多个多handler
Handler.setLevel(lel):指定被处理的信息级别，低于lel级别的信息将被忽略
Handler.setFormatter()：给这个handler选择一个格式
Handler.addFilter(filt)、Handler.removeFilter(filt)：新增或删除一个filter对象


每个Logger可以附加多个Handler。接下来我们就来介绍一些常用的Handler：
1) logging.StreamHandler
使用这个Handler可以向类似与sys.stdout或者sys.stderr的任何文件对象(file object)输出信息。它的构造函数是：
StreamHandler([strm])
其中strm参数是一个文件对象。默认是sys.stderr


2) logging.FileHandler
和StreamHandler类似，用于向一个文件输出日志信息。不过FileHandler会帮你打开这个文件。它的构造函数是：
FileHandler(filename[,mode])
filename是文件名，必须指定一个文件名。
mode是文件的打开方式。参见Python内置函数open()的用法。默认是’a'，即添加到文件末尾。

3) logging.handlers.RotatingFileHandler
这个Handler类似于上面的FileHandler，但是它可以管理文件大小。当文件达到一定大小之后，它会自动将当前日志文件改名，然后创建 一个新的同名日志文件继续输出。比如日志文件是chat.log。当chat.log达到指定的大小之后，RotatingFileHandler自动把 文件改名为chat.log.1。不过，如果chat.log.1已经存在，会先把chat.log.1重命名为chat.log.2。。。最后重新创建 chat.log，继续输出日志信息。它的构造函数是：
RotatingFileHandler( filename[, mode[, maxBytes[, backupCount]]])
其中filename和mode两个参数和FileHandler一样。
maxBytes用于指定日志文件的最大文件大小。如果maxBytes为0，意味着日志文件可以无限大，这时上面描述的重命名过程就不会发生。
backupCount用于指定保留的备份文件的个数。比如，如果指定为2，当上面描述的重命名过程发生时，原有的chat.log.2并不会被更名，而是被删除。


4) logging.handlers.TimedRotatingFileHandler
这个Handler和RotatingFileHandler类似，不过，它没有通过判断文件大小来决定何时重新创建日志文件，而是间隔一定时间就 自动创建新的日志文件。重命名的过程与RotatingFileHandler类似，不过新的文件不是附加数字，而是当前时间。它的构造函数是：
TimedRotatingFileHandler( filename [,when [,interval [,backupCount]]])
其中filename参数和backupCount参数和RotatingFileHandler具有相同的意义。
interval是时间间隔。
when参数是一个字符串。表示时间间隔的单位，不区分大小写。它有以下取值：
S 秒
M 分
H 小时
D 天
W 每星期（interval==0时代表星期一）
midnight 每天凌晨

 
 

日志输入到全局日志,db日志文件 屏幕

  1. import logging
  3. #日志输入到全局日志,db日志文件 屏幕
  5. # create logger
  6. logger = logging.getLogger('TEST-LOG') #TEST-LOG是日志名
  7. logger.setLevel(logging.DEBUG) #logging.DEBUG 全局的日志级别
  8. # 全局日志基本最高,子logging基本必须比全局高 否则不显示日志输出
  10. # create console handler and set level to debug
  11. ch = logging.StreamHandler() #创建屏幕输出显示
  12. ch.setLevel(logging.INFO) #屏幕输出日志级别
  14. # create file handler and set level to warning
  15. fh = logging.FileHandler("access.log") #文件的hander
  16. fh.setLevel(logging.WARNING) #文件的日志级别
  17. # create formatter
  18. formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
  20. # add formatter to ch and fh
  21. ch.setFormatter(formatter) #定义日志格式
  22. fh.setFormatter(formatter) #定义日志格式
  24. # add ch and fh to logger
  25. logger.addHandler(ch) #屏幕输出绑定到logger接口
  26. logger.addHandler(fh) #文件输出绑定到logger接口
  28. # 'application' code
  29. logger.debug('debug message')
  30. logger.info('info message')
  31. logger.warning('warn message')
  32. logger.error('error message')
  33. logger.critical('critical message')
 

日志输入到全局日志,db日志文件 屏幕 并按照时间切割保留最近3个db文件,每5秒切割1次

  1. #!/usr/sbin/python
  2. # -*- coding:utf-8 -*-
  3. import logging
  4. from logging import handlers #创建db文件日志切割,不加切割不用写
  6. #日志输入到全局日志,db日志文件 屏幕 并安装时间日志切割保留最近3个文件,每5秒切割1次
  8. # create logger
  9. logger = logging.getLogger('TEST-LOG') #TEST-LOG是日志名
  10. logger.setLevel(logging.DEBUG) #logging.DEBUG 全局的日志级别
  11. # 全局日志级别最高,子logging级别必须比全局高 否则不显示日志输出
  13. # create console handler and set level to debug
  14. ch = logging.StreamHandler() #创建屏幕输出显示
  15. ch.setLevel(logging.INFO) #屏幕输出日志级别
  17. # create file handler and set level to warning
  18. #fh = logging.FileHandler("access.log") #文件显示(db文件保存日志) 不加日志切割用这个
  19.  
  20. fh = handlers.TimedRotatingFileHandler("access.log",when="S",interval=5,backupCount=3) #文件显示(db文件保存日志)
  21. #TimedRotatingFileHandler 按时间切割保存, when="S",单位是秒(h是小时), interval=5,(5个单位切1次)backupCount=3 (保存最近3次,0是无限制保存)
  22. #fh = handlers.RotatingFileHandler("access.log",maxBytes=4,backupCount=3)
  23. #RotatingFileHandler 按时间切割保存 maxBytes=4 (文件满4bytes,就生成新文件) backupCount=3 (保存最近3次,0是无限制保存)
  26. fh.setLevel(logging.WARNING) #文件的日志级别
  27. # create formatter
  28. formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
  30. # add formatter to ch and fh
  31. ch.setFormatter(formatter) #定义日志格式
  32. fh.setFormatter(formatter) #定义日志格式
  34. # add ch and fh to logger
  35. logger.addHandler(ch) #屏幕输出绑定到logger接口
  36. logger.addHandler(fh) #文件输出绑定到logger接口
  38. # 'application' code
  39. logger.debug('debug message')
  40. logger.info('info message')
  41. logger.warning('warn message')
  42. logger.error('error message')
  43. logger.critical('critical message')
 
 
 
 
 
 

os模块

  1. import platform
  2. platform.platfrom()               #显示系统版本
  3. platform.system()                #显示系统版本
  5. os.chdir("/home")              #切换到/home目录模块
  6. os.getcwd()            #获取当前目录
  7. os.system("ls -h")             #在python中执行shell命令(不能切换目录),
  8. d=os.popen("df -h").read()     #把df的执行结果赋值给d
  9. print(d)
  10.  
  11.  
  12. os.path.abspath(__file__)                         #os.path.abspath 返回文件绝对路径
  13. os.mkdir("guol11")                             #创建1个目录
  14. os.makedirs("/home/guolm/1112211/a2/a3")           #创建多层目录
  15. os.makedirs("/home/guolm/1112211aa",exist_ok=True) #创建文件存在,就覆盖 不会报错
  16. os.rmkdir("guol11")        #目录为空，则删除,否则报错
  17. os.removedirs("1112211/a2/a4/")                 #可写绝对路径,若目录为空，则删除，并递归到上一级目录，如若也为空，则删除,依此类推
  19. os.listdir("") #列出当前目录所有,包含隐藏文件 os.listdir("..")列出上层目录所有
  20. os.rename("guo","gg") #重命名 guo为gg
  22. os.stat("gg")     #获取文件或目录信息 os.stat("gg").st_size 获取文件大小 (看输出写参数)
  24. os.sep                #显示分割符，win下为"\\",Linux下为"/"
  25. os.linesep            #输出行终止符，win下为"\r\n",Linux下为"\n"
  26. os.pathsep            #分割文件路径的字符 win是; linux是:
  27. os.environ            #获取系统的环境变量
  29. 返回文件路径
  30. import os,sys
  31. file_path=os.path.abspath(__file__)                #os.path.abspath 返回文件绝对路径
  32. print(file_path)
  33. #E:\install\pycharm\guolm\day6\supba.py
  34.  
  35. print(os.path.split(file_path))                #优化返回文件的目录绝对路径
  36. #('E:\\install\\pycharm\\guolm\\day6', 'supba.py')
  37.  
  38. print(os.path.dirname(file_path)) #返回文件的目录路径
  39. #E:\install\pycharm\guolm\day6
  41. print(os.path.dirname(os.path.dirname(file_path))) #返回文件的目录上层目录的路径
  42. E:\install\pycharm\guolm
  44. print(os.path.basename(file_path)) #返回文件名
  45. supba.py
  46.  
  47. print(os.path.exists(file_path)) #判断文件路径是否存在 True为真 False为假
  48. #True
  49. print(os.path.isabs(file_path)) #判断文件是否为绝对路径,True为真 False为假
  50. #True
  51. print(os.path.isfile(file_path)) #判断file_path是否为存在的文件
  52. #True
  53. print(os.path.isdir(file_path)) #判断file_path是否为存在的目录
  54. #False
  55. print(os.path.getatime(file_path)) #返回file_path文件或目录最后存取时间
  56. #1496854045.527072
  57. print(os.path.getatime(file_path)) #返回file_path文件或目录最后修改时间
  58. #1496854045.527072

sys模块

  1. import sys
  3. print(sys.path) #返回模块路径
  4. print(sys.version) #输出python版本信息
  5. print(sys.maxsize) #输出最大的int值
  6. print(sys.platform) #显示系统类型
  7. sys.argv #把sys.argv写模块 被调用会显示绝对路径,后边跟的值也是传参给列表
  8. #命令行参数list,第一个元素是程序本身
  10. #交互,用户可输入1行内容
  11. # a=sys.stdin.readline()
  12. # print(a)
 










 










json    
pickle    





{}    
dict    





[]    
list    





"string"    
str    





1234.56    
int或float    





true/false    
True/False    





null    
None


















 




json:    用于字符串和python数据类型间进行转换


pickle:  用于python特有的类型和python的数据类型间进行转换




pickle的写入是二进制形式用wb模式,可以序列化python任何数据类型


json  的写入是字符串形式用w模式,只支持序列化python的str,int,float,set,list,dict,tuple数据类型,但json可和其他语言序列化




pickle功能: dumps,dump,loads,load


json 功能:  dumps,dump,loads,load


 


序列化和反序列化主要用于动态数据存储
pickle.dumps   序列化      内存-->硬盘
pickle.loads   反序列化    硬盘-->内存





pickle


如下2个py文件功能是实现数据的动态存档


这个文件的作用,读取内存数据写入到db文件


    

  1. import pickle
    2. 

  2. #import json as pickle 这是用json执行 注意把wb改成w
    3. 

  3. account={
    4. 

  4.  "id":63232223,
    5. 

  5.  "credit":15000,
    6. 

  6.  "balance":8000,
    7. 

  7.  "expire_date":"2020-5-21",
    8. 

  8.  "password":"sdfsf"
    9. 

  9. }
    10. 

  10. f=open("account1.db","wb")
    11. 

  11. f.write(pickle.dumps(account)) #相当于pickle.dump(account,f)
    12. 

  12. f.close()
    13. 





这个文件的作用,读取db文件写入到内存




    

  1. import pickle
    2. 

  2. #import json as pickle 这是用json执行 注意把rb改成r
    3. 

  3. f=open("account1.db","rb")
    4. 

  4. account=pickle.loads(f.read())#相当于account=pickle.load(f)
    5. 

  5. print(account)
    6. 

  6. print(account["id"])
    7. 

  7. #可以加如下,执行后注释 在执行看值是否改变
    8. 

  8. 

      

    1. account["balance"]-=3400
      2. 

    2. f=open("account1.db","wb")
      3. 

    3. f.write(pickle.dumps(account))
      4. 

    4. f.close()
      5. 


    

     
    


    9. 

  9.  
    10. 




 




 





 




shelve模块 比pickle简单


    

  1. import shelve
    2. 

    3. 

  3. #内存写入db文件, 字典形式,
    4. 

  4. f=shelve.open(r'sheve.txt')
    5. 

  5. f["student1"]={"name":"egon","age":18,"height":"180cm"}
    6. 

  6. print(f['student1'])
    7. 

  7. f.close()
    8. 

    9. 

  9. #读取db文件的数据
    10. 

  10. f=shelve.open(r'sheve.txt')
    11. 

  11. print(f['student1'])
    12. 

  12. print(f['student1']["name"])
    13. 

  13. f.close()
    14. 



 




随机生成数模块


 


    

  1. import random
    2. 

    3. 

  3. print(random.random()) #不能传参,随机生成大于0小于1之间的小数
    4. 

  4. #0.14251
    5. 

  5. print(random.uniform(1,3)) #随机生成大于1小于3的小数
    6. 

  6. #2.14251
    7. 

  7.  
    8. 

  8. print(random.randint(1,6))      #随机生成大于等于1且小于等于6的整数
    9. 

  9. #4
    10. 

  10. print(random.randrange(1,6))    #大于等于1且小于6的整数
    11. 

  11. #5
    12. 

  12.  
    13. 

  13. print(random.choice([1,'23',[4,5]]))  #随机得到1或23或[4,5]
    14. 

  14. #[4, 5]
    15. 

  15.  
    16. 

  16. print(random.sample([1,"23",[4,5]],2)) #随机获得任意2个元素,2可改
    17. 

  17. #[1, [4, 5]]
    18. 

    19. 

  19.  
    20. 

  20. #随机更改itme元素顺序
    21. 

  21. item=[1,3,5,7,9]
    22. 

  22. random.shuffle(item)
    23. 

  23. print(item)
    24. 

  24. #[3, 5, 9, 7, 1]
    25. 

    26. 

    27. 

  27. #生成随机验证码
    28. 

  28. import random
    29. 

    30. 

  30. def v_code():
    31. 

    32. 

  32.     code = ''
    33. 

  33.     for i in range(5):
    34. 

    35. 

  35.         num=random.randint(0,9)
    36. 

  36.         alf=chr(random.randint(65,90))
    37. 

  37.         add=random.choice([num,alf])
    38. 

  38.         code += str(add)
    39. 

  39.     return code
    40. 

    41. 

  41. print(v_code())
    42. 

  42. #W3E01
    43. 




 


 


 


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


 


 


copy


    

  1. #覆盖,把old.xml覆盖到new.xml, new.xml不存在就新建
    2. 

  2. shutil.copyfileobj(open("old.xml","r"),open("new.xml","w")) #需要新建old.xml文件
    3. 

  3. #把old.xml覆盖到new.xml, new.xml不存在就新建
    4. 

  4. shutil.copyfile("old.xml","new.xml") #需要新建old.xml文件
    5. 

  5. 

  6. #仅复制权限, 文件内容,组,用户都不变
    7. 

  7. shutil.copymode("f1.log","f2.log")
    8. 

  8. 

  9. #仅拷贝状态的信息,包括：mode bits, atime, mtime, flags
    10. 

  10. shutil.copystat('f1.log', 'f2.log')
    11. 

  11. 

  12. #拷贝文件和权限
    13. 

  13. shutil.copy('f1.log', 'f2.log')
    14. 

  14. #拷贝文件状态和信息
    15. 

  15. shutil.copy2('f1.log', 'f2.log')
    16. 



 


 


 


#递归


    

  1. #递归copy 把day2所以,复制给day4
    2. 

  2. #shutil.copytree('day2', 'day4', ignore=shutil.ignore_patterns('*.pyc', 'tmp*'))
    3. 

  3. 

  4. #递归copy,软连接拷贝成硬链接
    5. 

  5. shutil.copytree('f1', 'f2', symlinks=True, ignore=shutil.ignore_patterns('*.pyc', 'tmp*'))
    6. 

  6. 

  7. #递归删除 删除day4及其子目录和文件
    8. 

  8. shutil.rmtree("day4")
    9. 

  9. 

  10. #递归移动,它类似mv命令，也可重命名
    11. 

  11. shutil.move("./day4/2","./3223") #把day4目录的2文件,移动到当前目录,并改名为3223
    12. 



 


 


压缩与解压缩


    

  1. import shutil
    2. 

  2. #压缩
    3. 

  3. ##data_bak是文件名(默认存放当前路径),gztar压缩格式,root_dir 指定压缩路径, 压缩格式“zip”, “tar”, “bztar”，“gztar”
    4. 

  4. #shutil.make_archive("data_bak","gztar",root_dir="./day3")
    5. 

  5. 

  6.  
    7. 

  7. import tarfile
    8. 

  8. #压缩 (tar,gztar bztar)
    9. 

  9. t=tarfile.open("guolm.gztar","w") #可指定tar,gztar bztar
    10. 

  10. t.add(r'/Users/playcrab/PycharmProjects/untitled1/f1.log',arcname="f1.log") #压缩的文件,相当于把路径给重命名为f1.log
    11. 

  11. t.add(r'/Users/playcrab/PycharmProjects/untitled1/f2.log',arcname="f2.log") #压缩的文件,
    12. 

  12. t.close()
    13. 

  13. 

  14. #解压缩 (tar,gztar bztar)
    15. 

  15. #把# guolm.tar的内容解压到guolm目录(不创建默认就生成)
    16. 

  16. t=tarfile.open("guolm.gztar","r") #读取
    17. 

  17. t.extractall("guolm") #解压路径名
    18. 

  18. t.close()
    19. 

    20. 

  20.  
    21. 

  21. import zipfile
    22. 

  22. #zip压缩
    23. 

  23. z= zipfile.ZipFile('guolm.zip',"w")
    24. 

  24. z.write("f1.log")
    25. 

  25. z.write("f2.log")
    26. 

  26. z.close()
    27. 

  27. #zip解压缩
    28. 

  28. z=zipfile.ZipFile("guolm.zip","r")
    29. 

  29. z.extractall(path="./day3") #解压到当前day3目录下
    30. 

  30. z.close()
    31. 



 


 


 


 




 


import subprocess


http://www.cnblogs.com/alex3714/articles/5161349.html 


 


    

  1. subprocess.run("df -h |grep /dev/sda1",shell=True)         #相当于启动一个终端 执行shell命令
    2. 

  2. subprocess.call("df -h |grep /dev/sda1",shell=True)        #输出结果并返回状态 0正常,1出错
    3. 

  3. subprocess.check_call("df -h |grep /dev/sda1",shell=True)  #输出结果并返回状态,错误抛异常
    4. 

  4. subprocess.getstatusoutput("df -h |grep /dev/sda1")        #元组形式，第1个元素是执行状态，第2个是命令结果
    5. 

  5. subprocess.getoutput('ls /bin/ls')                         #执行命令返回结果
    6. 




 


#上面那些方法，底层都是封装的subprocess.Popen




    

  1. >>> res = subprocess.Popen("df -h |grep /dev/sda1",shell=True,stdout=subprocess.PIPE)
    2. 

  2. >>> res.stdout.read()
    3. 

  3. b'/dev/sda1                 97M   76M   22M  78% /boot\n'
    4. 

    5. 

  5. >>> res = subprocess.Popen("df -h |grep /dev/sda1",shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
    6. 

  6. >>> res.stdout.read()
    7. 

  7. b'/dev/sda1                 97M   76M   22M  78% /boot\n'
    8. 




 







    

  1. res.poll()                     返回res命令的执行状态 0是执行结束, None是正在执行
    2. 

  2. res.wait()                     等待res执行结束,返回执行结果状态
    3. 

  3. res.terminate()                杀掉res执行中的状态
    4. 

  4. res.communicate()              等待res执行结束
    5. 

  5. #res.communicate(timeout=2)    程序2秒钟不能执行完,自动结束,多用于程序备份 
    6. 







 




可用参数：


    

  1. args：shell命令，可以是字符串或者序列类型（如：list，元组）
    2. 

  2.  
    3. 

  3. bufsize：指定缓冲。0 无缓冲,1 行缓冲,其他 缓冲区大小,负值 系统缓冲
    4. 

  4.  
    5. 

  5. stdin, stdout, stderr：分别表示程序的标准输入、输出、错误句柄
    6. 

  6.  
    7. 

  7. preexec_fn：只在Unix平台下有效，用于指定一个可执行对象（callable object），它将在子进程运行之前被调用
    8. 

  8.  
    9. 

  9. close_sfs：在windows平台下，如果close_fds被设置为True，则新创建的子进程将不会继承父进程的输入、输出、错误管道。
    10. 

  10. 所以不能将close_fds设置为True同时重定向子进程的标准输入、输出与错误(stdin, stdout, stderr)。
    11. 

  11. shell：同上
    12. 

  12.  
    13. 

  13. cwd：用于设置子进程的当前目录
    14. 

  14.  
    15. 

  15. env：用于指定子进程的环境变量。如果env = None，子进程的环境变量将从父进程中继承。
    16. 

  16.  
    17. 

  17. universal_newlines：不同系统的换行符不同，True -> 同意使用 \n
    18. 

  18.  
    19. 

  19. startupinfo与createionflags只在windows下有效
    20. 

  20. 将被传递给底层的CreateProcess()函数，用于设置子进程的一些属性，如：主窗口的外观，进程的优先级等等
    21. 




 





 


 


 


 


 


 








 


 


 


 


 


 


 




 


 


 


 


 


 


 


 


 







 


 


 


 


 


 








 






            

            
posted @ 
2017-06-10 03:30 
Gavinkwok 
阅读(153) 
评论(0) 
 
收藏 
举报