p3

qiwsir · qiwsir · commit ec32239af5bd · 2016-04-06T22:26:27.000+08:00
diff --git a/203.md b/203.md
@@ -2,72 +2,72 @@
 
 #函数(3)
 
-在设计函数的时候，有时候我们能够确认参数的个数，比如一个用来计算圆面积的函数，它所需要的参数就是半径（πr^2），这个函数的参数是确定的。
+对于函数的参数，有时候我们能够确认参数的个数，比如一个用来计算圆面积的函数，它所需要的参数就是半径（πr^2），这个函数的参数是确定的。
 
 >你能不能写一个能够计算圆面积的函数呢？
 
-然而，这个世界不总是这么简单的，也不总是这么确定的，反而不确定性是这个世界常常存在的。如果看官了解量子力学——好多人听都没有听过的东西——就更理解真正的不确定性了。当然，不用研究量子力学也一样能够体会到，世界充满里了不确定性。不是吗？塞翁失马焉知非福，这不就是不确定性吗？
+然而，这个世界不总是这么简单的，也不总是这么确定的，反而不确定性是这个世界常常存在的。如果读者了解量子力学——好多人听都没有听过的东西——就更理解真正的不确定性了。当然，不用研究量子力学也一样能够体会到，世界充满里了不确定性。不是吗？塞翁失马焉知非福，这不就是不确定性吗？
 
 ##参数收集
 
-既然有很多不确定性，那么函数的参数的个数，也当然有不确定性，函数怎么解决这个问题呢？python用这样的方式解决参数个数的不确定性：
+世界是不确定的，那么函数参数的个数，也当然有不确定的时候，怎么解决这个问题呢？Python用这样的方式解决参数个数的不确定性。
 
-	def func(x,*arg):
-	    print x         #输出参数x的值
+	def func(x, *arg):
+	    print x         #Python 3请自动修改为print()的格式，下同，从略。
 	    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个
+	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收集起来。对照上面的例子不难发现：
+从上面例子可以看出，如果输入的参数个数不确定，其它参数全部通过`*arg`，以元组的形式由arg收集起来。对照上面的例子不难发现：
 
-- 值1传给了参数x
-- 值2,3,4,5,6.7.8.9被塞入一个tuple里面，传给了arg
+- 值1传给了参数`x`
+- 值2,3,4,5,6,7,8,9被塞入一个元组里面，传给了`arg`
 
-为了能够更明显地看出*args（名称可以不一样，但是*符号必须要有），可以用下面的一个简单函数来演示：
+为了能够更明显地看出`*args`（名称可以不一样，但是*符号必须要有），可以用下面的一个简单函数来演示：
 
     >>> def foo(*args):
-    ...     print args      #打印通过这个参数得到的对象
+    ...     print args      #Python 3: print(args)
     ... 
     
 下面演示分别传入不同的值，通过参数*args得到的结果：
 
-    >>> foo(1,2,3)
+    >>> foo(1, 2, 3)
     (1, 2, 3)
 
-    >>> foo("qiwsir","qiwsir.github.io","python")
+    >>> foo("qiwsir", "qiwsir.github.io", "python")
     ('qiwsir', 'qiwsir.github.io', 'python')
     
-    >>> foo("qiwsir",307,["qiwsir",2],{"name":"qiwsir","lang":"python"})
+    >>> foo("qiwsir", 307, ["qiwsir", 2], {"name":"qiwsir", "lang":"python"})
     ('qiwsir', 307, ['qiwsir', 2], {'lang': 'python', 'name': 'qiwsir'})
  
-不管是什么，都一股脑地塞进了tuple中。
+不管是什么，都一股脑地塞进了元组中。
 
     >>> foo("python")
     ('python',)
 
-即使只有一个值，也是用tuple收集它。特别注意，在tuple中，如果只有一个元素，后面要有一个逗号。
+即使只有一个值，也是用元组收集它。特别注意，在元组中，如果只有一个元素，后面要有一个逗号。
 
 还有一种可能，就是不给那个`*args`传值，也是许可的。例如：
 
     >>> def foo(x, *args):
-    ...     print "x:",x
+    ...     print "x:",x                  #Python 3: print("x:"+str(x))
     ...     print "tuple:",args
     ... 
     >>> foo(7)
     x: 7
     tuple: ()
 
-这时候`*args`收集到的是一个空的tuple。
+这时候`*args`收集到的是一个空的元组。
 
 >在各类编程语言中，常常会遇到以foo，bar，foobar等之类的命名，不管是对变量、函数还是后面要讲到的类。这是什么意思呢？下面是来自维基百科的解释。
 
