Python学习路程day4
- 作者: 五速梦信息网
- 时间: 2026年04月04日 13:31
############### 基础平台提供的功能如下 ############### def f1():
# 验证1
# 验证2
# 验证3
print 'f1' def f2():
# 验证1
# 验证2
# 验证3
print 'f2' def f3():
# 验证1
# 验证2
# 验证3
print 'f3' def f4():
# 验证1
# 验证2
# 验证3
print 'f4' ############### 业务部门不变 ###############
### 业务部门A 调用基础平台提供的功能### f1()
f2()
f3()
f4() ### 业务部门B 调用基础平台提供的功能 ### f1()
f2()
f3()
f4()
过了一周 Low BB 被开除了...
老大把工作交给 Low BBB，他是这么做的：
只对基础平台的代码进行重构，其他业务部门无需做任何修改
############### 基础平台提供的功能如下 ############### def check_login():
# 验证1
# 验证2
# 验证3
pass def f1(): check_login() print 'f1' def f2(): check_login() print 'f2' def f3(): check_login() print 'f3' def f4(): check_login() print 'f4'
老大看了下Low BBB 的实现，嘴角漏出了一丝的欣慰的笑，语重心长的跟Low BBB聊了个天：
老大说：
写代码要遵循开放封闭原则，虽然这个原则是用的面向对象开发，但是也适用于函数式编程，简单来说，它规定已经实现的功能代码不允许被修改，但可以被扩展，即：
- 封闭：已实现的功能代码块
- 开放：对扩展开发
如果将开放封闭原则应用在上述需求中，那么就不允许在函数 f1 、f2、f3、f4的内部进行修改代码，老板就给了Low BBB一个实现方案：
def w1(func):
def inner():
# 验证1
# 验证2
# 验证3
return func()
return inner @w1
def f1():
print 'f1'
@w1
def f2():
print 'f2'
@w1
def f3():
print 'f3'
@w1
def f4():
print 'f4'
对于上述代码，也是仅仅对基础平台的代码进行修改，就可以实现在其他人调用函数 f1 f2 f3 f4 之前都进行【验证】操作，并且其他业务部门无需做任何操作。
Low BBB心惊胆战的问了下，这段代码的内部执行原理是什么呢？
老大正要生气，突然Low BBB的手机掉到地上，恰恰屏保就是Low BBB的女友照片，老大一看一紧一抖，喜笑颜开，交定了Low BBB这个朋友。详细的开始讲解了
单独以f1为例：
def w1(func):
def inner():
# 验证1
# 验证2
# 验证3
return func()
return inner @w1
def f1():
print 'f1'
当写完这段代码后（函数未被执行、未被执行、未被执行），python解释器就会从上到下解释代码，步骤如下：
- def w1(func): ==>将w1函数加载到内存
- @w1
没错，从表面上看解释器仅仅会解释这两句代码，因为函数在没有被调用之前其内部代码不会被执行。
从表面上看解释器着实会执行这两句，但是 @w1 这一句代码里却有大文章，@函数名 是python的一种语法糖。
如上例@w1内部会执行一下操作：
- 执行w1函数，并将 @w1 下面的 函数 作为w1函数的参数，即：@w1 等价于 w1(f1)
所以，内部就会去执行：
def inner:
#验证
return f1() # func是参数，此时 func 等于 f1
return inner # 返回的 inner，inner代表的是函数，非执行函数
其实就是将原来的 f1 函数塞进另外一个函数中 - 将执行完的 w1 函数返回值赋值给@w1下面的函数的函数名
w1函数的返回值是：
def inner:
#验证
return 原来f1() # 此处的 f1 表示原来的f1函数
然后，将此返回值再重新赋值给 f1，即：
新f1 = def inner:
#验证
return 原来f1()
所以，以后业务部门想要执行 f1 函数时，就会执行 新f1 函数，在 新f1 函数内部先执行验证，再执行原来的f1函数，然后将 原来f1 函数的返回值 返回给了业务调用者。
如此一来， 即执行了验证的功能，又执行了原来f1函数的内容，并将原f1函数返回值 返回给业务调用着
Low BBB 你明白了吗？要是没明白的话，我晚上去你家帮你解决吧！！！
先把上述流程看懂，之后还会继续更新...
问答时间
问题：被装饰的函数如果有参数呢？
def w1(func):
def inner(arg):
# 验证1
# 验证2
# 验证3
return func(arg)
return inner @w1
def f1(arg):
print 'f1'
def w1(func):
def inner(arg1,arg2):
# 验证1
# 验证2
# 验证3
return func(arg1,arg2)
return inner @w1
def f1(arg1,arg2):
print 'f1'
def w1(func):
def inner(arg1,arg2,arg3):
# 验证1
# 验证2
# 验证3
return func(arg1,arg2,arg3)
return inner @w1
def f1(arg1,arg2,arg3):
print 'f1'
问题：可以装饰具有处理n个参数的函数的装饰器？
def w1(func):
def inner(*args,**kwargs):
# 验证1
# 验证2
# 验证3
return func(*args,**kwargs)
return inner @w1
def f1(arg1,arg2,arg3):
print 'f1'
问题：一个函数可以被多个装饰器装饰吗？
def w1(func):
def inner(*args,**kwargs):
# 验证1
# 验证2
# 验证3
return func(*args,**kwargs)
return inner def w2(func):
def inner(*args,**kwargs):
# 验证1
# 验证2
# 验证3
return func(*args,**kwargs)
return inner @w1
@w2
def f1(arg1,arg2,arg3):
print 'f1'
问题：还有什么更吊的装饰器吗？
#!/usr/bin/env python
#coding:utf-8 def Before(request,kargs):
print 'before' def After(request,kargs):
print 'after' def Filter(before_func,after_func):
def outer(main_func):
def wrapper(request,kargs): before_result = before_func(request,kargs)
if(before_result != None):
return before_result; main_result = main_func(request,kargs)
if(main_result != None):
return main_result; after_result = after_func(request,kargs)
if(after_result != None):
return after_result; return wrapper
return outer @Filter(Before, After)
def Index(request,kargs):
print 'index'
补充：以后写装饰器要加functiontools.wraper。因为它能获取原函数的原数据。
特点
递归算法是一种直接或者间接地调用自身算法的过程。在计算机编写程序中，递归算法对解决一大类问题是十分有效的，它往往使算法的描述简洁而且易于理解。
递归算法解决问题的特点：
(1) 递归就是在过程或函数里调用自身。
(2) 在使用递归策略时，必须有一个明确的递归结束条件，称为递归出口。
(3) 递归算法解题通常显得很简洁，但递归算法解题的运行效率较低。所以一般不提倡用递归算法设计程序。
(4) 在递归调用的过程当中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成栈溢出等。所以一般不提倡用递归算法设计程序。
def binary_search(data_source,find_n):
mid = int(len(data_source)/2)
if len(data_source) >=1 :
if data_source[mid] > find_n:
print('data in left of [%s]'% data_source[mid])
print(data_source[:mid])
binary_search(data_source[:mid],find_n)
elif data_source[mid] < find_n:
print('data in right of [%s]'% data_source[mid])
print(data_source[mid:])
binary_search(data_source[:mid],find_n)
else:
print ('found find_s',data_source[mid])
else:
print ("cannot find...")
if __name__ == '__main__':
data = list(range(2,25))
#print(data)
binary_search(data,1)
斐波那契：
利用函数编写如下数列：
斐波那契数列指的是这样一个数列 0, 1, 1, 2, 3, 5, 8, 13, 21, 34
def func(arg1,arg2,stop):
if arg1 == 0:
print (arg1, arg2)
arg3 = arg1 + arg2
print (arg3)
if arg3< stop:
func(arg2,arg3,stop)
func(0,1,30)
算法基础
要求：生成一个4*4的2维数组并将其顺时针旋转90度
#!_*_coding:utf-8_*_ array=[[col for col in range(5)] for row in range(5)] #初始化一个4*4数组
#array=[[col for col in 'abcde'] for row in range(5)] for row in array: #旋转前先看看数组长啥样
print(row) print('-------------')
for i,row in enumerate(array): for index in range(i,len(row)):
tmp = array[index][i] #get each rows' data by column's index
array[index][i] = array[i][index] #
print tmp,array[i][index] #= tmp
array[i][index] = tmp
for r in array:print r print('--one big loop --')
import re #导入模块名
p = re.compile("^[0-9]") #生成要匹配的正则对象 ， ^代表从开头匹配，[0-9]代表匹配0至9的任意一个数字， 所以这里的意思是对传进来的字符串进行匹配，如果这个字符串的开头第一个字符是数字，就代表匹配上了
m = p.match('14534Abc') #按上面生成的正则对象 去匹配 字符串， 如果能匹配成功，这个m就会有值， 否则m为None<br><br>if m: #不为空代表匹配上了
print(m.group()) #m.group()返回匹配上的结果，此处为1，因为匹配上的是1这个字符<br>else:<br> print("doesn't match.")<br> m = re.match("abc","bcdef") #match是从头开始匹配m = re.match("[0-9]","6ab6cdef"m = re.match("[0-9]{0,10}","7565412121545545abc") #以数字为开头，匹配接下来的数字0-10个
if m:
print (m.group())
m = re.findall("[0-9]{1,10}","75654500004548780212ab74c") #匹配所有数字，每个字符串最多10个数字，多余的另外生成一个字符串，中间有字母隔开再另外生成一个字符串
m = re.findall("[a-zA-Z]{0,10}","7565450000dfdsfds02124c")#匹配所有字母，但是有0次，所以会有很多['']
m = re.findall("[a-zA-Z]+","7565450000dfdsfds02124c")#匹配所有字母，+代表至少匹配1次，所以没有了
['']m = re.findall(".*","75654500004548780212ab74c") #匹配所有字符，结果会多一个[''],因为0次也包括
m = re.findall(".+","75654500004548780212ab74c") #匹配所有字符，至少匹配一次，所以最后没有了['']m = re.findall(".+","756-5.4@~5000 04 5487 80212ab74c") #匹配任意非空的字符m = re.search("^\d+$","1356545855") #匹配以数字开头数字结尾，中间如果不过是数字则匹配失败m = re.search("\d+","756-5.4@~5000 04 5487 80212ab74c") #search匹配第一个找到的数字，往后一直匹配到不是字符为止，不连续的数字不匹配后面的数字，需要用print(m.group())m = re.sub("\d+","|","756-5.4@~5000 04 5487 80212ab74c") #把所有的数字转换成|m = re.sub("\d+","|","756-5.4@~5000 04 5487 80212ab74c",count=2) #将前面两段连续的数字替换成|，756和5被替换成|if m:
print(m)
phone_str = "hey my name is alex, and my phone number is 13651054607, please call me if you are pretty!"
phone_str2 = "hey my name is alex, and my phone number is 18651054604, please call me if you are pretty!" m = re.search("(1)([358]\d{9})",phone_str2)
if m:
print(m.group())
ip_addr = "inet 192.168.60.223 netmask 0xffffff00 broadcast 192.168.60.255"
m = re.search("\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}", ip_addr)
print(m.group())contactInfo = 'Doe,John:555-1212' #中间不能有空格，否则匹配不了
match = re.search(r'(\w+), (\w+): (\S+)', contactInfo) #分组
"""
>>> match.group(1)
'Doe'
>>> match.group(2)
'John'
>>> match.group(3)
'555-1212'
"""
match = re.search(r'(?P<last>\w+), (?P<first>\w+): (?P<phone>\S+)', contactInfo)
"""
>>> match.group('last')
'Doe'
>>> match.group('first')
'John'
>>> match.group('phone')
'555-1212'
"""
email = "alex.li@126.com http://www.oldboyedu.com"
m = re.search(r"[0-9.a-z]{0,26}@[0-9.a-z]{0,20}.[0-9a-z]{0,8}", email) #r代表不转义
print(m.group())
相关文章
-
Python学习手册 ：Python 学习笔记第一天
Python学习手册 ：Python 学习笔记第一天
- 互联网
- 2026年04月04日
-
python学习之路 二 ：基本数据类型
python学习之路 二 ：基本数据类型
- 互联网
- 2026年04月04日
-
python学习之路 三：字符编码
python学习之路 三：字符编码
- 互联网
- 2026年04月04日
-
python学习第六天 条件判断和循环
python学习第六天 条件判断和循环
- 互联网
- 2026年04月04日
-
python学习道路(day5note)(列表生成式，生成器，装饰器，常用模块)
python学习道路(day5note)(列表生成式，生成器，装饰器，常用模块)
- 互联网
- 2026年04月04日
-
Python学习笔记—条件判断和循环
Python学习笔记—条件判断和循环
- 互联网
- 2026年04月04日
