Python学习 day4-2021.3.2（函数基础）

---

Python入门课程系列：

• Python学习 day1：认识Python
• Python学习 day2：判断语句与循环控制
• Python学习 day3：高级数据类型

---

函数就是最基本的一种代码抽象的方式

1. 函数基础

• 函数：是一系列python语句的组合，可以在程序中运行一次或者多次，一般是完成具体的独立的功能。
• 使用函数的意义：最大化复用代码以及最小化冗余代码。
• 函数的定义：
  def 函数名(参数列表): #参数可以是0-N个
  函数体[一系列的python语句，表示独立的功能]
• 函数的调用：本质上就是去执行函数定义里面的代码块，在调用函数之前必须先定义

print('小李的身高是%f'%1.63)
print('小李的体重是%d'%45)
print('小李的爱好是%s'%'学习')
print('小李的专业是%s'%'计算机')

#如果需要反复打印如上信息，就可以把它包装成函数
def printInfo():  #下面是函数的说明文档，一般在函数第一行，敲三个单引号即可添加。
    '''
    这个函数是用来打印个人信息的，是对小李信息显示的组合
    :return:
    ''' #添加好之后按住command，将鼠标放在函数名字上即可显示。
    print('小李的身高是%f' % 1.63)
    print('小李的体重是%d' % 45)
    print('小李的爱好是%s' % '学习')
    print('小李的专业是%s' % '计算机')
    pass
printInfo() #函数调用
printInfo() #多次调用
printInfo()

⚠️2. 函数参数

参数：其实就是函数为了实现某项特定的功能，进而为了得到实现功能所需要的数据。（简而言之：参数就是为了得到外部数据的）
重点： 传参 调用 不定长参数
难点： 缺省参数 不定长参数

#进一步去完善这样的需求【输出不同人的信息】，方案：通过传入参数来解决
def printInfo(name,height,weight,hobbit,pro): #形参
    print('%s的身高是%f' %(name,height))
    print('%s的体重是%d' %(name,weight))
    print('%s的爱好是%s' %(name,hobbit))
    print('%s的专业是%s' %(name,pro))
    pass
#调用带参数的信息
printInfo('小刘',1.64,55,'看小说','学生') #实参 

参数的分类：必选参数、默认参数[缺省参数]、可选参数、关键字参数

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

#2. 默认参数【缺省参数】
def sum1(a=20,b=30): #20和30就是默认参数，后面依然可以给a和b赋值，如果不赋值，它们也有默认值
    print('默认参数使用=%d'%(a+b))
    pass
sum1()
sum1(10) #这个值只能赋给a，如果用sum1(,10)这样的格式，会报错。
sum1(10,10)

#3.可选参数/可变参数/不定长参数 （当参数的个数不确定时使用，比较灵活）
def getCompute(*args): #❗️❗️args接受的数据是元组类型
    '''
    计算累加和
    :param args: 可变长的参数类型
    :return:
    '''
    result=0
    for item in args:
        result+=item
        pass
    print('result%d'%result)
    pass
getCompute(1)
getCompute(1,2)
getCompute(1,2,3)

# 4. 关键字可变参数：使用**来定义
# ❗️❗️在函数体内，参数关键字是字典类型 key是一个字符串
def keyfunc(**kwargs):
    print(kwargs)
    pass
# 调用
# keyfunc(1,2,3) 这样是不可以传递的，关键字可变参数必须是字典类型
dictA = {'name': 'leo', 'age': 35}
keyfunc(**dictA)  ##直接传递字典参数要带两个**，否则报错
keyfunc(name='peter', age=26) ##或者直接以命名参数(键值对)传入

#5. 可选参数和关键字可变参数的复合
#❗️❗️可选参数必须放在关键字可选参数之前，否则会报错
def complexfunc(*args,**kwargs):
    print(args)
    print(kwargs)
    pass
complexfunc(1,2,3,4)
complexfunc(1,2,3,4,name='susan')
complexfunc(age=36)

⚠️3. 函数返回值

• 概念：就是程序中函数完成一件事情后，最后给调用者的结果。如果在函数内部有return，就可以返回实际的值，否则返回None。
• 类型：返回值可以是任意类型，取决于return后面的类型
• 用途：给调用方返回数据

在一个函数体内可以出现多个return值 ，但是肯定只能返回一个return。如果在一个函数体内执行了return，意味着函数就执行完成退出了，return后面的代码语句将不会执行。
如果函数需要返回多个结果，则将需要返回的值用逗号隔开，最终会返回一个包含所有返回值的元组。

#例1:
def sum(a,b):
    sum=a+b
    return sum #将计算的结果返回给调用方
    pass
print(sum(10,30)) #函数的返回值返回到调用的地方
#40

