Python基础详细笔记(八)：使用函数

雨点打透心脏的1/2处 2023-09-28 08:08 11阅读 0赞

**目录**

[Python基础详细笔记(一)：基础语法][Python]

[Python基础详细笔记(二)：流程语句][Python 1]

[Python基础详细笔记(三)：字符串str][Python_str]

[Python基础详细笔记(四)：列表list][Python_list]

[Python基础详细笔记(五)：元组tuple][Python_tuple]

[Python基础详细笔记(六)：字典dict][Python_dict]

[python基础详细笔记(七)：集合set][python_set]

[Python基础详细笔记(八)：使用函数][Python 2]

8.1 函数介绍

8.2 函数定义

8.3 函数传的参数

必需参数

关键字参数

默认参数

不定长参数

8.4 强制位置参数

8.5 返回值return 语句

8.6 函数的嵌套调用

8.7 局部变量

8.8 全局变量

global关键字

nonlocal关键字

8.9 匿名函数

8.10 递归函数

[Python基础详细笔记(九)：异常处理][Python 3]

--------------------

## 8.1 函数介绍  ##

你可以定义一个由自己想要功能的函数，以下是简单的规则：

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

####  ####

## 8.2 函数定义 ##

下面是一个打印问候语的简单函数，名为greet\_user() ：

def greet_user():
        print("Hello")
    
    greet_user()

默认情况下，参数值和参数名称是按函数声明中定义的顺序匹配起来的。

## 8.3 函数传的参数 ##

#### 可更改(mutable)与不可更改(immutable)对象 ####

在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

*  **不可变类型：**变量赋值 **a=5** 后再赋值 **a=10**，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变 a 的值，相当于新生成了 a。
 *  **可变类型：**变量赋值 **la=\[1,2,3,4\]** 后再赋值 **la\[2\]=5** 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

python 函数的参数传递：

*  **不可变类型：**类似 C++ 的值传递，如整数、字符串、元组。如 fun(a)，传递的只是 a 的值，没有影响 a 对象本身。如果在 fun(a) 内部修改 a 的值，则是新生成一个 a 的对象。
 *  **可变类型：**类似 C++ 的引用传递，如 列表，字典。如 fun(la)，则是将 la 真正的传过去，修改后 fun 外部的 la 也会受影响

python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

### 参数 ###

以下是调用函数时可使用的正式参数类型：

*  必需参数
 *  关键字参数
 *  默认参数
 *  不定长参数

#### 必需参数 ####

必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。

def greet_user(username):
        print("Hello,"+username.title()+"!")
    greet_user('jesse')

更复杂点的应用，函数中带上参数变量:

def describe_pet(animal_type,pet_name):
        print("\nI have a"+animal_type+".")
        print("\nMy "+animal_type+"'s name is "+ pet_name.title() +".")
    describe_pet('hamster','harry')

调用函数多次

def describe_pet(animal_type, pet_name):
        """显示宠物的信息"""
        print("\nI have a " + animal_type + ".")
        print("My " + animal_type + "'s name is " + pet_name.title() + ".")
    describe_pet('hamster', 'harry')
    describe_pet('dog', 'willie')

位置实参的顺序很重要

#### 关键字参数 ####

关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。

使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

#可写函数说明
    def printinfo( name, age ):
       "打印任何传入的字符串"
       print ("名字: ", name)
       print ("年龄: ", age)
       return
     
    #调用printinfo函数
    printinfo( age=50, name="runoob" )

#### 默认参数 ####

调用函数时，如果没有传递参数，则会使用默认参数。以下实例中如果没有传入 age 参数，则使用默认值：

#可写函数说明
    def printinfo( name, age = 35 ):
       "打印任何传入的字符串"
       print ("名字: ", name)
       print ("年龄: ", age)
       return
     
    #调用printinfo函数
    printinfo( age=50, name="runoob" )
    print ("------------------------")
    printinfo( name="runoob" )

