pythonrq模块_python学习笔记-模块-

1.随机模块random

#随机模块，写一个验证程序

import random

print(chr(68))

#利用随机模块写一个验证码

import random

def v_code():

ret = ""

for i in range(0,5):

num = random.randint(0,9)

alf = chr(random.randint(65,90))#后续考虑一下如何如何把小写加进来

s=str(random.choice([num,alf]))

ret+=s

return ret

print(v_code())

2.os模块

#os模块

import os

print(os.getcwd()) #找到当前目录

print(os.chdir('test'))#相当于cd，后面参数就是对应的目录

print(os.chdir('..'))#相当于cd，后面参数就是对应的目录,..就又返回到上一层

#os.chdir 改变当前目录

print(os.pardir) #获取当前目录的父目录(..)

print(os.chdir('test'))

print(os.getcwd())

os.makedirs('dirname1/dirname2')

os.removedirs('test/dirname1/dirname2')

#相当于mkdir和rmdir

os.mkdir('test/test1')

os.rmdir('test/test1')

print(os.listdir()) #列出指定目录下所有的文件包括隐藏文件

os.remove()#删除一个文件

os.rename()#重命名文件

print(os.stat('python基础.py'))#获取文件信息

sys模块

#进度条如何做，也是通过调用sys模块，举例

import sys

sys.stdout.write("#")

sys.stdout.write("#")

sys.stdout.write("#")

sys.stdout.write("#")

sys.stdout.write("#")

for i in range(100):

print('#')

sys.stdout.write('#')

time.sleep(0.1)

sys.stdout.flush()

json模块

#转换成字符串方式的写过程

dic ='{"name":"alex"}'

f = open('hello','w')

f.write(dic)

#print(f.write(dic))

#再转换成字典方式读过程

f_read=open("hello","r")

data=f_read.read()

print(type(data))

data=eval(data)

print(data["name"])

#-------------------json---------------------

#通过使用json方式来完成以上过程

import json

dic = {"name":"sun","age":18,"male":"men"}

f = open("new_hello","w")

f.write(json.dumps(dic)) #---json的dumps功能先将字典原有的单引号“‘’”转化双引号，之后转换成字符串，该过程叫序列化

f_read=open("new_hello","r")

data=f_read.read()

data=json.loads(data) #-----json的loads功能将字符串转化成原有的数据类型，该过程叫反序列化

print(data["name"])

#另外一个功能，dump和loads

dic = {"name":"sun","age":18,"male":"men"}

f = open("new_hello1","w")

f.write(json.dumps(dic)) #---json的dumps功能先将字典原有的单引号“‘’”转化双引号，之后转换成字符串，该过程叫序列化

#上面两步可以替换成一步完成，通过使用dump

json.dump(dic,f)

f_read=open("new_hello","r")

data=f_read.read()

data=json.loads(data) #-----json的loads功能将字符串转化成原有的数据类型，该过程叫反序列化

#上面两步可以替换成一步完成，通过使用load完成

data=json.load(f_read)

print(data["name"])

5.pickle、shelve、xml模块

#------------------pickle------------------

#pickle方式和json方式完全一样，但是pickle主要用于python和python之间传输数据或者存储，json使用与所有编程语音

#pickle将数据转换成bytes,导致文件的转化过程不可见，所以在使用过程中不常见

#-----------------shelve-------------------

#主要将数据转化成字典，对字典在操作，同时方法只有open，不常用

#===========================xml======================

#属于标签语音，都是由标签标记的

re正则模块

#10个通配符，6个方法，findall、search

#一、通配符

#第一类

#. 表示一位通配

#^ 以..开头的

#$ 以..结尾的

#(0,+00)0个到无穷个

#+ (1，+00)1个到无穷个

#? (0,1) 0个到1个

#{} 随意配置，可以配置为{0,}和一样的意义，{1,}和+相同意义，{0,1}和？相同意义，{6} == {1,6}

#第二类

#[] 字符集，1)在[]里面没有特殊符号，都是可以匹配的,四个除外：/(转义)、-(范围)、^(非)

2)是或的关系，多选一

#() 分组，通过分组来匹配

#\ 让没意义的字符变成有意义的，有意义的变成没意义的

#| 表示或的关系

\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 匹配一个特殊字符边界，比如空格，&，#等

#注意，、+、? 都是贪婪匹配，也就是尽可能多的匹配，后面加?号使其变成惰性匹配

#例如：

import re

#当加?时就不是贪婪匹配了，这个意思表示

#-------------------------------方法-----------

#1. findall,查找所有匹配的字符，并以列表的方式将结果展示

#2. search,查找第一个匹配的值，并告之位置，同时以对象展示结果，通过调用group来展现具体的值，group()参数加分组名称可返回值

import re

re.search("(?P[a-z]+)(?P\d+)","alex36wusir34xialv33").group("age")

#3. match,相当于search前面加了^，匹配开头出现的字符，用法和search一样，由于search能够替代它，所以用的少

#4. split，分割函数，自定义分割方式分割字符，以列表方式输出。例如

import re

print(re.split("[ |]","hello abc|def")) #1)

import re

print(re.split("[ab]","asdabcd"))

