python笔记 - day6

python笔记 - day6

参考：

http://www.cnblogs.com/wupeiqi/articles/5501365.html

大纲：

利用递归，实现阶乘；

Python反射

python模块，sys，os

python正则表达式

递归例子，阶乘：

def func(num):
    print(num,"x",num-1)
    if num == 1:
        return 1
    return num * func(num-1)
x = func(7)
print(x)

反射学习:

总结：

反射：利用字符串的形式去对象(模块)中操作(寻找/检查/删除/设置)成员

实例：伪造web框架的路由系统
反射：基于字符串的形式去对象(模块)中操作其成员（getattr,delattr,setattr,hasattr）

不使用反射的例子：
t1.py  文件内容：
def login():
    print("login")

def logout():
    print("logout")

def home():
    print("home")

t2.py文件内容：

import t1
while True:
    inp = input(">>:")
    if inp == 'login':
        t1.login()
    elif inp == 'logout':
        t1.logout()
    elif inp == 'home':
        t1.home()
    else:
        exit("选项不存在")

应用反射的例子：

方法一，这个方法，用户只能调用，指定模块下的函数：
t1.py 文件内容：
def login():
    print("login")

def logout():
    print("logout")

def home():
    print("home")

t2.py  文件内容：
import t1
def run():
    inp = input(">>>(模块名):")
    if hasattr(t1,inp):  　　　　#hasattr()，判断用户输入的字符串对应的函数是否存在；
        func = getattr(t1,inp)  #getattr()，用来把用户输入的字符串，转换成执行函数的方法；
        func()  　　#比如用户这里输入的login,这里代码就等于，t1.login()
    else:
        print("")
if __name__ == '__main__':
    run()

方法二，这个方法，用户可以自己输入调用的，模块名/函数名：
def run():
    inp = input("请输入要访问的url(模块名/函数名)：")
    m,f = inp.split('/')   #把"模块名/函数名"，分别赋值给 m，f；
    obj = __import__(m)    #__import__，特点就是，加的参数类型是字符串；
    if hasattr(obj,f):     #这里obj就是模块名，f就是函数名
        func = getattr(obj,f)
        func()
    else:
        print('404')

if __name__ == '__main__':
    run()

方法三，能够实现，调用其他文件夹下的模块：
def run():
    inp = input("请输入要访问的url(模块名/函数名)：")
    m,f = inp.split('/')   #m，f  等同于   模块名/函数名
    obj = __import__("day5." + m,fromlist=True)    #day5：定义想要调用文件夹名称   m：模块名称   fromlist=True：不加，会报错
    if hasattr(obj,f):     #这里obj就是模块名，f就是函数名
        func = getattr(obj,f)
        func()
    else:
        print('404')

if __name__ == '__main__':
    run()

python模块：

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       错误相关

os模块：

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下为"\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)的第二个元素
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所指向的文件或者目录的最后修改时间

 random模块：

import random

print(random.random())
print(random.randint(1, 2))
print(random.randrange(1, 10))

模块操作实例：

print(__file__)  #获取当前py文件所在的路径，如果你到这个文件所在的文件夹下执行这个脚本，只能拿到文件名，不能拿到路径；

print(__name__)  #name

os.path.abspath(__file__)  #os.path.abspath(），永远获取到当前文件的绝对路径

os.path.dirname(os.path.abspath(__file__) ) #获取到上级的路径

sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
#把上一级，上一级，文件夹，添加到系统path

进度条：

import sys
import time

def view_bar(num, total):
    rate = float(num) / float(total)  #2.7下要float下，python3下其实可以不用float； 这里就是：1/100,2/100,3/100,4/100
    rate_num = int(rate * 100)  #1/100 = 0.01 x 100=1,2/100 = 0.02 x100=2,3/100 = 0.03 x 100 = 3等。。。。
    r = '\r%d%%' % (rate_num, )  #字符串拼接，"\r"，回到当前行的首个位置
    r1 = '\r%s>%d%%' % ("="*num,rate_num, ) #用=号乘以num，然后再格式化输出，就打印进度条了
    sys.stdout.write(r1) #write输出内容没有换行服
    sys.stdout.flush()  #输出清空

if __name__ == '__main__':
    for i in range(0, 101):  #就会生成0~100数字；
        time.sleep(0.1)     #等待0.1秒
        view_bar(i, 100)  #这里，i=0 ， i=1 ， i=2 ， i=3 ， i=4

md5加密：

import hashlib

obj = hashlib.md5(bytes('fdeafewaf',encoding='utf-8'))  #fdeafewaf这些内容，可以加，可以不加，加上后会更安全
#创建hash对象，md5:(message-Digest Algorithm 5)消息摘要算法,得出一个128位的密文

obj.update(bytes('123',encoding='utf-8')) #更新哈希对象，以字符串参数
result = obj.hexdigest()　#返回十六进制，数字字符串
print(result)

re，正则表达式：

【字符】

　　  .   匹配除换行符以外的任意字符
　　 \w  匹配字母或数字或下划线或汉字
　　 \s   匹配任意的空白符
　　 \d   匹配数字
　　 \b   匹配单词的开始或结束
　　 ^    匹配字符串的开始
　　 $    匹配字符串的结束

【次数】

　　*       重复零次或更多次
　　+ 　   重复一次或更多次
　　? 　　重复零次或一次
　　{n}   重复n次
　　{n,}  重复n次或更多次
　　{n,m} 重复n到m次

