Python——函数

一、什么是函数

函数是可被调用的，可重复使用的，用来实现单一，或相关功能的代码段。

函数的作用：

• 减少重复代码，提高应用的模块性
• 保持代码的一致性
• 增删改代码一次搞定，简单粗暴，更易扩展　　

一、创建函数

1、定义一个函数的规则

• 函数代码块以def关键字开头，后接函数标识符名称和()
• 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数
• 函数的第一行语句可以选择性地使用文档字符串——用于存放函数说明
• 函数内容以冒号起始，并且缩进
• return[表达式]结束函数，选择性返回一个值给调用方。如果没有return，则相当于返回None

语法：

def 函数名 （参数列表）
    函数体

2、形参和实参

 形参：虚拟变量，在定义函数和函数体的时候使用形参。目的是在函数调用时接收实参，实参个数、类型要与形参一一对应。

 实参：调用函数时传给函数的参数。可以是常量、变量、表达式、函数。

形参不占用内存空间，形参变量只有在被调用时才分配内存单元。

import time
def action1(n):
    print('Start action 1.')
    logger(n)
def action2(n):
    print('Start action 2.')
    logger(n)
def action3(n):
    print('Start action 3.')
    logger(n)
def logger(n):
    time_format = '%Y-%m-%d %X'
    time_current = time.strftime(time_format)
    with open('日志记录','a') as f:
        f.write("%s End action %s.
"%(time_current,n))
action1(10)
action2(20)
action3(30)

3、函数的参数

• 必需参数
• 关键字参数
• 默认参数
• 不定长参数

1. 无命名参数
2. 有命名参数

 必需参数

必需参数在调用和声明时的数量及顺序必须保持一致。

关键字参数

函数调用时使用关键字参数来确定传入的参数值，按照参数名匹配参数值，使用关键在参数允许含在在调用时参数的顺序与声明时不一致。

默认参数

定义函数时，设定默认参数。当调用函数时，缺省参数如果没有值传入，则使用默认参数设定的值。

def print_info(name,age,sex='male'):
 
    print('Name:%s'%name)
    print('age:%s'%age)
    print('Sex:%s'%sex)
    return
 
print_info('alex',18)
print_info('铁锤',40,'female')

不定长参数

例1：

def add(*args):
    print('args:',args)
    sum = 0
    for i in args:
        sum += i
    return sum
print('sum:',add(1,2,3,4,5))

输出：

args: (1, 2, 3, 4, 5)
sum: 15

例2：

def print_info(**kwargs):
    print('kwargs:',kwargs)
    sum = 0
    for i in kwargs:
        print('%s:%s' % (i, kwargs[i]))

print_info(name='oliver',age=20,sex='female')

输出：

kwargs: {'name': 'oliver', 'age': 20, 'sex': 'female'}
name:oliver
age:20
sex:female

*args用元组接收传入的参数，**kwargs用字典接收传入的键值对。

4、return

return的作用：

（1）结束函数

（2）返回某个对象

注意点：

如果不加return，默认返回None。

如果return有个对象，那么会将多个对象封装成一个元组。

遇到return语句，就会停止执行并返回结果。

5、函数的作用域

 L:local,局部作用域

 E:enclosing，函数嵌套作用域

 G:global，全局作用域

 B:built_in，python内置作用域

查找顺序：L→E→G→B

global关键字：

 例：（将local作用域中的变量声明为global作用域）

count = 10
def outer():
    global count    #打印前需先定义count的作用域
    print(count)  #local variable 'count' referenced before assignment
    count = 100
    print(count)
outer()

nonlocal关键字：

例：（将local作用域中的变量声明为enclosing作用域）

def outer():
    count = 10
    def inner():
        nonlocal count  #先声明为enclosing作用域
        count = 20
        print(count)
    inner()
    print(count)
outer()

在局部作用域，不能修改全局作用域的变量。

在Python中，只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，其它的代码块（如if、try、for等）是不会引入新的作用域的

6、高阶函数

将函数名作为实参传给另一个函数使用。

def f(n):
    return n*n
def foo(a,b,func):
    return func(a)+func(b)
print(foo(1,2,f))

输出: 5

函数不仅可以赋值，也可以作为函数的参数，还可以作为函数的返回值。

7、递归函数

 用递归函数实现打印斐波那契数列：0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181

前两项分别为：0和1，从第三项开始每一项是前两项之和，因此可得：f(n) = f(n-1) + f(n-2)

def fibo(n):
    if n <= 2:
        return n - 1
    return fibo(n-1)+fibo(n-2)

print(fibo(8))

输出： 13

递归函数特性：

• 调用自身函数
• 有一个结束条件

需要注意的是，凡是能用递归解决的问题，通过循环都可以解决，并且递归的效率比较低，一般只能递归998次，超出会报错。

8、内置函数

 eval()

eval()函数不仅可以将字符串转换为字典，还可以作为计算机使用。

print(eval('1+3/8*9'))

输出： 4.375

下面是几个非常重要的内置函数：

filter(function, sequence)

str = ['a', 'b', 'c', 'd']
def fun1(s):
    if s != 'a':
        return s
ret = filter(fun1, str)
print(list(ret))  # ret是一个迭代器对象

输出： ['b', 'c', 'd']

map(function, sequence)

str = ['hello', 'a', 'b']
def fun2(s):
    return s + "alvin"
ret = map(fun2, str)
print(ret)  # map object的迭代器
print(list(ret))

输出：

<map object at 0x7f382ca0aba8>
['helloalvin', 'aalvin', 'balvin']

reduce(function, sequence, starting_value)

from functools import reduce
def add1(x, y):
    return x + y
print(reduce(add1, range(1, 101)))  ## 4950 （注：1+2+...+99）

print(reduce(add1, range(1, 101), 20))  ## 4970 （注：1+2+...+99+20）

输出：

5050
5070

lambda

def add(a,b):
    return a + b
 
print add(2,3)
 
  
#匿名函数
add = lambda a,b : a + b
print add(2,3)