DAY10 函数基础

DAY10 函数基础

一. 函数的作用

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

• 函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

二. 函数的定义

2.1 函数的概念（什么是函数） - 机器

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

  （函数就是把实现某一特定功能的代码打成一个包，以后再需要这段代码对应的功能的时候不需要再写这段代码，而是直接调用封装这段代码）

2.2 函数分类（根据函数是谁创建的）

1. 系统函数（别人造好的机器） - python自带的函数
2. 自定义函数（自己造的机器） - 由程序员自己创造的函数

2.3 定义函数/创建函数 - 造机器

• 语法：
  def 函数名(形参列表):
  函数说明文档
  函数体

• 说明：
  def - 关键字：固定写法
  函数名 - 由程序员自己命名，但是必须符合命名要求和规范
  要求：是标识符；不是关键字
  规范：见名知义（看到函数名大概知道这个函数对应的功能）；
  字母都小写，多个单词用下划线隔开；
  不能使用系统的函数名，类名，模块名

• (): - 固定写法
  形参列表 - 以’变量名1, 变量名2， 变量名3,…'的形式存在，这里的变量名可以有也可以没有

  • 形参的作用：将函数外部的数据传递到函数里面
  • 怎么确定形参：看实现函数的功能需不需要额外的数据，需要几个（在函数体中就把形参当成对应的数据来使用）

• 函数说明文档 - 本质就是一个多行注释，用来描述函数的功能和使用方法

• 函数体 - 结构上：和def保持一个缩进的一条或者多条语句（至少一条）
  逻辑上：函数体就是实现函数功能的代码

# 定义一个函数求任意两个数的和
def sum2(num1, num2):
    """
    求两数的和（函数功能说明)
    :param num1: 第一个数(参数说明)
    :param num2: 第二个数
    :return: None（返回值说明）
    """
    print(num1 + num2)


# 练习1：定义一个函数统计指定字符串中中文的个数
def count(str1):
    """
    统计指定字符串中中文的个数
    :param str1:指定字符串
    :return:统计指定指定字符串中中文的个数
    """
    count_num = 0
    for x in str1:
        if '\u4e00' <= x <= '\u9fa5':
            count_num += 1
    # return count_num
    print(count_num)

# 练习2：定义一个函数，将指定的数据插入到指定列表的最前面
def insert_list(num, list1):  # 列表形参实参指向同一块内存，函数结束不会销毁
    """
    将指定的数据插入到指定列表的最前面
    :param num: 指定的数据
    :param list1: 指定列表
    :return: 插入后的列表
    """
    list1.insert(0, num)
    # return list1
    print(list1)

# 练习3：定义一个函数，任意一个整数的阶乘
def factorial(num):
    """
    任意一个整数的阶乘
    :param num: 需要求阶乘的整数
    :return: 整数的阶乘
    """
    factorial_num = 1
    for x in range(1, num+1):
        factorial_num *= x
    # return factorial_num
    print(factorial_num)

# 练习4：定义一个函数，求任意一个圆的面积
def area(r):
    """
    求任意一个圆的面积
    :param r: 圆的半径
    :return: 圆的面积
    """
    # return 3.14 * r * r
    print(3.14 * r * r)

2.4 函数的调用 - 使用机器

1. 定义函数不会执行函数体,调用函数才会执行函数体

2. 怎么调用函数

• 语法：函数名(实参列表)

• 说明：
  a.函数名 - 需要哪个函数的功能就调用那个函数，就写哪个函数的函数名
  （注意：函数名必须是已经定义好的函数的函数名）
  b.() - 固定写法
  c.实参列表 - 以’数据1, 数据2, 数据3,…'的形式存在
  实参就是通过形参从函数外部传递到函数内部具体的数据(实参是用来给形参赋值)

sum2(23, 50)

str1 = 'hello world!你好，世界！'
count(str1)

3. 函数调用过程

当代码指向到函数调用语句的时候：

第一步：先回到函数定义的地方

第二步：传参（用实参给形参赋值）

第三步：执行函数体

第四步：确定函数返回值

第五步：回到函数调用位置接着往后执行

三. 函数的返回值

3.1 返回值

• 返回值就是从函数内部传递到函数外部的数据

1. 怎么确定函数返回值（怎么将指定的数据作为返回值返回）
   看执行函数体的时候有没有遇到return,如果遇到return,return后面的值就是函数的返回值；如果没有遇到return,返回值是None

2. 怎么获取函数返回值
   获取函数调用表达式的值就是获取函数函数的返回值。
   函数调用表达式：调用函数的语句

