python学习记录day-10-函数

 函数的创建与调用

# 函数的创建于调用
def calc(a,b): # a和b是形参，形参在函数定义处
c=a+b
return c
result=calc(13,26) # 13和26称为实参
print(result)
# 函数调用的两种参数传递
# 方法一位置实参
'''
calc(10,20)
def calc(a,b)
'''
# 方法二关键字实参

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)

n1=11
n2=[22,33,44]
print('n1',n1)
print('n2',n2)
fun(n1,n2) # 位置传参，实参名称和行参名称可以不同。
print('n1',n1)
print('n2',n2)
'''
总结：在函数调用过程中，进行参数传递。
如果是不可变对象（整数、字符串、元组），在函数体的修改不会影响实参的值。arg1修改100，不影响n1的值
如果是可变对象（列表、字典、集合），在函数体的修改会影响实参的值。arg2的修改，会影响n2的值
'''

 函数返回值

# 函数返回值
# 函数返回多个值时，结果为元组
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))
'''
(1)如果函数没有返回值【函数执行完毕之后，不需要给调用处提供数据】 return可以省略不写
（2）函数的返回值，如果是一个，直接返回类型
（3）函数的返回值如果是多个，返回结果为元组
'''
def fun1():
print('hello')
fun1()

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

def fun3():
return 'hello','world'
print(fun3())

# 函数在定义时，是否需要返回值，视情况而定

函数定义默认值参数

# 函数定义默认值参数
# 函数定义时，给形参设置默认值，只有与默认值不符得到时候才需要传递实参
def fun(a,b=10):
print(a,b)

fun(100) # b采用默认值
fun(20,30)

print()

函数的参数定义

# 函数的参数定义

# 个数可变的位置参数
def fun(*args): # 可变的位置参数，结果是一个元组
print(args)

fun(10)
fun(10,30)
fun(30,405,50)

# 个数可变的关键字形参
def fun1(**args): # 个数可变的关键字形参，结果是一个字典
print(args)

fun1(a=10)
fun1(a=20,b=30,c=40)

# 个数可变的位置参数一次只能定义一个
"""def fun5(*args,*a):
pass""" # 报错
# 个数可变的关键字参数一次只能定义一个
# def fun6(**args,**a):
# pass 报错

def fun9(*args1,**args2):
pass
# def fun3(**args1,*args2): # 报错
# pass
# 在一个函数的定义过程中，既有个数可变的关键字形参，也有个数
# 可变的位置形参，要求个数

def fun(a,b,c): # abc在函数定义处，所以是形式参数
print('a=',a)
print('b=',b)
print('c=',c)

# 函数的调用
fun(10,20,30) # 函数调用时的参数传递，称为位置参数
lst=[11,22,33]
fun(*lst) # 在函数调用时，将列表中的每个元素都转换为位置实参传入

fun(a=100,b=300,c=400) # 函数的调用，关键字实参

dic={'a':111,'b':222,'c':333}
fun(**dic) # 在函数调用时，将字典中的键值对都转换为关键字实参传入

def fun(a,b=10): # b是在函数定义处，所以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)

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

# 调用
fun4(10,20,30,40) # 位置实参传递
fun4(a=10,b=30,c=50,d=90) # 关键字实参
fun4(10,20,c=40,d=50)
'''
要求，c和d只能采用关键字实参传递
可以这样
def fun4(a,b,*,c,d): # *表示，之后只能使用关键字参数
'''

'''函数定义时的形参的顺序问题'''
def fun5(a,b,*,c,d,**args):
pass

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

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

变量的作用域

# 变量的作用域
# 局部变量
def fun(a,b):
c=a+b # c 定义在函数内部，相当于局部变量。a和b为函数的形参，作用范围也是函数内部，相当于局部变量
print(c)
# print(c) 报错，超出变量作用域范围
# print(a)
# 全局变量
name='杨老师' # 全局变量
print(name)
def fun2():
print(name)
# 调用函数
fun2()

def fun3():
global age # 局部变量转变为全局变量
age=20
print(age)
fun3()
print(age)

递归函数

使用递归来计算阶乘

# 使用递归来计算阶乘
def fac(n):
if n==1:
return 1
else:
return n*fac(n-1)
print(fac(6))

斐波拉契数列

# 第一项+第二项=第三项
# 求第n项斐波拉契数列数字
def fib(n):
if n==1:
return 1
elif n==2:
return 1
else:
return fib(n-2)+fib(n-1)
print(fib(8))

# 输出前六位
for i in range(1,7):
print(fib(i),end='\t')

学习链接

【花了2万多买的Python教程全套，现在分享给大家，入门到精通(Python全栈开发教程)】 https://www.bilibili.com/video/BV1wD4y1o7AS/?p=96&share_source=copy_web&vd_source=5f93c948050b4284ccf31ae9244fad4c