Python学习之函数以及函数式编程详解

本文和大家分享的主要是python 函数及函数式编程相关内容，一起来看看吧，希望对大家 学习python有所帮助。

　　 函数基本语法及特性

　　 定义

　　数学函数定义: 一般的，在一个变化过程中，如果有两个变量 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 ），也就是如何编写程序的方法论。

　　主要思想是把运算过程尽量写成一系列嵌套的函数调用。

来源： 博客园