【10】函数

1.什么是函数

函数就是对实现某一特定功能的代码段的封装

2.函数的分类

• 内置函数(系统函数): python已经实现的函数，程序员直接用，例如: print()、input()、max()、len()等。相当于系统造好的机器
• 自定义函数: 程序员自己定的函数，相当于自己造机器

3.函数的定义(声明) - 造机器

1)语法:

def 函数名(参数列表):
    函数体   

2)说明:

def

声明函数的关键字，固定写法

函数名

• 要求: 标识符、不能是关键字
• 规范: 见名知义(看到函数名大概知道函数的功能)、所有字母都小写，多个单词用_隔开、不能和系统的函数名类名重名

()

固定写法

参数列表

• 形参1,形参2,形参3,... --> 变量名1,变量名2,变量名3,... ; 这儿的参数叫形参，形参可以没有也可以有多个。
• 形参的功能是将函数外面的数据传递到函数里面
  : - 固定写法

函数体

• 和def保持一个缩进的代码段；
• 函数体分为函数说明文档和实现函数功能的代码段两个部分

注意：函数体在函数声明的时候不会执行, 调用函数的时候才会执行函数体(重要！)

4. 函数调用 -- 使用机器

1)语法：

函数名（参数列表/实参列表）

2）说明

• 函数名 - 函数名对应的函数必须是已经声明的函数
• （） - 固定写法
• 参数列表 - 这儿的参数叫实参; 实参是用来给形参赋值的

4.2函数调用过程（重要！！！！）

函数在声明的时候不执行函数体，调用函数的时候才会执行函数体。

调用过程：

1）先回到函数声明的位置
2）用实参给形参赋值（参数传递）
3）执行函数体
4）执行完函数体，确定返回值

• 执行过程中遇到return，函数返回值为return后面的值
• 执行完函数，未遇到return，返回值为None

5）回到函数调用的位置，往后执行。

• 此时函数调用表达式的值才是函数的返回值

5.函数的参数

1)根据实参的写法将参数分为位置参数和关键字参数

- 位置参数（必备参数）

调用函数的时候，实参的数量和位置与形参保持一致

- 关键字参数

实参列表以‘形参名1=值1，形参名2=值2 ...’的方式调用函数，形参的顺序可与声明时形参顺序不同

def func1（a, b, c）:
    print(a, b, c)

#位置参数
func1(10, 20, 30)
#关键字参数
func1(c=30, a=10, b=20)

注意：位置参数和关键字参数可混合使用但是使用的时候一定要保证位置参数在关键字参数前面

func1(10, c=30, b=20)

2）参数默认值

• 声明函数的时候，函数的形参可以设置默认值。调用的时候若未给默认参数赋值，则会被认为默认值。
• 给参数设置默认值，同时为参数添加了数据类型；此方法等同于（形参名：类型）

注意：默认参数得放在没有默认值的形参后面

  def func2(a, b=30, c=20):
      print(a, b, c)


  func2(50, 10)     #50 10 20  调用最后一位默认参数
  func2(a=50, c=10)      #50 30 10   
  #当我们传参的时候想跳过某个或某几个默认参数直接给后面的默认参数赋值时，需幺用关键字参数来给后面赋值。

3）不定长参数

- a.声明函数的时候，在形参前加一个*，可以将这个形参变成元祖，然后同时接受多个位置参数的值

def func5(a, *num):
    print(num, a)


func5(1, 5, 6)            # (5, 6) 1

若形参中同时出现不定长与定长参数，尽量把不定长参数放在最后，若不定长参数放中间时，后面的定长参数需改成关键字参数或默认参数

  def func5(a, *num, b=100):
      print(num, a, b)


  func5(1, 5, 6)   # (5, 6) 1 100

b.声明函数的时候，在形参前加**，可将这个形参变成字典，然后同时接受多个关键字参数的值

def func6(**num):
    print(num)


func6(a=1, b=2, c=5)    #{'a': 1, 'b': 2, 'c': 5}

def func6(a, **num):
    print(a, num)


func6(a=1, b=2, c=5)          # 1 {'b': 2, 'c': 5}

c.注意：原则上一个函数的参数，既可以有定长，也可以有带一个的不定长和带两个 ** 的不定长；但是两个需要放在一个后面（关键字参数放在位置参数后面）

def func7(*args, **kwargs):
    print(args, kwargs)

func7(1, 2, 3, 4, a=3, b=2, c=5)  #(1, 2, 3, 4) {'a': 3, 'b': 2, 'c': 5}

练习：写一个函数求多个数的和，要求调用函数的时候既可以位置参数传参，也可以用关键字参数传参

4）参数类型说明

• 给参数设置默认值，默认是什么类型，参数就是什么类型
• 以‘参数名：类型名’的方式说明参数类型

def func3(nums: list, a: int, b=0):
    nums.append('abd')
    print(a+b, nums)


func3([], 10, 0)            # 10 ['abd']

练习：写一个函数，函数的功能是统计一个列表中指定元素的个数（类似count（）方法的功能）

