Python函数的参数与返回值

Python函数

4.1、函数初识

• 在编写程序的过程中，有某一功能代码块出现多次，但是为了提高编写的效率以及代码的重用，所以把具有独立功能的代码块组织为一个小模块，这就是函数
• 就是一系列Python语句的组合，可以在程序中运行一次或者多次，
• 一般具有独立的功能
• 代码的复用最大化以及最小化冗余代码，整体代码结构清晰，问题局部化
• 语法结构

def 函数名(参数1，参数2，参数3):
    """文档说明"""
    函数体
    return 值

• 函数定义

def pritInfo():
    '''
    这个函数用来打印小张信息
    '''
    #函数代码块
    print('小张的身高是%f'%1.73)
    print('小张的体重是%f'%130)
    print('小张的爱好是%s'%'周杰伦')
    print('小张的专业是%s'%'信息安全')

定义函数发生的事情：

1. 申请内存空间保存函数体代码
2. 将上述代码地址绑定给函数名
3. 定义函数不会执行函数体代码，但是会检测函数体语法

• 函数 调用

print(pritInfo())#打印的是内存地址
pritInfo()

调用函数发生的事情：

1. 通过函数名找到函数的内存地址
2. 然后加括号就是在触发函数体代码的执行

def foo():
    bar()
    print('from foo')
def bar():
    print('from bar')
    
foo()
"""执行过程"""
函数的使用分两个 阶段，
第一个阶段：定义
第二个阶段：调用
定义的时候只检测语法，不执行代码
在定义foo时咩有语法错误
然后再去定义bar，
最后再去调用foo()时，bar早就丢到内存中了，所以就不会报错，

def foo():
    bar()
    print('from foo')
    
foo()

def bar():
    print('from bar')
    
"""会报错"""
	

• 进一步去输出不同人的信息， 通过传入参数来解决

def pritInfo(name,height,weight,hobby,pro):

    #函数代码块
    print('%s的身高是%f'%(name,height))
    print('%s的体重是%f'%(name,weight))
    print('%s的爱好是%s'%(name,hobby))
    print('%s的专业是%s'%(name,pro))

• 调用带参数的信息

pritInfo('peter',175,130,'听音乐','甜品师')
pritInfo('小李',189,140,'打游戏','软件工程师')

---

4.2、函数参数

• 参数分类：

必选参数，默认参数【缺省参数】，可选参数，关键字参数

• 参数：其实就是函数为了实现某项特定功能，进而为了得到实现功能所需要的数据

def sum(a,b):#形式参数：只是意义上的一种参数，在定义的时候是不占内存地址的

sum=a+b
print(sum)

• 必选参数 （位置参数）

函数调用的时候，必选参数是必须要赋值的
sum(20,15)#20,15就是实际参数 实参， 实实在在的参数，是实际占用内存地址的
sum()不能这样写，需要传参

位置实参：在函数嗲用阶段，按照从左往右的顺序依次传入值

位置实参必须放在关键字实参前，否则报语法错误

在调用阶段，实参（变量值）会绑定给形参（变量名）

实参与形参的绑定关系：在函数调用时生效，调用结束后解除绑定关系

• 默认参数【缺省参数】（默认形参）

在定义函数阶段，就已经被赋值的形参，称之为默认形参

特点**：在定义阶段就已经被赋值，**意味着在调用阶段可以不用为其赋值

位置形参必须在默认形参的左边

def sum(a=1,b=11):
     print(a+b)

sum()#在调用的时候，如果未赋值，就用定义函数时给定的默认值
sum(10)#10赋给了a,b还是11,结果为21

• 关键字参数

关键字实参：在函数调用阶段，按照key=value的形式传入值

位置实参必须放在关键字实参前，否则报语法错误

指名道姓的给某个形参传值，

def a(a,b):
    res=a+b
    return res
print(a(b=2,a=1))

• 可变参数（当参数的个数不确定时，比较灵活）

*形参名：用来接受溢出的位置实参，溢出的位置实参会被*保存成元组形式

def getComputer(a,b*args):
    '''
    计算累加和
    '''
    # print(args)
    result=0
    for item in args:
        result+=item
    print(result)

getComputer(1,2,3,4)

"""结果如下"""
1 2 (3,4)

• *可用在实参中，实参中带*,把*后的值打散成位置实参

def func(x,u,z):
    print(x,u,z)
func(*[11,22,33])#相当于func(11,22,33)

def func2(x,y,*args):
    print(x,y,args)