#5. sub 替换 re.sub(匹配规则,替换目标,替换源,替换多少次)，以字符串方式输出。例如：

import re

print(re.sub("\d","A","akdjf23akfj887owierunc888",4))

#subn 增加输出替换多少次功能

import re

print(re.subn("\d","A","dk9sdj77y78i098j"))

#compile 编译,自定义规则

import re

com=re.compile("\d+")

print(com.findall("aljdf234lkjf098sdf79"))

#finditer 和findall效果是一样的，只是输出的迭代器

ret=re.finditer("\d","sdhf8687sdfh987skdfuh98789")

print(next(ret).group())

#正则知识回顾

#----------------总结-----------

import re

print(re.findall("(abc)*","abcabcabc"))

import re

ret = re.search("([^()]+)","12+(345+2-5(2-1)+(4*4-4))").group()

print(ret)

import re

print(re.findall("(?:abc)+","abcabcskdfjabc234"))

print(re.findall("c+","cccccccccasdf87cccc"))

print(re.findall("a(?:bc)|(?:ty)q","adfaabcq23sdhjhatyqskjf"))

logging模块

import logging

#默认从warning开始显示

logging.debug('this is debug')

logging.info('this is info')

logging.warning('this is warning')

logging.error('this is error')

logging.critical('this is critical')

#调整显示级别，该方式不是很灵活，可以采用另外一种方式

logging.basicConfig(

level=logging.DEBUG, #显示显示的级别

filename="logger.log", #生成文本log信息

filemode="w", #默认是追加日志，修改之后变成覆盖模式

format="%(asctime)s %(filename)s [%(lineno)s] %(message)s", #日志中时间、文件名、行号、消息

# datefmt="",

#

)

logging.debug('this is debug')

logging.info('this is info')

logging.warning('this is warning')

logging.error('this is error')

logging.critical('this is critical')

#----------------------logger-------------------

#即想在文件中输出，也想在屏幕中输出

def logger():

#设置logger

logger=logging.getLogger() #创建了一个对象，可以get到其他对象的功能

#该对象想要增加功能，需要先创建有某些功能的对象

fh = logging.FileHandler("loger.log") #可以向文件中发送内容

ch = logging.StreamHandler() #可以向屏幕中发送内容

#增加文件和屏幕输出格式

fm = logging.Formatter("%(asctime)s - %(filename)s - %(levelname)s %(message)s")

fh.setFormatter(fm) #由文本输出的fh，将其吸收

ch.setFormatter(fm) #由屏幕输出的ch，将其吸收

#吸收对象中的功能

logger.addHandler(fh) #通过addHandler吸收fh的功能

logger.addHandler(ch) #通过addHandler吸收ch的功能

logger.setLevel("DEBUG")

return logger

#-----------------

logger=logger()

#操作logger

logger.debug("logger debug message")

logger.info("logger info message")

logger.warning("logger warning message")

logger.error("logger error message")

logger.critical("logger critical message")

import logging

#注意事项1. 子对象命名是唯一的,该例子就是创建的对象名称一样，那么设置就同一个设置,以第一个为主

logger1 = logging.getLogger('mylogger')

logger1.setLevel(logging.INFO)

logger2 = logging.getLogger('mylogger')

logger2.setLevel(logging.DEBUG)

fh = logging.FileHandler("logger_test")

ch = logging.StreamHandler()

logger1.addHandler(fh)

logger1.addHandler(ch)

logger2.addHandler(fh)

logger2.addHandler(ch)

logger1.debug('logger1 debug message')

logger1.info('logger1 info message')

logger1.warning('logger1 warning message')

logger1.error('logger1 error message')

logger1.critical('logger1 critical message')

logger2.debug('logger2 debug message')

logger2.info('logger2 info message')

logger2.warning('logger2 warning message')

logger2.error('logger2 error message')

logger2.critical('logger2 critical message')

#注意事项2.创建子对象时，如果父对象还在工作，那么父对象输出一次，子对象也会输出一次

import logging

logger= logging.getLogger()

logger.setLevel(logging.INFO)

logger1 = logging.getLogger('mylogger')

logger1.setLevel(logging.INFO)

logger2 = logging.getLogger('yourlogger')

logger2.setLevel(logging.DEBUG)

logger3 = logging.getLogger('yourlogger.sonlogger')

logger3.setLevel(logging.DEBUG)

fh = logging.FileHandler("logger_test")

ch = logging.StreamHandler()

logger.addHandler(fh)

logger.addHandler(ch)

logger1.addHandler(fh)

logger1.addHandler(ch)

logger2.addHandler(fh)

logger2.addHandler(ch)

logger3.addHandler(fh)

logger3.addHandler(ch)

logger.debug('logger debug message')

logger.info('logger info message')

logger.warning('logger warning message')

logger.error('logger error message')

logger.critical('logger critical message')

logger1.debug('logger1 debug message')

logger1.info('logger1 info message')

logger1.warning('logger1 warning message')

logger1.error('logger1 error message')

logger1.critical('logger1 critical message')

logger2.debug('logger2 debug message')

logger2.info('logger2 info message')

logger2.warning('logger2 warning message')

logger2.error('logger2 error message')

logger2.critical('logger2 critical message')