我在CSDN学python-10

1、函数的创建、调用及参数传递

# Name：      Python study
# Designer：  MilesHugh
# Time：      2023/4/11  9:55

# 函数的创建和调用
# 函数：执行特定任务和完成特定功能的一段代码
# 函数功能：复用代码、隐藏实现细节、提高可维护性、提高可读性便于调试
# 函数的创建：
# def 函数名([输入函数]):
#      函数体
#      [return xxx]
def calc(a, b):  # a，b称为形式参数，简称形参，形参的位置是在函数的定义处
    c = a + b
    return c

result = calc(10, 20)
# 10，20称为实际参数的值，简称实参，实参的位置是函数的调用处
print(result)

#  函数调用的参数传递:
#  -位置实参：根据形参对应的位置进行实参传递
#  -关键字实参：根据形参名称进行实参传递
res = calc(b=10, a=20)   # 关键字实参传递，=左侧关键字参数
print(res)
# 注意：形参和实参的名称可以不相同
def fun(arg1, arg2):
    print('arg1', arg1)
    print('arg2', arg2)
    arg1 = 100
    arg2.append(10)
    print('arg1', arg1)
    print('arg2', arg2)
    #return

n1 = 11
n2 = [22, 33, 44]
print('n1', n1)
print('n2', n2)
fun(n1, n2)  # 位置传参，arg1、arg2是函数定义处的形参，n1、n2是函数调用处的实参
#  实参名称和形参名称可以不一致
print('n1', n1)
print('n2', n2)
# 在函数调用过程中，进行参数传递：
# -如果是不可变对象，在函数体的修改不会影响实参的值，arg1的修改为100，不影响n1的值 
# -如果是可变对象，在函数体的修改会影响到实参的值，arg2的修改，.append(10)会影响到n2的值

2、函数的返回值

# Name：      Python study
# Designer：  MilesHugh
# Time：      2023/4/11  10:28

# 函数的返回值
print(bool(0))  # False
print(bool(3))  # 非0的布尔值为True

def fun(num):
    odd = []  # 奇数
    even = []  # 偶数
    for i in num:
        if i % 2 :
            odd.append(i)
        else:
            even.append(i)
    return odd, even
# 函数调用
lst = [10, 29, 34, 23, 44, 53, 55]
print(fun(lst))
# 函数的返回值：
# -如果函数没有返回值【函数执行完毕之后，不需要给调用处提供数据】 return可以省略不写
# -函数返回值，如果是1个，直接返回原类型；如果是多个，返回的结果是元组
def fun1():
    print('hello')
    # return
fun1()

def fun2():
    return 'hello'
res = fun2()
print(res)

def fun3():
    return 'hello', 'python'
print(fun3())
# 函数在定义时，是否需要返回值，视情况而定

3、函数的参数定义

# Name：      Python study
# Designer：  MilesHugh
# Time：      2023/4/11  11:14

# 函数的参数定义
# -函数定义默认值参数：函数定义时，给形参设置默认值，只有与默认值不符的时候才需要传递实参
# -个数可变的位置参数：
# -个数可变的关键字形参：
print('------函数定义默认值参数------')
def fun(a, b=10):
    print(a, b)
# 函数的调用
fun(100)  # 只传一个参数，b采用默认值
fun(2, 3)  # 3将默认值10替换

print()  # 按ctrl可进行查看print()
# def print(self, *args, sep=' ', end='\n', file=None):
print('hello')  # 默认换行
print('hello', end='\t')  # 修改默认值，不换行
print('------个数可变的位置参数------')
# 结果是一个元组
# 使用*定义个数可变的位置形参，只能定义一个参数
def fun(*args):  # 函数定义时可变的位置参数
    print(args)
    # print(args[0])
fun(10)
fun(10, 30)
fun(20, 30, 40)
print('------个数可变的关键字形参------')
# 结果是一个字典
# 使用**定义个数可变的关键字形参，只能定义一个参数
def fun1(**args):
    print(args)
fun1(a = 10)
fun1(a=20, b=30, c=40)
# 在一个函数的定义过程中，既有个数可变的关键字形参，也有个数可变的位置形参，
#   要求个数可变的位置形参，放在个数可变的关键字形参之前
def fun2(*args1, **args2):
    pass

4、函数参数总结

# Name：      Python study
# Designer：  MilesHugh
# Time：      2023/4/11  12:10

