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

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

转载于:https://www.cnblogs.com/pingqiang/p/7768942.html