Time模块

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import time #调用time模块

1.time.time()  #返回当前时间戳  从1970年1月1日开始
2.time.perf_counter()#返回系统运行时间
3.time.process_time()#返回进程运行时间
4.time.localtime()#返回当前电脑时间
5.time.gmtiime()#返回utc结构化时间
6.time.strftime('%Y--%m--%d %H--%M--%S',time.localtime())#返回字符串格式时间
7.time.strptime('2019--06--11 08--30--46','%Y--%m--%d %H--%M--%S')
print(a)  #time.struct_time(tm_year=2019, tm_mon=6, tm_mday=11, tm_hour=8, tm_min=30, tm_sec=46, tm_wday=1, tm_yday=162, tm_isdst=-1)  返回一个结构化时间可分别引用
print(a.tm_year)  #2019
print(a.tm_wday)  #1
8.time.ctime(1)  #传递参数从1970年1月1日开始计时  #Thu Jan  1 08:00:01 1970
9.time.mktime()  #mktime(...)   mktime(tuple) -> floating point number

Datatime模块

1
2
3
import datetime

print(datetime.datetime.now())  2019-06-11 13:30:10.367575 #返回电脑当前时间

Ramdom模块

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import random

1.random.random() #随机生成一个0-1之间的浮点数
print(random.random())    #0.8325469381335062
print(random.random())    #0.24143660720088223
print(random.random())    #0.19366939568288866
print(random.random())    #0.16182727045935497
2.random.randint(1,8)  #随机生成一个1~8之间的数（包括8）  
3.random.choic('hello')  #随机生成一个参数内字符
print(random.choice('hello'))   #l
print(random.choice(['123',4,[1,2]]))  #[1, 2]
4.random.sample(['123',4,[1,2]],2)  #随机生成2个参数内字符
print(random.sample(['123',4,[1,2]],2))  #['123', [1, 2]]
5.random.randrange(1,3) #不包括3

random模块生成随机验证码

1
2
3
4
5
6
7
def c_void():  #生成5位随机验证码
viod=''
     for i in range(5):
       add=random.choice([random.randrange(10),chr(random.randint(65,90))])
         viod += str(add)
     print(viod)
c_viod()   #1MGC1

Sys模块

1.sys.argv() #传入参数 可以与python解释器交互

1
2
3
4
5
6
def down():
     pass
if sys.argv[1]=='post':
     print("down")
elif sys.argv[2]=='path':
     print('up')

2.sys.exit(0) #退出 0正常

3.sys.path #查找模块路径

1
2
print(sys.path)
#['E:\\full-stack\\week1\\day5', 'E:\\full-stack', 'D:\\python3.7\\python37.zip', 'D:\\python3.7\\DLLs', 'D:\\python3.7\\lib', 'D:\\python3.7', 'D:\\python3.7\\lib\\site-packages', 'c:\\users\\王123\\turtle-0.0.2\\turtle-0.0.2', 'E:\\pycharm\\PyCharm 2018.2.1\\helpers\\pycharm_matplotlib_backend']

4.sys.platform ##输出操纵系统类型

1
2
print(sys.platform)
#win32

Hashlib 加密模块

1
2
3
4
5
6
7
8
a=hashlib.md5()
a.update('abc'.encode('utf-8'))   #md5加密
print(a.hexdigest())  #输出密文900150983cd24fb0d6963f7d28e17f72
a.update('chen'.encode('utf-8')) #在‘abc’的基础上加上‘chen’加密
print(a.hexdigest()) #f5a939b1e52c4deb9e3d028d7ed7cb9e
b=hashlib.md5()
b.update('abcchen'.encode('utf-8')) #f5a939b1e52c4deb9e3d028d7ed7cb9e
print(b.hexdigest())

Os模块

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
os.getcwd()  
#获取当前工作目录，即当前python脚本工作的目录路径   
#E:\full-stack\week1\day5
os.chdir(''dirname)   
#改变当前脚本工作目录；相当于shell下cd
os.curdir()  #返回当前目录: ('.')
os.pardir()   #获取当前目录的父目录字符串名：('..')
os.makedirs('dirname1/dirname2')    #可生成多层递归目录
os.removedirs('dirname1')    
#若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir('dirname')    #生成单级目录；相当于shell中mkdir dirname
os.rmdir('dirname')    #删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir('dirname')    
#列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove()  #删除一个文件
os.rename("oldname","newname")  #重命名文件/目录
os.stat('path/filename')  #获取文件/目录信息