@@ -77,10 +77,10 @@
 
 >单词“foobar”或分离的“foo”与“bar”常出现于程序设计的案例中，如同Hello World程序一样，它们常被用于向学习者介绍某种程序语言。“foo”常被作为函数／方法的名称，而“bar”则常被用作变量名。
 
-除了用*args这种形式的参数接收多个值之外，还可以用**kargs的形式接收数值，不过这次有点不一样：
+除了用`*args`这种形式的参数接收多个值之外，还可以用**kargs的形式接收数值，不过这次有点不一样：
 
     >>> def foo(**kargs):
-    ...     print kargs
+    ...     print kargs        #Python 3:  print(kargs)
     ...
     >>> foo(a=1,b=2,c=3)    #注意观察这次赋值的方式和打印的结果
     {'a': 1, 'c': 3, 'b': 2}
@@ -94,10 +94,10 @@
     
 如果用`**kargs`的形式收集值，会得到dict类型的数据，但是，需要在传值的时候说明“键”和“值”，因为在字典中是以键值对形式出现的。
 
-看官到这里可能想了，不是不确定性吗？我也不知道参数到底会可能用什么样的方式传值呀，这好办，把上面的都综合起来。
+读者到这里可能想了，不是不确定性吗？我也不知道参数到底会可能用什么样的方式传值呀，这好办，把上面的都综合起来。
 
     >>> def foo(x,y,z,*args,**kargs):
-    ...     print x   
+    ...     print x       #Python 3用户请修改为print()格式，下同
     ...     print y
     ...     print z
     ...     print args
@@ -124,23 +124,23 @@
 
 很good了，这样就能够足以应付各种各样的参数要求了。
 
-##另外一种传值方式
+##一种优雅的姿势
 
-    >>> def add(x,y):
+    >>> def add(x, y):
     ...     return x + y
     ... 
-    >>> add(2,3)
+    >>> add(2, 3)
     5
 
-这是通常的函数调用方法，在前面已经屡次用到。这种方法简单明快，很容易理解。但是，世界总是多样性的，有时候你秀出下面的方式，甚至在某种情况用下面的方法可能更优雅。
+这是通常的函数调用时的传值方法。这种方法简单明快，很容易理解。但是，世界总是多样性的，有时候你秀出下面的方式，甚至在某种情况用下面的方法可能更优雅。
 
-    >>> bars = (2,3)
+    >>> bars = (2, 3)
     >>> add(*bars)
     5
 
 先把要传的值放到元组中，赋值给一个变量`bars`，然后用`add(*bars)`的方式，把值传到函数内。这有点像前面收集参数的逆过程。注意的是，元组中元素的个数，要跟函数所要求的变量个数一致。如果这样：
 
-    >>> bars = (2,3,4)
+    >>> bars = (2, 3, 4)
     >>> add(*bars)
     Traceback (most recent call last):
       File "<stdin>", line 1, in <module>
@@ -150,29 +150,29 @@
 
 这是使用一个星号`*`，是以元组形式传值，如果用`**`的方式，是不是应该以字典的形式呢？理当如此。
 
-    >>> def book(author,name):
-    ...     print "%s is writing %s" % (author,name)
+    >>> def book(author, name):
+    ...     print "{0}}is writing {1}".format (author,name)    #Python 3: print("{0}}is writing {1}".format (author,name))
     ... 
-    >>> bars = {"name":"Starter learning Python","author":"Kivi"}
+    >>> bars = {"name":"Starter learning Python", "author":"Kivi"}
     >>> book(**bars)
     Kivi is writing Starter learning Python
 
 这种调用函数传值的方式，至少在我的编程实践中，用的不多。不过，不代表读者不用。这或许是习惯问题。
 
-##复习
+##融会贯通
 
-python中函数的参数通过赋值的方式来传递引用对象。下面总结通过总结常见的函数参数定义方式，来理解参数传递的流程。
+Python中函数的参数通过赋值的方式来传对象引用。下面总结通过总结常见的函数参数定义方式，来理解参数传递的流程。
 
-###def foo(p1,p2,p3,...)
+###def foo(p1, p2, p3, ...)
 
 这种方式最常见了，列出有限个数的参数，并且彼此之间用逗号隔开。在调用函数的时候，按照顺序以此对参数进行赋值，特备注意的是，参数的名字不重要，重要的是位置。而且，必须数量一致，一一对应。第一个对象（可能是数值、字符串等等）对应第一个参数，第二个对应第二个参数，如此对应，不得偏左也不得偏右。
 
-    >>> def foo(p1,p2,p3):
-    ...     print "p1==>",p1
+    >>> def foo(p1, p2, p3):
+    ...     print "p1==>",p1        #Python 3用户修改为print()格式，下同
     ...     print "p2==>",p2
     ...     print "p3==>",p3
     ... 