##如果没有return sum，返回的是None
def sum(a,b):
    sum=a+b
    pass
print(sum(10,30))
#None

#例2-1:
def calcompute(num):
    result=0
    i=1
    while i<=num:
        result+=i
        i+=1
        pass
    return result
pass
#调用函数
value=calcompute(10)
print(type(value)) #type是int
print(value)
#例2-2: （❗️注意2-1和2-2的区别，除了list还可以返回元组等）
def calcompute(num):
    li=[]
    result=0
    i=1
    while i<=num:
        result+=i
        i+=1
        pass
    li.append(result)
    return li
pass
#调用函数
value=calcompute(10)
print(type(value)) #type是list
print(value)
#例2-3:返回元组
def returnTuple():
    '''
    返回元组类型的数据
    :return:
    '''
    return 1,2,3
pass
A=returnTuple()
print(type(A))
#例2-4 返回字典
def returnDict():
    '''
    返回字典类型的数据
    :return:
    '''
    return{'name':'测试'}
pass
A=returnDict()
print(type(A))

• 根据函数的返回值和函数的参数可以对函数进行分类：
  1.有参数有返回值
  2.有参数无返回值
  3.无参数有返回值
  4.无参数无返回值
• python中print和return的区别
  print的作用是将数据输出到控制端
  return的作用(之一)是返回计算的值，return返回的结果不能输出到控制台，需要通过print才能打印出来。

仔细比较下面4个例子

#例1 直接使用print打印结果
def sum(a,b):
    sum=a+b
    print(sum) #直接将sum结果输出到控制端
    pass
sum(10,30)
#40

#例2 没有return语句，所以没能给函数sum()赋值，打印出来也就是空值(None)
def sum(a,b):
    sum=a+b
    pass
print(sum(10,30))
#None

#例3 虽然有return，但直接调用sum()是没有输出结果的
def sum(a,b):
    sum=a+b
    return sum
    pass
sum(10,30)

 #例4 通过print将return返回的结果输出到控制台。
def sum(a,b):
    sum=a+b
    return sum
    pass
print(sum(10,30))
#40

4. 函数嵌套使用

函数可以嵌套调用，即在一个函数内部调用另外一个函数。内层函数可以访问外层函数中定义的变量，但不能重新赋值(rebind)。

#函数嵌套
def fun1():
    print('--------fun1 start--------')
    print('--------执行代码省略---------')
    print('--------fun1 end-----------')
    pass

def fun2():
    print('--------fun2 start--------')
    #调用第一个函数
    fun1()
    print('--------fun2 end----------')
    pass

fun2() #调用函数2

小结

课后作业

1. 写函数，接收n个数字，求这些参数数字的和
2. 写函数，找出传入的列表或元组的奇数，并返回一个新的列表
3. 写函数，检查传入字典的每一个value的长度，如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。PS：字典中的value只能是字符串或列表

答案

#题1: 
#接收n个数字，求这些参数数字的和
def sum(*args):
    result=0
    for item in args:
        result+=item
        pass
    return result
    pass
rs=sum(1,2,3)  #需要用一个变量来接收return回来的值 
print(rs) 
print('rs={}'.format(rs)) #format格式化输出
#6
#rs=6

# 接收一个数字，求累加和
def sum(a):
    i=1
    k=0
    while i <= a:
        k+=i
        i += 1
        pass
    return k
    pass
print(sum(6))

#题2: 
#方法1.1  #比较1.1和1.2的区别
def lis(container):
    list=[]
    for i in container:
        if i%2==1:
            list.append(i)
    return list
#a=lis((11,8,3,2,15)) 和下面的写法等价
a=lis([11,8,3,2,15]) #接受一个list或元组
print(a)
# 方法1.2
A=[]
def FindOdd(*args):
    for items in args:
        if items%2==0:
            A.append(items)
            pass
    return A
b=FindOdd(1,3,4,6,8) #使用不定长参数，接收一个元组
print(b)
#方法1.3 使用index取下标
def lis(container):
    list=[]
    index=1
    for i in container:
        if i%2==1:
            list.append(i)
            pass
        index+=1
        pass
    return list
a=lis([1,8,6,2,7])
print(a)

#题3：
def dictFun(dicParms):
    '''
    处理字典类型的数据
    :param kwargs: 字典
    :return:
    '''
    result={} #空字典
    for key,value in dicParms.items(): #key-value
        if len(value)>2:
            result[key]=value[:2] #向字典去添加数据
            pass
        else:
            result[key]=value
            pass
        pass
    return result
    pass
#函数调用
dictObj={'name':'hua','pro':'幼儿园班长','hobby':'画画'} #如果有int会报错
print(dictFun(dictObj))
#{'name': 'hu', 'pro': '幼儿', 'hobby': '画画'}