1. python内置了很多有用的函数,可以直接调用。
abs() 求绝对值,只传入一个参数
max() 接收任意多个参数,并返回最大的那个
2. 数据类型转换
python内置的常用函数包括数据类型转换函数。
int() 可以把其它数据类型转换为整数
float() 把其它数据类型转换为浮点数
str() 把其它数据类型转换为字符型
hex() 把整数转换成十六进制表示
3. 函数名是指向一个函数对象的引用,完全可以把函数名赋给一个变量
>>>a = abs # 变量a指向abs函数
>>>a(-1) # 所以也可以通过a调用abs函数
1
4. 在Python中,定义一个函数要使用def语句,依次写出函数名、括号、括号中的参数和冒号:,然后,在缩进块中编写函数体,函数的返回值用return语句返回。
defmy_abs(x):
if x >= 0:
return x
else:
return -x
注意def语句最后的:
函数体内部的语句在执行时,一旦执行到return时,函数就执行完毕,并将结果返回。因此,函数内部通过条件判断和循环可以实现非常复杂的逻辑。如果没有return语句,函数执行完毕后也会返回结果,只是结果为None。
如果你已经把my_abs()的函数定义保存为abstest.py文件了,那么,可以在该文件的当前目录下启动Python解释器,用from abstest import my_abs来导入my_abs()函数,注意abstest是文件名(不含.py扩展名)。
5. 空函数
定义一个什么事也不做的空函数,可以用pass语句:
defnop():
pass
pass可以用来作为占位符,比如现在还没想好怎么写函数的代码,就可以先放一个pass,让代码能运行起来。
pass还可以用在其他语句里,比如:
ifage >= 18:
pass
6.参数检查
调用函数时,如果参数个数不对,Python解释器会自动检查出来,并抛出TypeError。但是如果参数类型不对,内置函数abs会检查出参数错误,而我们定义的my_abs没有参数检查,会导致if语句出错,出错信息和abs不一样。
修改一下my_abs的定义,对参数类型做检查,只允许整数和浮点数类型的参数。数据类型检查可以用内置函数isinstance()实现:
defmy_abs(x):
if not isinstance(x, (int, float)):
raise TypeError('bad operand type')
if x >= 0:
return x
else:
return -x
7. 返回多个值
从一个点移动到另一个点,给出坐标、位移和角度,就可以计算出新的新的坐标:
importmath
defmove(x, y, step, angle=0):
nx = x + step * math.cos(angle)
ny = y - step * math.sin(angle)
return nx, ny
importmath语句表示导入math包,并允许后续代码引用math包里的sin、cos等函数。
然后,我们就可以同时获得返回值:
>>>x, y = move(100, 100, 60, math.pi / 6)
>>>print(x, y)
151.9615242270663270.0
但其实这只是一种假象,Python函数返回的仍然是单一值:
>>>r = move(100, 100, 60, math.pi / 6)
>>>print(r)
(151.96152422706632,70.0)
原来返回值是一个tuple!但是,在语法上,返回一个tuple可以省略括号,而多个变量可以同时接收一个tuple,按位置赋给对应的值,所以,Python的函数返回多值其实就是返回一个tuple,但写起来更方便。
8. 定义一个函数quadratic(a, b, c),接收3个参数,返回一元二次方程:ax2 + bx + c = 0的两个解。
importmath
defquadratic(a,b,c):
base=b*b-4*a*c
if base<0:
return '无解'
else:
x1=(-b+math.sqrt(base))/(2*a)
x2=(-b-math.sqrt(base))/(2*a)
return x1,x2
print('请输入一元二次方程的系数:')
a=float(input('输入a='))
b=float(input('输入b='))
c=float(input('输入c='))
x,y=quadratic(a,b,c)
print(x,y)
9. Python的函数定义非常简单,但灵活度却非常大。除了正常定义的必选参数外,还可以使用默认参数、可变参数和关键字参数,使得函数定义出来的接口,不但能处理复杂的参数,还可以简化调用者的代码。
10. 位置参数
计算xn:
defpower(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。
11. 默认参数
由于我们经常计算x2,所以,完全可以把第二个参数n的默认值设定为2:
defpower(x, n=2):
s = 1
while n > 0:
n = n - 1
s = s * x
return s
当n不输入,使用默认值n=2,若指定n,按指定n计算
当函数有多个参数时,把变化大的参数放前面,变化小的参数放后面。变化小的参数就可以作为默认参数。
有多个默认参数时,调用的时候,可以不按顺序提供部分默认参数。当不按顺序提供部分默认参数时,需要把参数名写上。
默认参数必须指向不变对象!像list不适合作为默认参数。
12. 可变参数
在Python函数中,还可以定义可变参数。可变参数就是传入的参数个数是可变的。
由于参数个数不确定,可以把a,b,c……作为一个list或tuple传进来,这样,函数可以定义如下:
defcalc(numbers):
sum = 0
for n in numbers:
sum = sum + n * n
return sum
但是调用的时候,需要先组装出一个list或tuple:
>>>calc([1, 2, 3])
14
>>>calc((1, 3, 5, 7))
84
可变参数在参数前面加了一个*号。在函数内部,参数numbers接收到的是一个tuple,因此,函数代码完全不变:
defcalc(*numbers):
sum = 0
for n in numbers:
sum = sum + n * n
return sum
调用该函数时,可以传入任意个参数,包括0个参数:
>>>calc(1, 2)
5
>>>calc()
0
Python允许在list或tuple前面加一个*号,把list或tuple的元素变成可变参数传进去:
>>>nums = [1, 2, 3]
>>>calc(*nums)
14
*nums表示把nums这个list的所有元素作为可变参数传进去。
13. 关键字参数
关键字参数允许你传入0个或任意个含参数名的参数,这些关键字参数在函数内部自动组装为一个dict。
defperson(name, age, **kw):
print('name:', name, 'age:', age, 'other:',kw)
函数person除了必选参数name和age外,还接受关键字参数kw。在调用该函数时,可以只传入必选参数:
>>>person('Michael', 30)
name:Michael age: 30 other: {}
也可以传入任意个数的关键字参数:
>>>person('Bob', 35, city='Beijing')
name:Bob age: 35 other: {'city': 'Beijing'}
>>>person('Adam', 45, gender='M', job='Engineer')
name:Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}
和可变参数类似,也可以先组装出一个dict,然后,把该dict转换为关键字参数传进去:
>>>extra = {'city': 'Beijing', 'job': 'Engineer'}
>>>person('Jack', 24, **extra)
name:Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}
**extra表示把extra这个dict的所有key-value用关键字参数传入到函数的**kw参数,kw将获得一个dict,注意kw获得的dict是extra的一份拷贝,对kw的改动不会影响到函数外的extra。
14. 命名关键字参数
要限制关键字参数的名字,就可以用命名关键字参数,例如,只接收city和job作为关键字参数。这种方式定义的函数如下:
defperson(name, age, *, city, job):
print(name, age, city, job)
和关键字参数**kw不同,命名关键字参数需要一个特殊分隔符*,*后面的参数被视为命名关键字参数。
调用方式如下:
>>>person('Jack', 24, city='Beijing', job='Engineer')
Jack24 Beijing Engineer
如果函数定义中已经有了一个可变参数,后面跟着的命名关键字参数就不再需要一个特殊分隔符*了:
defperson(name, age, *args, city, job):
print(name, age, args, city, job)
命名关键字参数必须传入参数名,这和位置参数不同。如果没有传入参数名,调用将报错:
>>>person('Jack', 24, 'Beijing', 'Engineer')
Traceback(most recent call last):
File "<stdin>", line 1, in<module>
TypeError:person() takes 2 positional arguments but 4 were given
由于调用时缺少参数名city和job,Python解释器把这4个参数均视为位置参数,但person()函数仅接受2个位置参数。
使用命名关键字参数时,要特别注意,如果没有可变参数,就必须加一个*作为特殊分隔符。
15. 参数组合
在Python中定义函数,可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数,这5种参数都可以组合使用。但是请注意,参数定义的顺序必须是:必选参数、默认参数、可变参数、命名关键字参数和关键字参数。
比如定义一个函数,包含上述若干种参数:
deff1(a, b, c=0, *args, **kw):
print('a =', a, 'b =', b, 'c =', c, 'args=', args, 'kw =', kw)
deff2(a, b, c=0, *, d, **kw):
print('a =', a, 'b =', b, 'c =', c, 'd =',d, 'kw =', kw)
在函数调用的时候,Python解释器自动按照参数位置和参数名把对应的参数传进去。
>>>f1(1, 2)
a =1 b = 2 c = 0 args = () kw = {}
>>>f1(1, 2, c=3)
a =1 b = 2 c = 3 args = () kw = {}
>>>f1(1, 2, 3, 'a', 'b')
a =1 b = 2 c = 3 args = ('a', 'b') kw = {}
>>>f1(1, 2, 3, 'a', 'b', x=99)
a =1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99}
>>>f2(1, 2, d=99, ext=None)
a =1 b = 2 c = 0 d = 99 kw = {'ext': None}
通过一个tuple和dict,也可以调用上述函数:
>>>args = (1, 2, 3, 4)
>>>kw = {'d': 99, 'x': '#'}
>>>f1(*args, **kw)
a =1 b = 2 c = 3 args = (4,) kw = {'d': 99, 'x': '#'}
>>>args = (1, 2, 3)
>>>kw = {'d': 88, 'x': '#'}
>>>f2(*args, **kw)
a =1 b = 2 c = 3 d = 88 kw = {'x': '#'}
16. 函数参数总结
默认参数一定要用不可变对象,如果是可变对象,程序运行时会有逻辑错误!
*args是可变参数,args接收的是一个tuple;
**kw是关键字参数,kw接收的是一个dict。
以及调用函数时如何传入可变参数和关键字参数的语法:
可变参数既可以直接传入:func(1, 2, 3),又可以先组装list或tuple,再通过*args传入:func(*(1,2, 3));
关键字参数既可以直接传入:func(a=1, b=2),又可以先组装dict,再通过**kw传入:func(**{'a': 1, 'b': 2})。
使用*args和**kw是Python的习惯写法,当然也可以用其他参数名,但最好使用习惯用法。
命名的关键字参数是为了限制调用者可以传入的参数名,同时可以提供默认值。
定义命名的关键字参数在没有可变参数的情况下不要忘了写分隔符*,否则定义的将是位置参数。
17. 递归函数
在函数内部,可以调用其他函数。如果一个函数在内部调用自身本身,这个函数就是递归函数。
fact(n) = n! = 1 x 2 x 3 x ... x (n-1) x n =(n-1)! x n = fact(n-1) x n:
def fact(n):
ifn==1:
return 1
return n * fact(n - 1)
使用递归函数需要注意防止栈溢出。在计算机中,函数调用是通过栈(stack)这种数据结构实现的,每当进入一个函数调用,栈就会加一层栈帧,每当函数返回,栈就会减一层栈帧。由于栈的大小不是无限的,所以,递归调用的次数过多,会导致栈溢出。
解决递归调用栈溢出的方法是通过尾递归优化,事实上尾递归和循环的效果是一样的。尾递归是指,在函数返回的时候,调用自身本身,并且,return语句不能包含表达式。
def fact(n):
return fact_iter(n, 1)
def fact_iter(num, product):
ifnum == 1:
return product
return fact_iter(num - 1, num * product)
可以看到,return fact_iter(num -1, num * product)仅返回递归函数本身,num - 1和num * product在函数调用前就会被计算,不影响函数调用。fact(5)对应的fact_iter(5, 1)的调用如下:
===> fact_iter(5, 1)
===> fact_iter(4, 5)
===> fact_iter(3, 20)
===> fact_iter(2, 60)
===> fact_iter(1, 120)
===> 120
尾递归调用时,如果做了优化,栈不会增长,因此,无论多少次调用也不会导致栈溢出。