标签：
递归，阶乘
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 = ‘\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 = ‘\r%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下为"\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所指向的文件或者目录的最后修改时间
#!/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 匹配数字
\b 匹配单词的开始或结束
^ 匹配字符串的开始
$ 匹配字符串的结束
次数：
* 重复零次或更多次
+ 重复一次或更多次
? 重复零次或一次
{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‘\bROAD$‘,‘RD.‘,s) #r为原始字符串，字符串中的所有字符都不转义
b = re.sub(r‘\bROAD\b‘,‘RD.‘,s) #只匹配两个\b中间字符
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("h\w+", 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‘]
标签：
原文地址：http://www.cnblogs.com/wangminghu/p/5585649.html