【把一段字符串里面，所有freddy都找出来】
import re
res = re.findall('freddy','feawfewafreddyfewfreddyaf')
print(res)
结果：['freddy', 'freddy']

【值匹配前面这个大“I”】
ret = re.findall(r'I\b','I am alIex')
print(ret)

【match：查找com字符】
res = re.match('com','comwww.runcomoob')
print(res)
结果：<_sre.SRE_Match object; span=(0, 3), match='com'>

result = re.match('com','comwww.runcomoob').group()
print(result)
结果：com

result1 = re.match('com','www.runcomoob')  #match只能匹配到，开头的字符串
print(result1)
结果：None

【span():打印取到结果的范围】
res = re.match('com','comwww.runcomoob')
print(res.span()) 　　
结果：(0, 3)

【search:全局搜索】
res = re.search('com','www.runcomoob')
print(res)
#结果：<_sre.SRE_Match object; span=(7, 10), match='com'> 7~10范围内取出来的

a = re.search('\\com','www.run\comoob')　　#只匹配com
print(a,"result:",a.group())
结果：<_sre.SRE_Match object; span=(8, 11), match='com'> result: com

aa = re.search('\\\\','www.run\comoob').group()   #只匹配"\"
print(aa)
aa = re.search(r'\\','www.run\comoob').group()　　#只匹配"\"
print(aa)
结果：\

aa = re.search(r'\\com','www.run\comoob').group()  #取出/com
print(aa)
结果：\com

【结论，以后匹配尽量使用“r”原生字符串匹配，\b，有特殊含义】
cc = re.search('\bblow','blow')
print(cc)
结果：None

cc = re.search(r'\bblow','blow').group()
print(cc)
结果：blow

cc = re.search('\\bblow','blow').group()
print(cc)
结果：blow

【sub：把格式是”g.t的“，都替换成have】
tt = re.sub("g.t","have",'I get A, I got B,i gut C')
print(tt)
结果：I have A, I have B,i have C

t1 = re.sub("g.t","have",'I get A, I got B,i gut C',2)  #这里的2，指的是替换的次数
print(t1)
结果：I have A, I have B,i gut C

【subn：结果中会打印出替换的次数】
t1 = re.subn("g.t","have",'I get A, I got B,i gut C')
print(t1)
结果：('I have A, I have B,i have C', 3)

【split：'\d+'以1个，或者多个数字，进行分割】
t3 = re.split('\d+','one11two2three3four4')
print(t3)
结果：['one', 'two', 'three', 'four', '']

【compile：查找所有包含oo的单词】
text = " aa cc dd oo dd ooo xx oo oo xx dd"
regex = re.compile(r'\w*oo\w*')
print(regex.findall(text))

正则分组：
        去已经匹配到的数据中再提取(匹配)数据

【match】 
r = re.match("h\w+",origin)
print(r.group())    #获取匹配到的所有结果
print(r.groups())   #获取模型中匹配到的分组结果
print(r.groupdict())#获取模型中匹配到的分组结果
结果：
has_你妹
()
{}

r = re.match("h(\w+)",origin)
print(r.group())    #获取匹配到的所有结果
print(r.groups())   #获取模型中匹配到的分组结果
print(r.groupdict())#获取模型中匹配到的分组结果
结果：
has_你妹
('as_你妹',)
{}

r = re.match("h(?P<name>\w+)",origin)  #给匹配到的内容设置一个key
print(r.group())    #获取匹配到的所有结果
print(r.groups())   #获取模型中匹配到的分组结果
print(r.groupdict())#获取模型中匹配到的分组结果
结果：
has_你妹
('as_你妹',)
{'name': 'as_你妹'}

【分组】
origin = "has_你妹 fewafeaw hal f43243fwef"
r = re.findall("\w+",origin)
print(r)
结果：['has_你妹', 'fewafeaw', 'hal', 'f43243fwef']

origin = "has_你妹 fewafeaw hal f43243fwef"
r = re.findall("h(\w+)",origin) #只返回分组里面的内容
print(r)
结果：['as_你妹', 'al']

oo = "has_你妹aabb fewafeaw halaabb f43243fwef"
rr = re.findall("h(\w+)a(ab)b",oo)　　　　#把匹配到的值，进行多次分组
print(rr)
结果：[('as_你妹', 'ab'), ('al', 'ab')]

【split：无分组】
origin = "hello alex bcd alex lge alex acd 19"
r = re.split("alex",origin,1)　　#以alex为分隔符，把字符串切割成列表
print(r)
结果：['hello ', ' bcd alex lge alex acd 19']

【有分组】
oo = "hello alex bcd alex lge alex acd 19"
r = re.split("(alex)",oo,1) 　　#如果有分组，以alex进行分割，并且会把alex取出来
print(r)

rr = re.split("a(le)x",oo,1)  #这里虽然只打印的le，但是却是以“alex”整体匹配出来的
print(rr)
结果：['hello ', 'le', ' bcd alex lge alex acd 19']

rrr = re.split("(a(l(e))x)",oo,1)
print(rrr)
结果:['hello ', 'alex', 'le', 'e', ' bcd alex lge alex acd 19'] ,分别分割出 'alex', 'le', 'e'

f=open("C:\abc.txt")
#这样打开文件不行，因为他把\a当成转义字符了，解决方法，再加个”\“  f=open("C:\\abc.txt")