python基础篇13-模块

 1 import time
 2 #print(help(time))  查看帮助
 3 
 4 print(time.time())    #1517193182.0534253   时间戳（s），unix诞生以来开始计算
 5 time.sleep(3)         #休眠3s
 6 print(time.clock())   #7.551609587825597e-07  计算cpu执行时间（不包括上面的3s）
 7 print(time.gmtime())  #结构化时间：time.struct_time(tm_year=2018, tm_mon=1, tm_mday=29, tm_hour=2, tm_min=36, tm_sec=5, tm_wday=0, tm_yday=29, tm_isdst=0) 即UTC（世界标准）时间，和北京时间差8h
 8 print(time.localtime())  #本地时间：time.struct_time(tm_year=2018, tm_mon=1, tm_mday=29, tm_hour=10, tm_min=45, tm_sec=10, tm_wday=0, tm_yday=29, tm_isdst=0)
 9 
10 #print(time.strftime(format,p_tuple))
11 print(time.strftime("%Y-%m-%d %H:%M:%S" ))  #字符串时间即自定义格式输出日期 2018-01-29 10:55:02
12 struct_time=time.localtime()
13 print(time.strftime("%Y-%m-%d %H:%M:%S",struct_time))  #将结构化时间以字符串时间输出：2018-01-29 10:58:51
14 
15 #time.strptime(string,format)  将字符串时间以结构化时间输出
16 print(time.strptime("2018-01-29 10:58:51","%Y-%m-%d %H:%M:%S"))  #time.struct_time(tm_year=2018, tm_mon=1, tm_mday=29, tm_hour=10, tm_min=58, tm_sec=51, tm_wday=0, tm_yday=29, tm_isdst=-1)
17 #取某个时间值：
18 a=time.strptime("2018-01-29 10:58:51","%Y-%m-%d %H:%M:%S")
19 print(a.tm_hour)   #10
20 print(a.tm_mon)    #1
21 
22 #time.ctime(seconds)
23 print(time.ctime())  #取当前时间：Mon Jan 29 11:11:09 2018
24 print(time.ctime(234566))  #将给定的时间以看得懂的方式输出（unix诞生以来的时间开始计算）
25 
26 #time.mktime(p_tuple)
27 a=time.localtime()
28 print(time.mktime(a))  #将本地时间转化为时间戳：1517195833.0

1 import datetime
2 print(datetime.datetime.now())   #2018-01-29 11:20:48.342246

 1 import random
 2 print(random.random())  #取0-1内的随机数
 3 print(random.randint(1,8))  #1-8内的随机数，包括8
 4 print(random.choice("hello")) #在给定的字符串选取随机数
 5 print(random.choice([1,2,3,4,5])) #也可以放列表
 6 print(random.sample([1,2,[3,4]],2)) #在序列中随机选2个
 7 print(random.randrange(1,10))  #取1-10的数，不包括10
 8 
 9 
10 #生成随机验证码
11 import random
12 checkcode = ‘‘
13 for i in range(4):
14     current = random.randrange(0,4)
15     if current != i:
16         temp = chr(random.randint(65,90))
17     else:
18         temp = random.randint(0,9)
19     checkcode += str(temp)
20 print checkcode

 1 os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径；
 2 os.chdir("dirname")  改变当前脚本工作目录；相当于shell下cd ；os.chdir(r‘F:\code‘)
 3 os.curdir  返回当前目录: (‘.‘)
 4 os.pardir  获取当前目录的父目录字符串名：(‘..‘)
 5 os.makedirs(‘dirname1/dirname2‘)    可生成多层递归目录；os.makedirs(r‘abc\lriwu\alen‘)
 6 os.removedirs(‘dirname1‘)    若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推  ；s.removedirs(r‘abc\lriwu\alen‘)
 7 os.mkdir(‘dirname‘)    生成单级目录；相当于shell中mkdir dirname
 8 os.rmdir(‘dirname‘)    删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
 9 os.listdir(‘dirname‘)    列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
