新开课day12总结

函数位置参数和关键字参数

根据调用函数的时候实参的提供方式不同来分类的

• 位置参数：以’数据1,数据2,数据3,… '形式存在，通过位置来和形参一一对应

• 关键字参数：以’形参1=数据1,形参2=数据2,形参3=数据3… '形式存在(交换关键字参数的顺序不影响结果)

注意：

a.位置参数和关键字参数可以一起使用，但是位置参数必须放在关键字参数的前面

b .不管以什么样的形式传参，都必须保证每个参数都有值

def fun(a,b,c):
    print(a,b,c)
fun(10,b=90,c=89)
fun(10,90,c=89)
fun(10,90,89)
# fun(10,b=90,89)#报错positional argument follows keyword argument

参考默认值

在定义函数的时候，可以以’变量名=数据’的方式给参数赋默认值;

调用函数的时候有默认值的参数可以不用传参。

注意：定义函数的时候如果有的参数有默认值有的没有，没有默认值的参数必须在有默认值参数的前面

如下案例：

def fun(a,b,c = 2):
    print(a+b+c)
fun(12,23)#37
fun(12,23,c = 223)#258

#但是如下就报错
def fun(a = 12,b,c): #因为没有默认值的参数必须在有默认值参数的前面
    print(a+b+c)
fun(a = 2,12,23)#报错信息：non-default argument follows default argument

参数类型说明

可以让形参在函数体中使用的时候有相关提示

• 没有默认值的参数直接在参数名后加’:类型名’
• 有默认值的参数默认值的类型就是说明的类型

def fun(a):#不清楚a的类型数据
    pass
# 但是如下：
def fun1(str1):#清楚类型数据,但是字符串相关操作就没有提示
    pass
# 参数类型应该如下写
def fun2(a:str):#字符串
    pass
def fun3(b:list):#列表
    pass
def fun4(c:dict,d = 'abcd',e = [1,2,3,4]):
    pass

补充：通过类型注释对变量进行说明

dict1 = [
    {'1':2,'3':4},
    {'2':3,'4':'2'}
]
k = dict1[-1]['4']  # type:str
print(k.rjust(4, '0'))#字符串相关操作即可使用

#输出：0002

不定长参数：参数个数不确定

1)带*号的不定长参数

定义函数的时候在某个参数前加*，就可以让这个参数同时接受多个实参

案例：定义一个函数求多个数的和

#观察参数输出是什么类型
def sum1(*nums):#参数个数不确定
    print(*nums)#12 23
    print(nums)#(12, 23),输出就是一个元组
    print(nums[0])#12
sum1(12,23)

#求和
def sum1(*nums):
    total=0
    for i in nums:
        total+=i
    print(total)
sum1(1,2,3,4,5)#15

只能用位置参数传参

def test(x,y,*nums):
    print(x,y,nums)
# test(1,2,3,23,23,23)#1 2 (3, 23, 23, 23)
# test(x = 1,y = 12,22,12)#不满足位置参数和关键字参数规则，只能用位置参数传参

只能使用关键字参数

def test1(*num,x,y):
    print(*num,x,y)
test1(1,2,23,34,x = 12,y = 1)#1 2 23 34 12 1
# test1(1,2,3,4,5,6)#本以为可以将5，6传给x,y结果报错
# test1() missing 2 required keyword-only arguments: 'x' and 'y'
#因此，此时只能使用关键字参数

告诉使用者a能使用位置参数或关键字参数，b只能使用关键字参数

def test3(a,*,b):
    print(a,b)
test3(1,b = 23)
test3(a = 1,b = 23)
# test3(1,23)#报错test3() takes 1 positional argument but 2 were given

案例：

def student_information(name, classmate, *score):
    scores = 0
    for i in score:
        scores += i
    print(f'姓名:{name}, 班级教室:{classmate}, 总分:{scores}')

student = '王大炮'
classmate = 2205
scores = 148, 146, 149, 150
s = '王大炮',2205,148, 146, 149, 150
student_information('王大炮', 2205, *(148, 146, 149, 150))#注意必须要加上这个*号
student_information(student, classmate, *scores)
student_information(*s)				#姓名:王大炮, 班级教室:2205, 总分:593

2)带**号的不定长参数：定义函数时在某个参数前加**，就可以让这个参数接受多个实参

