人生苦短，我用python。

一、基本概念

1、定义函数

1 2	def 函数名（参数列表）: 函数体

1 2	def area(width, height): return width * height

2、调用函数

1 2	方式一：函数名（参数列表）方式二：变量名 = 函数名

#调用方式1
def printme( str ):
   print (str);
   return;
printme("我要调用函数!")

#调用方式2
pr = printme
pr("我要调用函数!")

3、参数传递

(1)可更改(mutable)与不可更改(immutable)对象：
在python中，numbers,strings,tuples,是不可更改的对象，而list,dict等则是可以修改的对象。

传不可变对象：传递的只是不可变对象的值，没有影响不可变对象本身。
传可变对象：可变对象在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了。

(2)参数：

必需参数
默认参数
可变参数
关键字参数

1)必选参数
必选参数就是在调用函数的时候要传入数量一致的参数。
1
2
def add(x, y): 
	print x + y
2)默认参数
默认参数是指在定义函数的时候提供一些默认值，如果在调用函数的时候没有传递该参数，则自动使用默认值，否则使用传递时该参数的值。
1
2
def add(x, y, z=1): #默认参数要放在所有必选参数的后面,默认参数应该使用不可变对象。
	print x + y + z
3)可变参数
可变参数允许你将不定数量的参数传递给函数。
1
2
3
4
5
6
7
8
def printinfo( arg1, *vartuple ):
	print (arg1)
	for var in vartuple:
		print (var)
	return;

printinfo( 10 );
printinfo( 70, 60, 50 );
4)关键字参数
而关键字参数则允许你将不定长度的键值对, 作为参数传递给一个函数。
1
2
3
4
5
6
7
8
9
10
11
def sum(**kwargs):               
	sum = 0
	for k, v in kwargs.items():
		sum += v
	return sum
	
dict1 = {'x': 1}
sum(**dict1) 

dict2 = {'x': 2, 'y': 6} 
sum(**dict2)
5)参数组合
它们在使用的时候是有顺序的，依次是必选参数、默认参数、可变参数、关键字参数。
1
2
3
4
5
6
def func(x, y, z=0, *args, **kwargs):
    print('x =', x)
    print('y =', y)
    print('z =', z)
    print('args =', args)
    print('kwargs =', kwargs)

# 函数
def func(x, y, z=1, *args, **kwargs):  # 必选参数、默认参数、可变参数、关键字参数
    print(x+y)
    print(z)
    for i,chr in enumerate(args):
        print(i,chr)
    for item in kwargs.items():
        print(item)
        
func(5, 6, 3,'me','you',**{'name':'LiLei', 'age':18})

4、return语句

return [表达式] 语句用于退出函数，选择性地向调用方返回一个tuple表达式。

(1)返回一个值

def sum( arg1, arg2 ):
	total = arg1 + arg2
	return total
	
total = sum( 10, 20 )

(2)返回多个值

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)

二、变量作用域

1、变量作用域

以 L –> E –> G –>B 的规则查找，即：在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内建中找。

L （Local）局部作用域
E （Enclosing）闭包函数外的函数中
G （Global）全局作用域
B （Built-in）内建作用域

x = int(2.9)  # 内建作用域
 
g_count = 0  # 全局作用域
def outer():
    o_count = 1  # 闭包函数外的函数中
    def inner():
        i_count = 2  # 局部作用域

2、作用域引入

Python 中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，其它的代码块（如 if/elif/else/、try/except、for/while等）是不会引入新的作用域的，也就是说这些语句内定义的变量，外部也可以访问

3、global和nonlocal关键字
(1)当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了

num = 1
def fun1():
    global num  # 需要使用 global 关键字声明
    print(num) 
    num = 123
    print(num)
fun1()

(2)如果要修改嵌套作用域（enclosing 作用域，外层非全局作用域）中的变量则需要nonlocal关键字了

def outer():
    num = 10
    def inner():
        nonlocal num   # nonlocal关键字声明
        num = 100
        print(num)
    inner()
    print(num)
outer()

作用域概览示例：

# 作用域
x = int(2.9)  # 1、内建作用域:builtins,内建模块的命名空间
g_count = 0  # 2、全局作用域:globals,全局变量，函数定义所在模块的命名空间
def outer():
    global g_count  # global 关键字声明
    o_count = 1  # 3、外部嵌套函数的命名空间（闭包中常见）:enclosing function
    def inner():
        nonlocal o_count # nonlocal关键字声明
        i_count = 2  # 4、局部作用域:locals,当前所在命名空间（如函数、模块），函数的参数也属于命名空间内的变量 
		
print(locals(),globals())  #打印局部命名空间和全局命名空间

3、闭包

内部函数对外部函数作用域里变量的引用（非全局变量），则称内部函数为闭包。

def line_conf(a,b):
    def line(x):
        return a*x+b
    return line  # 这里返回的就是闭包的结果

line1 = line_conf(1,1)  # 引用外部函数
line2 = line_conf(4,5)

print(line1(5))  # 通过引用外部函数的方式给内部函数传参
print(line2(5))

三、匿名函数

使用lambda来创建匿名函数。
lambda [arg1 [,arg2,.....argn]]:expression

1 2	sum = lambda arg1, arg2: arg1 + arg2 print (sum( 10, 20 ))

python中有几个定义好的全局函数方便使用：map、filter、reduce。

from functools import reduce 
foo = [2, 18, 9, 22, 17, 24, 8, 12, 27]

# map 遍历序列，对序列中每个元素进行操作，最终获取新的序列。
print (list(map(lambda x: x * 2 + 10, foo)))  # [14, 46, 28, 54, 44, 58, 26, 34, 64]


# filter 对于序列中的元素进行筛选，最终获取符合条件的序列。
print (list(filter(lambda x: x % 3 == 0, foo)))  # [18, 9, 24, 12, 27]

 
# reduce 对于序列内所有元素进行累计操作
print (reduce(lambda x, y: x + y, foo))  # 139