三、python函数详解

函数的定义：

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段.

定义规则：

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

# 定义函数
def func( str ):
   "打印任何传入的字符串"
   print(str)
   return

# 调用函数
func("我要调用用户自定义函数!")
func("再次调用同一函数")

参数

1）必选参数（位置参数），即函数调用时必须要传的参数

def func(a,b):
    c = a + b
    return c
print(func(12,10))

2）默认参数（关键字参数）

def func(a,b=100):
    c = a + b
    return c
print(func(12))
print(func(12,24))

3)不定长参数（可变参数）

# *args表示任何多个无名参数，在函数内部参数args接收的是一个tuple；

def func(*args):
    result= list(args)
    return result
a = func(1,2,3)
print(a)

def func(*args):
    sum = 0
    for n in args:
        sum = sum + n*n
    return sum

a = func(1,2,5,3)
print(a)

# **kwargs表示关键字参数，它是一个dict。并且同时使用*args和**kwargs时，必须*args参数列要在**kwargs前
def func(**kwargs):
    for key in kwargs:
        print ("{}:{}" .format(key,kwargs[key]) )

func(myarg1="two", myarg2=3) 

函数的返回值

解释：程序中函数完成一件事情后将结果返回给调用者。

带返回值的函数

想要在函数中把结果返回给调用者，需要在函数中使用return

def func(a,b):
    c = a+b
    return c

result = func(2,4)
print(result)

一个返回值可以返回多个数据

# 返回多个值的时候默认返回一个元祖，但是可以自己修改
def func(a,b):
    c = a // b   #商
    d = a % b    #余
    return c,d

result = func(45,2)
print(result)

def func(a,b):
    c = a // b
    d = a % b
    return [c,d]

result = func(45,2)
print(result)

全局变量和局部变量

局部变量

• 定义:在函数内部定义的变量
• 作用范围：只在函数内部起作用，在函数外部不能使用，因为齐作用范围只是在自己函数内部，所以不同的函数何以定义相同名字的局部变量，
• 作用：为了临时保存数据
• 当函数被调用时，局部变量我创建，当函数调用完成后这个变量就不能被使用了。

def fun():
    score = 100
    return score
print(fun())

#修改局部变量
def fun():
    score = 100
    print("修改前变量的值为{}".format(score))
    score = 888
    result = "修改后变量的值为{}".format(score)
    return result
print(fun())

全局变量

• 定义：即能被一个函数使用，也能被其他函数所使用

var = 100

def fun(num):
    return var + num
print(fun(400))

def fun1():
    return var
print(fun1())

在函数中修改全局变量

var = 99  # 定义全局变量
def func():
    global var

    print('修改前全局变量的值为{}'.format(var))
    var = 88
    return '修改后全局变量的值为{}'.format(var)

def func1():
    return "此刻全局变量的值为{}".format(var)

print(func())
print(func1())

装饰器：

在不改变函数的前提下为函数新增加新的功能

import time
def timer(func):
    def warper(*args,**kwargs):
        start = time.time()
        func(*args,**kwargs)
        end = time.time()
        return end-start
    return warper

@timer
def function(a):
    time.sleep(2)
    return [x for x in range(a)]
print(function(10000))

递归函数

• 理解：传递回归
  
  在函数内部可以调用其他的函数，如果一个函数在内部调用了自己本身，这个函数就是递归函数：

递归的特点：

• 必须有一个明确的临界条件，要不就会变成死循环了，最终撑爆系统
• 每次进入更深一层递归时，问题规模相比上次递归都应有所减少
• 递归执行效率不高，递归层次过多会导致栈溢出

# n!=1×2×3×...×n。阶乘亦可以递归方式定义：0!=1，n!=n * (n-1)!。

def func(n):
    if n == 1:   #如果n等于1表示已经递归到最后，返回1，这个就是临界条件。
        return 1
    else:
        return n * func(n -1)  #当没有到达临界条件时，用n乘以对n-1的递归，每次都把n乘进去，但是后面依然使用当下的这个递归函数，会再次调用计算n-1,直到递归结束，也就是将从n到1的数全部递归完。

print(func(4))

# 快速排序算法
def quick_sort(list1):
    if len(list1) <= 1:
        return list1
    else:
        mid_num = list1[0]
        big_nums = [i for i in list1[1:] if i >=mid_num]
        small_nums = [i for i in list1[1:] if i < mid_num]
        result = quick_sort(big_nums) + [mid_num] + quick_sort(small_nums)
        return result

a = [2,4,2,4,6,7,5,19]
print(quick_sort(a))
#结果：[19, 7, 6, 5, 4, 4, 2, 2]

匿名函数

关键字lambda表示匿名函数，冒号前面的n表示函数参数，可以有多个参数。

匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。

有些函数在代码中只用一次，而且函数体比较简单，使用匿名函数可以减少代码量，看起来比较"优雅“

calc = lamdba n : n**n
print(calc(10))
# calc 为函数名
# lamdba 为定义匿名函数关键字，和def类似
# n 为参数
# n**n 为返回值

l = [{'name':'电脑','price':1999},{'name':'电脑','price':2000}]
print(sorted(l,key=lambda dic:dic['price']))  #按价格排序
# 参数说明：
# iterable -- 可迭代对象。
# key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
# reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）