-    >>> foo("python",1,["qiwsir","github","io"])    #一一对应地赋值
+    >>> foo("python", 1, ["qiwsir","github","io"])   
     p1==> python
     p2==> 1
     p3==> ['qiwsir', 'github', 'io']
@@ -182,25 +182,25 @@ python中函数的参数通过赋值的方式来传递引用对象。下面总
       File "<stdin>", line 1, in <module>
     TypeError: foo() takes exactly 3 arguments (1 given)    #注意看报错信息
 
-    >>> foo("python",1,2,3)
+    >>> foo("python",1, 2, 3)
     Traceback (most recent call last):
       File "<stdin>", line 1, in <module>
     TypeError: foo() takes exactly 3 arguments (4 given)    #要求3个参数，实际上放置了4个，报错
 
-###def foo(p1=value1,p2=value2,...)
+###def foo(p1=value1, p2=value2, ...)
 
-这种方式比前面一种更明确某个参数的赋值，貌似这样就不乱子了，很明确呀。颇有一个萝卜对着一个坑的意味。
+这种方式比前面一种更明确某个参数的值，貌似这样就不乱子了，很明确呀。颇有一个萝卜对着一个坑的意味。
 
 还是上面那个函数，用下面的方式赋值，就不用担心顺序问题了。
 
-    >>> foo(p3=3,p1=10,p2=222)
+    >>> foo(p3=3, p1=10, p2=222)
     p1==> 10
     p2==> 222
     p3==> 3
 
 也可以采用下面的方式定义参数，给某些参数有默认的值
 
-    >>> def foo(p1,p2=22,p3=33):    #设置了两个参数p2,p3的默认值
+    >>> def foo(p1, p2=22, p3=33):    #设置了两个参数p2, p3的默认值
     ...     print "p1==>",p1
     ...     print "p2==>",p2
     ...     print "p3==>",p3
@@ -209,16 +209,16 @@ python中函数的参数通过赋值的方式来传递引用对象。下面总
     p1==> 11
     p2==> 22
     p3==> 33
-    >>> foo(11,222)     #按照顺序，p2=222,p3依旧维持原默认值
+    >>> foo(11, 222)     #按照顺序，p2=222, p3依旧维持原默认值
     p1==> 11
     p2==> 222
     p3==> 33
-    >>> foo(11,222,333)  #按顺序赋值
+    >>> foo(11, 222, 333)  #按顺序赋值
     p1==> 11
     p2==> 222
     p3==> 333
 
-    >>> foo(11,p2=122)
+    >>> foo(11, p2=122)
     p1==> 11
     p2==> 122
     p3==> 33
@@ -230,30 +230,30 @@ python中函数的参数通过赋值的方式来传递引用对象。下面总
 
 ###def foo(*args)
 
-这种方式适合于不确定参数个数的时候，在参数args前面加一个*，注意，仅一个哟。
+这种方式适合于不确定参数个数的时候，在参数args前面加一个`*`，注意，仅一个哟。
 
-    >>> def foo(*args):         #接收不确定个数的数据对象
+    >>> def foo(*args): 
     ...     print args
     ... 
-    >>> foo("qiwsir.github.io") #以tuple形式接收到，哪怕是一个
+    >>> foo("qiwsir.github.io")
     ('qiwsir.github.io',)
     >>> foo("qiwsir.github.io","python")
     ('qiwsir.github.io', 'python')
 
-####def foo(**args)
+###def foo(**args)
 
-这种方式跟上面的区别在于，必须接收类似arg=val形式的。
+这种方式跟上面的区别在于，必须接收类似`arg=val`形式的。
 
-    >>> def foo(**args):    #这种方式接收，以dictionary的形式接收数据对象
+    >>> def foo(**args):    
     ...     print args
     ... 
     
-    >>> 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)
     
-    >>> foo(a=1,b=2,c=3)    #这样就可以了，因为有了键值对
+    >>> foo(a=1,b=2,c=3)
     {'a': 1, 'c': 3, 'b': 2}
 
 下面来一个综合的，看看以上四种参数传递方法的执行顺序
@@ -289,6 +289,8 @@ python中函数的参数通过赋值的方式来传递引用对象。下面总
     targs_tuple==> ('3t1', '3t2')
     dargs_dict==> {'d2': '4d2', 'd1': '4d1'}
 
+对函数的基本内容已经介绍完毕，但是，并不意味着结束，因为还有更深刻的东西没说呢，且看下节。
+
 ------
 
 [总目录](./index.md)&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;[上节：函数(2)](./202.md)&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;[下节：函数(4)](./204.md)
