python day six

一、利用递归实现阶乘实例

#利用递归实现阶乘实例（实际就是函数调用函数）

#实现 1*2*3*4*5*6*7*8*9

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

a = func(9)
print (a)
#输出：362880

二、反射

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

'''
#例1:
#如一个WEB框架的路由系统
#定义一个commons.py的模块
def login():
    print("登录页面")

def loGout():
    print("退出页面")

def home():
    print("主页面")
#定义一个index.py的为主运行程序
import commons

def run():
    in1 = input("请输入访问的url:")
    if in1 == 'login':
        commons.login()
    elif in1 == 'logout':
        commons.logout()
    elif in1 == 'home':
        commons.home()
    else:
        print("404")
'''

'''
#内置函数getattr()

1.getattr()  #获取它的属性（也称成员）
例如：
getattr(commons,"login")
#去commons模块中寻找它的成员login
#以例1的案例更改后如下：
#1.getattr()
 def run():
     in1 = input("请输入访问的url:")
     func = getattr(commons,in1)
     func()
'''


'''
2.hasattr()
    hasattr(commons,"login")
    #查找commons里边有没有login；有返回True，没有则返回False

##python 有两个web模块：Tornado和Django
#以例1的案例更改后如下：
#2.hasattr()
def run():
    in1 = input("请输入访问的url:")
    if hasattr(commons,in1):
        func = getattr(commons,in1)
        func()
    else:
        print("404")
'''

'''
3.delattr() #在模块中删除某个成员
4.setattr() #在模块中再设置某个成员
'''

'''
5.__import__()  #以字符串的形式导入模块
    例如1：
    import commons as obj   #此处commons是模块名
    obj.login()     #执行obj里边的login函数，也就是执行commons里边的login函数

    例如2：（和例1功能相等，导入写法不一）
    obj = __import__("commons") #此处commons是字符串
    obj.login()

#以例1的案例更改后如下：
#__import__()  #以字符串的形式导入模块
def run():
    in1 = input("请输入访问的url(commons/login):")
    m,f = in1.split("/")
    obj = __import__(m)
    if hasattr(obj,f):
        func = getattr(obj,f)
        func()
    else:
        print("404")
'''

'''
6.当导入别的文件夹模块的时候
    例如：
        目录为：
        day6
            lib
                account.py
            text.py
        导入方法：
            m,f = in1.split("/")
            obj = __import__('lib.'+m, fromlist=True)
            #fromlist=True 代表告诉是以字符串拼接的方式
            #如果不加，只导入lib.之前的模块lib

'''

'''
#实例：伪造web框架的路由系统
    （路由系统：访问某一个url 就给定义到某个函数上）

'''

'''
反射总结：
    1.反射：
        基于字符串的形式去对象（模块）中操作（寻找/检查/删除/设置）其成员。
    2.反射功能（接口）：
        是由Python提供；
        4个功能：getattr()、delattr()、setattr()、hasattr()
    3.扩展：
        导入模块
            import 模块名
            from xxx import 模块名
        导入别的文件夹模块
            obj = __import__("xxx")
            #xxx是字符串
            obj = __import__("xxx."+xx,fromlist=True)
            #xxx是字符串、xx是一个变量也是一个字符串；
            #fromlist=True 告诉前边是以字符串拼接的方式

'''

三、模块中的特殊变量

1.__doc__     功能：将.py文件的注释自动封装到__doc__里边
             （注释：在.py文件开头用''' '''表示的内容）
                例如：
                     """
                        我是一个兵
                     """
                    print (__doc__)

2.__cached__  功能：显示字节码文件路径在哪里（也就是存放的位置）
                （在运行.py文件的时候会生成.pyc文件是字节码文件）

3.__file__    功能：查看当前.py文件的文件名
              1.print (__file__)

              2.查看绝对路径
                import os
                os.path.abcpath() 获取某个文件的绝对路径
                例：
                os.path.abspath(__file__)
                #查看当前文件的绝对路径

              3.查看当前目录的上级目录
                r1 = os.path.dirname(os.path.abcpath(__file__))
                print (r1)
              4.查看当前目录的上上级目录
                r2 = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
                print (r2)
                将目录加载到python系统目录里：
                import sys
                sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
                #这样目录永远加到了python系统目录里，以后当设计到bin目录都要加这行。

