Contents

# 函数

```   1 #!/usr/bin/python
2
3 def sayHello():
4     print 'Hello World!' # block belonging to the function
5
6 sayHello() # call the function
```

`Hello World!`

## 函数形参

```   1 #!/usr/bin/python
2
3 def printMax(a, b):
4     if a > b:
5         print a, 'is maximum'
6     else:
7         print b, 'is maximum'
8
9 printMax(3, 4) # directly give literal values
10
11 x = 5
12 y = 7
13
14 printMax(x, y) # give variables as arguments
```

```4 is maximum
7 is maximum```

## 局部变量

```   1 #!/usr/bin/python
2
3 def func(x):
4     print 'x is', x
5     x = 2
6     print 'Changed local x to', x
7
8 x = 50
9 func(x)
10 print 'x is still', x
```

```x is 50
Changed local x to 2
x is still 50```

## global语句

```   1 #!/usr/bin/python
2
3 def func():
4     global x
5
6     print 'x is', x
7     x = 2
8     print 'Changed local x to', x
9
10 x = 50
11 func()
12 print 'Value of x is', x
```

```x is 50
Changed global x to 2
Value of x is 2```

global语句被用来声明x是全局的——因此，当我们在函数内把值赋给x的时候，这个变化也反映在我们在主块中使用x的值的时候。

## 默认参数值

```   1 #!/usr/bin/python
2
3 def say(message, times = 1):
4     print message * times
5
6 say('Hello')
7 say('World', 5)
```

```Hello
WorldWorldWorldWorldWorld```

## 关键字参数

```   1 #!/usr/bin/python
2
3 def func(a, b=5, c=10):
4     print 'a is', a, 'and b is', b, 'and c is', c
5
6 func(3, 7)
7 func(25, c=24)
8 func(c=50, a=100)
```

```a is 3 and b is 7 and c is 10
a is 25 and b is 5 and c is 24
a is 100 and b is 5 and c is 50```

## 变长参数列表

```   1 def func(a, b=5, c=10, *arguments, **keywords):
2     print 'a is', a, 'and b is', b, 'and c is', c
3     print arguments
4     print keywords
5
6 func(1.0)
7 func(1.0, c=2, d=4, e=6)
8 func(2, 3, 4, 5, 6, f=7)
```

```s = [1,2,3,4,5,6]
func(*s)
d = {'a':1, 'b':2, 'c':2, 'd':3}
func(**d)```

## return语句

return语句用来从一个函数 返回 即跳出函数。我们也可选从函数 返回一个值 。

```   1 #!/usr/bin/python
2
3 def maximum(x, y):
4     if x > y:
5         return x
6     else:
7         return y
8
9 print maximum(2, 3)
```

`3`

maximum函数返回参数中的最大值，在这里是提供给函数的数。它使用简单的if..else语句来找出较大的值，然后 返回 那个值。

```   1 def someFunction():
2     pass
```

pass语句在Python中表示一个空的语句块。

## 文档字符串

Python有一个很奇妙的特性，称为 文档字符串 ，它通常被简称为 docstrings 。文档字符串是一个重要的工具，由于它帮助你的程序文档更加简单易懂，你应该尽量使用它。你甚至可以在程序运行的时候，从函数获得文档字符串！

```   1 #!/usr/bin/python
2
3 def printMax(x, y):
4     '''Prints the maximum of two numbers.
5
6     The two values must be integers.'''
7     x = int(x) # convert to integers, if possible
8     y = int(y)
9
10     if x > y:
11         print x, 'is maximum'
12     else:
13         print y, 'is maximum'
14
15 printMax(3, 5)
16 print printMax.__doc__
```

```5 is maximum
Prints the maximum of two numbers.

The two values must be integers.```

## lambda

lambda语句被用来创建新的函数对象，并且在运行时返回它们。

```   1 #!/usr/bin/python
2
3 def make_repeater(n):
4     return lambda s: s*n
5
6 twice = make_repeater(2)
7
8 print twice('word')
9 print twice(5)
```

```wordword
10```

## 函数式编程

"filter(function, sequence)"返回一个序列（sequence），包括了给定序列中所有调用function(item)后返回值为true的元素。（如果可能的话，会返回相同的类型）。例如，以下程序可以计算部分素数：

```>>> def f(x): return x % 2 != 0 and x % 3 != 0
...
>>> filter(f, range(2, 25))
[5, 7, 11, 13, 17, 19, 23]```

"map(function, sequence)" 为每一个元素依次调用function(item)并将返回值组成一个链表返回。例如，以下程序计算立方：

```>>> cube = lambda x: x*x*x
...
>>> map(cube, range(1, 11))
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]```

```>>> seq = range(8)
>>> add = lambda x, y: x+y
...
[0, 2, 4, 6, 8, 10, 12, 14]```

"reduce(func, sequence)" 返回一个单值，它是这样构造的：首先以序列的前两个元素调用函数，再以返回值和第三个参数调用，依次执行下去。例如，以下程序计算1到10的整数之和：

```>>> add = lambda x, y: x+y
...
55```

```>>> def sum(seq):
...     return reduce(lambda x,y:x+y, seq, 0)
...
>>> sum(range(1, 11))
55
>>> sum([])
0```

## 内置函数

eval语句用来计算存储在字符串中的有效Python表达式。下面是一个简单的例子。

```>>> eval('2*3')
6 ```

repr函数用来取得对象的规范字符串表示。反引号（也称转换符）可以完成相同的功能。注意，在大多数时候有eval(repr(object)) == object。

```>>> i = []
>>> i.append('item')
>>> `i`
"['item']"
>>> repr(i)
"['item']"```

str()返回对象的字符串显示

```>>> s = 'item'
>>> repr(s)
"'item'"
>>> str(s)
'item'```

len() 求长度

```>>> s = 'item'
>>> len(s)
4```

help() 看帮助

```import sys
help(sys)```

dir() 看模块或者对象的成员清单。比如用

`dir(__builtins__)`

range()函数用于产生一个列表

```>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(1, 10)
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(10, 1, -1)
[10, 9, 8, 7, 6, 5, 4, 3, 2]```

abs()求绝对值

```>>> abs(-1)
1
>>> abs(1+1j)
1.4142135623730951```

callable()判断一个对象是否可以作为函数被调用

```>>> callable(len)
True
>>> callable(9)
False```

chr()返回给定ascii码的字符

```>>> chr(65)
'A'```

unichr()返回指定unicode编码值的unicode字符

```>>> unichr(65)
u'A'```

ord()返回给定字符的ascii码

```>>> ord('A')
65
>>> ord(u'A')
65```

raw_input()读取一行字符串

```>>> raw_input("input a string:")
input a string:hello
'hello'```

input() 输入一个字符串，并对字符串中的表达式求值。等价于eval(raw_input())

```>>> input("input a number:")
input a number:10
10```

max求最大值

```>>> max(1, 2)
2
>>> max(1, 3, 2)
3
>>> s = [1,2,3,4,5,4,3]
>>> max(s)
5```

min求最小值，用法和max类似

sum求和

```>>> s = range(10)
>>> sum(s)
45
>>> sum(s, 20)
65```

type()对象的类型

```>>> type(10)
<type 'int'>
>>> type(3.14159)
<type 'float'>
>>> type('hello world')
<type 'str'>
>>> type(1+1j)
<type 'complex'>
>>> type(type)
<type 'type'>
>>> type(len)
<type 'builtin_function_or_method'>```

reversed()倒过来的序列

```>>> s = range(10)
>>> reversed(s)
<listreverseiterator object at 0xb7d3a8cc>
>>> [i for i in reversed(s)]
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
>>> for i in reversed(s):
...     print i*i,
...
81 64 49 36 25 16 9 4 1 0```

sorted()排序的序列

```>>> import random
>>> s = [random.randint(1,10) for i in range(10)]
>>> print s
[10, 5, 7, 4, 6, 7, 10, 8, 7, 3]
>>> sorted(s)
[3, 4, 5, 6, 7, 7, 7, 8, 10, 10]```

# end

Python语言的函数 (last edited 2008-02-23 15:35:57 by localhost)

ch3n2k.com | Copyright (c) 2008 czk. 浙ICP备06000584号