func2(*'hello')
"""结果如下"""
11 22 33
h e ('l','l','o')

• 形参实参都带*

def func(x,y,*args):#args=(3,4,5,6)
    print(x,y,args)
func(1,2*[3,4,5,6])#相当于func(1,2,3,4,5,6)

"""结果如下"""
1 2 (3,4,5,6)

• 关键字可变参数

1. **来定义
2. 在函数体内 参数关键字是一个字典类型，key是一个字符串
3. 可变参数指的是在调用函数的时候，传入的值（实参）的个数不固定

def Func(a,b**kwargs):
    print(a,b,kwargs)
Func(1,b=2,x=3,b=5)

def Infofunc(*args,**kwargs): #可选参数必须在关键字可选参数之前
     print(args)
     print(kwargs)
 Infofunc(1,2)
# Infofunc(12,13,46,age=18)

• **可用在实参中，实参中带**,把**后的值打散成关键字实参

def func(x,y,c):
    print(x,y,c)
#func(*{'x':1,'y':2,'c':3})#func('x','y','c')
func(**{'x':1,'y':2,'c':3})#func(x=1,y=2,c=3)


"""结果如下"""
1 2 3

• 形参与实参都带**

def func(x,y,**kwargs):
    print(x,y,kwargs)
func(**{'y':111,'x':211,'z':456,'d':789})#打散后相当于func(y=222,x=211,z=456,d=789)

"""结果如下"""
211 111 {'z':456,'d':789}

• 混用*与**：*args必须在**kwargs前面

def fun(*args,**kwargs):
    print(args)
    print(kwargs)
fun(1,2,3,4,5,6,8,x=1,y=2,z=3)

"""结果如下"""
(1,2,3,4,5,6,8)
{'x':1,'y':2,'z':3}

• 命名关键字参数（了解）

def func(x,y,*,a,b):#a和b为命名关键字参数
    print(x,y)
    print(a,b)

案例实现

• 接收N 个数字，求这些参数数字的和

def num(*args):
    '''
    #写函数，接收N 个数字，求这些参数数字的和
    '''
    result=0
    for  i in args:
        result+=i

    return result
a=num(1,2,2,2,2)
print(a)

• 找出传入的列表或元组的奇数位对应的元素，并返回一个新的列表

def Func1(con):
    '''
    找出传入的列表或元组的奇数位对应的元素，并返回一个新的列表
    '''
    listA=[]
    index=1
    for i in con:
        if index%2==1:#判断奇数位
            listA.append(i)
        index+=1
    return listA
# e=Func1([1,2,45,1,1,'as',{1,25,',hs'}])
e=Func1(list(range(1,11)))
print(e)

• 检查传入字典的每一个value的长度，如果大于2，那么仅仅保留前两个长度的内容，并将新的内容返回给调用者，PS:字典中的数据只能是字符串或者是列表

def Func2(dic):
    '''
    检查传入字典的每一个value的长度，如果大于2，那么仅仅保留前两个长度的内容，
    并将新的内容返回给调用者，PS:字典中的数据只能是字符串或者是列表
    '''
    result={}
    for key,value in dic.items():
        if len(value)>2:
            result[key]=value[:2]#向字典添加新的数据
        else:
            result[key]=value

    return result
#调用
dicObj={'name':'张三','hobby':['唱歌','跳舞','编程'],'major':'信息安全'}
print(Func2(dicObj))

---

4.3、函数返回值

• 概念：函数执行完以后会返回一个对象，如果在函数的内部有return，就可以返回实际的值，否则返回None
• 类型：可以返回任意 类型，返回值类型应该取决于return 后面的类型
• 用途：给调用方返回数据
• 在一个函数体内可以出现多个return ，但是肯定只有一个return
• 如果在一个函数体内，执行了return,意味着就执行完成推出了，return后面的代码将不会执行

#返回值

def Sum(a,b):
    sum=a+b
    return sum #将计算结果返回
result=Sum(12,15)#将返回的值赋给其他变量
print(result)

def calComputer(num):
    '''
    累加和
    '''
    listA=[]
    result=0
    i=1
    while i<=num:
        result+=i
        i+=1
        # listA.append(result)
    listA.append(result)
    return listA
message=calComputer(10)
print(type(message))

print(message)


def returnType():
    '''
    返回元组类型数据
    '''
    return 1,2,3
a =returnType()
print(type(a))
print(a)

def returnType1():
    '''
    返回字典类型
    '''
    return {"name":"成龙"}
b=returnType1()
print(type(b))
print(b)

---