示例

# -*- coding: cp936 -*-
#函数
#内建的callable函数可以用来判断函数是否可调用
#callable在Python3.0中不再可用,需要使用表达式hasattr(func, __call__)代替。
print '判断函数是否可调用'
import math
x = 1
y = math.sqrt
print callable(x)
print callable(y)

#定义函数
def hello(name):
    return 'Hello, ' + name + '!'

def hello_1(greeting, name):
    print '%s, %s!' % (greeting, name)

#参数可以有默认值
def hello_3(greeting='Hello', name='world'):
    print '%s, %s!' % (greeting, name)

#定义收集参数,不限传参数量,参数会以元组的形式传进来
#如果不传参数,params是个空元组
#这里的params不能使用关键字方式传参
def print_params(*params):
    print params

#params可以使用关键字方式传参,这里传进来的params是个字典
def print_params1(**params):
    print params

#普通参数与收集参数混合使用
def print_params2(title, *params):
    print title
    print params

#混合参数
def print_params4(x, y, z=3, *pospar, **keypar):
    print x,y,z
    print pospar
    print keypar

def fibs(num): #生成斐波那契数列
    result = [0, 1]
    for i in range(num-2):
        result.append(result[-2] + result[-1])
    return result

def foo(x,y,z,m=0,n=0):
    print x,y,z,m,n
#函数中调用另一个函数
def call_foo(*args, **kwds):
    print "Calling foo!"
    foo(*args, **kwds)

#文档化函数
#如果在函数的开头写下字符串,它就会作为函数的一部分进行存储,这称为文档字符串。
def square(x):
    'Calculates the square of the number x' #文档字符串
    return x*x

gp = 'global' #定义个全局变量
def fun1(gp):
    #因为有个同名的局部变量gp,所以需要用globals()来引用全局变量gp
    #globals()返回全局作用域
    print gp + globals()['gp'];
    print locals() #locals()返回函数所在的作用域

def fun2():
    global gp #告诉Python解释器 gp是个全局变量
    gp = 'fun2-global'

#函数可以通过元组返回多个值
#如果函数没有return,默认返回None
#不可变数据结构(字符串、数字、元组)按值传递
#可变数据结构按引用传递
#函数内部也可以引用外部的变量

print '调用函数'
print hello('world')
print hello('Gumby')
print '多个函数参数'
hello_1('Hello', 'world!')
#也可以这样传参数
#关键字参数
#如果函数的参数带默认值，调用时可只提供部分参数,或者不提供参数
hello_1(name='Hello', greeting='world!')#这样可以不用关心参数顺序(参数名一定要对应)
hello_3('HHello', name='wworld')#位置参数和关键字参数可以混合使用
print fibs(10)
print_params('p1', 'p2', 3)
#也可以这样传参
params = ('p1', 'p2', 3)
print_params(*params)

print_params1(x=1, y=2, z=3) #关键字传参
#也可以这样传参
params = {'x':1, 'y':2, 'z':3}
print_params1(**params)

print_params2('tt', 1, 2, 3)
print_params4(1,2,3,5,6,7,foo=1,bar=2)#混合传参

print '访问文档字符串'
print square.__doc__

print 'help函数'
print help(square)

print '作用域' #或者叫 命名空间
#可以把作用域理解成一个不可见的字典
#vars函数可以返回这个字典(一般来说这个字典是不能修改的)
x = 1
scope = vars()
print scope['x']
scope['x'] += 1
print x

fun1('aaa-')
fun2()
print gp

print '嵌套函数'
def foo():
    def bar():
        print "Hello, world!"
    bar()
    
foo()

print '函数闭包'
#内部函数存储外部函数作用域的行为叫做闭包
#外部作用域的变量一般来说是不能进行重新绑定的。但在Python3.0中,
#nonlocal关键字被引入。它和global关键字的使用方式类似，可以让用户
#对外部作用域(但并非全局作用域)的变量进行赋值。
def multiplier(factor):
    def multiplyByFactor(number):
        return number*factor #内层函数可以访问外层作用域中的factor
    return multiplyByFactor

print multiplier(2)(3)

print '递归'
def factorial(n):#求n的阶乘
    if n == 1:
        return 1
    else:
        return n * factorial(n-1)

print factorial(5)

print 'map函数'
#下面两句代码等效
print map(str, range(10))
print [str(i) for i in range(10)]

print 'filter函数'
def func(x):#字义过滤函数
    return x.isalnum()
seq = ["foo", "x41", "?!", "***"]
print filter(func, seq)
#也可以用lambda表达式创建函数
print filter(lambda x: x.isalnum(), seq)
#上面的代码等效于列表推导式
print [x for x in seq if x.isalnum()]

print 'reduce函数'
#reduce函数会将序列的前两个元素与给定的函数联合使用,
#并且将它们的返回值和第3个元素继续联合使用,直到整个序列
#处理完毕，并且得到一个最终的结果。
numbers = [1, 5, 8, 10, 13]
print reduce(lambda x,y: x+y, numbers)#计算列表中数字之和
#等效于内建函数sum的功能
print sum(numbers)

print 'apply函数' #用来调用函数的函数
#apply(函数名, 元组参数(可选), 字典参数(可选))
print apply(sum, (numbers,))

运行测试