# 函数参数的总结
def fun(a, b, c):  # a,b,c在函数定义处，形式参数
    print('a=', a)
    print('b=', b)
    print('c=', c)

# 函数的调用
fun(1, 2, 3)  # 函数调用时的参数传递，位置参数
lst = [11, 22, 33]
fun(*lst)  # 在函数调用时，将列表中的每个元素都转换为位置实参传入
print('-------------')
fun(a=10, b=20, c=30)  # 函数的调用，关键字实参
dic = {'a': 11, 'b': 22, 'c': 33}
fun(**dic)  # 在函数调用时，将字典中的键值对都转换为关键字实参传入

def fun1(a, b=10): # b是在函数定义处，形参，而且进行了赋值，所以b称为默认值形参
    print('a=', a)
    print('b=', b)

def fun2(*args):  # 个数可变的位置形参
    print(args)

def fun3(**args2):  # 个数可变的关键字形参
    print(args2)

fun2(10, 20, 30, 40)
fun3(a=11, b=22, c=33, d=44)

def fun4(a, b, c, d):
    print('a=', a)
    print('b=', b)
    print('c=', c)
    print('d=', d)

# 调用fun4函数
fun4(10, 20, 30, 40)  # 位置参数传递
fun4(a=10, b=20, c=30, d=40)  # 关键字实参传递
fun4(10, 20, c=30, d=40)  # 前两个参数，采用位置实参传递，而c，d采用的是关键字实参传递
print('------若要求c，d只能采用关键字实参传递------')
# 从*之后的参数，在函数调用时，只能采用关键字参数传递
def fun5(a, b, *, c, d):
    print('a=', a)
    print('b=', b)
    print('c=', c)
    print('d=', d)
fun4(10, 20, c=30, d=40)
print('------函数定义时的形参的顺序问题------')

def fun5(a, b, * ,c, d, **args):
    pass

def fun6(*args, **args2):
    pass

def fun7(a, b=10, *args, **args2):
    pass

函数的参数总结

	参数的类型	函数的定义	函数的调用	备注
1	位置实参		√
	将序列中的每个元素都转换为位置实参		√	使用*
2	关键字实参		√
	将字典中的每个键值对都转换为关键字实参		√	使用**
3	默认值形参	√
4	关键字形参	√		使用*
5	个数可变的位置形参	√		使用*
6	个数可变的关键字形参	√		使用**

5、变量的作用域

# Name：      Python study
# Designer：  MilesHugh
# Time：      2023/4/12  8:49

# 变量的作用域
# -程序代码能访问该变量的区域
# -根据变量的有效范围可分为：
# 局部变量——在函数内定义并使用的变量，只在函数内部有效，局部变量使用global声明，这个变量就成全局变量
# 全局变量——函数体外定义的变量，可作用于函数内外
def fun(a, b):
    c = a + b   # c称为局部变量，c在函数体内进行定义的变量，a，b为函数的形参，作用范围也是函数内部，相当于局部变量
    print(c)
# print(c)  # a，c超出了作用范围（超出作用域）
# print(a)
name = '余生'  # name的作用范围为函数内部和外部，称为全局变量
def fun2():
    print(name)
# 调用函数
fun2()

def fun3():
    age = 20
    print(age)
fun3()

def fun4():
    global age1  # 函数内部定义的变量-局部变量，使用global声明，就变成全局变量
    age1 = 20
    print(age1)
fun4()
print(age1)

6、递归函数

# Name：      Python study
# Designer：  MilesHugh
# Time：      2023/4/12  10:10

# 递归函数：
# -一个函数的函数体内调用了该函数本身
# 递归的组成部分：
# -递归调用与递归终止条件
# 递归的调用过程：
# -每递归调用完一次函数，都会在栈内存分配一个栈帧
# -每执行完一次函数，都会释放相应的空间
# 递归的优缺点：
# -缺点：占用内存多，效率低下
# -优点：思路和代码简单
print('------计算6的阶乘------')
def fac(n):
    if n == 1:
        return 1
    else:
        res = n * fac(n-1)
        return res
print(fac(6))
print('------斐波那契数列:1,1,2,3,5,8,......,(n-1)+(n-2)------')
def fib(n):
    if n == 1:
        return 1
    elif n == 2:
        return 1
    else:
        return fib(n-1) + fib(n-2)
# 斐波那契数列第6位上的数字
print(fib(6))
print('------输出这个数列前6位上的数字------')
for i in range(1, 7):
    print(fib(i))