[Python]函数与函数编程

1. 函数

使用def语句可定义函数：

def add(x, y):
    return x + y

函数体就是在调用函数时所执行的一系列语句。调用函数的方法是在函数名称后面加上参数。参数的顺序必须与函数定义匹配，否则会引发TypeError异常。可以为函数的参数设置默认值，例如：

def split(line, delimiter=‘,‘):
    statements

如果给最后一个参数名加上星号"*"，函数就可以接受任意数量的参数：

def fprintf(file, fmt, *args):
    file.write(fmt % args)
fprintf(out, "%d %s %f", 42, "hello world", 3.45)

在这个例子中，所有余下的参数都作为一个元组放入args变量。要把元组args当作参数传递给函数，可以在函数调用中使用*args语法。例如：

def printf(fmt, *args):
    fprintf(sys.stdout, fmt, *args)

提供函数参数还有一种方式，即显示地命名每个参数并为其指定一个值，这称为关键字参数，例如：

def foo(w, x, y, z):
    statements
foo(x=3, y=22, w=‘hello‘, z=[1, 2])

使用关键字参数时，参数的顺序无关紧要。但除非提供了默认值，否则必须显式地命名所有必需的函数参数。位置参数和关键字参数可以同时使用，前提是所有位置参数必须先出现，给所有非可选参数提供值，例如：

foo(‘hello‘, 3, z=[1, 2], y=22)

如果函数定义的最后一个参数以"**"开头，可以把所有额外的关键字参数都放入一个字典中，并把这个字典传递给参数。例如：

def make_table(data, **params):
    fgcolor = params.pop("fgcolor", "black")
    bgcolor = params.pop("bgcolor", "white")
    width = params.pop("width", None)
    if params:
        raise TypeError("Unsupported configuration options %s" % list(params))
make_table(items, fgcolor="black", bgcolor="white", border=1, borderstyle="grooved", cellpoadding=10, width=400)

关键字参数和可变长度参数列表可以一起使用，只要"**"参数出现在最后即可，例如：

def spam(*args, **kwargs):
    statements

?

2. 参数传递与返回值

调用函数时，函数参数仅仅是引用传入对象的名称。参数传递的基本语义和其他编程语言中已知的方式不完全相同，如“按值传递”和“按引用传递”。比如传递不可变的值，参数看起来实际是按值传递的，如果传递的是可变对象（如列表或字典）给函数，然后再修改此可变对象，这些改动将反映在原始对象中。例如：

a = [1, 2, 3, 4, 5]
def square(items):
    for i, x in enumerate(items):
        items[i] = x * x
square(a) # a = [1, 4, 9, 16, 25]

return语句从函数返回一个值。如果没有指定任何值或者省略return语句，就会返回None对象。如果返回值有多个，可以把它们放在一个元组中，例如：

def factor(a):
    d = 2
    while (d <= (a / 2)):
        if ((a / d) * d == a):
            return ((a / d), d)
        d = d + 1
    return (a, 1)

?

3. 作用域规则

每次执行一个函数时，就会创建新的局部命名空间。该命名空间代表一个局部环境，其中包含函数参数的名称和在函数体内赋值的变量名称。解析这些名称时，解释器将首先搜索局部命名空间。如果没有找到匹配的名称，它就会搜索全局命名空间。如果在全局命名空间中也找不到匹配值，最终会检查内置命名空间。如果仍然找不到，就会引发NameError异常。
命名空间的特性之一是在函数中对全局变量的操作，例如：

a = 42
def foo():
    a = 13
foo() # a仍然是42

执行这段代码时，尽量在函数foo中修改了变量a的值，但最终a仍然是42.在函数中对变量进行赋值时，这些变量始终绑定到该函数的局部命名空间中，因此函数体中的变量a引用的是一个包含值13的全新对象，而不是外部的变量。使用global语句可以改变这种行为，例如：

a = 42
def foo():
    global a
    a  = 13
foo() # a的值已变13

Python支持嵌套的函数定义，例如：

def countdown(start):
    n = start
    def display():
        print(‘T-minus %d‘ % n)
    while n > 0:
        display()
        n -= 1

使用静态作用域绑定嵌套函数中的变量，即解析名称时首先检查局部作用域，而后由内向外一层层检查外部嵌套函数定义的作用域。如果找不到匹配，最后将搜索全局命名空间和内置命名空间。可以使用nonlocal语句绑定外部变量，例如：

