字符串导入,用反射进行优化

递归的案例:阶乘

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)

跟着老男孩管教育学Python开发【第伍篇】:模块,老男孩python

图片 1

反射

  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框架的路由系统。

递归的案例:阶乘

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

十一分规变量__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

反射

f1:函数名

‘f1’:字符串

commons:

index:

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

index:

hasattr():寻找

getattr():检查

delattr():删除

setattr():设置

更为优化,字符串导入。

index:

补给,当供给导入文本夹上面包车型大巴:

web框架的路由系统。

十分变量__name__

  1. #唯有实践当前文件的时候,当前文件的特殊变量__name__
    == ‘__main__’

  2.  

  3. def run():

  4.     print(‘rum’)

  5.  

  6. if
    __name__ == “__main__”:

  1.     run()

特出变量__file__

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回到当前行的第3人置

  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)

特种变量__name__

os模块

用以提供系统级别的操作。

os.getcwd():获取当前工作目录,即近日python脚本工作的目录路径。

os.chdir(“dirname”):改变如今剧本工作目录,约等于shell下cd。

os.curdir:再次回到当前目录(’.’)。

os.pardir:获取当前目录的父目录字符串名(’..’)。

os.makedirs(‘dir1/dir二’):可生成多层递归目录。

os.removedirs(‘dirname一’):若目录为空,则删除,并递归到上一级目录,若也为空,则删除,依次类推。

os.mkdir(‘dirname’):生成单级目录,也正是shell中mkdir、dirname。

os.rmdir(‘dirname’):删除单级目录,若目录不为空则无法删除,报错,约等于shell中rmdir
dirname。

os.listdir(‘dirname’):列出钦点目录下的有所文件和子目录,包蕴隐形文件,并以列表格局打字与印刷。

os.remove():删除2个文件。

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分割成目录和文件名2元组重返。

os.path.dirname(path):再次回到path的目录,其实正是os.path.split(path)的首先个要素。

os.path.basename(path):再次来到path最终的文书名,若是path以/或\最终,那么就赶回空值。即os.path.split(path)的第1个要素。

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所指向的文本只怕目录的结尾修改时间。

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

速度百分比:

hashlib

用以加密相关的操作,代替了md伍模块和sha模块,首要提供SHA1,SHA2二肆,SHA256,SHA51二,MD伍算法。

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)

os模块

用以提供系统级别的操作。

os.getcwd():获取当前工作目录,即近日python脚本工作的目录路径。

os.chdir(“dirname”):改变近日剧本工作目录,相当于shell下cd。

os.curdir:重返当前目录(’.’)。

os.pardir:获取当前目录的父目录字符串名(’..’)。

os.makedirs(‘dir1/dir2’):可生成多层递归目录。

os.removedirs(‘dirname壹’):若目录为空,则删除,并递归到上一流目录,若也为空,则删除,依次类推。

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)的第四个因素。

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是1个留存的目录,重回True,不然重回False。

os.path.join(path1[,path2[,…]]):将多少个途径组合后回到,第三个相对路径在此以前的参数将被忽略。

os.path.getatime(path):再次来到path所指向的文书也许目录的末梢得到时间。

os.path.getmtime(path):再次来到path所指向的文件只怕目录的最后修改时间。

正则表明式

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

hashlib

用来加密相关的操作,代替了md五模块和sha模块,首要提供SHA一,SHA2二四,SHA25陆,SHA51二,MD5算法。

MD5加密:

司空见惯字符相称

  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’]

+:重复+前边八个字符的3次到n次

?:重复?前边3个字符的0次或3遍

{}:内定重复的次数,{一,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:相配任何10进制数,相当于[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)只用以匹配字符串的头部和尾巴部分。尾巴部分用空白符或非字母数字符来标识。

():钦点相配的组。

一般而言字符相称

函数

元字符相称

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

^:以怎么着早先

$:以什么样最终

*:重复*前边的字符0次到n次

+:重复+前面3个字符的贰遍到n次

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

{}:钦命重复的次数,{一,5}重复二遍到9遍,{5}重复6回,{,伍}重复0次到7遍,{伍,}重复捌遍到n次。

[]:或,[a-z]相配a到z的其他三个,[ab]匹配a或b。

[]当中的新鲜意义

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

^:表示非、排除,例如[^d]代表排除d;

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

\d:相配任何10进制数,相当于[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的交界。

零宽界定符(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全体配合的字符串,能够2遍输入两个组号,对应组号匹配的字符串。

壹、group()重返re全部合作的字符串。

二、group(n,m)再次来到组号为n,m所匹配的字符串,如若组号不存在,则赶回indexError格外。

叁、groups()重临一个含有正则表明式中有所小组字符串的元组,从1到所含的小组号,常常groups()不必要参数,重临二个元组,元组中的元正是正则表达式中定义的组。

start()再次回到相称起来的岗位。

end()再次回到相配甘休的职位。

span()重回一个元组包涵相称(初叶,甘休)的职务。

match

re.match(pattern,string,flags=0),match只相称初叶地点。

flags编写翻译标志位,用于修考订则表达式的合作情势,如是不是区分轻重缓急写,多行相配等。

findall

re.findall以列表方式重返全体相称的字符串。

search

借使相配成功,正是3个match object对象。

match object对象拥有以下措施:

group()再次回到被RE相配的字符串。

group()再次来到re全体卓殊的字符串,能够一遍输入七个组号,对应组号相称的字符串。

一、group()重回re全体相当的字符串。

2、group(n,m)再次回到组号为n,m所相称的字符串,假若组号不设有,则赶回indexError很是。

三、groups()重返贰个包涵正则表明式中装有小组字符串的元组,从壹到所含的小组号,日常groups()不需求参数,重临一个元组,元组中的元便是正则表明式中定义的组。

start()再次来到相配起来的地方。

end()重返相称停止的任务。

span()再次来到2个元组包罗匹配(起头,结束)的职务。

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

findall

re.findall以列表格局再次回到全部相称的字符串。

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)

sub

同盟替换。

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

设置最大替换次数

split

  1. import re

  2.  

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

  4. print(ret)

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

subn

compile

re.compile(strPattern[,flag])

本条主意是Pattern类的工厂方法,用于将字符串情势的正则表明式编写翻译为帕特tern对象。第1个参数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。

split

正则分组

在曾经极度到的数量中再领取数额。

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’]

compile

re.compile(strPattern[,flag])

其一法子是Pattern类的工厂方法,用于将字符串格局的正则表明式编写翻译为Pattern对象。第一个参数flag是十分情势,取值能够运用按位或运算符’|’,表示还要生效,例如re.I|re.M,能够把平日应用的正则表明式编写翻译成正则表明式对象,那样能够进步自然的频率。

re.I:使卓殊对大小写不敏感。

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

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

re.S:使”.”相配包含换行在内的保有字符。

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

正则分组

在曾经十分到的多少中再领取数据。

match的分组相称

findall的分组匹配

 

split的分组相配

http://www.bkjia.com/Pythonjc/1183352.htmlwww.bkjia.comtruehttp://www.bkjia.com/Pythonjc/1183352.htmlTechArticle跟着老男孩教育学Python开发【第五篇】:模块,老男孩python
递归的案例:阶乘 壹*2*3*4*5*6*7… 反射 f1:函数名 ‘f1’:字符串
commons: index: 用…