python基础------模块

一，日志模块：logging

#简单应用
import logging
logging.debug("hello python")
logging.info("hello world")
logging.warning("hello java")  #日志级别默认WARNUNG 只显示warning一下的，上面的debug，info没打印出来
logging.error("hello C")
logging.critical("hello C++")

#打印结果：
#WARNING:root:hello java
#ERROR:root:hello C
#CRITICAL:root:hello C++
#

日志的等级从下到上：critical-->error-->warning-->info-->debug

2,灵活设置日志等级，位置，日志格式

import logging
#日志等级设置成debug
logging.basicConfig(level=logging.DEBUG,  #日志等级设置成debug
                    format="%(asctime)s %(filename)s %(levelname)s %(message)s",
                    filename = "test.txt", #设置文件名
                    filemode = "w",    #以w模式写入内容
                    )
logging.debug("debug message")
logging.info("info message")
logging.warning("warning message")
logging.error("error message")
logging.critical("critical message")

2.1 test.txt文件中的内容：

2017-04-27 19:29:49,808 logging模块.py DEBUG debug message
2017-04-27 19:29:49,825 logging模块.py INFO info message
2017-04-27 19:29:49,826 logging模块.py WARNING warning message
2017-04-27 19:29:49,826 logging模块.py ERROR error message
2017-04-27 19:29:49,826 logging模块.py CRITICAL critical message

2.2  format中可能用到的格式化串

 

'''

%(name)s Logger的名字
%(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用户输出的消息
'''

 

2.3 logger对象方法：推荐用法

 

import logging
#日志模块
def get_logger():
    logger = logging.getLogger() #获得一个logger对象

    fh = logging.FileHandler("a.txt") # 创建一个文件流,需要给一个文件参数

    sh = logging.StreamHandler()  #创建一个屏幕流，

    logger.setLevel(logging.DEBUG) #设定最低等级debug
    #写入文件的中的格式
    fm = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")

    logger.addHandler(fh)#把文件流添加进来，流向文件
    logger.addHandler(sh) #把屏幕流添加进来，流向屏幕

    fh.setFormatter(fm) #在文件流添加写入格式
    sh.setFormatter(fm) #在屏幕流添加写入格式

    return logger

logger = get_logger()
logger.debug("hello world")
logger.info("world python")
logger.warning("hello java")
logger.error("python C")
logger.critical("hello C++")

2.3 a.txt文件中内容

#内容都是一样的，只是两个流派都弄出来了

#屏幕上的内容：
2017-04-27 19:57:38,336 - root - DEBUG - hello world
2017-04-27 19:57:38,337 - root - INFO - world python
2017-04-27 19:57:38,337 - root - WARNING - hello java
2017-04-27 19:57:38,337 - root - ERROR - python C
2017-04-27 19:57:38,338 - root - CRITICAL - hello C++


#文件中的内容：
2017-04-27 19:57:38,336 - root - DEBUG - hello world
2017-04-27 19:57:38,337 - root - INFO - world python
2017-04-27 19:57:38,337 - root - WARNING - hello java
2017-04-27 19:57:38,337 - root - ERROR - python C
2017-04-27 19:57:38,338 - root - CRITICAL - hello C++

二：序列化模块：json 重要

1，只有两个方法，1.1，序列化方法，1.2，反序列方法

如果我们要在不同的编程语言之间传递对象，就必须把对象序列化为标准格式，比如XML，但更好的方法是序列化为JSON，因为JSON表示出来就是一个字符串，可以被所有语言读取，也可以方便地存储到磁盘或者通过网络传输。JSON不仅是标准格式，并且比XML更快，而且可以直接在Web页面中读取，非常方便。

 

import json,os
# d={"name":"egon"}
#
# s =json.dumps(d)
#
# f = open("b.txt","w")
# f.write(s)
#
# f.close()
# a=open("b.txt")
# data = a.read()
# data2 = json.loads(data)
# print(data2["name"])
# a.close()

#序列化方法,就是把数据以json字符串形式写入到文件
d = {"name":"egon"}

j = json.dumps(d) #把字典转成json字符串

f = open("b.txt","w")
f.write(j)  #等同于data = json.dump(d,f)
f.close()

#反序列化方法，
f = open("b.txt")
data = json.loads(f.read())  #把文件中的json字符串读出来，以字典的格式
print(data["name"])   #egon
f.close()

 

三，pickle 模块

跟json差不多，只能在python之间用，有局限性

四，os模块，正则表达式

元字符：

  1，   .  通配符，可以代替除了\n之外的所有字符

  2，   +  重复前一个字符1到无穷次

  3，   *  重复前一个字符0到无穷次

  4，   ?  重复前一个字符0到1次

  5，   ^  从字符串开头匹配，在[]里就是取反的意思

  6，   $  从字符串结尾匹配

  7，   |   或的关系

  8，   \   转义符  1，在元字符前加上\使其变成普通的字符，2，将普通字符变成有特殊功能的符号，后面会介绍

  9，   ()   分组  在有()的时候匹配，优先匹配  可以在()里加上?:取消优先级，不要问我为什么，这是语法 

  10， {} 可以指定范围，还可以指定重复次数

  11，  []     * + . 在列表里都是普通字符，  -  ^  \ 还有特殊意义

import re

#  .
print(re.findall("e.l","hello"))  #['ell']
print(re.findall("o...r","hello world")) #['o wor']

#  +
print(re.findall("a+","aab"))   #['aa']
print(re.findall("ab+","abbbbcc"))  #['abbbb']

