C++Python开发【第陆篇】:模块

递归的案例:阶乘

1*2*3*4*5*6*7…

  1. def func(num):

  2.     if
    num == 1:

  3.         return 1

  4.     return num * func(num – 1)

  5.  

  6. ret = func(7)

  7. print(ret)

反射

  1. def f1():

  2.    print(‘f1’)

f1:函数名

‘f1’:字符串

commons:

  1. def login():

  2.     print(‘登录页面’)

  3.  

  4. def logout():

  5.     print(‘退出页面’)

  6.  

  7. def home():

  8.     print(‘主页面’)

index:

  1. import commons

  2.  

  3. def run():

  4.     inp = input(‘请输入要拜访的url:’)

  1.     if
    inp == ‘login’:

  2.         commons.login()

  3.     elif inp == ‘logout’:

  4.         commons.logout()

  5.     elif inp == ‘home’:

  6.         commons.home()

  7.     else:

  8.         print(‘404’)

  9.  

  10. if
    __name__ == ‘__main__’:

  11.     run()

用反射实行优化,利用字符串的款型去对象(模块)中操作(寻找)成员。

index:

  1. import commons

  2.  

  3. def run():

  4.     inp = input(‘请输入要访问的url:’)

  1.     #反射:利用字符串的样式去对象(模块)中操作(寻找/检查/删除/设置)成员
  1.     #hasattr查看inp是不是留存(重回True
    or False)

  2.     if
    hasattr(commons,inp):

  3.         func = getattr(commons,inp)

  1.         func()

  2.     else:

  3.         print(‘404’)

  4. if
    __name__ == ‘__main__’:

  5.     run()

hasattr():寻找

getattr():检查

delattr():删除

setattr():设置

更是优化,字符串导入。

index:

  1. def run():

  2.     inp = input(‘请输入要拜访的url:’)

  1.     m,f = inp.split(‘/’)

  2.     obj = __import__(m)

  3.     if
    hasattr(obj,f):

  4.         func = getattr(obj,f)

  5.         func()

  6.     else:

  7.         print(‘404’)

  8.  

  9. if
    __name__ == ‘__main__’:

  10.     run()

增加补充,当需求导入文本夹上边包车型大巴:

  1. obj = __import__(‘lib.account’)
  1. print(obj)

  2. 输出:<module ‘lib’ from
    ‘D:\\work_software\\PycharmProjects\\oldboy_python\\day6\\lib\\__init__.py’>

  1. obj =
    __import__(‘lib.account’,fromlist=True)

  2. print(obj)

  3. 输出:<module ‘lib.account’ from
    ‘D:\\work_software\\PycharmProjects\\oldboy_python\\day6\\lib\\account.py’>

web框架的路由系统。

破例变量__file__

  1. import os

  2.  

  3. print(__file__)

  4.  

  5. #abspath()获取相对路径

  6. print(os.path.abspath(__file__))

  1.  

  2. #获得上级目录dirname()

  3. ret =
    os.path.dirname(os.path.abspath(__file__))

  4. ret_1 =
    os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

  1. print(ret)

  2. print(ret_1)

  3. 输出:

  4. D:/work_software/PycharmProjects/oldboy_python/day6/bin/admin.py

  1. D:\work_software\PycharmProjects\oldboy_python\day6\bin\admin.py
  1. D:\work_software\PycharmProjects\oldboy_python\day6\bin
  1. D:\work_software\PycharmProjects\oldboy_python\day6

独特变量__name__

  1. #只有执行当前文件的时候,当前文件的特种变量__name__
    == ‘__main__’

  2.  

  3. def run():

  4.     print(‘rum’)

  5.  

  6. if
    __name__ == “__main__”:

  1.     run()

sys模块

用以提供python解释器相关的操作。

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

