Python学习5
函数
调用函数
要调用一个函数,需要知道函数的名称和参数,比如求绝对值的函数abs
,只有一个参数
a=abs(-122)
print(a)
122
调用函数的时候,如果传入的参数数量不对,会报TypeError
的错误,并且Python会明确地告诉你:abs()
有且仅有1个参数,但给出了两个:
a=abs(-122,2)
print(a)
TypeError: abs() takes exactly one argument (2 given)
而max
函数max()
可以接收任意多个参数,并返回最大的那个:
a=max(1,3,5,67)
print(a)
67
数据类型转换
Python内置的常用函数还包括数据类型转换函数,比如int()
函数可以把其他数据类型转换为整数:
a=int(12.33)
print(a)
12
定义函数
在Python中,定义一个函数要使用def
语句,依次写出函数名、括号、括号中的参数和冒号:
,
然后,在缩进块中编写函数体,函数的返回值用return
语句返回
任何传入参数必须放在圆括号中间,关于这个参数的规矩嘛:
1、在调用函数时,对函数进行参数传递必须与函数声明时的参数列表对应。
2、函数声明时可以声明默认参数,在函数调用时如果没有对默认参数进行传值,这默认参数使用预设值,默认参数要放在参数列表最右侧
3、函数外传参的参数数据类型须一一对应(有些可以强转,碧如float转int)
4、参数类型多种多样,并不局限于常见的int、float、str等参数类型,也可以传类对象等 函数内容以冒号起始,并且缩进。
return [表达式] 结束函数,选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
以自定义一个abs函数为例:
def my_abs(a):
if a >=0:
return a
else:
return -a
print(my_abs(-56))
56
例:
def animal(animal1,animal2):
print('Look,there is a ' +animal1)
print('Look,here is a ' +animal2)
animal('tiger','lion')
def action(action1,action2):
print('He is ' +action1)
print('She is ' +action2)
action('swimming','sleeping')
Look,there is a tiger
Look,here is a lion
He is swimming
She is sleeping
空函数
如果想定义一个什么事也不做的空函数,可以用pass
语句:
def nop():
pass语句什么都不做,那有什么用?实际上
passpass
可以用来作为占位符,比如现在还没想好怎么写函数的代码,就可以先放一个pass
,让代码能运行起来
参数检查
当传入了不恰当的参数时,内置函数abs
会检查出参数错误,而我们定义的my_abs
没有参数检查,会导致if
语句出错,出错信息和abs
不一样。所以,这个函数定义不够完善。
让我们修改一下my_abs
的定义,对参数类型做检查,只允许整数和浮点数类型的参数。数据类型检查可以用内置函数isinstance()
实现:
def my_abs(a):
if not isinstance(a,(float,int)):
raise TypeError('类型错误')
if a >=0:
return a
else:
return -a
print(my_abs('a'))
File "D:/python/project/text.py", line 204, in my_abs
raise TypeError('类型错误')
TypeError: 类型错误
返回多个值
import math
def move(x, y, step, angle=0):
nx = x + step * math.cos(angle)
ny = y - step * math.sin(angle)
return nx, ny
x, y = move(100, 100, 60, math.pi / 6)
print(x,y)
151.96152422706632 70.0
原来返回值是一个tuple!但是,在语法上,返回一个tuple可以省略括号,而多个变量可以同时接收一个tuple,按位置赋给对应的值,
所以,Python的函数返回多值其实就是返回一个tuple,但写起来更方便。
例子:
请定义一个函数quadratic(a, b, c)
,接收3个参数,返回一元二次方程 ax^2+bx+c=0ax2+bx+c=0 的两个解。
# import math
# def quadratic(a,b,c):
# return (-b+math.sqrt(b**2-4*a*c))/(2*a),(-b-math.sqrt(b**2-4*a*c))/(2*a)
# print(quadratic(1,3,-4))
函数的参数
位置参数
我们先写一个计算x2的函数:
def power(x):
return x * x
对于power(x)
函数,参数x
就是一个位置参数。
当我们调用power
函数时,必须传入有且仅有的一个参数x
:
>>> power(5)
25
>>> power(15)
225
现在,如果我们要计算x3怎么办?可以再定义一个power3
函数,但是如果要计算x4、x5……怎么办?我们不可能定义无限多个函数。
可以把power(x)
修改为power(x, n)
,用来计算xn
def power(x, n):
s = 1
while n > 0:
n = n - 1
s = s * x
return s
对于这个修改后的power(x, n)
函数,可以计算任意n次方:
>>> power(5, 2)
25
>>> power(5, 3)
125
修改后的power(x, n)
函数有两个参数:x
和n
,这两个参数都是位置参数,调用函数时,传入的两个值按照位置顺序依次赋给参数x
和n
默认参数
由于我们经常使用x2,所以我们可以把n的默认值设置为2
def power(x, n=2):
s = 1
while n > 0:
n = n - 1
s = s * x
return s
这样,当我们调用power(5)
时,相当于调用power(5, 2)
:
>>> power(5) 25 >>> power(5, 2) 25
设置默认参数时,需要注意一下两点:
一是必选参数在前,默认参数在后,否则Python的解释器会报错
二是当函数有多个参数时,把变化大的参数放前面,变化小的参数放后面。变化小的参数就可以作为默认参数。
默认函数如使用不当,也会掉坑里:
先定义一个函数,传入一个list,添加一个END
再返回:
def add_end(L=[]):
L.append('END')
return L
当你正常调用时,结果似乎不错:
>>> add_end([1, 2, 3])
[1, 2, 3, 'END']
>>> add_end(['x', 'y', 'z'])
['x', 'y', 'z', 'END']
当你使用默认参数调用时,一开始结果也是对的:
>>> add_end()
['END']
但是,再次调用add_end()
时,结果就不对了:
>>> add_end() ['END', 'END'] >>> add_end() ['END', 'END', 'END']
原因解释如下:
Python函数在定义的时候,默认参数L
的值就被计算出来了,即[]
,因为默认参数L
也是一个变量,它指向对象[]
,每次调用该函数,
如果改变了L
的内容,则下次调用时,默认参数的内容就变了,不再是函数定义时的[]
了。
* 定义默认参数需要注意一点:默认参数必须指向不变对象!!!
要修改上面的例子,我们可以用None
这个不变对象来实现:
def add_end(L=None):
if L is None:
L = []
L.append('END')
return L
现在,无论调用多少次,都不会有问题:
>>> add_end()
['END']
>>> add_end()
['END']
可变参数,关键词参数,命名关键字参数 见:
https://www.liaoxuefeng.com/wiki/1016959663602400/1017261630425888
参数组合
在Python中定义函数,可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数,这5种参数都可以组合使用。
但是请注意,参数定义的顺序必须是:必选参数、默认参数、可变参数、命名关键字参数和关键字参数。
例题:
以下函数允许计算两个数的乘积,请稍加改造,变成可接收一个或多个数并计算乘积:
# def demo(*num):
# if len(num)==0:
# return 'error'
# n=1
# for i in num:
# n=n*i
# return n
# print(demo(2,5,4,16,45))
28800
递归函数
在函数内部,可以调用其他函数。如果一个函数在内部调用自身本身,这个函数就是递归函数。
举个例子,我们来计算阶乘n! = 1 x 2 x 3 x ... x n
,用函数fact(n)
表示,可以看出:
fact(n)=n!=1\times2\times3\times\cdot\cdot\cdot\times(n-1)\times n=(n-1)!\times n=fact(n-1)\times nfact(n)=n!=1×2×3×⋅⋅⋅×(n−1)×n=(n−1)!×n=fact(n−1)×n
所以,fact(n)
可以表示为n x fact(n-1)
,只有n=1时需要特殊处理。
于是,fact(n)
用递归的方式写出来就是:
def fact(n):
if n==1:
return 1
return n * fact(n-1)
print(fact(5))
递归函数的优点是定义简单,逻辑清晰。理论上,所有的递归函数都可以写成循环的方式,但循环的逻辑不如递归清晰。
使用递归函数需要注意防止栈溢出。在计算机中,函数调用是通过栈(stack)这种数据结构实现的,每当进入一个函数调用,栈就会加一层栈帧,每当函数返回,栈就会减一层栈帧。由于栈的大小不是无限的,所以,递归调用的次数过多,会导致栈溢出。