4.python函数基础（上）

一.函数基础

1.什么是函数

一系列python语句的组合，可以在程序中运行一次或者多次，一般是完成具体的独立的功能

2.为什么要使用函数

代码的复用最大化，以及最小化冗余代码，整体代码结构清晰，问题局部化

为了提高编写的效率以及代码的重用，把具有独立功能的代码块组织为一个小模块

3.函数定义及调用

def 函数名(参数列表)     #可以是0个，也可以多个参数
    函数体              #一系列python语句，表示独立的功能

函数名(参数)     #即可调用，参数0-n个
#本质上是去执行函数定义里面的代码块，在调用之前必须先定义

二.简单应用

案例一：

print('小张的身高是%f'%1.73)
print('小张的体重是%f'%160)
print('小张的爱好是%s'%'唱歌')
print('小张的专业是%s'%'计算机')
# 想反复多次的打印小张的信息，可以copy，但是很麻烦

针对上面的场景，就需要进一步的去优化代码，用函数将相同功能的代码块进行包装【方案：封装函数】

def printInfo():      # 函数代码块
    '''               # 在第一行用字符串做函数说明
    这个函数用来打印小张个人信息
    :return:
    '''
    print('小张的身高是%f' % 1.73)
    print('小张的体重是%f' % 160)
    print('小张的爱好是%s' % '唱歌')
    print('小张的专业是%s' % '计算机')
    pass

# 函数的调用
printInfo()

进一步去完善这样的需求，例如【输出不同人的信息】，通过传入参数来解决

函数为了实现某些特定的功能，进而为了得到实现功能所需要的数据

def printInfo(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))
    pass
printInfo('小桃',1.67,58,'打游戏','数学')  #实际参数,打印小桃的信息
printInfo('Peter',1.89,67.3,'跳舞'，'金融')   #打印Peter的信息

二.函数的参数

参数分类：必选参数、默认参数（缺省参数）、可选参数、关键字可选参数
目的：函数为了实现功能，获得实现这些功能所需要的数据（为了得到外部数据）

1. 必选参数-----变量可以是列表或元组

def sum(a,b):    #形式参数：只是意义上的一种参数，在定义是不占内存地址
    sum=a+b
    print(sum)   
sum(20,15)    #参数调用，20、15是实际参数，实实在在的参数，占用内存地址
sum()       #报错，必须出具体的参数值 

 2. 默认参数(缺省参数)--------始终存在于参数列表的尾部

def sum1(a=20,b=30):       #有缺省参数时，调用的时候可以不赋值
    print('默认参数的使用=%d'%(a+b))
    pass
sum1()     #有缺省参数时+调用没有赋值，默认使用缺省参数
sum1(10)   #也可以重新赋值,相当于给a重新赋值10，b使用默认参数30


# 【默认参数】不能放在【必选参数】前面，如def sum1(a=20,b)----是错误的
def sum1(a,b=30):       # 正确，默认参数 在 必选参数 的后面
    print('默认参数的使用=%d'%(a+b))
    pass
sum1(10)
sum1(20,40)

3. 可选参数（可变参数）---------当参数的个数不确定时使用，比较灵活，元组

def getCumputer(*args):   # *args表示可变长的参数，是元组类型
    '''
    计算累加和
    :param args: 可变长的参数类型
    :return:
    '''
    # print(args)     #输出的时元组类型
    result=0
    for item in args:
        result+=item
        pass
    print('result=%d'%result)
    pass

getCumputer((1,2,3,4,5,6))    # 错误，直接给数据，非元组
getCumputer(1)
getCumputer(1,2)
getCumputer(1,2,3)
getCumputer(1,2,3,4,5,6,7,8)

4. 关键字可选参数-------输入的是字典，key是字符串，（**字典）为参数

def keyFunc(**kwargs):
    print(kwargs)
    pass

keyFunc(1,2,3)   #错误，不可以传递 ，**是字典，必须输入键值对

#方法一：
dictA={'name':'leo','age':19}
keyFunc(**dictA)
keyFunc(dictA)     #这样是不行的，必须加**
#方法二：
keyFunc(name='Peter',age=34)       # 这样是可以的，可以传递0-n个字典

5.组合使用（*args和**kwards）-----可选参数放在关键字可选参数之前

def complexFunc(*args,**kwards):
    print(args)
    print(kwards)
    pass
complexFunc()           #不会报错，空元组和空字典
complexFunc(1,2,3,4)     #不会报错，以元组形式传递给*args
complexFunc(1,2,3,4,name='刘德华')      #字典输入方法二
complexFunc(age=36)       #不会报错，以字典形式传递给**kwards


def TestMup(**kwards,*args):   #不符合要求
    '''
    【可选参数】必须放到【关键字可选参数】之前
    可选参数：接受的是一个元组类型
    关键字可选参数：接受的数据是一个字典类型
    :param kwards:
    :param args:
    :return:
    '''
    pass

三. 函数的返回值

概念：函数执行完之后，会返回一个对象，如果在函数内部有return，就会返回实际的值，否则返回null

 返回值类型：可以返回任意类型，取决于return后面的类型 

注意：在一个函数体内可以出现多个return值，但是肯定只能返回一个return 。如果在一个函数体内，执行了return，意味着函数就能退出了，执行已经完成，return后面的代码将不在执行

def sum(a,b):
    sum=a+b
    pass
sum(10,20)     #没有返回

#两种返回并打印方式：
#方法一：
def sum(a,b):
    sum=a+b
    return sum   # 将计算结果返回
    pass
print(sum(10,20))    # 将函数的返回值返回到调用的地方，再打印输出

