Python函数基础
Python函数:
- 基本上所有的高级语言都支持函数,Python也不例外。Python不但能非常灵活地定义函数,而且本身内置了很多有用的函数,可以直接调用。
- 函数就是最基本的一种代码抽象的方式。
函数基础
概念:
在编写程序的过程中,有某一功能代码块出现多次, 但是为了提高编写的效率以及代码的重用,所以把具有独立功能的代码块组织为一个小模块,这就是函数。
想一想,下面这段代码打印一个美女。如果在程序中不同地方打印美女呢?那是不是没一个地方都要写一段?要解决这种代码重复的问题,函数上场了!
函数定义:
def + 关键字 + 小括号 + 冒号+ 换行缩进 + 代码块 定义一个函数:
def 函数名():
代码块
函数调用:
函数名加()即可调用该函数
函数说明文档:
函数内容的第一行可以用字符串进行函数说明
# print('小张的身高是%f'%1.73)
# print('小张的体重是%f'%160)
# print('小张的爱好是%s'%'唱歌')
# print('小张的身高是%s'%'计算机信息管理')
#处理其他的逻辑信息
# 多次去打印出小张的信息
print('---------------多次输出相同的信息---------------------')
# print('小张的身高是%f'%1.73)
# print('小张的体重是%f'%160)
# print('小张的爱好是%s'%'唱歌')
# print('小张的专业是%s'%'计算机信息管理')
# 针对上面的场景 就需要进一步的去优化代码【方案:封装函数】
# 函数的定义
# def 函数名(参数列表):0-n 个
# 代码块
def printInfo():
'''
这个函数是用来打印个人信息的 是对小张信息显示的组合
:return:
'''
# 函数代码块
print('小张的身高是%f' % 1.73)
print('小张的体重是%f' % 160)
print('小张的爱好是%s' % '唱歌')
print('小张的专业是%s' % '计算机信息管理')
pass
#函数的调用
# printInfo() #函数的调用
# printInfo() #多次调用
# printInfo()
# printInfo()
# printInfo()
# print('我是其他的代码块...')
# 进一步的去完善这样的需求【输出不同人的信息】 方案:通过传入参数来解决
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('小李',189,200,'打游戏','咨询师') #实参
print('------------------带参数的调用---------------------------')
printInfo('peter',175,160,'码代码','计算机应用')
函数参数
定义函数的时候,我们把参数的名字和位置确定下来,函数的接口定义就完成了。对于函数的调用者来说,只需要知道如何传递正确的参数,以及函数将返回什么样的值就够了
Python的函数定义非常简单,但灵活度却非常大。除了正常定义的必选参数外,还可以使用默认参数、可变参数和关键字参数,使得函数定义出来的接口,不但能处理复杂的参数,还可以简化调用者的代码
缺省参数
缺省参数,在调用函数时如果没有传参数,那么会使用定义函数时给的缺省值。
缺省参数必须在参数列表的最后面,否则会报错。
不定长参数
一个函数有时候会处理比当初声明的参数要多,这就是不定长参数,定义函数时不用声明参数名。加了星号(*)的变量args会存放所有未命名的变量参数,args为元组;而加**的变量kwargs会存放命名参数,即形如key=value的参数, kwargs为字典。
引用参数
Python中函数参数是引用传递(注意不是值传递)。对于不可变类型,因变量不能修改,所以运算不会影响到变量自身;而对于可变类型来说,函数体中的运算有可能会更改传入的参数变量。
# 参数的分类:
# 必选参数、默认参数[缺省参数]、可选参数、关键字参数
# 参数:其实就是函数为了实现某项特定的功能,进而为了得到实现功能所需要的数据
# 为了得到外部数据的
# 1 必选参数
def sum(a,b): #形式参数:只是意义上的一种参数,在定义的时候是不占内存地址的
sum=a+b
print(sum)
pass
# 函数调用 在调用的时候必选参数 是必须要赋值的
# sum(20,15) #20 15 实际参数:实参,实实在在的参数,是实际占用内存地址的
# sum(15) #不能这样写的,
# 2:默认参数【缺省参数】 始终存在于参数列表中的尾部
# def sum1(a,b=40,c=90):
# print('默认参数使用=%d'%(a+b))
# pass
# # 默认参数调用
# sum1(10) #在调用的时候如果未赋值,就会用定义函数时给定的默认值
# sum1(2,56)
#可变参数(当参数的个数不确定时使用,比较灵活
# def getComputer(*args): #可变长的参数
# # '''
# # 计算累加和
# # :param args: 可变长的参数类型
# # :return:
# # '''
# # # print(args)
# # result=0
# # for item in args:
# # result+=item
# # pass
# # print('result=%d'%result)
# # pass
# #
# # getComputer(1)
# # getComputer(1,2)
# # getComputer(1,2,3)
# # getComputer(1,2,3,4,5,6,7,8)
# 关键字可变参数 0-n
# ** 来定义
# 在函数体内 参数关键字是一个字典类型 key是一个字符串
def keyFunc(**kwargs):
print(kwargs)
pass
# 调用
# keyFunc(1,2,3) 不可以传递的
dictA={"name":'Leo',"age":35}
# keyFunc(**dictA)
# keyFunc(name='peter',age=26,)
# keyFunc()
# 组合的使用
# def complexFunc(*args,**kwargs):
# print(args)
# print(kwargs)
# pass
# # complexFunc(1,2,3,4,name='刘德华')
# complexFunc(age=36)
# def TestMup(**kwargs,*args): #不符合要求的
# '''
# 可选参数必须放到关键字可选参数之前
# 可选参数:接受的数据是一个元组类型
# 关键字可选参数:接受的数据是一个字段类型
# :param kwargs:
# :param args:
# :return:
# '''
# pass
函数返回值
所谓“返回值”,就是程序中函数完成一件事情后,最后给调用者的结果
举个生活中例子:
我给小明10块钱,让他给我买包烟。这个例子中,10块钱是我给小明的,就相当于调用函数时传递到参数,让小明买烟这个事情最终的目标是,让他把烟带回来然后给w我,,,此时烟就是返回值
你想要组装一台电脑,你将你的电脑配置参数传给电脑店老板,电脑店老板最后得返回一台组装好的电脑给你。你调用电脑店老板这个方法去帮你组装电脑,他总得给你返回一台组装好的电脑吧,这台电脑就是返回值。
程序中也需要返回值,比如用调用函数去计算两个数的和,最后得返回两个数相加的结果给调用者。
如果函数需要返回多个结果呢?
将要返回的值用逗号隔开。最终会返回一个包含所有返回值的元组。
# 函数返回值
# 概念:函数执行完以后会返回一个对象,如果在函数的内部有return 就可以返回实际的值,否则返回None
# 类型:可以返回任意类型,返回值类型应该取决于return后面的类型
# 用途:给调用方返回数据
# 在一个函数体内可以出现多个return值:但是肯定只能返回一个return
# 如果在一个函数体内 执行了return,意味着函数就执行完成退出了,return后面的代码语句将不会执行
def Sum(a,b):
sum=a+b
return sum#将计算的结果返回
pass
# rs=Sum(10,30) #将返回值赋给其他的变量
# print(rs) #函数的返回值返回到调用的地方
def calComputer(num):
li=[]
result=0
i=1
while i<=num:
result+=i
i+=1
pass
li.append(result)
return li
pass
# 调用函数
# value=calComputer(10)
# print(type(value)) #value 类型
# print(value)
def returnTuple():
'''
返回元组类型的数据
:return:
'''
# return 1,2,3
return {"name":"测试"}
pass
A=returnTuple()
print(type(A))
函数嵌套调用
函数可以嵌套调用,即在一个函数内部调用另外一个函数。
内层函数可以访问外层函数中定义的变量,但不能重新赋值(rebind)
# 函数嵌套
def fun1():
print("--------------fun1 start-------------------")
print("--------------执行代码省略-------------------")
print("--------------fun1 end-------------------")
pass
def fun2():
print("--------------fun2 start-------------------")
# 调用第一个函数
fun1()
print("--------------fun2 end-------------------")
pass
fun2() #调用函数2
# 函数的分类:根据函数的返回值和函数的参数
# 有参数无返回值的
# 有参数又返回值的
# 无参数又返回值的
# 无参数无返回值的