Python【第四天】函数【1】

总体描述

函数概念：
一系列Python语句的组合，可以在程序中运行一次或者多次，一般是完成具体的独立的功能
意义：
代码的复用最大化以及最小化冗余代码，整体代码结构清晰，问题局部化
函数定义：
def + 关键字 + 小括号 + 冒号 + 换行缩进 + 代码块 定义一个函数
def 函数名():
代码块
函数的分类：根据函数的返回值和函数的参数
有参数无返回值的
有参数有返回值的
无参数有返回值的
无参数无返回值的

初始函数

函数调用：
函数名加()即可调用函数，本质上就是去执行函数定义里面的代码块，再调用函数之前 必须先定义
函数说明文档：
函数内容的第一行可以用字符串进行函数说明
定义函数的时候，我们把参数的名字和位置确定下来，函数的接口定义就完成了。
对于函数的调用者来说，只需要知道如何传递正确的参数，以及函数将返回什么样类型的值就够了。

# print("小张的身高是%.2fm"%1.78)
# print("小张的体重是%dkg"%73)
# print("小张的爱好是%s"%'唱歌')
# print("小张的专业是%s"%'软件工程')
#处理其他的逻辑信息
#多次打印出小张的信息
# print("------------------------多次打印------------------------")
# print("小张的身高是%.2fm"%1.78)
# print("小张的体重是%dkg"%73)
# print("小张的爱好是%s"%'唱歌')
# print("小张的专业是%s"%'软件工程')
# 针对上边的场景 就需要进一步去优化代码【方案：封装函数】
#函数的定义
# def printInfo():
#     '''
#     这个函数是用来打印个人信息的 是对小张信息显示的组合
#     '''
# #函数代码块
#     print("小张的身高是%.2fm"%1.78)
#     print("小张的体重是%dkg"%73)
#     print("小张的爱好是%s"%'唱歌')
#     print("小张的专业是%s"%'软件工程')
#     pass
#函数的调用
# for item in range(1,4):
#     printInfo()  #函数的调用
#     pass
# 进一步去完善这样的需求【输出不同人的信息】 方案：通过传入的参数来解决
# 函数的定义：
# def 函数名(参数列表):0-n
#     代码块
def printInfo(name,height,weight,hobby,pro):
    '''
    这个函数是用来打印个人信息的 是对小张信息显示的组合
    '''
#函数代码块
    print("%s的身高是%.2fm"%(name,height))
    print("%s的体重是%dkg"%(name,weight))
    print("%s的爱好是%s"%(name,hobby))
    print("%s的专业是%s"%(name,pro))
    pass
name = input('请输入姓名:')
height = float(input('请输入身高:'))
weight = int(input('请输入体重:'))
hobby = input('请输入爱好:')
pro = input('请输入专业:')
printInfo(name,height,weight,hobby,pro)

函数参数

参数的分类：
必选参数、默认参数[缺省参数]、可选参数、关键字参数
参数：函数为了实现某项的定的功能，进而为了得到实现功能所需要的数据
就是为了得到外部数据

