Python函数

最新推荐文章于 2024-03-11 09:41:52 发布

卢同学.

最新推荐文章于 2024-03-11 09:41:52 发布

阅读量310

点赞数

分类专栏： Python 文章标签： python

本文链接：https://blog.csdn.net/weixin_44801980/article/details/108524727

版权

Python 专栏收录该内容

120 篇文章 4 订阅

订阅专栏

1、函数的定义

function：代码块。 /就是将我们要执行的代码进行结构的整合，形成可重复调用的代码块。
（1）关键字: def

（2）函数名
命名规范：
<1>、 字母开头。
<2>、 不允许有关键字 。
<3>、 不允许有特殊符号 。
<4>、 不允许莫名其妙的函数名 a,b。

（3）参数
参数是定义在参数括号里，由调用时传入，作用在函数内部的变量。
<1>、 如果有参数，写在参数括号里。
<2>、 如果没有，写空括号。

（4）内容块
函数的调用:
函数在没有调用之前不会执行, 函数名加括号，并且进行对应的传参的形式。
在定义函数是定义的参数,我们称之为 "形参 " 。
在调用函数的时候我们传递值 我们称之为 "实参"。

2、函数的优点

函数与代码复制的相比较，优点如下：
（1）减少冗余代码。
（2） 代码结构清晰。
（3） 有助于保持代码的一致性。

3、创建函数

语法格式
def FunctionName([parameterlist]):
['''comments''']
[functionbody]

参数说明
FunctionName:函数名称。
parameterlist：可选参数，用于指定向函数中传递的参数。
comments：可选参数，表示为函数指定注释。
functionbody：可选参数，要执行的功能代码。如果函数有返回值，可以使用return返回语句。（如果定义一个什么也不做的函数，可以使用pass作为占位符）。

4、调用函数

语法格式
FunctionName([parametersvalue])

参数说明：
FunctionName:函数名称。
parametersvalue:可选参数，用于指定各个参数的值。若无则写一对小括号即可。

5、参数传递

5.1、形式参数
在定义函数时，函数名后括号里的参数我们称之为 "形参"。

5.2、实际参数
在调用函数时，函数名后括号里的参数我们称之为 "实参"。 即调用函数时的传递值为"实参"。


5.3、参数位置
也称为必备参数，必须按照真确的顺序传递到函数中，即调用时的数量和位置必须和定义的一致。

特点1:数量必须与定义的一致。数量与定义的不一致时，可能会抛出TypeError异常。

案例
调用BMI指标函数 Fun_bmi(person,height,weight),将参数少传递一个代码如下:
Fun_bmi("json",1.80)   计算json的BMI指标
执行上面这行代码，会报TypeError

特点2:位置必须与定义的一致。位置与定义的不一致时，可能会抛出TypeError异常或产生的结果与预期不符合。

案例
调用BMI指标函数 Fun_bmi(person,height,weight),将参数位置写错代码如下:
Fun_bmi(1.80,"json",50)   计算json的BMI指标
执行上面这行代码，会报TypeError


5.4、关键字参数
说明
在指定实际参数时，不再需要与形式参数位置完全一致。
案例
调用BMI指标函数 Fun_bmi(person,height,weight),写上参数名字代码如下:

Fun_bmi(height=1.80,person="json",weight=50)   /计算json的BMI指标
执行上面这行代码，显示结果与预期一致。


5.5、为参数设置默认值
说明
（1）定义函数时，直接指定形式参数的默认值，这样当没有传入参数时会直接使用默认值，不会抛出异常。
（2）定义函数时，指定默认的形式参数必须放在所有参数的最后，否则会产生语法错误。

格式
def FunctionName(...,[parameter1=defaultvalue1]):
[代码块]

参数说明
FunctionName:函数名称。
parameter1=defaultvalue1：可选参数，用于指定向函数中传递的参数，并且为该参数设置默认值defaultvalue1。


5.6、查看当前的默认值。
案例
调用BMI指标函数 Fun_bmi(person,height,weight)
Fun_bmi(1.80,"json",weight=50)   /计算json的BMI指标

显示上面函数的默认值，可以使用Fun_bmi.__default__，结果为"50"