注意：只能使用关键字传参，输出是字典，他接受到的所有关键字参数会成为字典的元素

def tes(**x):
    print(x)
tes()			# {}
tes(e = 23)		# {'e': 23}
tes(q = 1,e = 23)# {'q': 1, 'e': 23}
tes(a = 1,c = 22,d = 12,e = 32)# {'a': 1, 'c': 22, 'd': 12, 'e': 32}

常见的参数为：*args，**kwargs：灵活使用，既可以使用位置参数，也可以使用关键字参数，二者还可以一起使用

def tes1(*args,**kwargs):
    print("args:",args,'kwargs:',kwargs)
tes1()              # args: () kwargs: {}
tes1(1,12,12)       # args: (1, 12, 12) kwargs: {}
tes1(1,12,a = 12)   # args: (1, 12) kwargs: {'a': 12}
tes1(1,k = 12,b = 12)   # args: (1,) kwargs: {'k': 12, 'b': 12}
tes1(a = 1,x = 12,k = 12)# args: () kwargs: {'a': 1, 'x': 12, 'k': 12}

函数返回值

1)在函数内部怎么确定函数返回值：return后面的值就是函数的返回值

• 在函数体实现函数功能的时候，可以在任何你需要的地方(一般在最后)

• return使用方法：return 需要返回的数据

• return 除了可以返回数据，return还可以结束函数（即函数只要遇到return整个函数提前结束）

• 如果执行函数的时候没有遇到return这个函数的返回值是None

案例：返回单个数据

def fun(num1):
    return num1
print(fun(2))#2

案例：返回多个数据，实际上返回一个元组

def fun(num1,num2):
    return num1+num2,num2*num1
print(fun(2,3))#(5, 6)

案例：return的终止作用

def fun(num1,num2):
    return num1+num2
    return num2*num1  #值未被返回，上一个return终止了函数
print(fun(2,3)) #输出5

2)在函数外部怎么使用函数返回值

使用函数调用表达式的值就是使用函数的返回值(函数调用表达式的结果就是函数的值)

返回值可以做的函数调用表达式都可以做

案例：在函数外使用返回值

def fun(num1):
    return num1*2
print(fun(12))#24
#可利用函数表达式进行算数运算
print(fun(12)+121)#145
#也可以转化类型
print(str(fun(12)))

def fun1(num1):
    return num1*2,num1
#转化类型
print(list(fun1(12)))#[24, 12]
print(fun1(12))#(24, 12)
print(dict([list(fun1(12)),list(fun1(22))]))#{24: 12, 44: 22}

变量作用域

根据变量作用域(可使用范围）不同，可以将变量分为全局变量和局部变量两种

1.全局变量

• 没有定义在函数或者类中的变量
• 作用域从定义开始到程序结束

看案例：

a = 12  #a就是一个全局变量
for i in range(2): #i也是一个全局变量
    print(f'在循环中使用a：{a}')  # 打印三遍：在循环中使用a：12，不报错
print(f'循环中的i：{i}') #循环中的i：1

def fun1():
    print(f'在函数中使用a：{a}')
fun1()		# 在函数中使用a：12，不报错

2.局部变量

• 定义在函数中的变量就是局部变量，局部变量的作用域是从定义开始到函数结束（形参是局部变量）

def fun2(m):#m是局部变量
    x = 10  #x也是局部变量
    print(f'在函数中使用m,x：{m},{x}')
    
fun2(23) #在函数中使用m,x：23,10

# print(f'在函数外使用局部变量m,x：{m},{x}')#报错：name 'm' is not defined

引入关键字global

1. 在函数中修改全局变量

作用：如果想要在函数里面定义一个全局变量或者修改一个全局变量的值，需要在函数中使用global关键字

a = 12 #a是一个全局变量
def fun1():
    global a
    a = 20  #修改全局变量a
    print(f'在函数中使用a：{a}')#在函数中使用a：20
fun1()
print(f'在函数外使用a：{a}')#在函数外使用a：20

2. 使用局部变量的值

a = 90	#a全局变量
def fun():
    global age	#age局部变量
    age = 12
fun()	#必须要调用函数
print(f'全局变量a:{a},局部变量age:{age}')#全局变量a:90,局部变量age:12