python初步学习-python函数（一）

python 函数

函数是组织好的，可重复使用的，用来实现单一或者相关联功能的代码段。

函数能提高应用的模块性和代码的重复利用率。

函数定义

python中函数定义有一些简单的规则：

函数代码块以def关键词开头，后面接函数标识符名称和圆括号()
任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
函数的第一行语句可以选择性的使用文档字符串-用于存放函数说明。如使用'''说明文字'''
函数内容以冒号:起始，并且缩进。
return 表达式结束函数，选择性的返回一个值给调用方。不带表达式的return相当于返回 None

函数最关键的两个元素是参数和返回值

语法

def 函数名(参数1，参数2，...，参数n)：

    函数体（语句块）

默认情况下，参数值和参数名称是按函数声明中定义的顺序匹配起来的

命名

python对命名的一般要求：

文件名：全小写，可使用下划线
函数名：小写，可以用下划线风格单词以增加可读性。如：myfunction，my_example_function。注意：混合大小写仅被允许用于这种风格已经占据优势的时候，以便保持向后兼容。有的人，喜欢用这样的命名风格：myFunction，除了第一个单词首字母外，后面的单词首字母大写。这也是可以的，因为在某些语言中就习惯如此。
函数的参数：如果一个函数的参数名称和保留的关键字(所谓保留关键字，就是python语言已经占用的名称，通常被用来做为已经有的函数等的命名了，你如果还用，就不行了。)冲突，通常使用一个后缀下划线好于使用缩写或奇怪的拼写。
变量:变量名全部小写，由下划线连接各个单词。如color = WHITE，this_is_a_variable = 1。

函数调用

函数调用看下面一个例子：

>>> def add(x,y):       #为了能够更明了显示参数赋值特点，重写此函数

...     print "x=",x    #分别打印参数赋值结果

...     print "y=",y

...     return x+y

...

>>> add(10,3)           #x=10,y=3

x= 10

y= 3

13

>>> add(3,10)           #x=3,y=10

x= 3

y= 10

13

所谓调用，最关键是要弄清楚如何给函数的参数赋值。这里就是按照参数次序赋值，根据参数的位置，值与之对应。

还可以直接把赋值语句写到里面，就明确了参数和对象的关系。当然，这时候顺序就不重要了，也可以这样

>>> add(y=10,x=3)       #x=3,y=10

x= 3

y= 10

13

在定义函数的时候，参数可以像前面那样，等待被赋值，也可以定义的时候就赋给一个默认值。例如：

>>> def times(x,y=2):       #y的默认值为2

...     print "x=",x

...     print "y=",y

...     return x*y

...

>>> times(3)                #x=3,y=2

x= 3

y= 2

6

>>> times(x=3)              #同上

x= 3

y= 2

6

如果不给那个有默认值的参数传递值（赋值的另外一种说法），那么它就是用默认的值。如果给它传一个，它就采用新赋给它的值。如下：

>>> times(3,4)              #x=3,y=4,y的值不再是2

x= 3

y= 4

12

>>> times("ping")         #再次体现了多态特点

x= ping

y= 2

'pingping'

函数中的文档

__doc__方法返回的内容就为函数中的说明文档

>>> def my_fun():

...     """

...     This is my function.

...     """

...     print "I am a craft."

...

>>> my_fun.__doc__

'\n    This is my function.\n

如果在交互模式中用help(my_fun)得到的也是三个引号所包裹的文档信息。

Help on function my_fun in module __main__:

my_fun()

    This is my function.

参数

在定义函数的时候（def来定义函数，称为def语句），函数名后面的括号里如果有变量，它们通常被称为“形参”。调用函数的时候，给函数提供的值叫做“实参”，或者“参数”。

参考下面这个例子：

>>> def add(x):     #x是参数，准确说是形参

...     a = 10      #a是变量

...     return a+x  #x就是那个形参作为变量，其本质是要传递赋给这个函数的值

...

>>> x = 3           #x是变量，只不过在函数之外

>>> add(x)          #这里的x是参数，但是它由前面的变量x传递对象3

13

>>> add(3)          #把上面的过程合并了

13

参数收集

上面那个例子中的参数是确定的。那么如果参数的个数不确定，那么函数怎么去收集这些参数呢？