10 os.remove()  删除一个文件
11 os.rename("oldname","newname")  重命名文件/目录
12 os.stat(‘path/filename‘)  获取文件/目录信息
13 os.sep    输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
14 os.linesep    输出当前平台使用的行终止符，win下为"\r\n",Linux下为"\n"
15 os.pathsep    输出用于分割文件路径的字符串；windows:‘;‘  linux:‘:‘
16 os.name    输出字符串指示当前使用平台。win->‘nt‘; Linux->‘posix‘
17 os.system("bash command")  运行shell命令，直接显示
18 os.environ  获取系统环境变量
19 os.path.abspath(path)  返回path规范化的绝对路径;print(os.path.abspath(‘./os.py‘))
20 os.path.split(path)  将path分割成目录和文件名二元组返回
21 os.path.dirname(path)  返回path的目录。其实就是os.path.split(path)的第一个元素
22 os.path.basename(path)  返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
23 os.path.exists(path)  如果path存在，返回True；如果path不存在，返回False
24 os.path.isabs(path)  如果path是绝对路径，返回True
25 os.path.isfile(path)  如果path是一个存在的文件，返回True。否则返回False
26 os.path.isdir(path)  如果path是一个存在的目录，则返回True。否则返回False
27 os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
28 os.path.getatime(path)  返回path所指向的文件或者目录的最后存取时间
29 os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间

1 sys.argv           命令行参数List，第一个元素是程序本身文件名
2 sys.exit(n)        退出程序，正常退出时exit(0)
3 sys.version        获取Python解释程序的版本信息
4 sys.maxint         最大的Int值
5 sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
6 sys.platform       返回操作系统平台名称
7 sys.stdout.write(‘please:‘)
8 val = sys.stdin.readline()[:-1]

 1 import hashlib
 2  
 3 m = hashlib.md5()
 4 m.update("Hello".encode(‘utf8‘)) #python3中，内存中的字符串都是unicode类型，update参数一定需要接收bytes类型，所以需要encode转换（因为python3中只有bytes和str两种数据类型）
 5 m.update("It‘s me".encode(‘utf8‘)) 
 6 print(m.digest()) #2进制格式hash   b‘]\xde\xb4{/\x92Z\xd0\xbf$\x9cR\xe3Br\x8a‘
 7 print(len(m.hexdigest())) #16进制格式hash 5ddeb47b2f925ad0bf249c52e342728a
 8 
 9 
10 #加密过程等同于：
11 m2 = hashlib.md5()
12 m2.update("HelloIt‘s me".encode(‘utf8‘)) 
13 print(len(m2.hexdigest())) #16进制格式hash 5ddeb47b2f925ad0bf249c52e342728a
14 
15 
16 
17 
18 import hashlib
19  
20 # ######## md5 ########
21  
22 hash = hashlib.md5()
23 hash.update(‘admin‘)
24 print(hash.hexdigest())
25  
26 # ######## sha1 ########
27  
28 hash = hashlib.sha1()
29 hash.update(‘admin‘)
30 print(hash.hexdigest())
31  
32 # ######## sha256 ########
33  
34 hash = hashlib.sha256()
35 hash.update(‘admin‘)
36 print(hash.hexdigest())
37  
38  
39 # ######## sha384 ########
40  
41 hash = hashlib.sha384()
42 hash.update(‘admin‘)
43 print(hash.hexdigest())
44  
45 # ######## sha512 ########
46  
47 hash = hashlib.sha512()
48 hash.update(‘admin‘)
49 print(hash.hexdigest())

 1 import logging  
 2 logging.debug(‘debug message‘)  
 3 logging.info(‘info message‘)  
 4 logging.warning(‘warning message‘)  
 5 logging.error(‘error message‘)  
 6 logging.critical(‘critical message‘)  
 
 
 
 #输出
 WARNING:root:warning message
 ERROR:root:error message
 CRITICAL:root:critical message

 1 import logging  
 2 logging.basicConfig(level=logging.DEBUG,  
 3                     format=‘%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s‘,  
 4                     datefmt=‘%a, %d %b %Y %H:%M:%S‘,  
 5                     filename=‘/tmp/test.log‘,  
 6                     filemode=‘w‘)  
 7   
 8 logging.debug(‘debug message‘)  
 9 logging.info(‘info message‘)  
10 logging.warning(‘warning message‘)  
11 logging.error(‘error message‘)  
12 logging.critical(‘critical message‘)
 
 
 
 #查看输出：
 cat /tmp/test.log 
 Mon, 05 May 2014 16:29:53 test_logging.py[line:8] DEBUG debug message
 Mon, 05 May 2014 16:29:53 test_logging.py[line:9] INFO info message
 Mon, 05 May 2014 16:29:53 test_logging.py[line:10] WARNING warning message
 Mon, 05 May 2014 16:29:53 test_logging.py[line:11] ERROR error message
 Mon, 05 May 2014 16:29:53 test_logging.py[line:12] CRITICAL critical message

 1 import logging
 2 #创建一个日志（logger）对象
 3 logger = logging.getLogger()
 4 
 5 # 创建一个handler即文件输出流对象，用于写入日志文件
 6 fh = logging.FileHandler(‘test.log‘)
 7 
 8 # 再创建一个handler即标准输出流对象，用于输出到控制台
 9 ch = logging.StreamHandler()
