Python（11）函数

Python（11）函数简介

• 函数定义
• 调用函数
• 创建函数
• 传递函数
• 形参
• 可变长参数
• 函数式编程
• 变量作用域
• 生成器

函数

第一种：无返回值

def hello()
    print 'hehfds'

第二种：有返回值或者对象

def a():
    return ['dsf',10084,-94.5] # 返回列表
def b():
    return 'adf',[43,'python'],"fsd" # 返回元组，元组可以不带括号
def c():
    return ('fds',324,"fdfd") #返回元组

调用函数

第一种调用：标准调用

def foo(x):
    print 'fsd'

foo(42)      # 标准调用
foo('fds')   # 标准调用
foo(y)       # 标准调用

foo(x=43)     # 关键字调用
foo(x='fdsf') # 关键字调用
foo(x=y)      # 关键字调用

第二种调用：关键字调用

def con(host, port):
    print 'fsd'

con('fsd',980)            # 参数顺序要对应
con(port=777,host='fsdf') # 参数顺序可以换

创建函数

前向引用

def foo():
    print 'fooooooo'
    bar() # 可以在函数bar()定义前定义foo()

def bar():
    print 'fbaddd'

foo()

函数属性

可以在两个模块使用相同的变量名字，句点属性标识对于量个模块意味了不同的命名空间。

内嵌函数

def foo():
    print 'foooo'
    def bar():
        print 'barrrr'
    bar() 

foo()

foooo
barrrr

装饰器

装饰器是一个函数。
可以引入日志
增加计时逻辑检测性能
给函数增加事务的能力
用一个函数装饰另外一个函数，给原来的函数附加额外的功能

def tsfun(func):
    def warper():
        print 'beuty'
        return func()
    return warper

@tsfun
def foo():
    print 'foooooo'

beuty
foooooo

传递函数

def foo():
    print 'foooooo'
bar = foo # bar是引用
bar()     # bar()是调用

foooooo

函数作为参数来调用：

def foo():
    print 'foooooo'

def bar(func):
    print 'fdfdf'
    return func()

bar(foo)


fdfdf
foooooo

形参

def foo(cost, rate = 0.8): # 默认参数rate必须在cost后
    return cost * rate

print foo(100)
print foo(100,1)

80.0
100

可变长参数

第一种：非关键字可变长参数

def foo(arg, *test):
    print 'arg1 = ', arg
    for x in test:
        print 'arg2 = ',x

foo(100,200)

arg1 =  100
arg2 =  200

and

def foo(arg, *test): # *test必须放在最后
    print 'arg1 = ', arg
    for x in test:
        print 'arg2 = ',x

foo(100,200,300)

arg1 =  100
arg2 =  200
arg2 =  300

第二种：关键字变量参数

def foo(arg1, arg2 = 'default', **test):
    print 'arg1 = ', arg1
    print 'arg2 = ', arg2
    for x in test:
        print 'arg3 = ',x

foo(arg1 = 100, c = 200 ,arg2 = 'fsdf', d = 34)

arg1 =  100
arg2 =  fsdf
arg3 =  c
arg3 =  d

函数式编程

第一种：匿名函数

lambda

def a(x, y = 2):
    return x + y

b = lambda x, y = 2: x+y
print a(3)
print b(3)

5
5

第二种：

apply() 已成为历史，会被淘汰

第三种：

filter()

# 输入为一个函数，一个序列
# 输出为使函数返回值为True的序列
print filter(lambda x: x % 2 == 1, [1, 2, 3, 4, 5])
[1, 3, 5]

第四种：

map()

print map((lambda x: x + 2), [0,1,2,3])
# 输入为列表，映射后返回为列表
[2, 3, 4, 5]

第五种：

reduce()

print reduce((lambda x, y: x + y), [0,1,2,3])

6

变量作用域

globa语句

a = 'xyz'
def foo():
    global a # 防止全局变量的值把局部变量的值给覆盖掉
    a = 'gsd'
    print a

foo()
print a

gsd
gsd

闭包

在一个内部函数里，对在外部作用域的变量进行引用，内部函数就被认为 闭包

def foo(x = 0):
    fo = [x]
    def bar():
        fo[0] += 1
        return fo[0]
    return bar

fo = foo(5)

print fo()
print fo()

6
7

生成器

生成器是一个带yield的语句函数
一个生成器能暂停执行并返回一个中间结果