python day six

发布时间:2019-08-12 09:51:44编辑:auto阅读(1538)

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

    #利用递归实现阶乘实例(实际就是函数调用函数)
    
    #实现 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、元字符:  . ^ $ * + ? {} [] | () \    (11个)
                    1 .     代表除换行符以外的任何一个字符
                    2 ^     匹配字符串开始位置
                    3 $     匹配字符串终止位置 
                    4 *     匹配0-多次
                    5 +     匹配1-多次
                    6 ?     匹配0-1次
                    7 {}   匹配固定几次,或者一个范围
                                    {1-5}从1-5次
                                    {,5}从0-5次
                                    {1,}从1-多次
                    8 []   匹配或的概念
                                1.匹配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']

关键字

上一篇: python 元组tuple

下一篇: python 分析redis