欢迎加入QQ讨论群258996829
苹果6袋
麦子学院
Python学习之函数以及函数式编程详解
发布时间：2017-07-23 21:13 回复:0 查看:2097 最后回复：2017-07-23 21:13
函数基本语法及特性
定义
数学函数定义:
一般的，在一个变化过程中，如果有两个变量
x
和
y
，并且对于
x
的每一 个确定的值，
y
都有唯一确定的值与其对应，那么我们就把
x
称为自变量，把
y
称为因变 量，
y
是
x
的函数。自变量
x
的取值范围叫做这个函数的定义域。
但编程中的「函数」概念，与数学中的函数是有很
同的
函数是逻辑结构化和过程化的一种编程方法
函数的优点
·
减少重复代码
·
使程序变的可扩展
·
使程序变得易维护
函数与过程
·
定义函数
def
fun1(): #
函数名称
"The function decription" print("in the func1")
return 0 #
返回值
·
定义过程
def
fun2():"The progress decription"
print("in the func2")
·
函数与过程 过程就是没有返回值的函数 但是在
python
中，过程会隐式默认返回
none
，所以在
python
中即便是过程也可以算作函数。
def
fun1():
"The function decription"
print("in the func1")
return 0
def
fun2():
"The progress decription"
print("in the func2")
x=fun1()
y=fun2()
print("from func1 return is %s" %x)
print("from func2 return is %s" %y)
结果为：
in the func1
in the func2
from func1
return
is 0
from func2
return
is
None
返回值
要想获取函数的执
结果，就可以 return
语 把结果返回。
1.
函数在执
过程中只要遇到return
语 ，就会停 执 并返回结果，所以也可以 解为
return
语 代表着函数的结束，如果未在函数中指定
return,
那这个函数的返回值为
None
。
2.
3.
接受返回值
4.
赋予变量，例如：
5.
def
test():
print('in the test')
return 0
x=test()
1.
返回什么样的变量值
return
个数没有固定，
return
的类型没有固定。 例如：
def
test1():
print('in the test1')
def
test2():
print('in the test2')
return 0
def
test3():
print('in the test3')
return 1,'hello',['alex','wupeiqi'],{'name':'alex'}
def
test4():
print('in the test4')
return test2
x=test1()
y=test2()
z=test3()
u=test4()
print(x)
print(y)
print(z)
print(u)
结果是：
in the test1
in the test2
in the test3
in the test4
None
0
(1, 'hello', ['alex', 'wupeiqi'], {'name': 'alex'})
<
function test2 at 0x102439488>
·
返回值数
=0:
返回
None
没有
return
·
返回值数
=1:
返回
object return
一个值，
python
基本所有的数据类型都是对象。
·
返回值数
>1:
返回
tuple
，
return
多个值。
·
返回可以返回函数
:return test2
会将
test2
的内存地址返回。
1.
为什么要有返回值
?
想要整个函数执行的结果。
可能对执行结果进行相关操作。
比如登陆，返回true
接下来就可以进行其他操作。 如果是
false
则不给操作。
函数参数
形参和实参定义
·
形参
形式参数，不是实际存在，是虚拟变量。在定义函数和函数体的时候使用形参，目的是在函数调用时接收实参(
形参个数，类型应与实参一一对应
)
。
变量只有在被调时才分配内存单元
·
实参
实际参数，调用函数时传给函数的参数，可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以
把这些值传送给形参。因此应预先用赋值，输入
等办法使参数获得确定值。
·
区别
形参是虚拟的，不占用内存空间.
形参变量只有在被调用时才分配内存单元，，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调函数后，则不能再使该形参变量。
实参是一个变量，占用内存空间，数据传送单向，实参传给形参，不能形参传给实参。
def
calc(x,y): #x,y
为形参
res = x**y
return res
c = calc(a,b) #a,b
为实参
print(c)
def
test(x,y): #x,y
为形参
print(x)
print(y)
x=1 #x
为实参
y=2 #y
为实参
test(x=x,y=y) #
等号左边
x,y
为形参，等号右边
x,y
为实参，引用不分顺序，按关键字引用。
默认参数
定义函数的时候，还可以有默认参数。
函数的默认参数的作用是简化调用，你只需要把必须的参数传进去。但是在需要的时候，又可以传入额外的参数来覆盖默认参数值。
#
定义一个计算
x
的
N
次方的函数
,
默认是
2
次方
def
test6(x,n=2):
s=1
while n>0:
n=n-1
s=s*x
print(s)
return s
test6(2)
默认参数只能定义在必需参数的后面.
可变参数
如果想让一个函数能接受任意个参数，我们就可以定义一个可变参数：
def
fn(*args):
print args
可变参数的名字前面有个 *
号，我们可以传入
0
个、
1
个或多个参数给可变参数：
Python
解释器会把传入的一组参数组装成一个
tuple
传递给可变参数，因此，在函数内部，直接把变量
args
看成一个
tuple
就好了。
定义可变参数的目的也是为了简化调用。假设我们要计算任意个数的平均值，就可以定义一个可变参数：
def
average(*args):
...
这样，在调用的时候，可以这样写：
>>> average()0>>> average(1, 2)1.5>>> average(1, 2, 2, 3, 4)2.4
位置参数和关键字
位置参数调用：实参与形参位置一一对应;
关键参数调用
:
位置无需固定。
正常情况下，给函数传参数要按顺序，如果不按顺序就可以用关键参数调用，只需指定参数名即可，但关键参数必须放在位置参数之后。
def
test5(u,v,w):
print(u)
print(v)
print(w)
test5(3,w=2,v=6)
函数调用
Python
内置了很多有用的函数，我们可以直接调用。
要调用一个函数，需要知道函数的名称和参数，比如求绝对值的函数 abs
，它接收一个参数。
调用 abs
函数：
>>> abs(-21)21
调用函数的时候，如果传入的参数数量不对，会报TypeError
的错误，并且
Python
会明确地告诉你：
abs()
有且仅有
1
个参数，但给出了两个：
>>> abs(21,8)
Traceback (most recent
call
last):
File "/Users/cathy/PycharmProjects/p51cto/day3/func_test3.py", line 67, in
abs(21,8)
TypeError: abs() takes exactly one
argument (2 given)
如果传入的参数数量是对的，但参数类型不能被函数所接受，也会报TypeError
的错误，并且给出错误信息：
str
是错误的参数类型：
>>> abs('a')
Traceback (most recent
call
last):
File "/Users/cathy/PycharmProjects/p51cto/day3/func_test3.py", line 69, in
abs('a')
TypeError:
bad operand type
for abs(): 'str'
递归函数
在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。
举个例子，我们来计算阶乘 n! = 1 * 2 * 3 * ... * n
，用函数
fact(n)
表示：
def
fact(n):
if n==1:
return 1
return n * fact(n - 1)
递归函数的优点是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。
嵌套函数
python
允许在定义函数的时候，其函数体内又包含另外一个函数的完整定义。
name = "test1"
def
changeout():
name = "test2"
def
changeinner():
name = "test3"
print("changeinner
赋值打印
", name)
changeinner() #
调用内层函数
print("
外层调用内层打印
", name)
changeout()
print("
调用外层打印
", name)
内部函数可以访问其外部函数的作用域，但是外部函数不能访问内部函数的作用域。
def change1(name):
匿名函数
匿名函数就是不需要显式的指定函数
#
这段代码
def calc(n): return n**n print(calc(10))
#
换成匿名函数
calc = lambda n:n**n print(calc(10))
函数式编程
单说，"
函数式编程
"
是一种
"
编程范式
"
（
programming paradigm
），也就是如何编写程序的方法论。
主要思想是把运算过程尽量写成一系列嵌套的函数调用。
来源：
博客园