10 
11 #日志格式对象
12 formatter = logging.Formatter(‘%(asctime)s - %(name)s - %(levelname)s - %(message)s‘)
13 
14 fh.setFormatter(formatter)  #为文件输出设置日志格式
15 ch.setFormatter(formatter)  #为标准输出设置日志格式
16 
17 #通过addHandler为logger添加文件输出对象和标准输出对象
18 logger.addHandler(fh) #logger对象可以添加多个fh和ch对象
19 logger.addHandler(ch)
20 #logger1.setLevel(logging.DEBUG)   设置输出日志级别，不指定默认是warnning
21 logger.debug(‘logger debug message‘)
22 logger.info(‘logger info message‘)
23 logger.warning(‘logger warning message‘)
24 logger.error(‘logger error message‘)
25 logger.critical(‘logger critical message‘)

#控制台输出
2018-01-30 09:53:10,887 - root - WARNING - logger warning message
2018-01-30 09:53:10,887 - root - ERROR - logger error message
2018-01-30 09:53:10,887 - root - CRITICAL - logger critical message



#文件输出
cat test.log
2018-01-30 09:53:10,887 - root - WARNING - logger warning message
2018-01-30 09:53:10,887 - root - ERROR - logger error message
2018-01-30 09:53:10,887 - root - CRITICAL - logger critical 

 1 [DEFAULT]
 2 ServerAliveInterval = 45
 3 Compression = yes
 4 CompressionLevel = 9
 5 ForwardX11 = yes
 6   
 7 [bitbucket.org]
 8 User = hg
 9   
10 [topsecret.server.com]
11 Port = 50022
12 ForwardX11 = no

 1 import configparser
 2 
 3 config = configparser.ConfigParser()   #生成一个文件操作句柄
 4 config["DEFAULT"] = {‘ServerAliveInterval‘: ‘45‘,
 5                      ‘Compression‘: ‘yes‘,
 6                      ‘CompressionLevel‘: ‘9‘}
 7 
 8 config[‘bitbucket.org‘] = {}
 9 config[‘bitbucket.org‘][‘User‘] = ‘hg‘
10 config[‘topsecret.server.com‘] = {}
11 topsecret = config[‘topsecret.server.com‘]
12 topsecret[‘Host Port‘] = ‘50022‘  # mutates the parser
13 topsecret[‘ForwardX11‘] = ‘no‘  # same here
14 config[‘DEFAULT‘][‘ForwardX11‘] = ‘yes‘
15 with open(‘example.ini‘, ‘w‘) as configfile:   #创建文件
16     config.write(configfile)

 1 import configparser
 2 
 3 config = configparser.ConfigParser()
 4 #---------------------------------------------查
 5 print(config.sections())   #[]
 6 config.read(‘example.ini‘)   #关联文件
 7 print(config.sections())    #[‘bitbucket.org‘, ‘topsecret.server.com‘] 即打印字段，default是默认字段，不会显示出来
 8 print(config.defaults())    #OrderedDict([(‘compression‘, ‘yes‘), (‘compressionlevel‘, ‘9‘), (‘serveraliveinterval‘, ‘45‘), (‘forwardx11‘, ‘yes‘)]) 查看default字段下的所有属性以及属性值
 9 print(config.items(‘bitbucket.org‘))  #[(‘serveraliveinterval‘, ‘45‘), (‘compression‘, ‘yes‘), (‘compressionlevel‘, ‘9‘), (‘forwardx11‘, ‘yes‘), (‘user‘, ‘hg‘)] 查看非default字段下的所有属性以及属性值
