Python 函数章节笔记

函数基础关键字

#函数的基础定义格式
"""
def 函数名():
    函数体...
其中def属于函数的声明关键字,而python里面的函数体用空格来区分
""" 

#函数的返回值关键字
"""
def 函数名():
    函数体...
    return 值/对象;
如果一个函数中不存在return,则默认返回None
"""

#函数的生成器关键字
"""
def 函数名():
    函数体...
    yield 返回值/对象;
一个函数里可以同时存在多个yield,具体在后续生成器章节细讲
"""

函数的参数

#普通参数
#定义了一个基础函数,包含普通参数value
def func(value):
    #输入value的内容
    print(value);
#调用这个函数并往内部传递参数"hello word"
func("hello word");#输出结果:hell oword


#默认参数
#定义了一个基础函数,存在一个默认参数value,默认值为10
def func(value=10)
    print(value);
func();#输出结果10
func(20);#输出结果20

#默认参数常见误区
#定义了一个基础函数,存在一个默认列表参数以及普通参数value
def func(value,temp_list=[1,2,3]):
    #在列表的最后将value值添加进来
    temp_list.append(value)
    #输出temp_list
    print(temp_list);

func(4);#输出结果[1,2,3,4]
func(5);#输出结果[1,2,3,4,5]
func(6);#输出结果[1,2,3,4,5,6]

func(4,[1,2,3]);#输出结果[1,2,3,4]
func(5,[1,2,3]);#输出结果[1,2,3,5]
func(6,[1,2,3]);#输出结果[1,2,3,6]
"""
导致这种情况的原因为:若函数存在默认参数为可变类型(list/set/dict等),
则会维护这个默认参数的内存引用,函数在被调用时,所用的默认参数地址相同
"""

#动态参数
#定义了两个动态参数
"""
*号为标识符
*args为接收值类型的动态参数,参数类型为tuple
**kwargs为接收键值对类型的动态参数,参数类型为dirc
若标识了动态参数,则这个参数可以同时接受多个参数,最终以标识类型存放
"""
def func(*args,**kwargs):
    print("""*args为{}类型为{},**kwargs为{},类型为{}""".format(args,type(args),kwargs),type(kwargs));
func(1,2,3,a=1,b=2,c=3);#输出结果:*args为(1, 2, 3)类型为<class 'tuple'>,**kwargs为{'a': 1, 'b': 2, 'c': 3},类型为<class 'dict'>

func([1,2,3],[4,5,6],[7,8,9],{"a":1,"b":2,"c":3});
#输出结果:*args为([1, 2, 3], [4, 5, 6], [7, 8, 9], {'a': 1, 'b': 2, 'c': 3})类型为<class 'tuple'>,**kwargs为{},类型为<class 'dict'>

作用域(闭包思想)

#有点抽象,简洁理解就是:将外部函数定义数据,内部函数调用数据,外部函数返回内部函数,外部函数释放时,数据与内部函数绑定在一起
#定义一个外部函数
def outerFunc(value):
    #定义一个内部函数
    def innerFunc():
        print(value);
    #返回内部函数的引用 
    return innerFunc;
temp=outerFunc("hello word");#输出结果:hello word
#在上述代码中,outerFunc作为外部函数返回了内部函数innerFunc的引用,此时temp=innerFunc;
#此时,若外部函数outerFunc执行完毕之后,将会释放自身的空间,但是其中的元素Value由于内部函数innerFunc会调用
#所以,Value函数并没有被释放,而是继续与innerFunc绑定在一起

装饰器

#装饰器 通过闭包思想完成
#外部outerFunc函数
def outerFunc(func):
    #内部innerFunc函数
    def innerFunc():
        #返回值为传进来的func函数的返回值
        return func();
    #返回值为内部函数
    return innerFunc;

#声明一个func函数,内部输出hello word
def func():
    print("hello word");

#将func函数的地址传递给outerFunc,然后outerFunc返回了内部函数innerFunc的引用,此时func=innerFunc
#由于innerFunc会用到外函数里的func引用(也就是原Func)
#则在outerFunc执行完后,不会释放func的引用,而是与innerFunc绑定在一起
func=outer(func);

#此时调用的是innerFunc函数,但是由于innerFunc函数内部调用了原func函数,所以func的输出结果不变
func();

使用@字符实现装饰器

#装饰器 通过@字符实现
def outerFunc(func):
    #内部innerFunc函数
    def innerFunc():
        #返回值为传进来的func函数的返回值
        return func();
    #返回值为内部函数
    return innerFunc;

#声明一个func函数,内部输出hello word
#@outerFunc与func=outer(func)的效果相同,都是将自身函数传递给outerFunc
@outerFunc
def func():
    print("hello word");

#此时调用的是innerFunc函数,但是由于innerFunc函数内部调用了原func函数,所以func的输出结果不变
func();

装饰器小实例

#装饰器 小实例 返回value1+value2的值,在返回不动Func的情况将值加入一个列表

#定义了一个空列表
value_List=list();

