本节内容
- 函数基本语法及特性
- 参数与局部变量
- 返回值 & 嵌套函数
- 递归
- 匿名函数
- 函数式编程介绍
- 高阶函数
- 内置函数
Python 语言从未如此性感！
函数
函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。能提高应用的模块性，和代码的重复利用率。
特性
- 减少重复代码
- 使程序变的可扩展
- 使程序变得易维护
语法
1 #Author:Junce Liu
2 # 函数
3 def function():
4 """第一个函数""" # 函数作用注释
5 print("Hello World!") # 功能
6 return 0 # 结束函数，并返回值
7 function() # 函数调用
8
9 输出结果如下：
10 Hello World!
函数调用
你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。
定义一个函数
你可以定义一个由自己想要功能的函数，以下是简单的规则：
- 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
- 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
- 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
- 函数内容以冒号起始，并且缩进。
- return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
#Author:Junce Liu
import time # 导入时间模块
def logger():
time_format = '%Y-%m-%d %X' # 定义时间，年月日时
time_current = time.strftime(time_format)
with open("a.txt",'a+',encoding="utf8") as f:
f.write(
"%s\n"
"独上高楼望尽天涯路.\n"
"衣带渐宽终不悔,为伊消得人憔悴。\n"
"众里寻他千百度，蓦然回首，那人却在，灯火阑珊处。\n"%time_current)
def a():
print("12306")
logger() # 调用函数logger
def b():
print("10086")
logger() # 调用函数logger
a() # 执行a
b() # 执行b
写入结果如下：
2016-12-19 19:51:28
独上高楼望尽天涯路.
衣带渐宽终不悔,为伊消得人憔悴。
众里寻他千百度，蓦然回首，那人却在，灯火阑珊处。
2016-12-19 19:51:28
独上高楼望尽天涯路.
衣带渐宽终不悔,为伊消得人憔悴。
众里寻他千百度，蓦然回首，那人却在，灯火阑珊处。
返回值
特性
- 返回值 = 0：返回None # 没有定义return的值，返回None
- 返回值 = 1：返回object # return一个值，返回一个值
- 返回值 > 1: 返回tuple # return多个值，返回一个元组
return语句[表达式]退出函数，选择性地向调用方返回一个表达式，不带参数值的return语句返回None. 之前的例子都没有示范如何返回数值。
下例便告诉你怎么做：
1 #Author:Junce Liu
2 def fun(): # 定义函数
3 with open("Junce",'a+',encoding="utf8") as f: # 函数功能，追加“Hello Warld!”
4 f.write("Hello World！\n")
5 return "追加一句话",0,{"还能定义 return 好多参数...."} # return 结束函数并返回值，返回值的作用是显示整个函数的执行目的....可任意发挥
6
7 输出效果如下：
8 ('追加一句话', 0, {'还能定义 return 好多参数....'}) None None # 多参数以元组形式返回。
参数
以下是调用函数时可使用的正式参数类型：
- 必备参数
- 关键字参数
- 默认参数
- 不定长参数
实参 & 形参
形参 变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量
实参 可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值
参数 须以正确的顺序传入函数，调用时的数量必须和声明时的一样。调用 fun() 函数，你必须传入一个参数，不然会出现语法错误.
1 #Author:Junce Liu
2 def fun(x,y):
3 """第一个函数"""
4 print(x)
5 print(y)
6
7 fun(1,2) # 定义位置参数 x = 1, y =2，一一对应
8 fun(y=6,x=3) # 定义关键字参数 x = 3, y = 6，与顺序无关
9 fun(8,y=9) # 定义混参数 x = 8 , y = 9 , 关键字参数不能在位置参数前
10
11 输出结果如下：
12 1
..... # 省略2,3,6,8...
17 9
特性
- 关键字调用，与形参顺序无关。
- 位置参数调用，与形参相对应的。
- 关键字参数不允许写在位置参数前面,调用时的数量必须和声明的一致.
默认参数
调用函数时，默认(缺省)参数的值如果没有传入，则被认为是默认值。
下例会打印默认的age，如果age被传入参数则改变默认。
因此，我们初步断定默认参数在被调用时非必须传递.
1 #Author:Junce Liu
2 def fun(name,age=18): # 默认定义了age = 18
3 print(name)
4 print(age)
5 fun("Junce") # 赋值 name,位置参数.并调用
6 fun("Junce",21) # 重新给 age 赋值，位置参数
7
8 输出效果如下：
9 Junce
10 18
11 Junce
12 21
参数组
你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述2种参数不同，声明时不会命名.我们这里叫它 “参数组”
基本语法如下：
定义参数组 *args,接收N个位置参数
1 #Author:Junce Liu
2 def fun(*args): # 定义参数组 * 后加任意字符串,接收N个位置参数转换成元组形式
3 print(args)
4 fun(1,2,3,4,5,6) # 传入多个数组，并调用。
5 fun(*[1,2,3,4,5,6]) # 定义一个列表为参数组 Junce = tuple(*[1,2,3,4,5,6])
6
7 输出效果如下：
8 (1, 2, 3, 4, 5, 6) # 输出效果为元组(stuple)形式
9 (1, 2, 3, 4, 5, 6)
结合字典，kwargs把关键字参数转换成字典格式。
1 def fun(**kwargs): # 结合字典，**kwargs把关键字参数转换成字典格式。
2 print(kwargs)
3 print(kwargs['name']) # 取值 Junce
4 fun(name='junce',age=18)
5 fun(**{'name':'Junce','age':18})
6 输出效果如下：
7 {'name': 'junce', 'age': 18}
8 junce
9 {'name': 'Junce', 'age': 18}
10 Junce
各种结合
1 def fun(name,age,*args,**kwargs):
2 print(name)
3 print(age)
4 print(args)
5 print(kwargs)
6 fun('Junce',18,Job='programme',Name='liu')
7
8 输出效果如下：
9 Junce
10 18
11 ()
12 {'Job': 'programme', 'Name': 'liu'}
变量作用域
一个程序的所有的变量并不是在哪个位置都可以访问的。访问权限决定于这个变量是在哪里赋值的。
变量的作用域决定了在哪一部分程序你可以访问哪个特定的变量名称。
两种最基本的变量作用域：
- 全局变量
- 局部变量
全局变量 & 局部变量
定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。
局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。
1 #Author:Junce Liu
2 school = "西安交通大学" # 定义全局变量
3 def fun(school):
4 print(school)
5 school = "Junce" # 实参传入
6 print("after change",school) # 函数内打印...到底最后会显示谁呢？
7 fun(school) # 函数调用 school,调用的是全局变量
8 print("注意啦，全局变量！",school)
9
10 输出效果如下：
11 西安交通大学
12 after change Junce # 这里打印的是实参
13 注意啦，全局变量！ 西安交通大学
局部声明
调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。
1 #Author:Junce Liu
2 school = "西安交通大学" # 定义全局变量
3 def fun(name):
4 global school # 声明调用局部变量
5 school = "浙江大学" # 定义局部变量
6 print(school)
7 name = "Junce" # 实参传入
8 print("after change",school) # 函数内打印...到底最后会显示谁呢？
9 fun(school) # 函数调用 school,调用的是全局变量
10 #print("注意啦，全局变量！",school)
11 print("声明后的局部变量：",school)
12
13 输出效果如下：
14 浙江大学 # 注意，函数调用时显示的是声明的局部变量
15 after change 浙江大学可更改类型
在函数中，除了变量,元组,字符串，整数的全局变量在声明前不能更改。像字典，列表，等复杂点的参数可以不定义global 也可以更改。
1 #Author:Junce Liu
2 names = ["Junce","Eric","Jack"] # 定义列表，
全局变量
4 def fun(names):
5 names[0] = "鲁路修" # 切片更改，列表参数
7 print(names)
8
9 fun(names)
10 print("更改后>>:",names)
11
12 输出效果如下：
13 ['鲁路修', 'Eric', 'Jack']
14 更改后>>: ['鲁路修', 'Eric', 'Jack']
递归
在函数内部，可以调用其他函数. 如果一个函数在内部调用自身本身，这个函数就是递归函数。
1 #Author:Junce Liu
2 def fun(n):
3 print(n)
4 return fun(n+1) # 返回值，调用自己
5 fun(0) # 从0开始返回
输出结果：0 - 998 循环次数，后会报错。
特性
- 必须有一个明确的结束条件
- 每次进入更深一层递归时，问题规模相比上次递归都应有所减少
- 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构
- 现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。
- 由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）
- 堆栈扫盲http://www.cnblogs.com/lln7777/archive/2012/03/14/2396164.html
例子
理论总是乏味的，我们举个例子更加直观理解。
1 #Author:Junce Liu
2 def fun(n):
3 print(n)
4 if int(n/2) >0: # 判断如果/2 > 0，则已整数方式调用自己整除。
5 return fun(int(n/2))
6 print("->",n) # 前面没定义n的具体数值，我们打印下它到底是谁？
7 fun(10) # 实参传入 10
8
9 输出效果如下：
10 10
11 5
12 2
13 1
14 -> 1
匿名函数
- python 使用 lambda 来创建
- lambda只是一个表达式，函数体比def简单很多。
- lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
- lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。
- 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
语法
匿名函数 “lambda” 只有一个语句：
lambda [arg1 [,arg2,.....argn]]:expression
匿名函数不需要return来返回值，表达式本身结果就是返回值
1 #Author:Junce Liu
2 f = lambda x: x * x # 数字相乘
3 print(f(3))
4 输出结果如下：
5 9
函数式编程
函数是Python内建支持的一种封装，我们通过把大段代码拆成函数，通过一层一层的函数调用，就可以把复杂任务分解成简单的任务，这种分解可以称之为面向过程的程序设计。函数就是面向过程的程序设计的基本单元。
函数式编程中的函数这个术语不是指计算机中的函数（实际上是Subroutine），而是指数学中的函数，即自变量的映射。也就是说一个函数的值仅决定于函数参数的值，不依赖其他状态。比如sqrt(x)函数计算x的平方根，只要x不变，不论什么时候调用，调用几次，值都是不变的。
Python对函数式编程 提供部分支持，由于Python允许使用变量。因此，Python不是纯函数式编程语言。
定义
简单说，”函数式编程”是一种”编程范式”（programming paradigm），也就是如何编写程序的方法论。
主要思想是把运算过程尽量写成一系列嵌套的函数调用。举例来说，现在有这样一个数学表达式：
(1 + 2) * 3 - 4
传统的过程式编程，可能这样写：
var a = 1 + 2;
var b = a * 3;
var c = b - 4;
函数式编程要求使用函数，我们可以把运算过程定义为不同的函数，然后写成下面这样：
var result = subtract(multiply(add(1,2), 3), 4);
这段代码再演进以下，可以变成这样
add(1,2).multiply(3).subtract(4)
这基本就是自然语言的表达了。再看下面的代码，大家应该一眼就能明白它的意思吧：
merge([1,2],[3,4]).sort().search("2")
因此，函数式编程的代码更容易理解。
要想学好函数式编程，不要玩py,玩Erlang,Haskell, 好了，我只会这么多了.但是这不是重点
高阶函数
未完待更新…….
各位看博客的妹子们,现在页面是不是还丑了点？是的，我自己都不想看…..回头讲页面优化一并将这个做了。
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