#### 不定长参数 ####

你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述 2 种参数不同，声明时不会命名。

# 可写函数说明
    def printinfo( arg1, *vartuple ):
       "打印任何传入的参数"
       print ("输出: ")
       print (arg1)
       print (vartuple)
     
    # 调用printinfo 函数
    printinfo( 70, 60, 50 )

加了星号 \* 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。

如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量。

# 可写函数说明
    def printinfo( arg1, *vartuple ):
       "打印任何传入的参数"
       print ("输出: ")
       print (arg1)
       for var in vartuple:
          print (var)
       return
     
    # 调用printinfo 函数
    printinfo( 10 )
    printinfo( 70, 60, 50 )

加了两个星号 \*\* 的参数会以字典的形式导入。

# 可写函数说明
    def printinfo( arg1, **vardict ):
       "打印任何传入的参数"
       print ("输出: ")
       print (arg1)
       print (vardict)
     
    # 调用printinfo 函数
    printinfo(1, a=2,b=3)

如果单独出现星号 \* 后的参数必须用关键字传入

def f(a,b,*,c):
        return a+b+c
    f(1,2,c=3) # 正常

####  ####

### 8.4 强制位置参数 ###

Python3.8 新增了一个函数形参语法 / 用来指明函数形参必须使用指定位置参数，不能使用关键字参数的形式。

在以下的例子中，形参 a 和 b 必须使用指定位置参数，c 或 d 可以是位置形参或关键字形参，而 e 和 f 要求为关键字形参:

def f(a, b, /, c, d, *, e, f):
        print(a, b, c, d, e, f)
    f(10, 20, 30, d=40, e=50, f=60)

### 8.5 返回值return 语句 ###

**return \[表达式\]** 语句用于退出函数，选择性地向调用方返回一个表达式。不带参数值的 return 语句返回 None。之前的例子都没有示范如何返回数值

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

**无参数、无返回值**

def 函数名():
        语句

**无参数、有返回值**

def 函数名():
        语句
        return 需要返回的数值

> 注意:  
> 一个函数到底有没有返回值，就看有没有return，因为只有return才可以返回数据  
> 在开发中往往根据需求来设计函数需不需要返回值  
> 函数中，可以有多个return语句，但是只要执行到一个return语句，那么就意味着这个函数的调用完成

**有参数、无返回值**

def 函数名(形参列表):
        语句

**有参数、有返回值**

def 函数名(形参列表):
        语句
        return 需要返回的数值

注：函数名不能重复

## 8.6 函数的嵌套调用 ##

一个函数里面又调用了另外一个函数，这就是所谓的函数嵌套调用

def testB():
        print('---- testB start----')
        print('这里是testB函数执行的代码...(省略)...')
        print('---- testB end----')
    
    def testA():
        print('---- testA start----')
        testB()
        print('---- testA end----')
    
    testA()
    
    ''' 
    ---- testA start----
    ---- testB start----
    这里是testB函数执行的代码...(省略)...
    ---- testB end----
    ---- testA end----
    '''

如果函数A中，调用了另外一个函数B，那么先把函数B中的任务都执行完毕之后才会回到上次 函数A执行的位置

## 8.7 局部变量 ##

*  局部变量，就是在函数内部定义的变量
 *  其作用范围是这个函数内部，即只能在这个函数中使用，在函数的外部是不能使用的
 *  局部变量的作用，为了临时保存数据需要在函数中定义变量来进行存储
 *  当函数调用时，局部变量被创建，当函数调用完成后这个变量就不能够使用了

def test1():
        a=300
        print(a)
        a=200
        print(a)
    def test2():
        a=400
        print(a)

## 8.8 全局变量 ##

*  在函数外边定义的变量叫做全局变量
 *  全局变量能够在所有的函数中进行访问