5.7、默认值必须指向不可变对象
说明
使用可变对象作为函数的默认值时，多次调用可能会导致不符合预期的结果。

案例:定义1个函数，并为其参数设置可变的默认值。
def demo(obj=[]): #定义函数并为参数obj指定默认值[]
print("obj的值："，obj)
obj.append(1)

test1:
demo()
输出： obj的值： []

test2:
demo()
demo()
输出：
obj的值： []
obj的值： [1]

test3:
def demo(obj=None):   /定义函数并为参数obj指定默认值[]
if obj == None
obj = []
print("obj的值：",obj)
obj.append(1)

demo()
demo()
输出：
obj的值： []
obj的值： []


5.8、可变参数
可变参数也叫不定长参数。即传入函数的实际参数个数不定。

(1)*parameter
说明
表示接收任意多个实际参数并放到一个元组中。

案例-1
定义一个函数，让其可以接收任意多个实际参数。
代码如下：
def printcoffee(*coffeename):   /定义输出我喜欢的咖啡名字的函数
print('\n我喜欢的咖啡有：')
for item in coffeename:
	print(item)    /输出咖啡名字

调用3次这个函数，分别指定不同个数的实际参数，代码如下：
printcoffee('蓝山')
printcoffee('蓝山','土耳其')
printcoffee('蓝山','土耳其','摩卡')

输出：
我喜欢的咖啡有:
蓝山
我喜欢的咖啡有:
蓝山
土耳其
我喜欢的咖啡有:
蓝山
土耳其
摩卡

案例-2
如果想使用一个已经存在的列表作为函数的可变参数，可以在列表的名称前面加上*，代码如下：
param = ['蓝山','土耳其','摩卡']   /定义列表
printcoffee(*param)   /通过列表指定函数的可变参数

输出：
我喜欢的咖啡有:
蓝山
土耳其
摩卡


(2)**parameter
说明
表示接收任意多个类似关键字参数一样显示赋值的实际参数，并放到一个字典中。

案例-1
定义一个函数，让其可以接收任意多个显示赋值的实际参数。

代码如下：
def printsign(**sign):    /定义输出我喜欢的咖啡名字的函数
print()
for key,value in sign.items():
print("["+key+"]的星座是："+value)    /输出咖啡名字
调用2次这个函数，代码如下：
printsign(A="水瓶"，B="双鱼")
printsign(A="水瓶"，B="双鱼",c="白羊")

输出：
[A]的星座是：水瓶
[B]的星座是：双鱼
[A]的星座是：水瓶
[B]的星座是：双鱼
[C]的星座是：白羊

案例-2
如果想要使用一个已经存在的字典作为函数的可变参数，可以在字典的名称前面加**
代码如下：
dict = {"A":"水瓶","B":"双鱼","C":"白羊"}
print(**dict)
输出：
[A]的星座是：水瓶
[B]的星座是：双鱼
[C]的星座是：白羊

6、无参数函数

案例
无参数函数
def keru():
print("hello lukr")
调用函数
keru()
输出:
hello lukr

7、返回值

说明
为函数设置返回值的作用是将函数的处理结果返回给调用它的程序。

格式
relut = return [value]
参数说明:
relut:用于保存返回结果
value:可选参数，用于指定返回的值，可以是一个或多个。
当函数中没有return语句时，或者省略了return语句的参数时，将返回None，即返回空值。

8、函数的划分

8.1、按照参数类型划分：位置参数;关键字参数;默认参数;参数组

（1）位置参数
是我们在传参的时候，实参传递的顺序按照形参定义的顺序进行传递的传参方式。
#有参数函数
def KERU(name,age):
print("hello %s,I'm %s years old"%(name,age))
#调用函数
KERU("lukr",18)
KERU(18,"lukr")
# 输出：
# hello lukr,I'm 18 years old
# hello 18,I'm lukr years old

（2）关键字参数
是我们在传参的时候，以形参等于实参的形式忽略形参定义的顺序进行传参的传参方式。
有参数函数
def KERU(name,age):
print("hello %s,I'm %s years old"%(name,age))
调用函数
KERU(name = "lukr",age = 18)
KERU(age = 18,name = "lukr")
输出：
hello lukr,I'm 18 years old
hello lukr,I'm 18 years old