print(os.stat(r"E:/full-stack/week1/day5"))   #os.stat_result(st_mode=16895, st_ino=5348024557502549, st_dev=2429873425, st_nlink=1, st_uid=0, st_gid=0, st_size=4096, st_atime=1560688434, st_mtime=1560688434, st_ctime=1560002672)

os.sep    
#输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
os.linesep    
#输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"
os.pathsep    #输出用于分割文件路径的字符串
os.name    
#输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command")  
#运行shell命令，直接显示
os.environ  
#获取系统环境变量
os.path.abspath(path)  
#返回path规范化的绝对路径
os.path.split(path)  
#将path分割成目录和文件名二元组返回
os.path.dirname(path)  
#返回path的目录。其实就是os.path.split(path)的第一个元素
os.path.basename(path)  
#返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素

print(os.path.abspath('E:/full-stack/week1/day5'))
#E:\full-stack\week1\day5
print(os.path.dirname('E:/full-stack/week1/day5'))
#E:/full-stack/week1
print(os.path.basename('E:/full-stack/week1/day5'))
#day5

os.path.exists(path)  
#如果path存在，返回True；如果path不存在，返回False
# os.path.isabs(path)  如果path是绝对路径，返回True
# os.path.isfile(path)  如果path是一个存在的文件，返回True。否则返回False
# os.path.isdir(path)  如果path是一个存在的目录，则返回True。否则返回False
# os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
# os.path.getatime(path)  返回path所指向的文件或者目录的最后存取时间
# os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间

Logging 日志模块

logging.debug(‘debug message’)

logging.info(‘info message’)

logging.warning(‘hello everone’)

logging.error(‘error message’)

logging.critical(‘critical message’)

默认输出级别为warning C>E>W>I>D

1
2
3
#WARNING:root:hello everone 
#ERROR:root:error message
#CRITICAL:root:critical message

自定义日志存储

1
2
3
4
5
6
7
8
9
10
11
logging.basicConfig(level=logging.DEBUG,   #调整输入的级别  
format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',  #定义输出的格式
datefmt='%a, %d %b %Y %H:%M:%S',  
filename='test.log',  #定义输入日志的文件
filemode='a') 
#Thu, 13 Jun 2019 21:24:52 loggingģ��.py[line:17] DEBUG debug message
logging.debug('debug message5')
logging.info('info message2')
logging.warning('warning message12')
logging.error('error message8')
logging.critical('critical message')

创建对象调用日志，输入到文件和屏幕

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)  #定义日志输出级别
# 创建一个handler，用于写入日志文件
fh = logging.FileHandler('test.log')
# 再创建一个handler，用于输出到控制台
ch = logging.StreamHandler()
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
fh.setFormatter(formatter)
ch.setFormatter(formatter)
logger.addHandler(fh) #logger对象可以添加多个fh和ch对象
logger.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')

Re——正则

正则是对字符串进行处理的，引入正则的目的是为了进行模糊匹配。

正则的元字符

. 通配符 不能代指\n 只能代指一个字符

^ 尖角符 只在开始匹配

$ 只在结尾匹配

重复匹配

* [0,+00) + [1,+00) ? [0,1] {} 可定义匹配次数

结论 * = {0,+00} + = {1,+00} ? ={0,1}

特殊字符

[] 字符集 取消元字符的特殊功能 (\ ^ -)例外

[ ^ ] 取反

\

# 1.反斜杠后面跟元字符去除其特殊功能

# 2.反斜杠后面跟普通字符实现特殊功能

# \d 匹配任何十进制数 相当于类[0-9]

# \D 匹配任何非数字字符 [^0-9]

# \s 匹配任何空白字符 相当于类[\t \n \r \f \v]

# \S 匹配任何空白字符 相当于类[^\t \n \r \f \v]