4.__package__ 功能：查看当前所在包的名称。
              1.当在当前目录下执行，放回None；
                print(__package__)
              2.当导入别的模块时，执行就返回模块所在的文件夹：
                import commons from login
                print (login,__package__)

5.__name__    功能：执行某.py文件时，那么__name__就等于__main__
                    只有执行当前文件时，当前文件的特殊变量__name__ == "__main__"
                    正式由于这种特性，因此在主运行文件里加上：
                    if __name__ == "__main__":

四、python模块sys

#sys（python解释器相关的内容都在里边）
1.sys.argv      执行脚本传参数，输出list；第一个元素就是脚本本身aa.py
                例如：
2.sys.exit(n)   退出程序，n是退出时屏幕打印的内容

3.sys.version() 获取python解释器的版本

4.sys.path      返回模块的搜索路径，初始时使用python的环境变量值

5.sys.platfORM  返回操作系统的平台

6.sys.stdin：    输入相关
7.sys.stdout:    输出相关
    sys.stdout.flush()    输出清空
    sys.stdout.write(r) 输出不加换行符
    print (r) 输出自动加换行符
8.sys.stderr：错误相关

9.\r            回到当前行的首位置
    例如：
        r = '%d%%' %(num)   #num是一个可遍历的变量
        输出：1%2%3%...100%
        加了\r之后：
        r = '\r%d%%' %(num)   #num是一个可遍历的变量
        输出：2%会把1%覆盖，3%会把2%覆盖，最后是100%
        
#进度条案例
import sys
import time
def jindutiao(num,total):
    r = num / total
    r1 = int(r*100)
    #result = '%d%%' %(r1)  #没有格式化输出
    result = '\r%s>%d%%' %("="*num,r1)  #有格式化输出
    sys.stdout.write(result)
    sys.stdout.flush()

if __name__ == '__main__':
    for i in range(1,101):
        time.sleep(0.1)     #延迟0.1s
        jindutiao(i,100)

五、python模块os

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

六、python加密模块hashlib

#md5是不可逆的，通过密文比较方法确认

#例如：
import hashlib              #导入加密模块
obj = hashlib.md5()         #定义MD5加密
#obj.update('123')          #python2.7的写法
obj.update(bytes('123',encoding='utf-8'))   #python3.0的写法，必须用bytes
result = obj.hexdigest()    #obj.hexdigest就是获取加密后的字符串
print(result)               #打印加密后的字符串

#为了防止MD5 对称破解，可以用一下方法来解决：
import hashlib                            #导入加密模块
obj = hashlib.md5(bytes('djfjdsofhosdfjo13432534eee',encoding='utf-8'))         
                                          #定义MD5加密,首先加密这里的字符串
#obj.update('123')                        #python2.7的写法加密
obj.update(bytes('123',encoding='utf-8')) #python3.0的写法加密，必须用bytes
                                          #这里加密是在上边定义的时候加密基础之上再加密。
result = obj.hexdigest()                  #obj.hexdigest就是获取加密后的字符串
print(result)                             #打印加密后的字符串

七、python正则表达式

#正则表达式用的python的re模块
#它是一个小型编程语言，主要做字符串的一个匹配
#导入 import re
1.re.findall(x,y)
 #去字符串y里边，把所有匹配规则x的的结果，通过一个列表形式返回来。
    例如：
        import re
        a= re.findall('yang','dkfjdyangdif')
        print(a)