def countdown(start):
    n = start
    def display():
        print(‘T-minus %d‘ % n)
    def decrement():
        nonlocal n
        n -= 1
    while n > 0:
        display()
        decrement()

nonlocal声明不会把名称绑定到任意函数中定义的局部变量，而是搜索当前调用栈中的下一层函数定义，即动态作用域。例如：

i = 0
def foo():
    i = i + 1 # UnboundLocalError异常

尽管有一个全局变量i，但它不会给局部变量i提供值。函数定义时就确定了变量是局部的还是全局的，而且在函数中不能突然改变它们的作用域。

?

4. 函数对象与闭包

函数在Python中是第一类对象。即可以把它们当作参数传递给其他函数，放在数据结构中，以及作为函数的返回结果。例如：

def callf(func):
    return func()

把函数当作数据处理时，它将显式地携带与定义该函数的周围环境相关的信息。这将影响到函数中自由变量的绑定方式。例如：

# foo.py
x = 42
def callf(func):
    return func()

# main.py
import foo
x = 37
def helloworld():
    reutrn "x is %d" % x
foo.callf(helloworld) # x is 37

在上例中，即使foo.py中也定义了一个变量x，变际调用的是与helloworld()函数相同的环境中定义的值。将组成函数的语句和这些语句的执行环境打包在一起时，得到的对象称为闭包。事实上所有函数都拥有一个指向了定义该函数的全局命名空间的__globals__属性。例如：

def page(url):
    def get():
        return urlopen(url).read()
    return get
python = page("http://www.python.org")
jython = page("http://www.jython.org")
pydata = python() # 获取http://www.python.org
jydata = jython() # 获取http://www.jython.org

?

5. 装饰器

装饰器是一个函数，其主要用途是包装另一个函数或类。这种包装的首要目的是透明地修改或增强被包装对象的行为。表示装饰器的语法是特殊符号"@"，例如：

@trace
def square(x):
    return x * x

上面的代码可以简化为：

def square(x):
    return x * x
square = trace(square)

现在考虑trace的实现：

enable_tracing =  True
if enable_tracing:
    debug_log = open("debug.log", "w")

def trace(func):
    if enable_tracing:
        def callf(*args, **kwargs):
            debug_log.write("Calling %s: %s, %s\n" % (func.__name__, args, kwargs))
            r = func(*args, **kwargs)
            debug_log.write("%s returned %s\n" % (func.__name__, r))
            return r
        return callf
    else:
        return func

这段代码中，trace()创建了写有一些调试输出的包装器函数，然后调用了原始函数对象。因此如果调用square()函数，看到的将是包装器中write()方法的输出。
使用装饰器时，它们必须出现在函数或类定义之前的单独行上。可以同时使用多个装饰器，例如：

@foo
@bar
@spam
def grok(x):
    passgrok = foo(bar(spam(grok)))

装饰器也可以接受参数，例如：

@eventhandler(‘BUTTON‘)
def handle_button(msg):
    ...
@eventhandler(‘RESET‘)
def handle_reset(msg):
    ...

如果提供参数，装饰器的语义如下所示：

def handle_button(msg):
    ...
temp = eventhandler(‘BUTTON‘)
handle_button = temp(handle_button)

对于类装饰器，应该让装饰器函数始终返回类对象作为结果。需要使用原始类定义的代码可能要直接引用类成员。
?

6. 生成器与yield

函数使用yield关键字可以定义生成器对象。生成器是一个函数，它生成一个值的序列，以便在迭代中使用，例如：

def countdown(n):
    while n > 0:
        yield n
        n -=1
    return

如果调用该函数，其中的代码不会开始执行，它会返回一个生成器对象，该对象在_next_()被调用，例如：

c = countdown(10)
c.__next__()

调用_next_()时，生成器函数将不断执行语句，直到遇到yield语句为止。通常不会在生成器上直接调用_next_()方法，而是在for语句、sum()或一些使用序列的其他操作中使用，例如：

for n in countdown(10):
    statements
a = sum(countdown(10))

生成器函数完成的标志是返回或引发StopIteration异常，这标志着迭代的结束。如果生成器没有全部完成，并且不再使用，可以调用close()方法，虽然通常情况下可以不必调用，例如：