速度百分比:

  1. import time

  2. import sys

  3.  

  4. def view_bar(num,total):

  5.     rate = float(num)/float(total)

  6.     rate_num = int(rate * 100)

  7.  

  8.     #数字进程呈现

  9.     #\r回到当前行的第贰个人置

  10.     r = ‘\r%d%%’%(rate_num)

  11.     #出口不换行

  12.     sys.stdout.write(r)

  13.  

  14.     #进程条展现

  15.     “””

  16.     r1 = ‘\r%s>%d%%’%(“=”*num,rate_num)

  17.     sys.stdout.write(r1)

  18.     “””

  19.  

  20.     sys.stdout.flush()

  21.  

  22. if
    __name__ == ‘__main__’:

  23.     for i in
    range(0,101):

  24.         time.sleep(0.1)

  25.         view_bar(i,100)

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”,”newname”):重命名文件/目录

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)的第3个成分。

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是3个设有的目录,再次回到True,不然重返False。

os.path.join(path1[,path2[,…]]):将四个途径组合后重临,第2个相对路径从前的参数将被忽略。

os.path.getatime(path):再次来到path所指向的文本可能目录的结尾获得时间。

os.path.getmtime(path):再次回到path所指向的文书可能目录的终极修改时间。

hashlib

用以加密相关的操作,代替了md5模块和sha模块,首要提供SHA1,SHA224,SHA256,SHA512,MD5算法。

MD5加密:

  1. import hashlib

  2.  

  3. #添加自定义key再来做加密

  4. obj =
    hashlib.md5(bytes(‘shisjajlj131424rdt5t6577ueuewmz’,encoding=’utf-8′))

  1. obj.update(bytes(‘123′,encoding=’utf-8’))
  1. result = obj.hexdigest()

  2. print(result)

正则表明式

字符匹配:普通字符、元字符。

日常字符匹配

  1. import re

  2.  

  3. ret =
    re.findall(‘alex’,’adasjkalex78272hshdsjhds’)

  4. print(ret)

  5. 输出:[‘alex’]

元字符匹配

.:除换行符以外的别的一个字符

  1. import re

  2.  

  3. ret =
    re.findall(‘al.x’,’uiiu9alaxuialbx798alcx21oalaaxiwq2al\nxjk’)

  1. print(ret)

  2. 输出:[‘alax’, ‘albx’, ‘alcx’]

^:以什么样开头

  1. import re

  2.  

  3. ret =
    re.findall(‘^al.x’,’al@xjkasjalexk’)

  4. print(ret)

  5. 输出:[‘al@x’]