3. 什么时候需要返回值
   如果实现函数的功能产生了新的数据，我们就应该将新的数据返回

• 原因：每次调用函数的时候，系统会自动为这个函数创建一个临时的栈区域，用来保存在函数中产生的数据（形参也是保存在这里）

  当函数调用结束的时候系统会自动释放这块内存（内存中的数据会被删除），只有返回值不会直接删除

def func4():
    return 100, 200   # 返回一个元组，函数只能返回一个数据，可以是一个容器，包含多个元素


def func5() -> str:    # ->str 返回值类型说明
    return 'abc'


a = func5()
print('abc'[-1], func5()[-1], a[-1])     # c c c

3.2 return

return 在函数中有两个作用：

1. 返回返回值 - 谁在return的后面，谁就是返回值
2. 提前结束函数 - 执行函数体的时候如果return，函数直接结束

四. 函数的参数

4.1 位置参数和关键字参数 - 根据实参传递方式分类

1. 位置参数：以’实参1, 实参2, 实参3,…'的形式存在，通过位置一一对应的方式来给形参赋值
2. 关键字参数：以’形参1 = 实参1, 形参2 = 实参2,…'的形式存在，直接用=来确定实参和形参的对应关系

注意：位置参数和关键字参数可以混用，混用的时候位置参数必须在关键字参数的前面

def func1(x, y, z):
    print(f'x:{x}, y:{y}, z:{z}')

func1(10, 20, 30)  # x:10, y:20, z:30
func1(20, 10, 30)   # # x:20, y:10, z:30

func1(x=10, y=20, z=30)   # x:10, y:20, z:30
func1(y=20,x=10,  z=30)   # x:10, y:20, z:30

func1(10, y=20, z=30)   # x:10, y:20, z:30
func1(10, z=30, y=20)   # x:10, y:20, z:30

# func1(x=10, 20, 30)   位置参数要在关键字参数前面

4.2 参数默认值 - 形参

• 定义函数的时候，可以通过’形参名 = 值’的方式给参数赋默认值；如果一个形参有默认值，那么在调用的时候这个形参可以不用赋值
• 注意：定义函数的时候，如果有的参数有默认值有的参数没有，那么没有默认值的参数必须在有默认值参宿和的前面

def func2(x=10, y=20, z=30):
    print(f'x:{x}, y:{y}, z:{z}')


func2(10, 20)    # x:10, y:20, z:30
func2(10, 20, 40)  # x:10, y:20, z:40 覆盖默认值
func2(y=50, z=40)  # x:10, y:50, z:40 x用默认值，y,z赋值

4.3 参数类型说明 - 定义函数的时候指定参数的类型

参数类型说明可以提示使用者在调用的时候该传什么数据；又可以让参数在函数体中有代码提示

1. 方法1-没有默认值的参数：形参:类型名
2. 方法2：给参数赋默认值，默认值的类型就是参数的类型

# 补充：变量类型说明
dict1 = {'a': 10, 'b': 'abc', 'c':[10, 20]}
key = input()  # c
x = dict[key]   # type:list
x.count()   # 可以有代码提示

4.4 不定长参数 - 解决参数个数不确定的问题

1. 带*的不定长参数
   定义函数的时候，如果在某个形参前面加*，那么这个参数就变成了一个不定长参数，调用的时候这个形参可以接受若干个实参

• 本质：如果形参有*，那么这个参数就会自动变成一个元组，它接收到所有的实参会作为这个元组的元素

• 注意：a.带*的不定长参数在传参的时候只能使用位置参数
  b.定长参数和带*的不定长参数混用的时候，*前的定长参数必须用位置参数传参，*后的定长参数必须用关键字参数传参

2. 带**的不定长参数
   本质：如果形参前有**，那么这个参数就会自动变成一个字典，它接受到的所有的实参会作为这个字典的键值对
   注意：传参的时候只能用关键字参数

def func5(*num):   # 参数可以是0，1，2，...
    print(f'num:{num}')


func5()   # num:()
func5(10)   # num:(10,)
func5(20, 30, 43, 45)   # num:(20, 30, 43, 45)


# 练习：定义一个函数，求多个数的和
def sum1(*num):
    s = 0
    for x in num:
        s += x
    return s


print(sum1(10, 20, 30))   # 60


def func3(x, *y, z):
    pass


func3(10, 20, 30, 40, z=100)


def func4(a, *, b):   # b必须用关键字参数
    pass


def func6(**x):
    print(x)


# func6(10, 20) 报错不能传位置参数
func6(a=10, b=20, c=30)    # 只能传关键字参数  {'a': 10, 'b': 20, 'c': 30}