def func4(list1:list, item):
    count = 0
    for item1 in list1:
        if item1 == item:
            count += 1
    print(count)


func4([10, 5, 6, 8, 10, 9, 6, 10], 10)   # 10

6.函数的返回值

1）什么是返回值

• 作用：将函数体重产生的数据传递到函数外面
• 返回值：函数调用表达式的值，即return关键字后面的值

- 注意：

a.函数调用表达式

• 调用函数的语句；
• 他的结果就是这个函数的返回值；
• 通过函数调用表达式获取函数的返回值。

b.return关键字

• return只能出现在函数体中；

• 当执行函数体的时候遇到return，函数直接结束；并且会返回return后面的值

• 如果函数体中没有return，则函数体自然死亡，返回-None-

def func10(n):
    print(n)

print(func10(10))  #  10 None

def func10(n):
    print(n)
    return n

print(func10(10))   # 10  10

2）什么时候需要返回值

初学者建议：只要实现函数产生了新的数据，就可以把这个数据用返回值返回

#python中一个函数可以返回一个或多个返回值
#
def func2():
    return 2, 20

x,y = func2()
print(x,y)        # 2,20

z = func2()
print(z)          # (2, 20)

7 . 匿名函数

• 没有函数名的函数就是匿名函数

1）语法

lambda 形参列表：返回值

- lambda

关键字、固定写法

- 形参列表

和普通函数的形参列表一样。（参数相关的语法中，除了 '形参：类型' 不适用，其他语法均可）

- ：

固定写法

- 返回值

相当于普通函数中return后面的语句

lambda n1, n2: n1 +n2

注意：匿名函数只能实现一行代码的函数体

2）调用

函数（实参列表）

函数不一定是函数名，可以使通过任何方式获得的类型为function的值

注意：python中声明函数，可以看做声明类型为function的变量；匿名函数可以看成是function类型的数据。

变量名 = lambda 参数列表：返回值
变量名（）

a = (lambda n1, n2: n1 +n2)
a(1, 2)

7.函数作为变量（重要！！！！）

1）

python中声明函数其实就是在声明一个类型是function的变量，函数名就是变量名。

#声明一个函数func1，有一个参数一个返回值；
#func1是类型是function的变量，它里面存的数据是一个函数，函数名为func1，有一个参数n
def func1(n):
    return n*n


a = 100

print(a, type(a), a//2)
print(func1, type(func1), func1(10))

#  100 <class 'int'> 50
 # <function func1 at 0x000001DA4F5C1EA0> <class 'function'> 100

2） 普通变量能做的函数都能做

a.用一个变量给另一个变量赋值

def fun2(n):
    return n*3

a1 = fun2
print(a1(22))        # 66

b.变量可以作为列表/元祖的元素、作为列表的值等

def fun3(n):
    return  n*2


dict1 = {'a': fun3, 'b': list1}
dict1['b'].append(100)
print(dict1)
print(dict1['a'](9))

c.变量作为函数的实参

#将函数作为实参传递给另一个函数（实参高阶函数、闭包）
def fun4(a):
    a('abc')

fun4(print)

应用：sort方法的高级使用

• 列表- sort（key)
• key 需要传一个类型是function的值（函数），要求这个函数有一个参数和一个返回值
• 参数指向的是列表中的每个元素，返回值事排序的时候的比较对象

num = ['19', '90', '50', '5']
num.sort(key=lambda x:int(x))
print(num)


students = [
    {'name':'xiaoming', 'age':23, 'score':90},
    {'name':'huahua', 'age':30, 'score':70},
    {'name':'zhangsan', 'age':19, 'score':100}
]

students.sort(key=lambda items:items['age'])
print(students)
students.sort(key=lambda items:items['score'])
print(students)
students.sort(key=lambda items:items['name'][-1])
print(students)

# max  函数 
print(max(students, key=lambda x:x['score']))

d.变量作为函数的返回值

list3 = []

for i in range(5):
     list3.append(lambda x:x*i)

list3[3](3)
list3[0](3)
list3[2](3)

8.变量的作用域

1）全局变量和局部变量

a. 全局变量：

• python中除了在函数或者类中声明的变量，都是全局变量。
• 全局变量的作用域是从声明开始到文件结束的任何位置。

b.局部变量：

• 在函数中声明的变量就是局部变量。
• 从声明开始到函数结束都可以使用。

注意：不能在函数中直接修改一个全局变量的值，而是重新声明一个新的局部变量。

2）global 和 nonlocal

global

想要在一个函数中去修改一个全局变量的值，或者想要在函数中声明一个全局变量

global 变量名
变量名 = 值

nonlocal

想要在局部的局部中修改一个局部变量的值

nonlocal 变量名
变量名 = 值

9. 函数的调用过程：

函数调用过程又叫压栈的过程：
每次调用函数，系统都会在内存的栈区间自动开辟一个临时的内存空间，用来保存在函数中声明的局部变量（其中形参也是保存在这个区域中），当函数调用结束，这个内存区域会自动销毁（）