python语言编程能力
函数默认参数
实例1:
class Test(object):
def process(self,data=[]):
data.sort()
data.append("end")
return data
test1 = Test()
print(test1.process())//不会重新创建
test2 = Test()
print(test2.process())//不会重新创建
test3 = Test()
print(test3.process(data=["23","ew"]))//非空则重新创建
test4 = Test()
print(test4.process())//不会重新创建
结果输出:
等同于在
Test
类第一次声明的时候,创建了Test.process.__defaults__
对象,这个对象在类声明时候创建,创建后指向一个固定的ref
。使用这个类创建对象,不会重新生成这个对象。如果参数是[]
,不会重新创建,如果非空则重新创建,
同时,默认参数不使用的时候不写成None违反编程规范8.1。
实例2:
def exten_list(val, List=[]):
print(f'info:{List},id:{id(List)}')
List.append(val)
return List
list1 = exten_list(10)
list2 = exten_list(20)
list3 = exten_list("a")
list4 = exten_list(14, [3])
list5 = exten_list("b")
print(f'info:{list1},id:{id(list1)}')
print(f'info:{list2},id:{id(list2)}')
print(f'info:{list3},id:{id(list3)}')
print(f'info:{list4},id:{id(list4)}')
结果输出:
函数的参数默认值:只会在函数声明时初始化一次,之后不会再变;注意,函数声明,只有参数个数相同时,才是同一个声明,所以那些传入参数的调用,不是同一个函数声明了;只有缺省第二个参数的,才是同一类调用
装饰器(作用域)
函数装饰器的工作原理如下:
假设用funA()函数装饰器去装饰funB()函数,如下所示:
#funA 作为装饰器函数
def funA(fn):
#...
fn() # 执行传入的fn参数
#...
return '...'
@funA
def funB():
#...
等同于:
def funA(fn):
#...
fn() # 执行传入的fn参数
#...
return '...'
def funB():
#...
funB = funA(funB)
实例0:
#funA 作为装饰器函数
def funA(fn):
print("C语言中文网")
fn() # 执行传入的fn参数
print("http://c.biancheng.net")
return "装饰器函数的返回值"
@funA
def funB()://相当于funB = funA(funB)
print("学习 Python")
结果输出:
实例1:
def outer(f):
def inner(*arg, **kargs):
inner.co += 1
return f(*arg, **kargs)
inner.co = 0
return inner
@outer
def cu():
pass
if __name__ == "__main__":
cu()
cu()
cu()
print(cu.co)
结果输出:
return inner不等于return inner(),返回的是函数名,因此cu已经被inner替代了,最终cu.co=inner.co;万物皆对象,函数也是一个对象,因此函数这个对象本身可以访问属性,而且赋值时可以增加一个属性。不过实际意义不大
实例2:
#coding:gbk
def A(func):
def inner():
inner.i += 1
print("i加1,i={0}".format(inner.i))
inner.i = 0
print("i赋值")
return inner
@A
def B():
pass
@A
def C():
pass
B()//等价于B() = A(B()),执行inner():
B()
B()
C()
C()
print(id(B), id(B.i))
print(id(C), id(C.i))
结果输出:
B和C分别是俩对象,所以有两个id。(先是装饰器执行,有几个装饰器就执行几遍“i赋值”)
多层装饰器
实例1:
def dec_a(function):
print("aaa")//步骤4
def inner_func():
print("bbb")//步骤5
function()
return inner_func
def dec_b(function):
print("ccc") //步骤2
def inner_func():
function()
print("ddd")//步骤7
return inner_func
@dec_a //步骤3
@dec_b //步骤1
def test():
print("wegwrtegw")//步骤6
test()
结果输出:
装饰器
@
等同于函数名从test
变成了dec_a(dec_b(test))
,执行test
等同于执行dec_a
.注意即便不执行test()方法,ccc/aaa还是会打印,因为先执行装饰器,从下向上,所以先打印ccc再打印aaa,说明装饰器是在解释器加载函数的时候就完成的。
实例2:
def A(func):
def _A():
print ("A now")
func()
return _A
def B(func):
def _B():
func()
print ("B now")
return _B
@A
@B
def test1():
print ("do something")
test1()
结果输出:
re.match和re.search
实例1:
import re
result_sum = 0
pattern = 'back'
if re.match(pattern, 'backup.txt'):
result_sum += 1
if re.match(pattern, 'text.txt'):
result_sum += 2
if re.match(pattern, 'backup.txt'):
result_sum += 4
if re.match(pattern, 'backup.txt'):
result_sum += 8
print (result_sum)
结果输出: