`

python defining functions and calling functions

阅读更多

Python actually allow very flexible syntax of defining functions in terms of the argument it also provide very flexible argument in terms of calling the functions. 

the references material is the control flow of the python code : http://docs.python.org/2/tutorial/controlflow.html 

 

Part of the code is as follow. 

4.6. Defining Functions

We can create a function that writes the Fibonacci series to an arbitrary boundary:

>>>
>>> def fib(n):    # write Fibonacci series up to n
...     """Print a Fibonacci series up to n."""
...     a, b = 0, 1
...     while a < n:
...         print a,
...         a, b = b, a+b
...
>>> # Now call the function we just defined:
... fib(2000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597

The keyword def introduces a function definition. It must be followed by the function name and the parenthesized list of formal parameters. The statements that form the body of the function start at the next line, and must be indented.

The first statement of the function body can optionally be a string literal; this string literal is the function’s documentation string, ordocstring. (More about docstrings can be found in the section Documentation Strings.) There are tools which use docstrings to automatically produce online or printed documentation, or to let the user interactively browse through code; it’s good practice to include docstrings in code that you write, so make a habit of it.

The execution of a function introduces a new symbol table used for the local variables of the function. More precisely, all variable assignments in a function store the value in the local symbol table; whereas variable references first look in the local symbol table, then in the local symbol tables of enclosing functions, then in the global symbol table, and finally in the table of built-in names. Thus, global variables cannot be directly assigned a value within a function (unless named in a global statement), although they may be referenced.

The actual parameters (arguments) to a function call are introduced in the local symbol table of the called function when it is called; thus, arguments are passed using call by value (where the value is always an object reference, not the value of the object). [1] When a function calls another function, a new local symbol table is created for that call.

A function definition introduces the function name in the current symbol table. The value of the function name has a type that is recognized by the interpreter as a user-defined function. This value can be assigned to another name which can then also be used as a function. This serves as a general renaming mechanism:

>>>
>>> fib
<function fib at 10042ed0>
>>> f = fib
>>> f(100)
0 1 1 2 3 5 8 13 21 34 55 89

Coming from other languages, you might object that fib is not a function but a procedure since it doesn’t return a value. In fact, even functions without a return statement do return a value, albeit a rather boring one. This value is called None (it’s a built-in name). Writing the value None is normally suppressed by the interpreter if it would be the only value written. You can see it if you really want to using print:

>>>
>>> fib(0)
>>> print fib(0)
None

It is simple to write a function that returns a list of the numbers of the Fibonacci series, instead of printing it:

>>>
>>> def fib2(n): # return Fibonacci series up to n
...     """Return a list containing the Fibonacci series up to n."""
...     result = []
...     a, b = 0, 1
...     while a < n:
...         result.append(a)    # see below
...         a, b = b, a+b
...     return result
...
>>> f100 = fib2(100)    # call it
>>> f100                # write the result
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

This example, as usual, demonstrates some new Python features:

  • The return statement returns with a value from a function. return without an expression argument returns None. Falling off the end of a function also returns None.
  • The statement result.append(a) calls a method of the list object result. A method is a function that ‘belongs’ to an object and is named obj.methodname, where obj is some object (this may be an expression), and methodname is the name of a method that is defined by the object’s type. Different types define different methods. Methods of different types may have the same name without causing ambiguity. (It is possible to define your own object types and methods, using classes, see Classes) The method append() shown in the example is defined for list objects; it adds a new element at the end of the list. In this example it is equivalent to result = result + [a], but more efficient.

4.7. More on Defining Functions

It is also possible to define functions with a variable number of arguments. There are three forms, which can be combined.

4.7.1. Default Argument Values

The most useful form is to specify a default value for one or more arguments. This creates a function that can be called with fewer arguments than it is defined to allow. For example:

def ask_ok(prompt, retries=4, complaint='Yes or no, please!'):
    while True:
        ok = raw_input(prompt)
        if ok in ('y', 'ye', 'yes'):
            return True
        if ok in ('n', 'no', 'nop', 'nope'):
            return False
        retries = retries - 1
        if retries < 0:
            raise IOError('refusenik user')
        print complaint

This function can be called in several ways:

  • giving only the mandatory argument: ask_ok('Do you really want to quit?')
  • giving one of the optional arguments: ask_ok('OK to overwrite the file?', 2)
  • or even giving all arguments: ask_ok('OK to overwrite the file?', 2, 'Come on, only yes or no!')

This example also introduces the in keyword. This tests whether or not a sequence contains a certain value.

The default values are evaluated at the point of function definition in the defining scope, so that

i = 5

def f(arg=i):
    print arg

i = 6
f()

will print 5.

Important warning: The default value is evaluated only once. This makes a difference when the default is a mutable object such as a list, dictionary, or instances of most classes. For example, the following function accumulates the arguments passed to it on subsequent calls:

def f(a, L=[]):
    L.append(a)
    return L

print f(1)
print f(2)
print f(3)

This will print

[1]
[1, 2]
[1, 2, 3]

If you don’t want the default to be shared between subsequent calls, you can write the function like this instead:

def f(a, L=None):
    if L is None:
        L = []
    L.append(a)
    return L

4.7.2. Keyword Arguments

Functions can also be called using keyword arguments of the form kwarg=value. For instance, the following function:

def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):
    print "-- This parrot wouldn't", action,
    print "if you put", voltage, "volts through it."
    print "-- Lovely plumage, the", type
    print "-- It's", state, "!"

accepts one required argument (voltage) and three optional arguments (stateaction, and type). This function can be called in any of the following ways:

parrot(1000)                                          # 1 positional argument
parrot(voltage=1000)                                  # 1 keyword argument
parrot(voltage=1000000, action='VOOOOOM')             # 2 keyword arguments
parrot(action='VOOOOOM', voltage=1000000)             # 2 keyword arguments
parrot('a million', 'bereft of life', 'jump')         # 3 positional arguments
parrot('a thousand', state='pushing up the daisies')  # 1 positional, 1 keyword

but all the following calls would be invalid:

parrot()                     # required argument missing
parrot(voltage=5.0, 'dead')  # non-keyword argument after a keyword argument
parrot(110, voltage=220)     # duplicate value for the same argument
parrot(actor='John Cleese')  # unknown keyword argument

In a function call, keyword arguments must follow positional arguments. All the keyword arguments passed must match one of the arguments accepted by the function (e.g. actor is not a valid argument for the parrot function), and their order is not important. This also includes non-optional arguments (e.g. parrot(voltage=1000) is valid too). No argument may receive a value more than once. Here’s an example that fails due to this restriction:

>>>
>>> def function(a):
...     pass
...
>>> function(0, a=0)
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
TypeError: function() got multiple values for keyword argument 'a'

When a final formal parameter of the form **name is present, it receives a dictionary (see Mapping Types — dict) containing all keyword arguments except for those corresponding to a formal parameter. This may be combined with a formal parameter of the form *name (described in the next subsection) which receives a tuple containing the positional arguments beyond the formal parameter list. (*name must occur before **name.) For example, if we define a function like this:

def cheeseshop(kind, *arguments, **keywords):
    print "-- Do you have any", kind, "?"
    print "-- I'm sorry, we're all out of", kind
    for arg in arguments:
        print arg
    print "-" * 40
    keys = sorted(keywords.keys())
    for kw in keys:
        print kw, ":", keywords[kw]

It could be called like this:

cheeseshop("Limburger", "It's very runny, sir.",
           "It's really very, VERY runny, sir.",
           shopkeeper='Michael Palin',
           client="John Cleese",
           sketch="Cheese Shop Sketch")

and of course it would print:

-- Do you have any Limburger ?
-- I'm sorry, we're all out of Limburger
It's very runny, sir.
It's really very, VERY runny, sir.
----------------------------------------
client : John Cleese
shopkeeper : Michael Palin
sketch : Cheese Shop Sketch

Note that the list of keyword argument names is created by sorting the result of the keywords dictionary’s keys() method before printing its contents; if this is not done, the order in which the arguments are printed is undefined.

4.7.3. Arbitrary Argument Lists

Finally, the least frequently used option is to specify that a function can be called with an arbitrary number of arguments. These arguments will be wrapped up in a tuple (see Tuples and Sequences). Before the variable number of arguments, zero or more normal arguments may occur.

def write_multiple_items(file, separator, *args):
    file.write(separator.join(args))

4.7.4. Unpacking Argument Lists

The reverse situation occurs when the arguments are already in a list or tuple but need to be unpacked for a function call requiring separate positional arguments. For instance, the built-in range() function expects separate start and stop arguments. If they are not available separately, write the function call with the *-operator to unpack the arguments out of a list or tuple:

>>>
>>> range(3, 6)             # normal call with separate arguments
[3, 4, 5]
>>> args = [3, 6]
>>> range(*args)            # call with arguments unpacked from a list
[3, 4, 5]

In the same fashion, dictionaries can deliver keyword arguments with the **-operator:

>>>
>>> def parrot(voltage, state='a stiff', action='voom'):
...     print "-- This parrot wouldn't", action,
...     print "if you put", voltage, "volts through it.",
...     print "E's", state, "!"
...
>>> d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}
>>> parrot(**d)
-- This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised !

so the rules in a nutshell, 

  • when defining a function, the order of the allowed arguments is "required argument, default argument, list argument, key-word argument in dictionary," in the form of (a, b = b_value, *list_arguments, **keywords_argument_in_dictionarys)"
  • when calling a function, it order of argument that you can pass  in is "required argument (positional argument) >  key-word argument | default argument > variable-length argument in list > key-word argument in dictionary" in the form of func(a, b = b_new_value, *list_arguments, **keywords_argument_in_dictionaries)"

 

 

分享到:
评论

相关推荐

    python3.6.5参考手册 chm

    Deprecated Python modules, functions and methods asynchat asyncore dbm distutils grp importlib os re ssl tkinter venv Deprecated functions and types of the C API Deprecated Build Options ...

    Modeling-and-Simulation-in-Python-pdf.pdf.pdf

    文档介绍了关于建模的一些基础概念,如计算(Computation)、函数定义(Defining functions)、参数(Parameters)、打印语句(Print statements)、条件判断(If statements)、可选参数(Optional parameters)、...

    Python Data Science Handbook Essential Tools for Working with Data

    functions, assigning variables, calling methods of objects, controlling the flow of a program, and other basic tasks. Instead, it is meant to help Python users learn to use Python’s data science ...

    Python Tutorial 入门指南3.6英文版

    4.7. More on Defining Functions 31 4.7.1. Default Argument Values 31 4.7.2. Keyword Arguments 33 4.7.3. Arbitrary Argument Lists 35 4.7.4. Unpacking Argument Lists 36 4.7.5. Lambda Expressions 37 ...

    20190201版PythonForDelphi含例程源码.zip

    Demo07 Using Delphi methods as Python functions Demo08 Using Delphi classes for new Python types Demo09 Making a Python module as a Dll Demo10 Mapping Delphi VCL components inside Python using ...

    Python 2.7 Tutorial 中文版.pdf

    在“Defining Functions”章节中,介绍了如何在Python中定义函数,包括参数的传递和默认值,以及返回值。在“More on Defining Functions”章节中,进一步深入了函数定义的更多内容,包括匿名函数(lambda表达式)和...

    python 2.6 turial

    - **More on Defining Functions** — 进一步讨论函数定义,包括参数传递、默认参数值、可变参数列表等高级主题。 #### Data Structures — 数据结构 在“数据结构”章节中,教程详尽地介绍了Python中各种内置数据...

    python-3.6.1 Tutorial

    - **Python Scopes and Namespaces(Python的作用域和命名空间)** - 介绍Python中的作用域规则和命名空间概念。 - **A First Look at Classes(初次了解类)** - 介绍类的基本概念和属性。 - **Random Remarks...

    Python Cookbook, 2nd Edition

    Using a Dictionary to Dispatch Methods or Functions Recipe 4.17. Finding Unions and Intersections of Dictionaries Recipe 4.18. Collecting a Bunch of Named Items Recipe 4.19. Assigning and ...

    python 官方快速教程

    - **9.2 Python Scopes and Namespaces**(Python的作用域和命名空间) - 作用域的概念及其对命名的影响。 - 示例代码:演示局部变量和全局变量。 - **9.3 A First Look at Classes**(初次接触类) - 类的基本...

    Python入门 PythonTutorial

    - **More on Defining Functions**:进一步讨论函数定义的高级特性,如可变参数列表等。 - **Coding Style**:推荐的编码风格,帮助提高代码可读性和可维护性。 #### 五、Data Structures(数据结构) - **More on...

    Matlab Tutorial - 53 - Defining Mathematical Functions.zip

    在Matlab中定义数学函数是进行数值计算和数据分析的基础。本教程主要涵盖了如何在Matlab环境中创建和使用自定义函数,以及如何优化这些函数以提高效率。以下是对这个主题的详细探讨: 首先,Matlab中的函数是通过...

    Bioinformatics Programming Using Python.pdf.pdf

    文档的详细目录部分被提及,提到了一些章节,比如“Simple Values”、“Primitives”、“Names, Functions, and Modules”等,这表明书籍的结构是按照这些基本概念划分的,逐步深入地向读者介绍如何使用Python在生物...

    python3.4 tutorial指导手册英文版

    ##### 9.2 Python 作用域与命名空间 (Python Scopes and Namespaces) - **作用域规则**:介绍 Python 中的作用域规则,包括局部作用域、全局作用域等。 - **命名空间概念**:解释命名空间的概念及其在作用域中的...

    scipylectures

    This chapter covers the fundamentals of the Python language, including basic types, control flow, defining functions, and object-oriented programming concepts. - **Basic Types:** Integers, floating-...

    Bioinformatics Programming Using Python

    Defining Functions和Function Parameters说明了如何定义函数以及函数参数的概念。在Python中定义函数可以让你编写可重复使用的代码块,处理生物信息学中的复杂计算和数据处理任务。函数参数则允许函数根据传入的...

Global site tag (gtag.js) - Google Analytics