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)
结果输出：
