day11-python函数基本操作

1.函数

1.1定义

函数是指将一组语句的集合通过一个名字或者说模块封装起来，要想使用这个函数，只需要调用其函数名称即可。

1.2 特点

• 减少代码的重复性
• 让程序变得可扩展
• 程序容易维护

1.3 语法

def function（）：    # 函数关键字和函数名称
    pass                    # 函数体

function()                 # 函数调用

 

2. 函数参数

2.1 实参和形参

• 形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量
• 实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值

2.2 位置实参

调用函数时，Python必须将函数调用中的每个实参都关联到函数定义中的对应形参，因此最简单快捷的方式是基于实参的顺序。这种关联的方式被称为位置实参。（使用位置实参来调用函数时，位置一定要正确）

def test(animal,name):
    print('我有个' + animal + ',它的名字是' + name.capitalize())

test('Dog','tom')
# 我有个Dog,它的名字是Tom

2.3 关键字参数

关键字参数是传递给函数的 名称-值 对。在实参中就将名称和值关联起来了，从而不用考虑函数调用中的顺序，但是在使用关键字参数时，必须准确的指定函数定义中的形参名称。

PS：关键字参数必须在位置参数之后。

def test(animal,name):
    print('我有个' + animal + ',它的名字是' + name.capitalize())

test(name='tom',animal='Dog')
# 我有个Dog,它的名字是Tom

2.4 默认参数

这个参数在调用时不指定，那就默认；指定了的话，就用指定的值。

def test(animal,name = 'tom'):
    print('我有个' + animal + ',它的名字是' + name.capitalize())

test('Dog')
# 我有个Dog,它的名字是Tom
 
 

def test(animal,name = 'tom'):
    print('我有个' + animal + ',它的名字是' + name.capitalize())

test('Dog','jcak')
# 我有个Dog,它的名字是Jcak

2.5 非固定参数

若你的函数在定义时不确定用户想传入多少个参数，就可以使用非固定参数

def test(name, age, *args):  # *args 会把多传入的参数变成一个元组形式
    print(name, age, args)

test("zxl", 18)
# zxl 18 () #后面这个()就是args,只是因为没传值,所以为空

test("wl", 32, "CN", "Python",'ee')
# wl 32 ('CN', 'Python', 'ee')

还可以有一个**kwargs

def stu(name, age, *args, **kwargs):  # *kwargs 会把多传入的参数变成一个dict形式
    print(name, age, args, kwargs)

stu("Alex", 22)
# Alex 22 () {}#后面这个{}就是kwargs,只是因为没传值,所以为空

stu("Jack", 32, "CN", "Python", sex="Male", province="ShanDong")
# Jack 32 ('CN', 'Python') {'province': 'ShanDong', 'sex': 'Male'}

 

3.全局与局部变量

• 在子程序中定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量。
• 全局变量作用域是整个程序，局部变量作用域是定义该变量的子程序。
• 当全局变量与局部变量同名时：在定义局部变量的子程序内，局部变量起作用；在其它地方全局变量起作用。

3.1 示例

a = 11
def test():
    a = 10
    print('函数体内:',a)

print('函数体外（调用函数之前）:',a)
# 函数体外（调用函数之前）: 11

test()
#函数体内: 10

print('函数体外（调用函数之后）:',a)
#函数体外（调用函数之后）: 11

3.2 global函数

global的作用是在函数体内创建修改全局变量

a = 11
def test():
    global a
    a = 10
    print('函数体内:',a)

print('函数体外（调用函数之前）:',a)
# 函数体外（调用函数之前）: 11

test()
#函数体内: 10

print('函数体外（调用函数之后）:',a)
#函数体外（调用函数之后）: 10

 

4. 返回值

要想获取函数的执行结果，就可以用return语句把结果返回，但是要注意:

• 函数在执行过程中只要遇到return语句，就会停止执行并返回结果，so 也可以理解为 return 语句代表着函数的结束
• 如果未在函数中指定return,那这个函数的返回值为None 

 

5.递归

如果一个函数在内部调用自身本身，这个函数就是递归函数。

递归特性:

1. 必须有一个明确的结束条件

2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少

3. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

def test(n):
    print(n)
    if int(n / 2) == 0:
        return n
    test(int(n / 2))

test(20)
# 20 10 5 2 1

 

6.匿名函数

匿名函数就是不需要显式的指定函数名称，本身无甚大用，但是配合其他函数使用时确实神器。。。

num = lambda w:2**w
print(num(10))

6.1 和map函数一起使用

map函数的作用是会对一个序列对象中的每一个元素进行相关操作，并且返回一个包含所有结果的map序列。

res = map(lambda x:x*2,[1,5,7,4,8])
print(type(res)) # <class 'map'>
for i in res:
    print(i)

# 2 10 14 8 16

6.2 filter函数

filter函数的作用是根据条件从序列中过滤出一些元素。

# 过滤出大于2的元素
res = filter(lambda x:x > 2,[1,5,7,4,8])
print(type(res)) # <class 'filter'>
for i in res:
    print(i)

# 5 7 4 8

6.3 reduce函数

reduce函数返回计算结果。为int类型。

from functools import reduce

res = reduce(lambda x,y:x + y,list(range(1,10)))
print(type(res),res) # <class 'int'>
for i in res:
    print(i)

# <class 'int'> 45

 

7.高阶函数

变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。

def add(x, y, f):
    return f(x) + f(y)

def foo(x):
    return x

res1 = add(3, -6, foo)
res2 = add(3, -6, abs)
print(res1,res2)
# -3 9