python day6

递归，阶乘
1*2*3*...7

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

x = func(7)
print(x)

反射
#利用字符串的形式去对像(模块)中操作(寻找/检查/删除/设置)成员
hasattr    #利用字符串的形式去对像(模块)判断是否存在，存在True，不存在False
getatrr    #利用字符串的形式去对像(模块)中操作(寻找)成员
delattr
setattr

 
commons.py
#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author:Minghu Wang

def login():
    print('炫酷登录页面')

def logout():
    print('炫酷退出页面')

def home():
    print('炫酷主页面')

   
index.py
import commons
def run():
    inp = input('请输入要访问的url：')  
    #hasattr  利用字符串的形式去对像(模块)判断是否存在，存在True，不存在False
    #getatrr  利用字符串的形式去对像(模块)中操作(寻找)成员
    #if hasattr(commons,login): 
    if hasattr(commons,inp):             #去commons判断你输入的是否存在此函数
        func = getattr(commons,inp)         #去commons寻找你输入相同字符函数
        func()
    else:
        print('404')

if __name__=='__main__':
    run()

   
   
   
结果
    请输入要访问的url：login
    炫酷登录页面

    请输入要访问的url：home
    炫酷主页面

    请输入要访问的url：logout
    炫酷退出页面

    请输入要访问的url：sadfskafjsafd
    404

   
   

   
   
程序二

----index.py

#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author:Minghu Wang

def run():
    # account/login
    inp = input('请输入要访问的url:')
    # inp字符串类型 inp = "login"
    # commons.inp() # commons.login
    # 利用字符串的形式去对象（模块）中操作（寻找/检查/删除/设置）成员，反射

    m, f = inp.split('/')        #以/方式输入分隔,前面为模块，后在为函数
    obj = __import__(m)          #以字符串形式调模块
    if hasattr(obj, f):
        func = getattr(obj, f)
        func()
    else:
        print('404')

if __name__ == '__main__':
    run()

   
   
----manager.py

#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author:Minghu Wang

def order():
    print('炫酷的订单页面')
   
   
   
   
----commons.py
   
#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author:Minghu Wang

def home():
    print('炫酷主页面')
   
   
   
----account.py

#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author:Minghu Wang

def login():
    print('炫酷登录页面')

def logout():
    print('炫酷退出页面')
   
   
   
结果：
    请输入要访问的url:manager/order           #输入manager/order
    炫酷的订单页面
   
    请输入要访问的url:account/jfkdsjfa
    404
   

   
obj = __import__('lib.account', fromlist=True)    #fromlist=True把lib和account拼接导入，否则查找到lib就停止了
print(obj)
   
#测试程序   
目录结构   
lib
    account.py
    commons.py
    manager.py
index.py

--index.py
def run():
    # account/login
    inp = input('请输入要访问的url:').strip()
    # inp字符串类型 inp = "login"
    # commons.inp() # commons.login
    # 利用字符串的形式去对象（模块）中操作（寻找/检查/删除/设置）成员，反射

    m, f = inp.split('/')
    # import lib.account
    obj = __import__("lib."+ m, fromlist=True)   #fromlist=True把lib拼接查找函数，否则查找到lib就停止了(调用lib目录模块)
    if hasattr(obj, f):                    #判断obj模块中是否有函数，有否为真，继续，没有报404
        func = getattr(obj, f)            #获取obj模块的函数
        func()                            #执行obj模块的函数
    else:
        print('404')

if __name__ == '__main__':
    run()
   
   
   
   
   
--manager.py
#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author:Minghu Wang

def order():
    print('炫酷的订单页面')
   
   
   
   
--commons.py   
#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author:Minghu Wang

def home():
    print('炫酷主页面')
   
   
   
--account.py
#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author:Minghu Wang
def login():
    print('炫酷登录页面')

def logout():
    print('炫酷退出页面')
       
       
       
结果
请输入要访问的url:manager/order
炫酷的订单页面       
       
       
       
       
       
       

获得我程序的根目录    （跨目录使用模块）
import sys
import os
#os.path.abspath 获得程序的绝对路径
#os.path.dirname 获取上级目录
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))  #os.path.abspath 获得程序的绝对路径
#print(sys.path)  

