Python的函数（补充浅拷贝和深拷贝）

news2024/11/13 23:47:37

一、定义

函数的定义：实现【特定功能】的代码块。

形参：函数定义时的参数，没有实际意义

实参：函数调用/使用时的参数，有实际意义

函数的作用：

1. 简化代码
2. 提高代码重用性
3. 便于维护和修改
4. 提高代码的可扩展性

函数的三要素：

1. 功能 len() max() sum()
2. 参数 s.clear() s.append('abc')
3. 返回值 s.sort() s1 = sorted(s)

函数定义的语法格式：

函数的分类：

1. 从定义角度—— 内置函数【别人写好的，你直接用】自定义函数
2. 从参数角度——无参函数有参函数
3. 从返回值角度——无返函数 None 有返函数

函数的调用/使用：

1. 无返函数函数名()
2. 有返函数方法1：print(函数名())
3. 方法2：变量名 = 函数名()

def my_fun():
    print("这是我的函数")

print(my_fun)
# 输出结果是   <function my_fun at 0x000002AA6DF7A3E0>
# 说明函数名是一个内存地址

# 无返函数直接调用
my_fun()

def you_fun():
    return 100

# 有返函数，输出调用
print(you_fun())

# 有返函数，使用变量接收调用
ret = you_fun()
print(ret)

二、函数的参数传递

函数在进行参数传递的时候，分为：位置参数、关键字参数、默认参数、位置不定长参数、关键字不定长参数。

位置参数：

传递参数时应该和定义时的参数保持位置和数量一一对应。

def fun(a, b, c):
    print(a, b, c)

# fun()
# TypeError: fun() missing 3 required positional arguments: 'a', 'b', and 'c'

fun(1, 2, 3)
#运行结果 1 2 3
fun('张三', 18, '男')
#运行结果 张三 18 男
fun([1,2,3], (4,5,6), {7,8,9})
# 运行结果 [1, 2, 3] (4, 5, 6) {8, 9, 7}

关键字参数

调用函数传递参数时，按照参数名=值的方式，传参的顺序可以和定义参数的顺序不一致。

def fun(name, age, sex):
    print(name, age, sex)

# 关键字参数
fun(name='张三', age=18, sex='男')
fun(age=18, sex='男', name='张三')

默认参数：

在函数定义时给参数设置默认值，那么在函数调用时，若不传参就是用默认值，若传参就是用传参的值。

def fun(name='张三', age=18, sex='男'):
    print(name, age, sex)

# 默认参数
fun()
fun('李四')
fun(age=66)
fun('小明', 30)
fun('小华', 23, '女')

位置不定长参数：

在定义函数时参数名前加 * ，也就是def fun( *args )，那么在传参的时候就可以传若干个位置参数。

将参数打包成——元组。

def fun(*num):
    print(num)
fun(1)
fun(1,2)
fun(1,2,3,4,5,6)

# 问：在一个函数中，位置不定长参数，可以有两个吗？
# 不允许
# 再问：一旦定义了位置不定参参数，是不是就不可以定义其他参数了呢？
# 答：可以定义，但是传参时必须是关键字参数

关键字不定长参数：

在定义函数参数名前加 ** ，也就是 def fun( **kwargs )，那么传参的时候就可以传若干个关键字参数。

将参数打包成——字典。

def fun(**kwargs):
    print(kwargs)

fun(a=12, b=13, c=15)
fun(姓名='张三', 年龄=18, 性别='男')

三、函数的返回值

如果函数的运行结果想在函数外使用，就需要设置返回值。
使用关键字 return 进行返回。
return 可以在函数中出现多次，但是只执行 1 次，遇见return返回值并结束函数。
与C语言不同，python中的return可以返回一个值或多个值，这个时候将返回的多个值到打包成一个元组。

def fun(*num):
    my_sum = 0
    for i in num:
        my_sum += i
    return my_sum

ret = fun(3,7,2,9,8)
print(ret, type(ret))

四、递归函数

递归函数有三要素：

边界条件/基线条件跳出/结束递归的条件
递归返回段满足结束条件时，返回
递归前进段不满足结束条件时，前进/继续递归

def rec(n):
    """
    求一个数n的阶乘
    :param n: 接收到一个整型值
    :return: 计算的阶乘结果
    """
    if n==1:
        return 1
    else:
        return n * rec(n-1)

n = 5
print(rec(n))

五、函数中变量的作用域

变量的作用域：是指变量能起作用的范围，根据作用范围大小不同分为全局变量和局部变量。

全局变量：定义在函数外，作用范围是整个程序，程序结束时全局变量声明周期结束。
局部变量：定义在函数代码块里或者函数的参数里，作用范围是整个函数，函数执行结束时局部变量生命周期结束。

六、函数嵌套

函数嵌套：在一个函数的内部还嵌套定义了另外一个函数。

外部的我们称之为外函数，内部的我们称之为内函数。

x = 100
def out_fun():
    # global x
    x = 200
    def in_fun():
        # global x
        x = 300
        print(f"内函数中输出{x}")
    in_fun()
    print(f"外函数中输出{x}")

out_fun()
print(f"函数外输出{x}")

七、闭包函数

什么是闭包函数？——如果内函数中使用了外函数的局部变量，并且外函数把内函数返回的过程就叫闭包。

形成闭包的条件：

函数嵌套
将内函数作为返回值返回
内函数必须使用外函数的局部变量

def out():
    x=200
    def in1():
        return x+100
    return in1
print(out()())

八、拷贝

使用深拷贝时，需要引入copy

使用浅拷贝时，可直接使用copy()

l1 = [1, 2, 3, ['a', 'b', 'c']]
# 浅拷贝
l2 = l1.copy()
# 深拷贝
import copy
l3 = copy.deepcopy(l1)
print("修改前")
print(l1)
print(l2)
print(l3)
# 修改值
l1[0] = 66
l2[1] = 88
l3[2] = 99
print("修改值后")
print(l1)
print(l2)
print(l3)
# 修改可变对象
l1[3][0] = 'hqyj'
l2[3][1] = 'hello'
l3[3][2] = 'xxxx'
print("修改可变对象后")
print(l1)
print(l2)
print(l3)