python模块之configparser_logging_re

Posted 2020-11-09 枫若雪

正则表达式的内容放在最下面了 

configparser 模块：

#!/usr/bin/env python
# coding:utf-8

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\'] = {}
# ts = config[\'topsecret.server.com\']
# ts[\'Host Port\'] = \'50022\'  # mutates the parser
# ts[\'ForwardX11\'] = \'no\'  # same here
#
# config[\'DEFAULT\'][\'ForwardX11\'] = \'yes\'
#
# with open(\'example.ini\', \'w\') as configfile:
#     config.write(configfile)


config = configparser.ConfigParser()

print(config.sections())
config.read(\'example.ini\')  # 读取配置文件
print(config.sections())  # [\'bitbucket.org\', \'topsecret.server.com\']

print(\'DEFAULT\' in config)  # 判断是否有键

print(config[\'DEFAULT\'][\'FORwardx11\'])  ## 块下的子键不区分大小写
print(config[\'bitbucket.org\'][\'User\'])

# DEFAULT 块比较特殊，会在 for 遍历时一起出来
# DEFAULT 作用是给所有的块都能共用
for i in config[\'bitbucket.org\']:
    print(i)

print(config.options(\'bitbucket.org\'))  # 拿到键
print(config.items(\'bitbucket.org\'))  # 拿到键值对的元组

print(config.get(\'bitbucket.org\', \'compression\'))  # 取bitbucket.org下的某值，DEFAULT下的值也算。

config.add_section("address")  # 加个区块
config.set("address", \'city\', \'suzhou\')  # 增加行

config.remove_section("topsecret.server.com")  # 删除块
config.remove_option("DEFAULT", "ForwardX11")  # 删除行

config.write(open("conf.cfg", \'w\'))  # 写入文件

 

logging 模块：

#!/usr/bin/env python
# coding:utf-8

import logging

## 日志操作模块
# -------------------------------logging.basicConfig 方式
# logging.basicConfig(
#     level=logging.DEBUG,  # 改变了默认级别
#     filename = "loggingtest.log",  ## 写入文件
#     filemode="a",  # a 追加模式  w 覆盖
#     format="%(asctime)s %(filename)s[%(lineno)s] %(message)s",  # 写入时间   输出message时的行号   内容
# )
#
# ## 参考 https://www.cnblogs.com/yuanchenqi/articles/5732581.html
#
# logging.debug(\'debug...\')
# logging.info(\'info...\')
# logging.warning(\'warning...\')  # 默认只显示此级往下
# logging.error(\'error.....\')
# logging.critical(\'critical......\')



# -------------------------------logger 对象方式
def logger():
    logger = logging.getLogger()
    logger.setLevel("DEBUG")

    fh =logging.FileHandler("logtest.log") #输出文件
    ch = logging.StreamHandler() #输出屏幕

    fm = logging.Formatter("%(asctime)s %(filename)s[%(lineno)s] %(message)s")

    fh.setFormatter(fm)
    ch.setFormatter(fm)

    logger.addHandler(fh)
    logger.addHandler(ch)
    return logger

logger = logger()

logger.debug("debug...")
logger.info("info...")
logger.warning("warning...")
logger.error("error...")
logger.critical("critical...")



# logger = logging.getLogger("logger")  ##根对象
# logger1 = logging.getLogger("logger1")
# logger2 = logging.getLogger("logger1.sontree") ## 子对象
## 如果子级和父级都有输出动作，那么子级的输出动作会输出2次
## 解决方法是取消父级的输出动作，只输出子级。

 

hashlib

import hashlib

## 普通的加密，存在撞库的危险
obj_a = hashlib.md5()
obj_a.update("hello".encode("utf8"))  # 5d41402abc4b2a76b9719d911017c592
print(obj_a.hexdigest())

obj_a.update("root".encode("utf8"))
print(obj_a.hexdigest()) #  e206121dbbe984f3bc6c6448846ed8cd 这一串实际上是基于前一次的原始字符之上的加密结果。

# obj_a.update("helloroot".encode("utf8"))  # e206121dbbe984f3bc6c6448846ed8cd 等于helloroot
# print(obj_a.hexdigest())

## 加盐的加密，降低撞库的风险
# obj_b = hashlib.md5() # 5d41402abc4b2a76b9719d911017c592
obj_b = hashlib.md5(\'1qaz@WSX\'.encode(\'utf8\'))
obj_b.update("hello".encode("utf8")) # 042cd0078e14743b5da893388d095859

print(obj_b.hexdigest())

 

re模块：

#!/usr/bin/env python
# coding:utf-8

## 正则表达式，作用就是做模糊匹配, 快速匹配
## 参考 https://www.cnblogs.com/yuanchenqi/articles/5732581.html

import re

lis = re.findall(\'\\d+\',"alex22jack33ran8sdsff100")
print(lis)

## 元字符  . ^ $ * + ? {} [] | () \\

# 点 . 是通配符 可以代替除了 \\n 外的任意一个字符
print(re.findall("a..x","absxdfsasdxkklarsx"))

# 尖角号 ^ 匹配只能以其开头的。
print(re.findall("^a..x","absxdfsasdxkklarsx"))

# 刀勒 $ 匹配只能以其结尾的。
print(re.findall("a..x$","absxdfsasdxkklarsx"))


# 星 * 匹配的是0到无穷次， 加 + 匹配的是1到无穷次
# 贪婪匹配
print(re.findall("alex*","absxdfsalexxxdds"))
print(re.findall("alex+","absxdfsalexxxdds"))
print(re.findall("alex*","absxdfsaledds"))
print(re.findall("alex+","absxdfsaledds"))

# 问号 ? 匹配 1次或0次
print(re.findall("alex?","alebsxdfsalexxxdds"))

\'\'\'
大括号{} 可以灵活运用  
{0,} == *
{1,} == +
{0,1} == ?
{1,5} 必须至少1个，最多取到5个
{5} 必须至少5位才能匹配
\'\'\'
print(re.findall("alex{2}","alexbsxdfsalexxxxdds"))
print(re.findall("alex{1,3}","alexbsxdfsalexxxxdds"))

print(re.findall("alex*?","alexbsxdfsalexxxxdds")) # 后面加问号，变成惰性匹配


# 最重要的字符集 []  方括号里面是字符集，特殊符号 * + ? 不再特殊，而 - 表示连续
print(re.findall("a[bc]","abexbsxdfsacexxxaxdds"))  # ab  ac
print(re.findall("a[bc]x","abexbsxdfsacxexxxaxdds"))  # acx
print(re.findall("a[b*]x","abexbsxdfsacxexxxa*xdds"))  # a*x

print(re.findall("a[a-z]","abexbsxdfsacxexxxa*xdds"))  # ab  ac
print(re.findall("a[a-z]*","abe,xbsxdfsacxexxxa*xdds"))  # abe  acxexxxa

print(re.findall("a[0-9]","ab8a7654cde"))  # a7
print(re.findall("a[0-9]*","ab8a7654cde"))  # a   a7654

print(re.findall("a[^0-9]","ab8a7654cde"))  # 逻辑非：不要0-9

print(re.findall("\\([^()]*\\)","12+(34*5+3-7*(3-1))"))  # 得到 (3-1)
print(re.findall("34\\*5","12+(34*5+3-7*(3-1))"))  # 星号被转义

\'\'\'
元字符之转义符\\
反斜杠后边跟元字符去除特殊功能,比如\\.
反斜杠后边跟普通字符实现特殊功能,比如\\d

\\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","12+(34*5+3-7*(3-1))"))
print(re.findall(r"I\\b","Hello I am LI LIST"))
print(re.findall(r"I\\\\c","Hello I am LI LI\\cST"))  ## 解释器会识别一次， re也会识别一次。所以要多加一个\\

print(re.findall(r"ka|bc","Hellbcoaskads"))  ## bc  ka

print(re.findall("(abc)","abcabcabckkkabc"))  # 得到四个abc
print(re.findall("(abc)+","abcabcabckkkabc"))  # 仅输出分组里的第一个
print(re.findall("(?:abc)+","abcabcabckkkabc"))  # 取消分组优先级

\'\'\'
re.findall是找到所有的，返回list， re.search是只找一个, 返回对象
\'\'\'
print("-------------------------------------")
print(re.search("\\d+","asdf321kdfas23"))
print(re.search("\\d{5}","asdf321kdfas23"))
print(re.search("\\d+","asdf321kdfas23").group())  # group方法取得结果

print(re.search("(abc)","abcabcabc"))
print(re.search("(?P<name>[a-z]+)\\d+","alex36wusir34xialv33")) ## 分组，组名name
print(re.search("(?P<name>[a-z]+)\\d+","alex36wusir34xialv33").group("name"))  # alex
print(re.search("(?P<name>[a-z]+)(?P<age>\\d+)","alex36wusir34xialv33").group("age"))  # 36


print(re.match("\\d+","666alex36wusir34xialv33"))##只在开头匹配,返回对象
print(re.match("\\d+","666alex36wusir34xialv33").group())  ## 666


print(re.split(" ","hello abc def")) # 按空格分开
print(re.split("[ |]","hello abc|def")) # 按空格或竖线分开
print(re.split("[ab]","aassfabcde")) # 按a或b分开
print(re.split("ab","aassfabcde")) # 按 ab 分开


print(re.sub("\\d+","*","asdf23asdfs88223asdfg")) # 数字被替换成*
print(re.sub("\\d","*","asdf23asdfs88223asdfg",5)) # 单个数字被替换成* 只替换5次

print(re.subn("\\d+","*","asdf23asdfs88223asdfg")) # 返回元组（结果，次数）


com = re.compile("\\d+")  # 赋值到变量，方便使用。
print(com.findall("asdf4123ghjkoo899dddsa"))


ret = re.finditer("\\d","fasdf765rqwrq3wcascsc32dfasdf") ##返回一个迭代器对象
print(next(ret).group())  # 拿到迭代器中第一个
print(next(ret))


print(re.findall("www\\.(baidu|163)\\.com","http://www.baidu.com/index.html")) # 只能拿到 baidu  因为默认有分组，优先返回分组
print(re.findall("www\\.(baidu|163)\\.com","http://www.163.com/index.html")) # 只能拿到 163 因为默认有分组，优先返回分组
print(re.findall("www\\.(?:baidu|163)\\.com","http://www.baidu.com/index.html")) # www.baidu.com  因为加了去优先级 ?:

 

正则表达式补充： findall 和 split 遇到了括号（分组）时，有特殊处理。

# ret = re.findall(\'www.(baidu|oldboy).com\', \'www.oldboy.com\')
# print(ret)  # [\'oldboy\']  
# 这是因为findall会优先把匹配结果组里内容返回,如果想要匹配结果,取消权限即可

# 取消分组优先， ?:
ret = re.findall(\'www.(?:baidu|oldboy).com\', \'www.oldboy.com\')
print(ret)  # [\'www.oldboy.com\']


# ret = re.split("(\\d+)", "eva3egon4yuan")
# print(ret)  # 结果 ： [\'eva\', \'3\', \'egon\', \'4\', \'yuan\']

ret = re.split("\\d+", "eva3egon4yuan")
print(ret)  # 结果 ： [\'eva\', \'egon\', \'yuan\']

 

import re
# 身份证号码
ret = re.search(\'^[1-9](\\d{14})(\\d{2}[0-9x])?$\', \'110105199912122277\')
print(ret.group())
print(ret.group(1)) # 拿到第一个括号内
print(ret.group(2)) # 拿到第二个括号内



# 手机号码
phone_number = input(\'please input your phone number ： \')
if re.match(\'^(13|14|15|17|18)[0-9]{9}$\',phone_number):
        print(\'合法的手机号码\')
else:
        print(\'不是合法的手机号码\')

 

更多的正则内容可参考 Eva Jin的博客  https://www.cnblogs.com/Eva-J/articles/7228075.html