• 必选参数`

def sum(a,b):  #形式参数：只是意义上的一种参数，在定义的时候是不占用内存地址的
    sum = a+b
    print(sum)
    pass
#函数的调用  在调用的时候必选参数 是必须赋值的
sum(20,15)  #20、15：实际参数(实参)：实实在在的参数，是实际占用内存地址的
# sum(15)  #不能这样写

• 默认参数【缺省参数】 失踪存在于参数列表中的尾部

def sum1(a = 20,b = 30):
    print('默认参数使用 = %d'%(a+b))
    pass
# 默认参数的调用
# 在调用的时候如果未赋值，就会用定义函数时给定的默认值
sum1()
sum1(10)
sum1(10,20)

• 可选参数【不定长参数】 当参数的个数不确定时使用，比较灵活

def getComplex(*args):  #可变长的参数类型
    '''
    计算累加和
    可变长的参数类型
    '''
    sum = 0
    for item in args:
        sum += item
    print("sum = %d"%sum)
    pass
getComplex(1)
getComplex(1,2)
getComplex(1,2,3)

• 关键字可变参数

**来定义
在函数体内，参数关键字是一个字典类型 key是一个字符串

def keyFunc(**kwags):
    print(kwags)
    pass
# 调用
# keyFunc(1,2,3)  #不可以传递的
dictA = {'name':'Leo','age':35}
# keyFunc(dictA)  #不可以的
keyFunc(**dictA)  #正确！！！
keyFunc(name = 'peter',age = 26)
keyFunc()  #不传也是可以的

• 组合使用

def complexFunc(*args,**kwags):
    print(args)
    print(kwags)
    pass
complexFunc()
complexFunc(1,2,3,4)  #将这几个数以元组的形式传入 *args
complexFunc(name = 'Leo')  #将 name = 'Leo' 以字典形式传入**kwags
complexFunc(1,2,3,4,name = 'Leo')
# def TestMup(**kwags,*args):  #不符合要求的
#     '''
#     可选参数必须放到关键字可变参数之前
#     可选参数：接收的数据是一个元组类型
#     关键字可选参数：接受的数据是一个字典类型
#     '''
#     pass

函数返回值

函数返回值：
当函数执行完以后，会返回一个对象，在函数的内部由return关键字，就会返回实际的值，否则返回None
类型：可以返回任意类型，返回值类型应该取决于return后面的类型
用途：给调用方返回数据
在一个函数体内，可以出现多个return值，但是肯定只能返回一个return
如果在一个函数体内执行了return 就意味着函数就执行完成退出了 return后边的语句就不会执行

def Sum(a,b):
    sum = a+b
    return sum  #将计算的结果返回
    pass

rs = Sum(10,20)
print(rs)  #函数的返回值返回到调用的地方

• 返回列表

def calComputer(num):
    li = []
    result = 0
    i = 1
    while i<=num:
        result += i
        i += 1
        li.append(result)
        pass
    
    return li
    pass
# 调用函数
value = calComputer(10)
print(type(value))
print(value)

• 返回元组

def returnTuple():
    '''
    返回元组类型的数据
    '''
    return 1,2,3  
    pass
tupleA = returnTuple()
print(type(tupleA))
print(tupleA)

• 返回字典

def returnDict():
    '''
    返回字典类型
    '''
    return {'name':'A','age':'B'}
    pass
dictA = returnDict()
print(type(dictA))
print(dictA)

函数的嵌套

def fun1():
    print("-------------------fun1  start-------------------")
    print("--------------------执行代码省略------------------")
    print("--------------------fun1  end--------------------")
    pass
def fun2():
    print("-------------------fun2  start-------------------")
    #调用第一个函数
    fun1()
    print("--------------------fun2  end--------------------")
    pass
fun2()  #调用函数2

案例

• 求数字和(参数)

def sumFunc(*args):
    result = 0
    #处理接收的数据
    for item in args:
        result += item
        pass
    return result
    pass

#调用函数
rs = sumFunc(1,2,3,4,5)
print('rs = {}'.format(rs))  #format 格式化输出
rs1 = sumFunc(4,5,6,7,8,9,10)
print('rs1 =%d'%rs1)

• 找奇数数位的元素(返回列表)

def process_Func(con):
    listNew = []
    index = 1
    for i in con:
        if index%2 == 1:  #判断奇数位
            listNew.append(i)
            pass 
        index += 1
        pass
    return listNew
    pass

# 参数为列表
listA = process_Func([1,2,3,4,5,6,7,8,9,10])
print(listA)
# 参数为元组
tupleA = process_Func(tuple(range(10,30)))
print(tupleA)

• 检查字典value的长度

def dictFunc(dicParms): #**kwargs
    '''
    处理字典类型的数据
    :param dictParms:字典
    '''
    result={} #空字典
    for key,value in dicParms.items():
        if len(value)>2:
            result[key] = value[:2] #向字典添加数据
            pass
        else:
            result[key] = value
            pass
    pass
    return result
#函数调用

dictObj={'name':'A','爱好':['打篮球','唱歌','跳舞'],'pro':'软件工程'}
print(dictFunc(dictObj))