2.字符分为：1、普通字符
            2、元字符：  . ^ $　＊　＋　？　｛｝　［］　｜　（）　＼    （１１个）
                １　．     代表除换行符以外的任何一个字符
                ２　＾     匹配字符串开始位置
                ３　＄     匹配字符串终止位置　
                ４　＊     匹配０－多次
                ５　＋     匹配１－多次
                ６　？     匹配０－１次
                ７ ｛｝   匹配固定几次，或者一个范围
                                ｛１－５｝从１－５次
                                ｛，５｝从０－５次
                                ｛１，｝从１－多次
                8 ［］   匹配或的概念
                            １.匹配b或者c都会匹配到输出（只能匹配一个字符）
                                p1 = re.findall('a[bc]d','abd')
                                print(p1)
                            2.匹配范围（匹配a-z的范围，但这里只能匹配一个字符）
                                p1 = re.findall('a[a-z]d','add')
                                print(p1)
                            3.匹配字符集(匹配+号之前的a-z的n个字符都会被匹配)
                                p1 = re.findall('a[a-z]+d','addfDDD')
                                print(p1)
                            4.中括号里边具有特殊意义的字符：
                                1 -     中横线代表范围：a-z 0-9
                                2 ^     代表非，否的意思
                                3 \d    代表数字
                9 \      功能： 1、\后加元字符，取消元字符的功能
                                2、\后加某些字符有一些特殊的意义
                         例：匹配单词字符
                                import re
                                #匹配首字母I，而不是字符串里边的I
                                p1 = re.findall(r'I\b','I am abcIdd')
                                #r ：代表原生字符串，r后边都是普通字符串
                                #\b ：匹配单词的开始或结束
                                print(p1)
                10 \w     匹配字母或数字或下划线或汉字

                11 \s     匹配任意的空白符

                12 \d     匹配数字

                13. \b    匹配单词的开始或结束

3.函数方法：
        1.match     匹配起始位置；match().group() group是match一个方法，取匹配值

        2.search    匹配到第一个就结束

        3.findall   返回一个列表

          finditer  返回一个对象，可以遍历、取值

        4.sub       匹配，替换

          subn      不但匹配、替换，还会把替换的次数打印出来

        5.split     分割

        6.re.compile(strPattern[,flag])
                    这个方法是Pattern类的工厂方法，用于将字符串形式的正则表达式编译为Pattern对象
                    。第二个参数flag是匹配模式，取值可以使用按位或运算符‘|’表示同时生效，如：
                    re.I | re.M
                    可以把正则表达式编译成一个正则表达式对象。可以把那些经常使用的正则表达式编译
                    成正则表达式对象，这样可以提高一定的效率，下面是一个正则表达式对象的一个例子
                        import re
                        text = "aaa is a handsome boy,he is cool,clever,and so on..."
                        regex = re.compile(r'\w*oo\w*')
                        print(regex.findall(text))

4.正则表达式分组
    （去已经匹配到的数据中，再匹配数据）
    r.group()       用"字符串"来匹配
    r.groups()      用()来匹配
    r.groupdict()   用?P<name> 来匹配,定义name为key，取的值为value

    例：
        # import re
        # text = "has hal dfdsjlfjdsl"
        # r = re.match("h(?P<name>\w+)",text)     #只匹配首
        # print(r.group())
        # print(r.groups())
        # print(r.groupdict())
        
        输出：
        has
        ('as',)
        {'name': 'as'}
        
        # import re
        # text = "has hal dfdsjlfjdsl hao"      #匹配多个
        # r = re.findall("h\w+",text)
        # print(r)
        
        输出：
        ['has', 'hal', 'hao']
        
        # import re
        # text = "has hal dfdsjlfjdsl hao"
        # r = re.findall("h(\w+)",text)
        # print(r)
        
        输出：
        ['as', 'al', 'ao']
        
        # import re
        # text = "hasbs hisbs dfdsjlfjdsl hdsas"
        # r = re.findall("h(\w+)",text)
        # r1 = re.findall("h(\w+)s(b)s",text)
        # print(r,r1)
        
        输出：
        ['asbs', 'isbs', 'dsas'] [('a', 'b'), ('i', 'b')]
        
        import re
        text = "asbs hisbs dfdsjlfjdsl hdsas"
        r1 = re.split("s(b)s",text,1)
        print(r1)
        
        #输出：
        ['a', 'b', ' hisbs dfdsjlfjdsl hdsas']