（3）默认参数
是在我们定义参数时候，我们给形参一个默认值，在我们调用函数的时候，如果不给有默认值的形参传参，会自动采用默认值。 注意：默认值参数必须写在正常参数的后面。

有参数函数
def KERU(name,age = 18):
print("hello %s,I'm %s years old"%(name,age))
调用函数
KERU(name = "lukr",age = 16)
KERU(age = 17,name = "lukr")
KERU(name = "lukr")
输出：
hello lukr,I'm 16 years old
hello lukr,I'm 17 years old
hello lukr,I'm 18 years old

注意：默认值要写在正常参数的后面，否则会报错
def KERU(age = 18,name):
print("hello %s,I'm %s years old"%(name,age))
调用函数
KERU(name = "lukr") 这里出现了歧义，<1>把参数传给了age，name忘记了传参<2>把参数传给了name，age采用默认值；计算机无法判断歧义，所以会报错。
输出：
SyntaxError: non-default argument follows default argument

注意：默认值要写在正常参数的后面，否则会报错
def KERU(name,age = 18,sex = "female"):
print("hello %s,I'm %s years old,%s."%(name,age,sex))
调用函数
KERU(name = "lukr")
输出：
hello lukr,I'm 18 years old,female.

（4）参数组
指我们将参数变成元组参数组或者字典参数组。
1.元组参数组
通过给形参前面添加*使参数变成一个元组，所有传递的参数变成元组的元素。
def hello(*data):
print(data)
调用函数
hello()
hello(1)
hello(1,2,3)
输出：
()
(1,)
(1, 2, 3)

2.字典参数组
通过给形参前面添加**使参数变成一个字典，所有传递的参数变成字典的键值对，这里传参要求键等于值的形式。
def hello(**data):
print(data)
调用函数
hello()
hello(a = 1)
hello(a = 1,b = 2,c = 3)
输出：
{}
{'a': 1}
{'a': 1, 'b': 2, 'c': 3}

def hello(*data,**kwd):
print(data)
print(kwd)
调用函数
hello(1,2,3)
输出：
(1, 2, 3)
{}
hello(a = 1,b = 2,c = 3)
输出：
()
{'a': 1, 'b': 2, 'c': 3}
hello(1,b = 2,c = 3)
输出：
(1,)
{'b': 2, 'c': 3}

8.2、按照返回值划分

区别点在于是否有返回值。

（1）返回型函数:有返回值。
 注:SAY_hello这个函数有返回值，作用是返回"hello world!"。类型是:str
def SAY_hello():
	return "hello world!"

SAY_hello()
 输出:
 无

print(type(SAY_hello()))
 输出:
 <class 'str'>

（2）计算型函数:没有返回值。
 注:say_hello这个函数没有返回值，它的功能只是打印出"hello world!"。类型是:None
def say_hello():
	print("hello world!")

say_hello()
 输出:
 hello world!

print(type(say_hello()))
 输出:
 hello world!
 <class 'NoneType'>

8.3、return
<1> return将函数当中的值返回出来。
<2> return结束，函数结束，函数当中return下面的语句不会执行。
<3> return只能返回一个值。
def say_hello():
print(“hello world!”)

def SAY_hello():
return "hello world!","thanks!"
print("thanks!")    不会执行，return结束，函数就结束了。

def SAY_HELLO():
return "HELLO WORLED!"


print(type(say_hello()))
输出:
hello world!
<class 'NoneType'>

print(type(SAY_hello()))
输出:
<class 'tuple'>

print(say_hello())
输出:
hello world!
None

print(SAY_hello())
输出:
('hello world!', 'thanks!') return只能返回1个参数

print(SAY_HELLO())
输出:
HELLO WORLED!return 只能返回1个参数

卢同学.

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Python函数

1、函数的定义function：代码块。 /就是将我们要执行的代码进行结构的整合，形成可重复调用的代码块。（1）关键字: def（2）函数名命名规范：<1>、字母开头。<2>、不允许有关键字。<3>、不允许有特殊符号。<4>、不允许莫名其妙的函数名 a,b。（3）参数参数是定义在参数括号里，由调用时传入，作用在函数内部的变量。<1>、如果有参数，写在参数括号里。<2>、如果没有，写空括号。
复制链接

扫一扫