python_函数

定义：

　　计算机中函数跟数学中的函数不一样，计算机函数指的是提前组织好的，可重复使用的一段子程序，或者说是一段可执行的代码过程。

 

作用：

　　1、提高代码的模块性，提高代码的重复利用性。

　　2、减少重复代码

　　3、便易扩展（增加或删除功能）

　　4、保持代码的一致性

 

语法：

　　python中用 def 来定义一个函数，格式如下：

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

3 函数名（参数列表）    #调用和执行函数

 

函数名的定义与变量的命名一样：

　　必须是字母或是下滑线开头

　　不能使用其他特殊符号

　　区分大小写

　　不能使用python内部的保留字

实例演示：

def Hello():
    print("hello word!")

Hello()  #函数的调用

 

形参和实参：　

def cal(x,y):  #这个x,y为形参（形式参数）
    print(x+y)

cal(3,8)  #这的参数叫实参（实际的参数）

>>>11

 

　形参是函数定义里的形式参数，实参是函数调用时传入的实际参数，参数的顺序是由严格顺序的。

 

函数的参数：

 　　位置参数：

　　传入的实参跟形参是一一对应的

def print_info(Name,Age):
    print("name:%s"%Name)
    print("age:%d"%Age)


print_info("Adair",18)

 

 　　默认参数：

　　　　若有参数不需要经常变化，可以在形参的位置把该参数指定上

def print_info(Name,Age=18):
    print("name:%s"%Name)
    print("age:%d"%Age)


print_info("Adair")

 

 　　　注：默认参数必须在位置参数后边

　　　若默认参数需要变化时，可以在实参上直接修改，

def print_info(Name,Age=18):
    print("name:%s"%Name)
    print("age:%d"%Age)


print_info("Adair",33)
>>>name:Adair
      age:33   




def print_info(Name,Age=18):
    print("name:%s"%Name)
    print("age:%d"%Age)


print_info("Adair",Age=22)
>>>name:Adair
      age:22 

注：默认参数必须指向不变对象！

　　可变参数：

　　如果在调用参数传入的实参个数不确定，就可以使用可变参数。可变参数用一个 （ * ）星号表示。

　　可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。

def Adder(*n):
    sum=0
    for i in n:
        sum = sum + i
    print(sum)

Adder(1,2,3,4,5,6)

>>>21

 

def Adder(*n):
    sum=0
    for i in n:
        sum = sum + i
    print(sum)

num=[1,2,3,4,5,6]
Adder(*num)

>>>21

 

一个（ * ）星号，可以把列表和元组的元素当成可变参数当作实参传到函数中　　

　　关键字参数：

　　关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。

def registered(name,age,**kw):
    print("name:",name)
    print("age:",age)
    print("hobby:",kw)

registered("Adair",12,outdoor="basketball",indoor="swimming")

>>>name: Adair
      　 age: 12
         hobby: {'outdoor': 'basketball', 'indoor': 'swimming'} 

 

def registered(name,age,**kw):
    print("name:",name)
    print("age:",age)
    for i in kw:
        print("%s:%s" %(i,kw[i]))

registered("Adair",12,outdoor="basketball",indoor="swimming")

>>>name: Adair
    age: 12
    outdoor:basketball
    indoor:swimming

 

　　参数的组合：

　　　　参数定义的顺序必须是：位置参数、默认参数、可变参数、命名关键字参数和关键字参数。

def registered(name,age,*w,gender="M",**kw):
    print("name:",name)
    print("age:",age)
    print("gender:",gender)
    print("hobby:",w)
    for i in kw:
        print("%s:%s" %(i,kw[i]))

registered("Adair",12,"basketball","swimming",Nativeplace="北京",property="One hundred million")

>>>name: Adair
    age: 12
    gender: M
    hobby: ('basketball', 'swimming')
    Nativeplace:北京
    property:One hundred million

 

函数的返回值(return):

　　return语句是python函数的一个返回值，每个函数中都应该有一个返回值，若没写python会自动返回一个None

　　当函数运行过程中与到return函数就会退出并返回值，也可以理解为return语句代表这函数的结束

　　return多个对象的时候，python会将其封装成一个元组进行返回　　

def Ret():
    print("asd")
    return 1

print(Ret())

 

函数的作用域：

 python中的作用域分为4层：

　　local：局部作用域，即函数中定义的作用域。

　　enclosing：嵌套的父级函数的局部作用域，即包含此函数的上级函数的局部作用域，但不是全局的；

　　globa，全局作用域，就是模块级别定义的变量；

　　built-in，系统固定模块里面的变量，比如int, bytearray等。

搜索变量的优先级顺序依次是：作用域局部>外层作用域>当前模块中的全局>python内置作用域，也就是LEGB。

python中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，像if、try、for这些是不存在作用域的

num = int(23.4) #built-in 内置作用域
name="Adair."   #glocal 全局作用域
def scope():
    scope="test"    #enclosing 外层作用域
    def x_scope():
        x_scope="Test" #local 作用域局部

函数内部可以读取函数外部的变量，但不能直接修改，想要在函数内部修改外部变量时需要使用glocal关键字先声明一下。

num = 111
def scope_test():
    print(num)

scope_test()
>>>111


num = 111
def scope_test():
    global num
    num+=222
    print(num)

scope_test()

global关键字声明的变量必须在全局作用域上，不能嵌套作用域上，当要修改嵌套作用域（enclosing作用域，外层非全局作用域）中的变量怎么办呢，这时就需要nonlocal关键字了

def scope_test():
    global num
    a=222
    print(a)
    def x_scope():
        nonlocal a
        a+=333
        print(a)
    x_scope()
scope_test()
11 >>>222
　　　 555

 

 高阶函数：

把函数作为参数传入，这样的函数称为高阶函数。

def foo(n):
    return n

def add(a,b,f):
    return f(a)+f(b)

print(add(2,3,foo)

1、函数名可以进行赋值

2、函数名可以作为函数的参数，也可以作为函数的返回值

 

递归函数：

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

举个例子，我们来计算阶乘n! = 1 x 2 x 3 x ... x n，用函数fact(n)表示

def fact(n):
    if n==1:
        return 1
    return n * fact(n - 1)

递归函数特性：

1. 必须有一个明确的结束条件；
2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少
3. 相邻两次重复之间有紧密的联系，前一次要为后一次做准备（通常前一次的输出就作为后一次的输入）。
4. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）