跨目录导入模块
    base_dir=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))    #定位我程序的根目录
    sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))  #将我的目录追加到sys.path

import os
import sys
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

from b import b1 as nb
nb.b()

程序实现
a
---a1.py
    def a():
        print('aaa')
b
---b1.py
    def b():
        print('bbb')

       
c
---test.py
    import os
    import sys
    sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))    # 一层层找
    from b import b1 as nb                        #导入b目录的b1程序,并别名
    nb.b()                                        #执行别名nb.b()  就是b目录中b1.py中的b函数
       

结果
bbb

当执行脚本时相等，别人调用时不执行(因为脚本名和__main__不相等)
__name__ == '__main__':  

老师博客：
http://www.cnblogs.com/wupeiqi/articles/5501365.html

进度百分比
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)

进度百分比完整
import sys
import time

def view_bar(num, total):
    rate = num / total
    rate_num = int(rate * 100)
    r1 = ' %s>%d%%' %("="*num, rate_num)
    sys.stdout.write(r1)
    sys.stdout.flush()
   
if __name__ == '__main__':
    # r = ' %d%%' % (1, )
    # print(r)
    # 0 - 100
    for i in range(0, 101):
        time.sleep(0.1)
        view_bar(i, 100)
       
       
       

   
       
       
       
重要
os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径之前的参数将被

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.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所指向的文件或者目录的最后修改时间

#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author:Minghu Wang
"""
我是注释
"""

print(__doc__)

__cached__
from bin import admin
print(__file__)
print(__package__)
print(admin.__package__)
只有执行当前文件时候，当前文件的特殊变量 __name__ == "__main__"
__name__ == __main__

def run():
    print('run')

if __name__ == "__main__":
    run()
import os
print(os.pathsep)

hashlib

用于加密相关的操作，代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法

import hashlib

# ######## md5 ########
hash = hashlib.md5()
# help(hash.update)
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())
print(hash.digest())

 
######## sha1 ########
hash = hashlib.sha1()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())

# ######## sha256 ########
hash = hashlib.sha256()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())

 
# ######## sha384 ########
hash = hashlib.sha384()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())

# ######## sha512 ########
hash = hashlib.sha512()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())

以上加密算法虽然依然非常厉害，但时候存在缺陷，
即：通过撞库可以反解。所以，有必要对加密算法中添加自定义key再来做加密。
#Md5加码
import hashlib
obj = hashlib.md5(bytes('kfdsjfkjsafkj',encoding='utf-8'))    #第二次加密码，防止撞库
obj.update(bytes('123',encoding='utf-8'))                        #给字节123加密码
result = obj.hexdigest()                                      #输出md5值                   
print(result)

结果
f4d91bff1af010c7161ce872447977b5

       
       
       
re        
正则表达式       
    字符：
    . 匹配除换行符以外的任意字符
    w 匹配字母或数字或下划线或汉字
    s 匹配任意的空白符
    d 匹配数字
     匹配单词的开始或结束
    ^ 匹配字符串的开始
    $ 匹配字符串的结束

    

    次数：
    * 重复零次或更多次
    + 重复一次或更多次
    ? 重复零次或一次
    {n} 重复n次
    {n,} 重复n次或更多次
    {n,m} 重复n到m次
    分组：
        去已经匹配到的数据中再提取数据
       
       
       
# match，从起始位置开始匹配，匹配成功返回一个对象，未匹配成功返回None       
# search,浏览整个字符串去匹配第一个，未匹配成功返回None
# findall，获取非重复的匹配列表；如果有一个组则以列表形式返回，且每一个匹配均是字符串；如果模型中有多个组，则以列表形式返回，且每一个匹配均是元祖；
# sub，替换匹配成功的指定位置字符串
# split，根据正则匹配分割字符串

s="web site is http://www.python.com"       
       
#search  匹配查找，直到找到第一个匹配为止，即不向下查找，匹配任意位置
re.search('w{3}..*..{2,4}',s)
a=re.search('w{3}..*..{2,4}',s)
a.group()
a=re.search('(w{3}).(.*.)(.{2,4})',s) #分组抽取
a.group(1)  #回显组1
a.group(2)
a.group(3)