c = countdown(10)
c.__next__()
c.close()
c.__next__() # 抛出异常

在生成器函数内部，在yield语句上出现GeneratorExit异常时就会调用close()方法。可以选择获取这个异常，例如：

def countdown(n):
    try:
        while n > 0:
            yield n
            n -= 1
    except GeneratorExit:
        print("Only made it to %d" % n)

?

7. 协程与yield表达式

在函数内，yield语句还可以用作出现在赋值运算符右边的表达式，例如：

def receiver():
    while True:
        n = (yield)
        print("Got %s" % n)

以这种方式使用yield语句的函数称为协程，它的执行是为了响应发送给它的值。它的行为也类似于生成器，例如：

r = receiver()
r.__next__()
r.send(1)
r.send(2)

在协程中需要首先调用_next_()这件事很容易被忘记，可以用一个自动完成该步骤的装饰器来包装协程，例如：

def coroutine(func):
    def start(*args, **kwargs):
        g = func(*args, **kwargs)
        g.next()
        return g
    return start

@coroutine
def receiver():
    while True:
        n = (yield)
        print("Got %s" % n)

r = receiver()
r.send("Hello World")

协程的运行一般是无限期的，除非它被显式关闭或者自己退出。使用close()可以关闭输入值的流，例如：

r.close()
r.send() # 抛出异常

关闭后如果继续给协程发送值，就会引发StopIteration异常，close()操作将在协程内部引发GeneratorExit异常。
?

8. 列表包含

函数的常用操作是将函数应用给一个列表的所有项，并使用结果创建一个新列表。这种操作很常见，因此出现了叫做列表推导的运算符，例如：

nums = [1, 2, 3, 4, 5]
squares = [n * n for n in nums]

列表推导的一般语法如下：

[expression for item1 in iterable1 if condition1
                                        for item2 in iterable2 if condition2
                                        ...
                                        for itemN in iterableN if conditionN]

下面给出一些例子：

a = [-3, 5, 2, -10, 7, 8]
b = ‘abc‘
c = [2 * s for s in a] # c = [-6, 10, 4, -20, 14, 16]
d = [s for s in a if s >= 0] # d = [5, 2, 7, 8]
e= [(x, y) for x in a
                                for y in b
                                if x > 0]
# e = [(5, ‘a‘), (5, ‘b‘), (5, ‘c‘),
                    (2, ‘a‘), (2, ‘b‘), (2, ‘c‘),
                    (7, ‘a‘), (7, ‘b‘), (7, ‘c‘),
                    (8, ‘a‘), (8, ‘b‘), (8, ‘c‘)]
f = [(1, 2), (3, 4), (5, 6)]
g  = [math.sqrt(x * x + y * y) for x, y in f] # g = [2.23606797749979, 5.0, 7.810249675906654]

?

9. 生成器表达式

生成器表达式是一个对象，它执行的计算与列表包含相同，但会迭代地生成结果，语法与列表包含相同，除了用圆括号代替方括号，如下：

(expression for item1 in iterable1 if condition1
                                        for item2 in iterable2 if condition2
                                        ...
                                        for itemN in iterableN if conditionN)

生成器表达式实际上不创建列表或者立即对圆括号内的表达式求值，它创建一个通过迭代并按照需要生成值的生成器对象，例如：

a  = [1, 2, 3, 4]
b = (10 * i for i in a)
print(b.__next__())
print(b.__next__())

使用列表推导时，Python实际上创建了包含结果数据的列表。而使用生成器表达式时，Python创建的是只知道如何按照需要生成数据的生成器。在某些应用中，可能影响性能和内存使用，例如：