def func(x,*arg):

    print x         #输出参数x的值

    result = x

    print arg       #输出通过*arg方式得到的值

    for i in arg:

        result +=i

    return result

print func(1,2,3,4,5,6,7,8,9)    #赋给函数的参数个数不仅仅是2个

运行此代码后，得到如下结果：

1                       #这是函数体内的第一个print，参数x得到的值是1

(2, 3, 4, 5, 6, 7, 8, 9) #这是函数内的第二个print，参数arg得到的是一个元组

45                      #最后的计算结果

从上面例子可以看出，如果输入的参数个数不确定，其它参数全部通过*arg，以元组的形式由arg收集起来。对照上面的例子不难发现：

值1传给了参数x
值2,3,4,5,6.7.8.9被塞入一个tuple里面，传给了arg

除了用args这种形式的参数接收多个值之外，还可以用*kargs的形式接收数值，不过这次有点不一样：

>>> def foo(**kargs):

...     print kargs

...

>>> foo(a=1,b=2,c=3)    #注意观察这次赋值的方式和打印的结果

{'a': 1, 'c': 3, 'b': 2}

如果这次还用foo(1,2,3)的方式，会有什么结果呢？

>>> foo(1,2,3)

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

TypeError: foo() takes exactly 0 arguments (3 given)

如果用**kargs的形式收集值，会得到dict类型的数据，但是，需要在传值的时候说明“键”和“值”，因为在字典中是以键值对形式出现的。

但是我们也不知道参数到底会可能用什么样的方式传值啊。把上面两种方式结合起来就解决了。但是参数传递的顺序很关键。

>>> def foo(x,y,z,*args,**kargs):

...     print x

...     print y

...     print z

...     print args

...     print kargs

...

>>> foo('qiwsir',2,"python")

qiwsir

2

python

()

{}

>>> foo(1,2,3,4,5)

1

2

3

(4, 5)

{}

>>> foo(1,2,3,4,5,name="qiwsir")

1

2

3

(4, 5)

{'name': 'qiwsir'}

另一种传值方式

>>> def add(x,y):

...     return x + y

...

>>> add(2,3)

5

这是通常的函数调用方法，在前面已经屡次用到。这种方法简单明快，很容易理解。你也可以通过这样传值

>>> bars = (2,3)

>>> add(*bars)

5

注意的是，元组中元素的个数，要跟函数所要求的变量个数一致。如果这样：

>>> bars = (2,3,4)

>>> add(*bars)

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

TypeError: add() takes exactly 2 arguments (3 given)

这是使用一个星号*，是以元组形式传值，如果用**的方式，是不是应该以字典的形式呢？理当如此。

>>> def book(author,name):

...     print "%s is writing %s" % (author,name)

...

>>> bars = {"name":"Starter learning Python","author":"Kivi"}

>>> book(**bars)

Kivi is writing Starter learning Python

全局变量和局部变量

简单来说，全局变量为定义在函数体外的变量，通常定义在脚本开头。局部变量为定义在函数体内的变量。

看下面这个例子：

x = 2

def funcx():

    x = 9

    print "this x is in the funcx:-->",x

funcx()

print "--------------------------"

print "this x is out of funcx:-->",x

输出结果：

this x is in the funcx:--> 9

--------------------------

this x is out of funcx:--> 2

可以看到，当调用funcx()函数后，函数体内部打印的值与函数体外部打印的值不同。两个变量彼此没有相互影响，虽然都是x。在这里看出，两个x各自在各自的领域内起作用。

如果将上面这个例子改写为下面这个例子，就能让函数体内部的变量变为全局变量

x = 2

def funcx():

    global x    #跟上面函数的不同之处

    x = 9

    print "this x is in the funcx:-->",x

funcx()

print "--------------------------"

print "this x is out of funcx:-->",x

以上两段代码的不同之处在于，后者在函数内多了一个global x，这句话的意思是在声明x是全局变量，也就是说这个x跟函数外面的那个x同一个，接下来通过x=9将x的引用对象变成了9。所以，就出现了下面的结果。

this x is in the funcx:--> 9

--------------------------

this x is out of funcx:--> 9

好似全局变量能力很强悍，能够统帅函数内外。但是，要注意，这个东西要慎重使用，因为往往容易带来变量的换乱。内外有别，在程序中一定要注意的。

巴特西