10 print(config.options(‘bitbucket.org‘))#[‘user‘, ‘serveraliveinterval‘, ‘compression‘, ‘compressionlevel‘, ‘forwardx11‘] 查看字段下的属性
11 print(‘bytebong.com‘ in config)# False   查看配置文件中是否有该字段
12 print(config.has_section(‘bitbucket.org‘))  #查看配置文件中是否有该字段
13 print(config[‘bitbucket.org‘][‘User‘]) # hg   查看属性值
14 
15 for key in config:
16     print(key)
17 # 输出：打印config下的所有字段
18 # DEFAULT
19 # bitbucket.org
20 # topsecret.server.com
21 
22 
23 for key in config[‘bitbucket.org‘]:
24     print(key)
25 # 输出：bitbucket.org字段下的属性以及default字段下的属性
26 # user
27 # compression
28 # compressionlevel
29 # serveraliveinterval
30 # forwardx11
31 
32 #---------------------------------------------删,改,增
33 
34 #删除字段
35 config.remove_section(‘topsecret.server.com‘)
36 
37 #添加字段
38 config.add_section(‘yuan‘)
39 
40 #修改属性值
41 config.set(‘bitbucket.org‘,‘user‘,‘lriwu‘)
42 
43 #删除键值对
44 config.remove_option(‘bitbucket.org‘,‘user‘)
45 
46 
47 (config.write(open(‘r.cfg‘, "w")))  #最后这句语句是必须的

1 import re
2 re.findall(‘w\w{2}l‘, ‘hello world‘)  #[‘worl‘]  模糊匹配
3 re.findall(‘alex‘,‘yuanaleSxalexwupeiqi‘)   #[‘alex‘]  精确匹配（如果只实现这一功能，使用字符串的方法就可以了）

 1 import re
 2 
 3 #‘.‘：匹配任意字符一次（不能匹配换行符）
 4 ret = re.findall(‘a..in‘, ‘helloalvin‘)
 5 print(ret)  # [‘alvin‘]
 6 
 7 #‘^‘:行首匹配
 8 ret = re.findall(‘^a...n‘, ‘alvinhelloawwwn‘)
 9 print(ret)  # [‘alvin‘]
10 
11 #‘$‘:行尾匹配
12 ret = re.findall(‘a...n$‘, ‘alvinhelloawwwn‘)
13 print(ret)  # [‘awwwn‘]
14 
15 #‘*‘:即匹配前面的字符[0,+oo]次
16 ret = re.findall(‘abc*‘, ‘abcccc‘)
17 print(ret)  # [‘abcccc‘]   #贪婪匹配
18 ret = re.findall(‘abc*‘, ‘ab‘)
19 print(ret)  # [‘ab‘]   #匹配0次例子
20 
21 #‘+‘:匹配前面的字符[1,+oo]次即匹配前面的字符至少一次
22 ret = re.findall(‘abc+‘, ‘abccc‘)
23 print(ret)  # [‘abccc‘]  #贪婪匹配
24 
25 #‘?‘:匹配前面的字符[0,1]次
26 ret=re.findall(‘abc?‘,‘abccc‘)#[0,1]
27 print(ret)#[‘abc‘]  #贪婪匹配
28 ret = re.findall(‘a?b‘, ‘aaaabhghabfb‘)
29 print(ret)  # [‘ab‘,‘ab‘,‘b‘]
30 
31 
32 ret = re.findall(‘abc{1,4}‘, ‘abccc‘)  #匹配前面的1-4次都行
33 print(ret)  # [‘abccc‘]  贪婪匹配
34 ret = re.findall(‘a{5}b‘,‘aaaaab‘)  #aaaaab  匹配前面的5次

1 ret=re.findall(‘abc*?‘,‘abcccccc‘)
2 print(ret)#[‘ab‘]

 1 # --------------------------------------------字符集[]
 2 ret = re.findall(‘a[bc]d‘, ‘acd‘)   #或的关系[b,c]表示b或c
 3 print(ret)  # [‘acd‘]
 4 
 5 ret = re.findall(‘[a-z]‘, ‘acd‘)
 6 print(ret)  # [‘a‘, ‘c‘, ‘d‘]
 7 
 8 #取消元字符的特殊功能
 9 ret = re.findall(‘[.*+]‘, ‘a.cd+‘)  #这里的.*+只表示自身意义
10 print(ret)  # [‘.‘, ‘+‘]
11 
12 # 在字符集里仍有功能的符号: - ^ \
13 ret = re.findall(‘[1-9]‘, ‘45dha3‘)     #‘-‘代表范围
14 print(ret)  # [‘4‘, ‘5‘, ‘3‘]
15 
16 ret = re.findall(‘[^a,b]‘, ‘45bdha3‘)    #‘^‘代表取反即除了a和b以外的
17 #等同于：ret = re.findall(‘[^ab]‘, ‘45bdha3‘)
18 print(ret)  # [‘4‘, ‘5‘, ‘d‘, ‘h‘, ‘3‘]
19 
20 
21 # 反斜杠后边跟元字符去除特殊功能,比如\.
22 # 反斜杠后边跟普通字符实现特殊功能,比如\d，相当于类 [0-9]
23 ret = re.findall(‘[\d]‘, ‘45bdha3‘)
24 print(ret)  # [‘4‘, ‘5‘, ‘3‘]