#  *
print(re.findall("ab*","abbbc"))  #['abbb']
print(re.findall("abbc*","abbbb"))# ['abb'] *是从0次开始

# + *都是贪婪匹配 在后面加上？就变成惰性匹配了
print(re.findall("ab+?","abbbcd")) #['ab']
print(re.findall("ab*?","abbbcd")) #['a']

#  ？
print(re.findall("ab?","abbc")) #['ab']
print(re.findall("abcc?","abccc")) #['abcc']

#  ^
print(re.findall("^hello","helloworld")) #['hello']
print(re.findall("^hello","pthon"))    # []

#  $
print(re.findall("ern$","pattern"))  # ['ern']
print(re.findall("erl$","pattern"))  # []

#  |
print(re.findall("(ab)|\d","addfab45vj")) #['ab', '', '']
data = re.search("(ab)|\d","addfab45vj")
print(data.group())    #ab

#  \
print(re.findall("a\d","a34d51")) #['a3']
print(re.findall("h\*e","h*ello")) #['h*e']
'''
\d  匹配任何十进制数；它相当于类 [0-9]。
\D 匹配任何非数字字符；它相当于类 [^0-9]。
\s  匹配任何空白字符；它相当于类 [ \t\n\r\f\v]。
\S 匹配任何非空白字符；它相当于类 [^ \t\n\r\f\v]。
\w 匹配任何字母数字字符；它相当于类 [a-zA-Z0-9_]。
\W 匹配任何非字母数字字符；它相当于类 [^a-zA-Z0-9_]
\b  匹配一个特殊字符边界，比如空格 ，&，＃等
'''
print(re.findall("\d","h*el3l452o")) #['3', '4', '5', '2']
print(re.findall("\D","h4e3ll2o"))   #['h', 'e', 'l', 'l', 'o']
print(re.findall("\s","h e\tl\rl\vo")) #[' ', '\t', '\r', '\x0b']
print(re.findall("\S","h\te\nllo"))    #['h', 'e', 'l', 'l', 'o']
print(re.findall("\w","h2<>3*l4"))     #['h', '2', '3', 'l', '4']
print(re.findall("\W","h*2j$3\no")) #['*', '$', '\n']
print(re.findall("\b","h*ello"))  #[]

# {}
print(re.findall("b{2}","abbbbc")) #['bb', 'bb'] 指定重复2次
print(re.findall("ab{1,3}","abbbbbc")) #['abbb']  指定范围，1到3次重复

# ()
print(re.findall(r"(ab)+c","ababc"))#['ab'] 因为括号的优先级，只显示括号内的匹配内容，括号外的+是匹配到了只是没显示出来
print(re.findall(r"(?:ab)+c","ababc")) #['ababc'] 加上？:取消括号的优先级，结果都显示出来了

# []
print(re.findall("a[bc]d","acd"))#['acd'] 匹配列表中的任意一个 只要满足就匹配出来了
print(re.findall("a[bc]d","abd"))#['abd']

print(re.findall("[*+.]","da.j34*js+")) #['.', '*', '+'] .* + 在列表内都是普通字符
print(re.findall("[^\d]","she231j")) #['s', 'h', 'e', 'j'] ^在列表内表示取反
print(re.findall("[a-z]","hello")) #['h', 'e', 'l', 'l', 'o'] - 在列表内表示a-z的范围都取
print(re.findall("[A-Z]","HeLLo")) #['H', 'L', 'L'] 只取A-Z的大写英文字母
print(re.findall("[0-9]","h1e2l3l4o5")) #['1', '2', '3', '4', '5'] 只取0-9的数字
print(re.findall("[\s]","\nsa")) # ['\n'] \还是有特殊意义

# r 在匹配规则前加上，使在ascll码类有特殊意义的变成原生字符串
#print(re.findall('c\l','abc\le')) #[] \l在ascll码表里有站位，所以匹配不出来
print(re.findall('c\\\\l','abc\le')) #['c\\l']
print(re.findall(r"c\\l","abc\le")) #['c\\l'] 变成原生字符串

# re方法

# re.finddall  #返回所有满足匹配条件的结果,放在列表里
ret = re.findall("ab","abcaa")
print(ret) #['ab']

# re.finditer  可迭代对象，迭代器
ret = re.finditer("a","abacdef")
print(next(ret).group()) #a
print(next(ret).group()) #a

# re.seach 只匹配第一个结果  函数会在字符串内查找模式匹配,只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以
                        # 通过调用group()方法得到匹配的字符串,如果字符串没有匹配，则返回None。
ret = re.search("\d","h31el34l5o0")
print(ret.group()) # 3

# re.math 只在字符串开始的位置匹配
ret = re.match("he","hello")
print(ret.group()) # he

# re.split 分割 先按l分割，得到'he',''和lo,在从'',lo开始分割,得到下面结果
ret = re.split("l","hello")
print(ret)  # ['he', '', 'o']

# re.sup 替换
ret = re.sub("l","A","hello")
print(ret)  # heAAo

#re.subn 替换 返回元组 可以选择添加替换次数,不添加次数，默认字符串里有几个就替换几个
ret = re.subn("l","A","hello")
print(ret) # ('heAAo', 2)

ret = re.subn("l","A","hello",1)
print(ret) # ('heAlo', 1)


#compile 编译方法 好处：对于多个字符串处理效率高
c = re.compile("he") #匹配规则
ret = c.findall("hellohe") #匹配内容
print(ret) #['he', 'he']