#match  匹配开始，只从开头查找匹配
s="aaa   www.python.com"
a=re.match('(w{3}).(.*.)(.{2,4})',s)   #无法匹配，因为不是以www开头
print(a)
print(a.group())  #显示所有组

s="www.python.com"
a=re.match('(w{3}).(.*.)(.{2,4})',s)   #无法匹配，因为不是以www开头
print(a)
print(a.group())  #显示所有组

结果
<_sre.SRE_Match object; span=(0, 14), match='www.python.com'>
www.python.com

       
#re.findall – 所有匹配对象
xx='fdsafa  abc djfdksaf fdskjfsjalf abc  sdkfjsalf abc'
a = re.findall('abc',xx)  #abc全部回显
print(a)

结果
['abc', 'abc', 'abc']

       
#search ,  match , findall 综合例子
import re
s="foo bar foo abc foo"           #以foo开头
a = re.match('foo',s).group()      #可以查找到，因为以foo开头
b = re.search('foo',s).group()     #可以匹配，因为有foo字符
c = re.findall('foo',s)            #可以匹配所有

print(a)
print(b)
print(c)

结果
foo
foo
['foo', 'foo', 'foo']

s="xxx bar foo abc foo"   #不以foo开头测试
re.match('foo',s).group()   #会报错，无法匹配，因为不是以foo开头
re.search('foo',s).group()  #可以匹配，因有foo字符

#多重选择匹配
import re
s="web site is http://www.python.com "
a=re.search('(w{3}).(.*.)(.{cn|com|org|net})',s)
print(a.group())

结果
www.python.com

#re.compile 将正则表达式编译成对象，使用对象进行匹配

例子：
# encoding: UTF-8
import re
pattern = re.compile(r'hello') # 将正则表达式编译成Pattern对象
match = pattern.match('hello world!')   # 使用Pattern匹配文本，获得匹配结果，无法匹配时将返回None
if match:
      print(match.group()) # 使用Match获得分组信息
### 输出 ###
hello

#re.sub 匹配替换

import re
s = '100 BROAD'
a=re.sub('ROAD$', 'RD.', s)
print(a)

结果
100 BRD.

import re
k = '100 BRROAD  ROAD'
a = re.sub('\bROAD$','RD.',k)    #有边界匹配替换
print(a)

结果
100 BRROAD  RD.

import re
s = '100 BRROAD  ROAD'
a = re.sub(r'ROAD$','RD.',s)   #r为原始字符串，字符串中的所有字符都不转义
b = re.sub(r'ROAD','RD.',s)  #只匹配两个中间字符

print(a)
print(b)

结果
100 BRROAD  RD.
100 BRROAD  RD.

       
       
       
       
       
正则综合练习

re.findall('alex','jsfjsfalexkjfkdslajfla')    
re.findall('al.x','jsfjsfaltxkjfkdslajfla')    #.x单个匹配

import re
origin = "hasaabc dfuojqw halaabc m098u2934l"
# r = re.match("hw+", origin)
# r = re.match("h(w+)", origin)
r = re.findall("h(w+)a(ab)c", origin)
print(r)
print(r.group())     # 获取匹配到的所有结果
print(r.groups())    # 获取模型中匹配到的分组结果
print(r.groupdict()) # 获取模型中匹配到的分组结果

# 无分组
origin = "hello alex bcd alex lge alex acd 19"
r = re.split("alex", origin, 1)
print(r)

r = re.split("a(le)x", origin, 1)
print(r)

结果
['hello ', ' bcd alex lge alex acd 19']
['hello ', 'le', ' bcd alex lge alex acd 19']

分组
    去已经匹配到的数据中再提取数据
# 有分组，给分隔字符整个加括号
import re
origin = "hello alex bcd alex lge alex acd 19"
r1 = re.split("(alex)", origin, 1)    #用alex做分隔并取其值
print(r1)
r2 = re.split("(al(ex))", origin, 1)   #取分隔字符中的值
print(r2)

结果
['hello ', 'alex', ' bcd alex lge alex acd 19']
['hello ', 'alex', 'ex', ' bcd alex lge alex acd 19']