1 ret=re.findall(‘I\b‘,‘I am LIST‘)
2 print(ret)#[]   
3 ret=re.findall(r‘I\b‘,‘I am LI$T‘)
4 print(ret)#[‘I‘,‘I‘]

 1 #-----------------------------eg1:
 2 import re
 3 ret=re.findall(‘c\l‘,‘abc\le‘)
 4 print(ret)#[]   没有匹配
 5 ret=re.findall(‘c\\l‘,‘abc\le‘)
 6 print(ret)#[]   没有匹配
 7 ret=re.findall(‘c\\\\l‘,‘abc\le‘)    #在python解释器里先将‘\\\\’转义成‘\\’；再在re模块里将‘\\‘转义成‘\’ ，即就匹配到了‘c\l’
 8 print(ret)#[‘c\\l‘]   匹配到了
 9 ret=re.findall(r‘c\\l‘,‘abc\le‘)     #r表示告诉python解释器里面的字符串就是原生字符串，在python接收器中无需转义
10 print(ret)#[‘c\\l‘]    匹配到了
11  
12 #-----------------------------eg2:
13 #之所以选择\b是因为\b在ASCII表中是有意义的
14 m = re.findall(‘\bblow‘, ‘blow‘)
15 print(m)  #[]     没有匹配
16 m = re.findall(r‘\bblow‘, ‘blow‘)
17 print(m)  #[‘blow‘]   匹配到了

1 print(re.search(‘(as)+‘,‘sdjkfasas‘).group())   #asas    ‘+‘ 匹配前面分组[1,+oo]次
2 ret = re.findall(‘www.(\w+).com‘,‘www.baidu.com‘)  #[‘baidu‘]  只会打印出组中的内容
3  ret = re.findall(‘www.(?:\w+).com‘,‘www.baidu.com‘)   #[‘www.baidu.com‘] 取消组的权限

1 ret=re.search(‘(?P<id>\d{2})‘,‘23/com‘)  #?P<id> 为分组取名字为id
2 print(ret.group())#23
3 print(ret.group(‘id‘))#23  #通过分组名取匹配到的值

ret=re.search(‘(?P<id>\d{2})/(?P<name>\w{3})‘,‘23/com‘)

 1 import re
 2 
 3 # 1
 4 re.findall(‘a‘, ‘alvin yuan‘)  # [‘a‘, ‘a‘]即返回所有满足匹配条件的结果,放在列表里
 5 # 2
 6 re.search(‘a‘, ‘alvin yuan‘).group()  # ‘a‘ 即返回匹配到的第一个对象,对象可以调用group()返回结果；如果字符串没有匹配，则返回None。
 7 
 8 # 3
 9 re.match(‘a‘, ‘abca‘).group()  # ‘a‘ 同search,不过只在字符串开始处进行匹配
10 
11 # 4 分割
12 ret = re.split(‘b‘, ‘abcd‘)
13 print(ret)  # [‘a‘, ‘cd‘]
14 
15 ret = re.split(‘[ab]‘, ‘abcd‘)  # 先按‘a‘分割得到‘‘和‘bcd‘,在对‘‘和‘bcd‘分别按‘b‘分割
16 print(ret)  # [‘‘, ‘‘, ‘cd‘]
17 
18 ret = re.split(‘[js]‘, ‘sdjksal‘)  #[‘‘, ‘d‘, ‘k‘, ‘al‘]
19 
20 # 5 替换
21 ret = re.sub(‘\d‘, ‘abc‘, ‘alvin5yuan6‘, 1)
22 print(ret)  # alvinabcyuan6
23 ret = re.subn(‘\d‘, ‘abc‘, ‘alvin5yuan6‘)  #没有指定第三个参数，全部替换
24 print(ret)  # (‘alvinabcyuanabc‘, 2)
25 
26 # 6  compile可以把正则表达式编译成一个正则表达式对象，可以把经常使用的正则表达式编译成正则表达式对象，这样可以提高一定的效率。
27 obj = re.compile(‘\d{3}‘)  #实现一种规则可以匹配多次
28 ret = obj.search(‘abc123eeee‘)
29 print(ret.group())  # 123
30 
31 #7
32 ret = re.finditer(‘\d‘,‘ds3sy4784a‘)
33 print(res)  #<callable_iterator object at 0x00000233DBFA5208>  返回的结果是迭代器对象
34 print(next(ret).group())  #3