python模块之re，os，sys。冒泡算法和反射。

python内置模块之（os，sys，hashlib，re）

os模块

os.path.dirname()   # 获取文件的上一层目录名,其实就是os.path.split(path)的第一个元素
os.path.abspath()   # 获取文件的绝对路径,包括文件名
os.getcwd()                 获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname")         改变当前脚本工作目录；相当于shell下cd
os.curdir                   返回当前目录: ('.')
os.pardir                   获取当前目录的父目录字符串名：('..')
os.makedirs('dir1/dir2')    可生成多层递归目录
os.removedirs('dirname1')   若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir('dirname')         生成单级目录；相当于shell中mkdir dirname
os.rmdir('dirname')         删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir('dirname')       列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove()                 删除一个文件
os.rename("oldname","new")  重命名文件/目录
os.stat('path/filename')    获取文件/目录信息
os.sep                      操作系统特定的路径分隔符，win下为"\",Linux下为"/"
os.linesep                  当前平台使用的行终止符，win下为"	
",Linux下为"
"
os.pathsep                  用于分割文件路径的字符串
os.name                     字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command")   运行shell命令，直接显示
os.environ                  获取系统环境变量
os.path.split(path)         将path分割成目录和文件名二元组返回
os.path.basename(path)      返回path最后的文件名。如何path以／或结尾，那么就会返回空值。即os.path.split(path)的第二个元素
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所指向的文件或者目录的最后修改时间

sys模块实现进度条

import sys
import time


def view_bar(num, total):
    rate = float(num) / float(total)
    rate_num = int(rate * 100)
    r = '
%d%%' % (rate_num, )
    sys.stdout.write(r)
    sys.stdout.flush()


if __name__ == '__main__':
    for i in range(0, 100):
        time.sleep(0.1)
        view_bar(i, 100)

sys模块

sys.argv           # 命令行参数List，第一个元素是程序本身路径
sys.exit(n)        # 退出程序，正常退出时exit(0)
sys.version        # 获取Python解释程序的版本信息
sys.maxint         # 最大的Int值
sys.path           # 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform       # 返回操作系统平台名称
sys.stdin          # 输入相关
sys.stdout         # 输出相关
sys.stderror       # 错误相关

hashlib模块

import hashlib
obj = hashlib.md5()     # 如果需要加盐,写法是:obj = hashlib.md5(bytes('asd23', encoding='utf-8'))
obj.update(bytes('123', encoding='utf-8'))   #3.0版本python写法,2.0版本写法是:obj.update('123')
result = obj.hexdigest()
print(result)

模块中的特殊变量

__file__            # 获取当前文件的完整路径加文件名
__doc__             # 获取当前文件的文件级别注释
__packege           # 获取模块文件的陌路名
__name__            # 只有执行(不是被导入的)当前文件时,特殊变量name才等于main,否则不等于.

re模块

这个模块提供了与 Perl 相似l的正则表达式匹配操作。Unicode字符串也同样适用。

正则表达式使用反斜杠" "来代表特殊形式或用作转义字符，这里跟Python的语法冲突，因此，Python用" \\ "表示正则表达式中的" "，因为正则表达式中如果要匹配" "，需要用来转义，变成" \ "，而Python语法中又需要对字符串中每一个进行转义，所以就变成了" \\ "。

上面的写法是不是觉得很麻烦，为了使正则表达式具有更好的可读性，Python特别设计了原始字符串(raw string)，需要提醒你的是，在写文件路径的时候就不要使用raw string了，这里存在陷阱。raw string就是用'r'作为字符串的前缀，如 r" "：表示两个字符""和"n"，而不是换行符了。Python中写正则表达式时推荐使用这种形式。

绝大多数正则表达式操作与 模块级函数或RegexObject方法 一样都能达到同样的目的。而且不需要你一开始就编译正则表达式对象，但是不能使用一些实用的微调参数。

正则表达式元字符：

