Python开发【第5节】【函数基础】

1、函数

　函数的本质就是功能的封装。

　函数的作用

• 提升代码的重复利用率，避免重复开发相同代码
• 提高程序开发效率
• 便于程序维护

2、函数定义

def 函数名(参数):
　　 """
　　 函数文档
　　 """
    函数功能代码...
    函数功能代码...

调用函数:函数名(参数)

形参:声明函数时()中的参数是形参
　　形参只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。
　　形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量。

实参:调用函数时()中的参数是实参，实参可以是常量、变量、表达式、函数等
　　实参在函数调用时，必须有确定的值，以便把这些值传送给形参。

函数文档：

• 函数的作用
• 函数的参数介绍(个数，数据类型)
• 函数的返回值（数据和类型）

3、默认参数

def 函数名(形参=默认值,形参=默认值...):
    函数功能代码...
    函数功能代码...
    ...

调用函数：
    函数名()  # 调用函数时所有形参采用默认值操作
    函数名(实参,实参...) # 调用时形参使用实参的值而抛弃默认值

4、关键参数

def 函数名(形参=默认值,形参=默认值...):
    函数功能代码...
    函数功能代码...
    ...

调用函数：
    函数名(形参=实参,形参=实参...)　　

5、收集参数

5.1、*args参数

def 函数名(*args):
    函数功能代码...
    函数功能代码...
    ...

调用函数：函数名(实参，实参...)   没有数量限制

*args 会把多传入的参数变成一个元组形式

5.2、**kwargs参数

def 函数名(**kwargs):
    函数功能代码...
    函数功能代码...
    ...

调用函数: 函数名(形参=实参,形参=实参...) 没有数量限制
*kwargs会把多传入的参数变成一个dict形式

6、函数返回值

return语句的特征:

• 具有return语句的函数称为具有返回值的函数
• return可以为当前函数执行完毕返回一个结果，这样的函数调用可以被接受
• return执行之后，函数则会终止，所有return之后的语句不会被执行
• 一个函数可以书写多个return语句，但是一般会放入分支结构当中。
• 一个函数如果需要返回多个数据，需要借助复合数据类型（list，tuple，set，dict）来操作
• 不带参数值的return语句返回None。

#!/usr/bin/python3

# 可写函数说明
def sum( arg1, arg2 ):
   # 返回2个参数的和."
   total = arg1 + arg2
   print ("函数内 : ", total)
   return total;

# 调用sum函数
total = sum( 10, 20 );
print ("函数外 : ", total)

7、变量

　全局变量：

在程序的一开始定义的变量称为全局变量，全局变量作用域是整个程序

　局部变量：

在子程序中定义的变量称为局部变量，局部变量作用域是定义该变量的子程序

#!/usr/bin/python3

total = 0; # 这是一个全局变量
# 可写函数说明
def sum( arg1, arg2 ):
    #返回2个参数的和."
    total = arg1 + arg2; # total在这里是局部变量.
    print ("函数内是局部变量 : ", total)
    return total;

#调用sum函数
sum( 10, 20 );
print ("函数外是全局变量 : ", total)

8、匿名函数（lambda）

　　lambda的主体是一个表达式，但可对有限的逻辑完成封装。

　　lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。

res = map(lambda x:x**2,[1,5,7,4,8])
for i in res:
    print(i)

执行结果：
1
25
49
16
64

9、递归函数

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

2.特性：

• 必须有一个明确的结束条件
• 每次进入更深一层递归时，问题规模相比上次递归都应有所减少
• 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

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

calc(10)

输出：
10
5
2
1

二分法查找：

data = [1, 3, 6, 7, 9, 12, 14, 16, 17, 18, 20, 21, 22, 23, 30, 32, 33, 35]
def binary_search(dataset,find_num):
    print(dataset)

    if len(dataset) >1:
        mid = int(len(dataset)/2)
        if dataset[mid] == find_num:  #find it
            print("找到数字",dataset[mid])
        elif dataset[mid] > find_num :# 找的数在mid左面
            print("\033[31;1m找的数在mid[%s]左面\033[0m" % dataset[mid])
            return binary_search(dataset[0:mid], find_num)
        else:# 找的数在mid右面
            print("\033[32;1m找的数在mid[%s]右面\033[0m" % dataset[mid])
            return binary_search(dataset[mid+1:],find_num)
    else:
        if dataset[0] == find_num:  #find it
            print("找到数字啦",dataset[0])
        else:
            print("没的分了,要找的数字[%s]不在列表里" % find_num)

binary_search(data,66)