# \w 匹配任何字符数字字符 相当于类[1-9a-zA-Z]

# \W 匹配任何非字符数字字符 相当于类[^1-9a-zA-Z]

# \b 匹配一个特殊字符边界 也就是指单词和特殊字符的位置

() 分组

使用举例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
a=re.findall('w..l','hello world')  
print(a)
b=re.findall('w..l','hello w\nld')
print(b)
#['worl']
#[]

a=re.findall('^h...o','hello world hoxlo')
print(a)   
b=re.findall('^h...o','hlllll hello')
print(b）
#['hello']
#[]

a=re.findall('a..x$','asdsafasalex')   
#  $只在结尾匹配
print(a)
b=re.findall('a..x$','asdsafasalexx')   
#  $只在结尾匹配
print(b)
#['alex']
#[]

a=re.findall('ab*','asfasdabbbabs')
#a后面可有0-无穷个b
print(a)
# + [1,+00)
a=re.findall('a+b','asfasdabbbabs')
#b前面可有1-无穷个a
print(a)
#? [0,1]
a=re.findall('a?b','asfasdabbbabs') 
#0到1个a 后面有一个b
print(a)
# {}  可定义匹配次数
a=re.findall('a{1,3}b','asfasdaaaaaabbbabs')
#1—3个a后面一个b
print(a)
#['a', 'a', 'abbb', 'ab']
#['ab', 'ab']
#['ab', 'b', 'b', 'ab']
#['aaab', 'ab']

a=re.findall('a[a-z]x','adxabxaex')  
#输出a（a-z中任意一个）x
b=re.findall('a[w,,]x','adxa*xa,x')  
#输出a（w或,）x
print(a,'\n',b)
a=re.findall('[1-9，a-z，A-Z]','adxabxaex456as4f65as489aw4d6') 
#输出1-9的数字，a-z的字母,A-Z的字母
print(a)
#['adx', 'abx', 'aex']
#['a,x']
#['a', 'd', 'x', 'a', 'b', 'x', 'a', 'e', 'x', '4', '5', '6', 'a', 's', '4', 'f', '6', '5', 'a', 's', '4', '8', '9', 'a', 'w', '4', 'd', '6']

a=re.findall('[^4,5]','466865416132132')   
#[ ^ ]  取反 除去4，5的其他数字
print(a)
#['6', '6', '8', '6', '1', '6', '1', '3', '2', '1', '3', '2']

print(re.findall(r'i\b','hello,i am a list')) 
#i后有空格特殊字符 输出‘i’
a=re.search('sb','asfasbffsdsb') #.group()  
#匹配出满足条件的第一个结果
print(re.search('sb','asfasbffsdsb'))
print(a.group())
a=re.search('a\+','a+hi').group() 
#+号元字符失去作用，表示普通字符
print(a)
#['i']
#<re.Match object; span=(4, 6), match='sb'>
#sb
#a+

print(re.search('(as)+','dsasdasfgdgdasas').group())
#as  as整体作为一个组去匹配

print(re.search('(as)|3','3as3').group())
#3   |或的意思，as整体作为一个被非掉

a=re.search('(?P<id>\d{3})/(?P<name>\w{3})','weeew34ttt123/000')  
      #\d 表示匹配3个数字  \w 表示匹配3个数字字符


print(a.group())
print(a.group('id'))
print(a.group('name'))
#123/000
#123
#000
正则表达式的使用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
正则表达式的方法：
1.re.findall()  #所有结果都返回一个列表
2.re.search() #返回一个对象（object）,对象可以调用group方法
3.match()   
#只在字符串开始匹配，也指返回一个对象 可调用group方法
4.re.split()
'ads'.split('s')
a=re.split('[k,s]','asjksdasfa')  
#先分k  [asj,sdasfa] 再分s [a,j,'',da,fa]
print(a)
5.re.sub()
#替换
a=re.sub('a..x','s..b','gsdfasgsalexagdafas')
print(a)  #gsdfasgss..bagdafas
re.findall('\.com','asdas.comsda')
obj=re.compile('\.com')  #将规则编译成对象