#方法二：
def sum(a,b):
    sum=a+b
    return sum   # 将计算结果返回
    pass
rs=sum(10,20)    # 将调用的【返回值】赋值给其他的变量
print(rs)        #打印输出 返回值

# 案例：累加和计算
def calComputer(num):
    result=0
    i=1
    while i<=num:
        result+=i
        i+=1
        pass
    return result
    pass
#方法一：
print(calComputer(10))
#方法二：
value=calComputer(10)
print(value)
print(type(value))    #int类型

# 案例：要返回一个列表,不是返回整形int
def calComputer(num):
    listA=[]
    result=0
    i=1
    while i<=num:
        result+=i
        i+=1
        pass
    listA.append(result)
    return listA            # 返回类型由return决定
    pass
print(calComputer(10))
print(type(calComputer(10)))

# 案例要返回一个元组类型的数据
# 1.
def returntuple():
    '''
    返回元组类型的数据
    :return:
    '''
    return 1,2,3
    pass
A=returntuple()
print(type(A))


#2.
def calComputer(num):
    result=0
    i=1
    while i<=num:
        result+=i
        i+=1
        pass
    rs=result,           #元组中只有一个值时，要加逗号，否则被视为int
    return  rs           # 返回类型由return决定
    pass
print(calComputer(10))
print(type(calComputer(10)))

# 案例：(返回字典类型的数据)----正确案例
def returntuple():
    '''
    返回字典类型的数据
    :return:
    '''
    return {'name':'测试'}
    pass
A=returntuple()
print(type(A))

四. 函数的嵌套使用

在一个函数内部调用另外一个函数，内层函数可以访问外层函数中定义的变量，但不能重复赋值

def fun1():
    print('------------fun1开始执行-------')
    print('------------执行代码省略--------')
    print('------------fun1 end----------')
    pass

def fun2():
    print('------------fun2开始执行-------')
    fun1()     # 在这里调用第一个函数
    print('------------fun2 end----------')
    pass

fun2()     # 此时调用fun2

函数的分类：根据函数的返回值和函数的参数:
1.有参数-无返回值的
2.有参数-有返回值的
3.无参数-有返回值的
4.无参数-无返回值的

总结：
函数基础：def定义函数、函数调用、函数说明
函数参数*：函数传参、缺省函数、不定长参数
函数返回值：return、多个返回值-----1or多个都由return决定
函数嵌套调用：嵌套调用方法

五. 作业

1. 写函数，接收n个数字，求出这些参数数字的和（可变长的数据args、元组，、是序列，可以遍历）

#  正确答案
def sum1(*args):
    '''
    处理接收数据
    :param args:可变长参数（n个数），可以接受一个元组
    :return:计算和
    '''
    sum=0
    for item in args:
        sum+=item
        pass
    return sum
    pass
#调用函数
sum1((1,2,3,4,5,6,7))   #数据输入 错误
print(sum1(1,2,3,4,5,6,7))   #正确

2. 写函数，找出传入列表或元组的奇数位对应的元素，并返回一个新的列表，接收的变量可以是元组也可以是列表（序列）

# 正确答案
def processFunc(con):
    '''
    处理列表数据
    :param con: 接收的是一个列表或元组
    :return:新的列表对象
    '''
    listA=[]
    index=1
    for i in con:      #i是列表中的值，不是索引
        if index%2==1:    #判断奇数位,用索引判断
            listA.append(i)
            pass
        index+=1
        pass
    return listA
    pass
rs=processFunc([1,2,3,4,5,6,7])
rs2=processFunc(list(range(10,30)))
print(rs)
print(rs2)

# 错误答案
def fun2(LT):
    listA=[]
    for i in (0,len(LT)):
        if i%2!=0:
            rs=LT[i]
            pass
        else:
            continue
            pass
        listA.append(rs)
        pass
    return listA
print(fun2([1,2,3,4,5,6]))
#修改之后
def fun2(LT):
    listA=[]
    index=1
    for i in LT:          # i表示的是列表中的数据，不是索引
        if index%2!=0:
            rs=i
            listA.append(rs)
            pass
        index+=1
        pass
    return listA
print(fun2([1,2,3,4,5,6]))

3. 写函数，【检查传入字典的每一个（需要遍历）】value的长度，如果大于2，那么只保留前两个长度的内容，并将内容返回给调用者。PS：字典中的value只能是字符串或者列表

分析：传入字典，则参数是字典---可变关键字参数**kwards 或者 随便一个变量

# 老师方法
def dictFunc(dicParms):
    '''
    处理字典数据
    :param value: 字典
    :return: str或list
    '''

#  遍历字典，可以获取字典的key，也可以是value

    result={}   #空字典
    for key,value in dicParms.items():   #获得字典的项key-value
        if len(value)>2:
            result[key]=value[0:2]     #像字典里添加数据
            pass
        else:
            result[key]=value
            pass
        pass
    return result
    pass

dictObj={'name':'欧阳','hobby':['打球','唱歌','跳舞','python'],'编码':'465367'}
print(dictFunc(dictObj))

def fun3(dictA):
    '''
    处理字典数据
    :param value: 字典
    :return: str或list
    '''
# 要检查传入字典的每一个value，必须先遍历
    for key,value in dictA.items():
        if len(value)>2:  # 或者**kwards
            dictA[key]=value[:2]
            pass
        else:
            dictA[key]=value
            pass

    return dictA
    pass

# 调用函数，首先定义一个元组
dictR={'name':'欧阳','hobby':['打球','唱歌','跳舞','python'],'编码':'465367'}
print(fun3(dictR))