$:以怎么着最后

  1. import re

  2.  

  3. ret =
    re.findall(‘al.x$’,’al@xhhalexuieuial#x’)

  4. print(ret)

  5. 输出:[‘al#x’]

*:重复*眼下的字符0次到n次

  1. import re

  2.  

  3. ret =
    re.findall(‘al.*x’,’yiuial3278hcxuxewualeexo’)

  4. print(ret)

  5. 输出:[‘al3278hcxuxewualeex’]

+:重复+后边一个字符的贰回到n次

?:重复?前边二个字符的0次或二回

{}:钦点重复的次数,{1,5}重复2回到5遍,{5}重复五回,{,5}重复0次到八次,{5,}重复捌回到n次。

[]:或,[a-z]匹配a到z的其余多少个,[ab]匹配a或b。

[]里头的卓殊意义

-:表示范围,例如[0-9]表示0到9。

^:表示非、排除,例如[^d]意味着排除d;

\:反斜杠后边跟元字符去除新鲜效果;反斜杠前面跟普通字符达成特殊意义;引用序号对应的字组所匹配的字符串,例如re.search(r”(alex)(eric)com\2″,”alexericcomeric”)。

\d:匹配任何十进制数,也等于[0-9]。

\D:匹配任何非数字字符,也便是[^0-9]。

\s:匹配任何空白字符,也等于[ \t\n\r\f\v]。

\S:匹配任何非空白字符,也正是[^ \t\n\r\f\v]。

\w:匹配任何字母数字字符,也就是[a-zA-Z0-9_]。

\W:匹配任何非字母数字字符,约等于[^a-zA-Z0-9_]。

\b:匹配四个字符串的分界,也正是指单词和空格间的地方。字符串是指接连的假名、数字和下划线组成的。注意,\b的定义是\w和\W的交界。

  1. import re

  2.  

  3. ret = re.findall(r’I\b’,’I am aaIbbb’)

  1. print(ret)

  2. 输出:[‘I’]

零宽界定符(zero-width
assertions)只用以匹配字符串的底部和底部。底部用空白符或非字母数字符来标识。

():内定匹配的组。

函数

match

re.match(pattern,string,flags=0),match只匹配初始地方。

flags编写翻译标志位,用于修校勘则表明式的十分格局,如是还是不是区分轻重缓急写,多行匹配等。

  1. import re

  2.  

  3. ret =
    re.match(‘com’,’comwww.runcomoob’)

  4. print(ret)

  5.  

  6. ret =
    re.match(‘com’,’comwww.runcomoob’).group()

  7. print(ret)

  8.  

  9. ret =
    re.match(‘com’,’comwww.runcomoob’).span()

  10. print(ret)

  11.  

  12. 输出:

  13. <_sre.SRE_Match object; span=(0, 3), match=’com’>

  1. com

  2. (0, 3)

search

要是匹配成功,就是三个match object对象。

  1. import re

  2.  

  3. ret =
    re.search(‘\dcom’,’www.4comrunco.5com’)

  4. print(ret)

  5.  

  6. 输出:<_sre.SRE_Match object; span=(4, 8), match=’4com’>

match object对象拥有以下办法:

group()再次来到被RE匹配的字符串。

group()重临re全体非凡的字符串,能够一遍输入四个组号,对应组号匹配的字符串。

壹 、group()重回re全部格外的字符串。

② 、group(n,m)再次来到组号为n,m所匹配的字符串,尽管组号不设有,则赶回indexError格外。

三 、groups()重返多个饱含正则表明式中有所小组字符串的元组,从1到所含的小组号,日常groups()不须求参数,再次回到2个元组,元组中的元就是正则表明式中定义的组。

start()再次来到匹配起来的职位。

end()重临匹配结束的岗位。

span()再次回到1个元组包罗匹配(开端,结束)的岗位。

findall

re.findall以列表格局重返全体匹配的字符串。

sub

卓越替换。

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

  1. import re

  2.  

  3. ret = re.sub(“g.t”,”have”,’I get A,I got B,I gut C’)

  4. print(ret)

  5. 输出:I have A,I have B,I have C

安装最大替换次数

  1. import re

  2.  

  3. ret = re.sub(“g.t”,”have”,’I get A,I got B,I gut C’,2)

  4. print(ret)

  5. 输出:I have A,I have B,I gut C

subn

  1. import re

  2.  

  3. ret = re.subn(“g.t”,”have”,’I get A,I got B,I gut C’)

  4. print(ret)

  5. 输出:(‘I have A,I have B,I have C’, 3)

split

  1. import re

  2.  

  3. ret =
    re.split(‘\d+’,’0one1two2three3four4′)

  4. print(ret)

  5. 输出:[”, ‘one’, ‘two’, ‘three’,
    ‘four’, ”]

compile

re.compile(strPattern[,flag])

这几个主意是Pattern类的工厂方法,用于将字符串方式的正则表明式编写翻译为Pattern对象。第③个参数flag是同盟情势,取值能够接纳按位或运算符’|’,表示还要生效,例如re.I|re.M,能够把日常使用的正则表明式编写翻译成正则表明式对象,这样能够抓好一定的效能。

  1. import re

  2.  

  3. text = “JGood is a handsome boy,he is cool,clever,and
    so on…”

  4. regex = re.compile(r’\w*oo\w*’)

  1. ret = regex.findall(text)

  2. print(ret)

  3. 输出:[‘JGood’, ‘cool’]

re.I:使万分对大小写不灵活。

re.L:做地点化识别(locale-aware)匹配。

re.M:多行匹配,影响^和$。

re.S:使”.”匹配包蕴换行在内的拥有字符。

re.U:遵照Unicode字符集解析字符。这些标识影响\w,\W,\b,\B。

正则分组

在已经万分到的数额中再领取数据。

match的分组匹配

  1. import re

  2.  

  3. origin = “has dhjdahk29832”

  4. r = re.match(“h\w+”,origin)

  5. #获取匹配到的装有结果

  6. print(r.group())

  7. #取得模型中匹配到的分组结果

  8. print(r.groups())

  9. #得到模型中非凡到的分组结果

  10. print(r.groupdict())

  11. 输出:

  12. has

  13. ()

  14. {}

  15.  

  16. import re

  17.  

  18. origin = “has dhjdahk29832”

  19. r = re.match(“h(\w+)”,origin)

  20. #收获匹配到的富有结果

  21. print(r.group())

  22. #得到模型中万分到的分组结果

  23. print(r.groups())

  24. #赢得模型中万分到的分组结果

  25. print(r.groupdict())

  26. 输出:

  27. has

  28. (‘as’,)

  29. {}

  30.  

  31. import re

  32.  

  33. origin = “has dhjdahk29832”

  34. r = re.match(“h(?P<name>\w+)”,origin)

  35. #收获匹配到的拥有结果

  36. print(r.group())

  37. #获得模型中匹配到的分组结果

  38. print(r.groups())

  39. #获取模型中匹配到的分组结果

  40. print(r.groupdict())

  41. 输出:

  42. has

  43. (‘as’,)

  44. {‘name’: ‘as’}

findall的分组匹配

  1. import re

  2.  

  3. origin = “has sajkd hjda hk2983ds wqw2”

  4. r = re.findall(“h(\w+)”,origin)

  5. print(r)

  6. 输出:[‘as’, ‘jda’, ‘k2983ds’]

  7.  

  8. import re

  9.  

  10. origin = “hasaabc sajkd hjdaabc hk2983dsaabc
    wqw2”

  11. r = re.findall(“h(\w+)a(ab)c”,origin)

  12. print(r)

  13. 输出:[(‘as’, ‘ab’), (‘jd’, ‘ab’), (‘k2983ds’,
    ‘ab’)]

 

split的分组匹配

  1. import re

  2.  

  3. origin = “hello alex bcd alex lgc alex acd 19”

  1. r = re.split(“alex”,origin,1)

  2. print(r)

  3. 输出:[‘hello ‘, ‘ bcd alex lgc alex
    acd 19’]

  4.  

  5. import re

  6.  

  7. origin = “hello alex bcd alex lgc alex acd 19”

  1. #匹配值中()的情节需求输出

  2. r = re.split(“(alex)”,origin,1)

  3. print(r)

  4. 输出:[‘hello ‘, ‘alex’, ‘ bcd alex
    lgc alex acd 19’]

  5.  

  6. import re

  7.  

  8. origin = “hello alex bcd alex lgc alex acd 19”

  1. r = re.split(“a(le)x”,origin,1)

  2. print(r)

  3. 输出:[‘hello ‘, ‘le’, ‘ bcd alex lgc
    alex acd 19’]

  4.  

  5. import re

  6.  

  7. origin = “hello alex bcd alex lgc alex acd 19”

  1. r = re.split(“(a(le)x)”,origin,1)

  2. print(r)

  3. 输出:[‘hello ‘, ‘alex’, ‘le’, ‘ bcd
    alex lgc alex acd 19’]

  4.  

  5. import re

  6.  

  7. origin = “hello alex bcd alex lgc alex acd 19”

  1. r = re.split(“(a(l(e))x)”,origin,1)

  2. print(r)

  3. 输出:[‘hello ‘, ‘alex’, ‘le’, ‘e’, ‘
    bcd alex lgc alex acd 19’]