def outerFunc(func):
    #内部innerFunc函数
    def innerFunc(value1,value2):
        #声明临时变量retruned_Value变量用于接收原Func的结果
        returned_Value=func(value1,value2);
        #将结果添加进value_List列表
        value_List.append(returned_Value);
        #返回结果
        return returned_Value;
    #返回值为内部函数
    return innerFunc;

#定义Func函数,用于返回两个值想加的结果
@outerFunc
def Func(value1,value2):
    #返回两个数相加的值
    return value1+value2;

print(Func(1,2));#输出结果:3
print(Func(3,4));#输出结果:7
print(Func(5,6));#输出结果:11
print(value_List);#输出结果:[3, 7, 11]

Lambda表达式与三元运算表达式

Lambda表达式

#Lambda表达式用于定义简单快捷的匿名函数
"""
格式如下
lambda 参数:函数体;
在lambda表达式中,函数体只能存在一条语句,而返回值则是运算结果
"""
func1=lambda *args:print(args);
func2=lambda x,y:x*y;

print(func1(1,2));#输出结果:(1,2),None
print(func2(1,2));#输出结果:2

三元表达式

#三元运算符通常用于做简单的if判断
"""
格式如下
True结果 if 判断条件 else False结果
"""
#若3>2则返回True,反之False
value1= True if 3>2 else False;
#若SC2在我最爱SC2里面则返回最爱SC2反之返回我不爱SC2
value2= "最爱SC2" if "SC2" in "我最喜欢SC2" else "我不爱SC2";
print(value1);#输出结果:True
print(value2);#输出结果:最爱SC2

生成器

#生成器 不好描述 自行看代码
"""
格式如下
def func():
    yield 参数;
我们将这种函数称为生成器函数,一个生成器函数可以存在多个yield关键词与返回值
但是如果中途有return,则会直接结束函数的执行
如果直接执行生成器函数,则返回的是一个生成器

如下
def func();
    yield 参数;

temp_func=func();这里就是返回了一个生成器

执行生成器有两种方法
1:next(temp_func);
2:temp_func.send(); send方法可以带参数传递,但是第一次调用只能传递None

如果生成器执行到末尾不存在yield时,则会报错,碰到return也会报错,如果要解决这个问题可以用for
"""
def func():
    yield 1;
    yield 2;
    yield 3;
    return None;
    yield 4;
#先获取生成器
temp = func();
print(next(temp));#输出结果:1
print(next(temp));#输出结果:2
print(next(temp));#输出结果:3
print(next(temp));#输出结果:报错,错误类型StopIteration(停止迭代)

for循环调用生成器(建议)

#采用for循环来调用生成器
def func()
    for temp_i in range(5):
        yield temp_i;

for temp_i in func():
    print(temp_i)
#输出结果:0,1,2,3,4

带参数的生成器

#带参数的生成器函数
def func(temp_List)

    #用于计数的值
    index=0;   
    while True:
        #每次循环index+1
        index+=1;
        #将传进的值添加进temp_List,并获取index作为返回值
        temp_value = yield index;
        temp_List.append(temp_value);
#用于存放值
value_List=list();
#先获取生成器
builderFunc = func(value_List);

print(builderFunc.send(None));#第一调用send只能传递None,输出结果:1
print(builderFunc.send(10));#输出结果:2
print(builderFunc.send(20))#输出结果:3
print(value_List);#输出结果[10,20]

"""
补充:第一次执行生成器时send(None),并没传参进去,而是获取到了值,第二次send(10)的时,才传入值的
"""

推导式

#推导式 用于返回列表,集合,字典,元组
"""
类型左括号  值 for 条件 可选嵌套for 条件 if值选择  类型右括号
"""

列表/集合/字典推导式

#推导式实例

#实例1
value_List1=[i for i in range(3)];
print(value_List1);#输出结果:[0,1,2]

#实例2
value_List2=[[i,i+1] for i in range(3)]
print(value_List2)#输出结果:[[0,1],[1,2],[2,3]];

#实例3
value_List3=[{i:j} for i in range(3) for j in range(2)]
print(value_List3)#输出结果:[{0: 0}, {0: 1}, {1: 0}, {1: 1}, {2: 0}, {2: 1}]

#实例4
value_List4=[(i,j) for i in range(4) for j in range(4) if i>=1 and j >=1 ]
print(value_List4)
#输出结果:[(1, 1), (1, 2), (1, 3), (2, 1), (2, 2), (2, 3), (3, 1), (3, 2), (3, 3)]

#由于列表,集合,字典的推导式大部分都是相似的,所以这边不举例其他类型了

元组推导式

#由于元组的特殊性,使得元组无法动态的添加元素,所以元组的推导式会存在不同

#这里返回的是一个生成器
value_Tuple=(i for i in range(3));
"""
调用方法1:
next(value_Tuple)或send(value_Tuple)依次取值,若生成器终止会报错
调用方法2:
for temp in value_Tuple:利用for循环取值
调用方法3:
tuple(value_Tuple)直接将其转换为元组类型使用
"""

#所以这边建议采用这样的格式
value_Tuple2=tuple(i for i in range(3));
print(value_Tuple2);#输出结果:(0, 1, 2)