. 除换行符以外的任意一个字符
^ 锚定行首,以什么字符(串)开头,如果^在中括号中,那么表示非的意思
& 锚定行首,以什么字符(串)结尾
* 重复匹配,可以重复0-多次
+ 重复匹配,可以重复1-多次,最少有一个
? 重复匹配,可以重复0-1次
{} 重复匹配,可以指定重复的次数,{1,5}或{3}.重复至少1次,最多5次或重复3次
[] 指定匹配范围,[a-z],表示a到z的任意字符,其他元字符在中括号中仅表示普通字符,除了-
() 分组匹配,匹配被括号起来的一组字符,小括号在re模块的大部分方法中还表示,在已经匹配到的数据中再去匹配,比如match,findall,search
 转义,后面跟元字符取消元字符的特殊意义,后面跟普通字符实现特殊功能
d  任意十进制数字
D  任意任何非数字字符
s  匹配任何空白字符
S  匹配任何非空白字符
w 匹配任何字符数字字符
W 匹配任何非字符数字字符
 匹配一个单词边界,也就是指单词和空格之间的位置

findall（查找字符串中所有匹配到的字符串,返回一个列表）：

import re
result = re.findall('gouyc', 'gouyc123asdagouycfsdf')
print(result)

finditer（查找字符串中所有匹配到的字符串,从左到右匹配.返回一个迭代器,如果没有匹配到,返回空列表）：

it = re.finditer(r'(gouyc)', 'gouycasddf12gouyc3123')
for i in it:
    print(i.group())

match：

import re
re.match(r'gouyc', 'asdhgouyc').group()

注意：

• match,只匹配字符串的起始位置,后面的不找

• 返回一个对象,通过对象的group()方法获取匹配到的内容

• r表示原生字符串,去掉string中特殊字符串的意义.

search：

import re

re.search('yacai', 'yacai23laflyacai32njsdfj', flags=0)

 search,匹配字符串中的所有位置,匹配到一个结果后停止.未匹配成功返回None
 返回一个对象,通过对象的group()方法获取匹配到的内容


sub（查找替换）：

re.sub(partten,repl,string,max=0)

group（用来获取findall,match,search返回的对象中的数据）

groups（用来获取findall,match,search返回的对象中的数据,以元祖的形式返回）

groupdict（用字典的方式返回findall,match,search返回的对象中的数据,需要在partten中指定key）

import re
re.match('h(?P<name>w+)', has hjksahk12332).groupdict

subn（不光替换,最后会统计替换的次数返回给我们）

split（以指定模式分割字符串，返回列表）

import re
re.split(1, 'one1two2three3four4')

compile（将模式编译成一个对象,通过对象的findall方法来查找）

import re
regex = re.compile(r'w*oo')
regex.findall('string')

反射

利用字符串的形式去对象(模块)中操作（查找，检查，调用）其成员,就叫做反射

import commons

if __name__ == '__main__':
    inp = input('请输入url: ')
    if hasattr(commons, inp):  # 以字符串的形式去对象中检查属性,如果有返回True,否则返回False
        url = getattr(commons, inp) # 以字符串的形式去对象中寻找属性,有则获取属性,否则报对象中没有属性的错误
        url() # 执行getattr获取的属性
    else:
        print('404')

进阶版本
if __name__ == '__main__':
    inp = input('请输入url: ')
    m, f = inp.split('/')
    obj = __import__(m)         # 根据字符串去导入模块
    if hasattr(obj, f):
        url = getattr(obj, f)
        url()
    else:
        print('404')

注意：如果模块在其他目录下,那么使用__import__()的时候,需要加一个参数,fromlist=True.否则,将只能找到目录,找不到目录下的模块.

递归（如果函数包含了对其自身的调用，该函数就是递归的）：

递归实现阶乘

def func(num):
    if num == 1:
        return 1
    return num * func(num - 1)

print(func(5))

Python冒泡排序算法的运作如下：

　　1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。
　　2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
　　3.针对所有的元素重复以上的步骤，除了最后一个。
　　4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

冒泡算法排序

array = [1,2,3,6,5,4]
for i in range(len(array)):
    for j in range(i):
        if array[j] > array[j + 1]:
            array[j], array[j + 1] = array[j + 1], array[j]
print array