f = open("data.txt")
lines = (t.strip() for t in f)
comments = (t for t in lines if t[0] == ‘#‘)
for c in comments:
    print(c)

生成器表达式不会创建序列形式的对象，不能对它进行索引。但是，使用内置的list()函数可以将生成器表达式转换为列表，例如：

clist = list(comments)

?

10. lambda运算符

使用lambda语句可以创建表达式形式的匿名函数：

lambda args: expression

args是以逗号分隔的参数列表，而expression是用到这些参数的表达式，例如：

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

使用lambda语句定义的代码必须是合法的表达式。lambda语句中不能出现多条语句和其他非表达式语句，比如for或while。
?

11. 文档字符串

通常，函数的第一条语句会使用文档字符串，用于描述函数的用途，例如：

def factorial(n):
    """Computes n factorial. For examples:
            >>> factorial(6)
            120
    """
    if n <= 1: return 1
    else: return n* factorial(n-1)

文档字符串保存在函数的__doc__属性中，IDE通常使用该函数提供交互式帮助。如果需要使用装饰器，可能会破坏与文档字符串相关的帮助功能，例如：

def wrap(func):
    call(*args, **kwargs):
        return func(*args, **kwargs)
    return call
@wrap
def factorial(n):
    """Computes n factorial."""

如果查目的地以上函数的帮助，可能会看到一个相当奇怪的内容，解决方法是编写可以传递函数名称和文档字符串的装饰器函数，例如：

def wrap(func):
    call(*args, **kwargs):
        return func(*args, **kwargs)
    call.__doc__ =  func.__doc__
    call.__name__ = func.__name__
    return call

因为这是一个常见问题，所以functools模块提供了函数wraps，用于自动复制这些属性，例如：

from functools import wraps
def wrap(func):
    @wrap(func)
    call(*args, **kwargs):
        return func(*args, **kwargs)
    return call

?

12. 函数属性

可以给函数添加任意属性，例如：

def foo():
    statements
foo.secure = 1
foo.private = 1

函数属性保存在函数的__dict__属性中，__dic__属性是一个字典。和文档字符串一样，也要注意混合使用函数属性和装饰器的问题。如果使用装饰器包装函数，实际上是由装饰器函数而非原始函数来访问属性。
?

13. eval()、exec()和compile()函数

eval(str [, globals [, locals]])函数执行一个表达式字符串并返回结果，例如：

a = eval(‘3 * math.sin(3.5 + x) + 7.2‘)

相似地，exec(str [, globals [, locals]])函数执行一个包含任意Python代码的字符串。例如：

a = [3, 5, 10, 13]
exec("for i in a: print(i)")

这两个函数都会在调用者的命名空间中执行。eval()和exec()函数可以接受一个或两个可选的映射对象，分别用作代码执行的全局和局部命名空间，例如：

globals = {‘x‘: 7, ‘y‘: 10, ‘birds‘: [‘Parrot‘, ‘Swallow‘, ‘Albatross‘]}
locals = {}
a = eval("3 * x + 4 * y", globals, locals)
exec("fro b in birds: print(b)", globals, locals)

compile(str, filename, kind)函数将字符串编译为字节码，其中str是包含要编译代码的字符串，而filename是定义该字符串的文件，kind参数指定了要编译代码的类型。single表示一条语句，exec代表一组语句，而eval代表一个表达式。例如：

s = "for i inrange(0, 10): print(i)"
c = compile(s, ‘‘, ‘exec‘)
exec(c)
s2 = "3 * x + 4 * y"
c2 = compile(s2, ‘‘, ‘eval‘)
result = eval(c2)

原文地址：http://blog.51cto.com/hanviseas/2165689

时间： 2024-10-10 21:39:05

[Python]函数与函数编程的相关文章

从C#到Python —— 3 函数及函数编程

在C#中没有独立的函数存在,只有类的(动态或静态)方法这一概念,它指的是类中用于执行计算或其它行为的成员.在Python中,你可以使用类似C#的方式定义类的动态或静态成员方法,因为它与C#一样支持完全的面向对象编程.你也可以用过程式编程的方式来编写Python程序,这时Python中的函数与类可以没有任何关系,类似C语言定义和使用函数的方式.此外,Python还支持函数式编程,虽然它对函数式编程的支持不如LISP等语言那样完备,但适当使用还是可以提高我们工作的效率. 本章主要介绍在过程编程模式下

3.关于python函数，以及作用域，递归等知识点

一.使用函数编程的好处. 大大的提高了代码的重用行,重复的逻辑或者操作,可以定义到一个函数里,多次调用. 下面是关于提高代码重用性的例子. 现在老板让你写一个监控程序,监控服务器的系统状况,当cpu＼memory＼disk等指标的使用量超过阀值时即发邮件报警,你掏空了所有的知识量,写出了以下代码. while True: if cpu利用率 > 90%: #发送邮件提醒 连接邮箱服务器 发送邮件 关闭连接 if 硬盘使用空间 > 90%: #发送邮件提醒 连接邮箱服务器 发送邮件 关闭连接 i

浅析python函数

慢慢的开始进入状态啦,被明老师说我什么都不会后我觉得是该反思下自己这个学期的学习了,虽然我对实验没有很大的兴趣,但是既然名老师要求我开始做实验,我就跟着小丹师姐好好学学,用Tanger师兄的话来说就是:做实验有利于你理解生物信息学数据处理的原理,也许有一天,未来做生物信息的学弟学妹会看到这段话,就像我在码迷上看到free_mao的博文一样,生物信息还是基于生物的,生物原理必须要理解,不然和做计算机有什么区别呢?以前对书本的知识不够重视,语言的学习进度很缓慢,现在希望能分享一些学习心得体会给大家,

python函数

python函数学习 1. 概述: 函数是重用的程序段,用关键字def来定义,可以任意多次地运行这个语句块,被称为调用函数.Python提供了许多内建函数,比如print(),也可以自己创建函数,这被叫做用户自定义函数,函数能提高应用的模块性,和代码的重复利用率. 2.函数语法: 函数代码块以 def 关键词开头,后接函数标识符名称和圆括号(). 任何传入参数和自变量必须放在圆括号中间.圆括号之间可以用于定义参数. 函数的第一行语句可以选择性地使用文档字符串-用于存放函数说明. 函数内容以冒号起

Python 函数对象 命名空间与作用域 闭包函数 装饰器 迭代器 内置函数

一.函数对象 函数(Function)作为程序语言中不可或缺的一部分,但函数作为第一类对象(First-Class Object)却是 Python 函数的一大特性. 那到底什么是第一类对象(First-Class Object)呢? 在 Python 中万物皆为对象,函数也不例外,函数作为对象可以赋值给一个变量.可以作为元素添加到集合对象中.可作为参数值传递给其它函数,还可以当做函数的返回值,这些特性就是第一类对象所特有的. 1.函数身为一个对象,拥有对象模型的三个通用属性:id.类型.和值.

python 函数

函数的定义 函数最重要的目的是方便我们重复使用相同的一段程序. 将一些操作隶属于一个函数,以后你想实现相同的操作的时候,只用调用函数名就可以,而不需要重复敲所有的语句. 创建函数 def 函数名 (参数列表) 函数体 例如: def sum1(a,b): c = a + b return c e=1 f=2 print (sum1(e,f)) 首先def 是定义函数名 sum1是函数名 括号中的a, b是函数的参数,是对函数的输入.参数可以有多个,也可以完全没有(但括号要保留). c = a +

Python 五、Python函数

一.函数概述 1.函数的基础概念 函数是python为了代码最大程度地重用和最小化代码冗余而提供的基础程序结构. 函数是一种设计工具,它能让程序员将复杂的系统分解为可管理的部件 函数用于将相关功能打包并参数化 在python中可以创建4种函数: 全局函数:定义在模块中 局部函数:嵌套于其它函数中 lambda(匿名)函数:仅是一个表达式 方法:与特定数据类型关联的函数,并且只能与数据类型关联一起使用 函数和过程的联系:每个Python函数都有一个返回值,默认为None,也可以使用"return

六、Python函数

Python函数 一.函数 函数就是完成特定功能的一个语句组,这组语句可以作为一个单位使用,并且给它取一个名字 可以通过函数名在程序的不同的地方多次执行(这通常叫做函数调用),却不需要在所有地方都重复编写这些语句 自定义函数和预定义函数 函数作用:降低编程的难度.代码重用 当我们自己定义一个函数时,通常使用def语句 def 函数名(参数列表): #可以没有参数 函数体 #!/usr/bin/python a = int(raw_input("please enter a number:&quo

Python 3.X 调用多线程C模块，并在C模块中回调python函数的示例

由于最近在做一个C++面向Python的API封装项目,因此需要用到C扩展Python的相关知识.在此进行简要的总结. 此篇示例分为三部分.第一部分展示了如何用C在Windows中进行多线程编程:第二部分将第一部分的示例进行扩展,展示了如何在python中调用多线程的C模块:第三部分扩展了第二部分,增加了在C模块的线程中回调python的演示. 本文所用的环境为:64位Win7 + python 3.4 x86 + vs2010 一.windows下的C语言多线程程序 windows下多线程编程