如果一个变量，既能在一个函数中使用，也能在其他的函数中使用，这样的变量就是全局变量

# 定义全局变量
    a = 100
    
    def test1():
        print(a)  # 虽然没有定义变量a但是依然可以获取其数据
    
    def test2():
        print(a)  # 虽然没有定义变量a但是依然可以获取其数据
    
    # 调用函数
    test1()
    test2()

#### global关键字 ####

*  部变量和全局变量是不同变量
 *  局部变量是函数内部的占位符，与全局变量可能重名但不同
 *  函数运算结束后，局部变量被释放
 *  可以使用global保留字在函数内部使用全局变量
 *  函数使用global保留字声明全局变量

函数内部默认只能读取全局变量的值，如需要修改全局变量，则需要使用global关键字进行声明，否则在函数内修改全局变量会报英文错误。

a = 2
    def show():
        global a
        a = 4
        print(a)
    show()

#### **nonlocal关键字** ####

通过使用nonlocal关键字可以在一个嵌套的函数中修改嵌套作用域的变量

def func():
        a=1
        def func_in():
            nonlocal a
            a=2
        func_in()
        print(a)
    func()

## 8.9 匿名函数 ##

Python 使用 lambda 来创建匿名函数。

所谓匿名，意即不再使用 **def** 语句这样标准的形式定义一个函数。

*  lambda 只是一个表达式，函数体比 **def** 简单很多。
 *  lambda 的主体是一个表达式，而不是一个代码块。仅仅能在 lambda 表达式中封装有限的逻辑进去。
 *  lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
 *  虽然 lambda 函数看起来只能写一行，却不等同于 C 或 C++ 的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

>     lambda [arg1 [,arg2,.....argn]]:expression

x = lambda a : a + 10
    print(x(5))
    
    #两个参数
    # 可写函数说明
    sum = lambda arg1, arg2: arg1 + arg2
     
    # 调用sum函数
    print ("相加后的值为 : ", sum( 10, 20 ))
    print ("相加后的值为 : ", sum( 20, 20 ))

我们可以将匿名函数封装在一个函数内，这样可以使用同样的代码来创建多个匿名函数。

以下实例将匿名函数封装在 myfunc 函数中，通过传入不同的参数来创建不同的匿名函数：

def myfunc(n):
      return lambda a : a * n
     
    mydoubler = myfunc(2)
    mytripler = myfunc(3)
     
    print(mydoubler(11))
    print(mytripler(11))

### 8.10 递归函数 ###

递归就是一个函数在它的函数体内调用它自身。执行递归函数将反复调用其自身，每调用一次就进入新的一层。递归函数必须有结束条件。  
当函数在一直递推，直到遇到墙后返回，这个墙就是结束条件。  
所以递归要有两个要素，结束条件与递推关系

**迭代实现阶乘**

def factorial(n):
        result = 1
        for i in range(2, n+1):
            result *= i
        return result
    
    x= factorial(5)
    print(x)

**递归实现阶乘**

def factorial(n):
       if n == 1:
           return 1
       else:
           return n * factorial(n - 1)
    
    x=factorial(10)
    print(x)

##  ##

[Python]: https://blog.csdn.net/qq_21402983/article/details/124851579
[Python 1]: https://blog.csdn.net/qq_21402983/article/details/124868275
[Python_str]: https://blog.csdn.net/qq_21402983/article/details/124874343
[Python_list]: https://blog.csdn.net/qq_21402983/article/details/124910598
[Python_tuple]: https://blog.csdn.net/qq_21402983/article/details/124925215
[Python_dict]: https://blog.csdn.net/qq_21402983/article/details/124933849?spm=1001.2014.3001.5501#t0
[python_set]: https://blog.csdn.net/qq_21402983/article/details/124937624
[Python 2]: https://blog.csdn.net/qq_21402983/article/details/124975844
[Python 3]: https://blog.csdn.net/qq_21402983/article/details/124770362