python学习笔记系列----（二）控制流

    实际开始看这一章节的时候，觉得都不想看了，因为每种语言都会有控制流，感觉好像我不看就会了似的。快速预览的时候，发现了原来还包含了对函数定义的一些描述，重点讲了3种函数形参的定义方法，章节的最后讲述了PEP8的一些重要的规范，在学习的过程中还是学到了些知识。

    2.1  if 语句

    if语句就不多说了，经常跟else if .. 和 else ..一起使用，如下所示：

>>> x = int(raw_input("Please enter an integer: "))
Please enter an integer: 42
>>> if x < 0:
...     x = 0
...     print 'Negative changed to zero'
... elif x == 0:
...     print 'Zero'
... elif x == 1:
...     print 'Single'
... else:
...     print 'More'
...
More

   实际上elif 就是else if的缩写，这样缩写的原因是，python代码是采用缩进的方式，简写可以避免过度的缩进~~

    2.2  for 语句

   python的for跟C风格语言的for有很大的不一致，python的for可以遍历任何序列（列表或者字符串）的元素。比如一个list元素，现在要遍历list元素里的每个值,python可以如下操作：

    words = ['cat', 'window', 'defenestrate']

    for w in words:
        print w

  如果按照以前的思想，应该是这样的：

    for i in range(len(words)):
        print words[i]

     在次基础上，如果现在需要做一些变更，比如words里面的长度大于6的字符串，复制该字符串到第一位，之后words就应该为['defenestrate','cat', 'window', 'defenestrate']，那会怎么实现呢？

# 方法1     
for i in range(len(words)):
        if len(words[i]) > 6:
            words.insert(0, words[i])

# 方法2
    for w in words:
        if len(w) > 6:
            words.insert(0,w)
            
    print words

    方法1是以前常用的方法，方法2是python特有的方法，but~~~陷入死循环了~~.为啥呢？因为words在读到第3个字符串时，发现长度大于6，此时words又加了一个位，此时长度又增加了一位，这时for循环没有结束，又读了第四个字符串，又大于6，又在[0]下增加一位，因此无限循环了。罪魁祸首是words增加一位后，长度也增加了，那怎么不让其长度增加呢？嘿嘿，使用list的切片。list的切片实现了list对象的一个浅拷贝，意思就是list做切片的时候，复制了一份原内存的数据放到了一块新的内存中了（id(words)和id(words[:])内存地址是不一样的）。对list切片对象进行遍历，操作list原对象，所以即使list原对象的长度变化了也不会影响list切片的长度。

    for w in words[:]:
        if len(w) > 6:
            words.insert(0,w)

   据此学习，总结出对list等可变对象进行循环遍历时，如果只进行读操作，可以正常使用；如果使用其他操作，特别是增加操作的时候，注意循环遍历的条件使用对象的切片进行操作。

2.3 range() 方法

   range()方法的作用就是产生一个有序的数字，比如以下示例:

>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(5, 10)
[5, 6, 7, 8, 9]
>>> range(0, 10, 3)
[0, 3, 6, 9]
>>> a = ['Mary', 'had', 'a', 'little', 'lamb']
>>> for i in range(len(a)):
...     print i, a[i]

  最后一种就是之前介绍的用C风格的方法遍历序列对象用的方法。

2.4 break 和 continue关键字

     跟C语言一样，break的作用就是从跳出最近的for或者while循环。而continue的作用是继续当前循环的下一个迭代。在此就不列举例子了。

2.5 pass 关键字

    pass关键字不做事情，一般放在一个需要body但是暂时却又未想好做神马的地方，如以下三个地方：

>>> while True:
...     pass
>>> class MyEmptyClass:
...     pass
>>> def initlog(*args):
...     pass 

 2.6 定义函数   

>>> 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

     函数的定义啰嗦了，关键字def就引入了一个函数的定义，值得注意的以下几点：

A. 函数体的第一行可以是一个可选的字符串，这个字符串是函数的文档字符串，称为docString，主要作用就是解释下这个函数的功能和使用，让调用者能方便的感知其作用，这个在后面会有详细介绍。同时这是一个好的编程习惯，应该保持。

B. 函数在执行的过程中会产生一张新的表用来存储函数的局部变量，在函数中所有的赋值都是将值存储在这个表中，函数的引用首先会查这个表，然后查上层函数的这个表，再是全局变量表，最后就去内置表中查找，函数调用实参实际就是从函数的局部变量表内查找其值，参数的传递始终是传值调用，这里的传值，指的是对象的引用，而不是对象的值。

C.上述示例中是没有return语句的，实际这类属于不带表达参数的return，函数执行完毕就会返回None。

2.7 函数形参的3种常用方式

2.7.1 默认参数

       默认参数是指在函数定义的时，就给形参默认一个值，如果调用的时没有传递参数，则使用之前给的默认值。

def ask_ok(prompt, retries=4, complaint='Yes or no, please!'):
    pass

类似上面的函数，有2个默认参数，可以如下进行调用

ask_ok('Do you really want to quit?')
ask_ok('OK to overwrite the file?', 2)
ask_ok('OK to overwrite the file?', 2, 'Come on, only yes or no!')

官网有给出2个有趣的例子

i = 5
def f(arg=i):
    print arg
i = 6
f()

这个打印多少呢？答案是当然是5，第一个i值属于函数定义域内的值，第二个i实际上已经是另一个i（两个i的id（i）是不同的），函数执行时，arg使用的默认值，就首先在函数的定义域内查找i，查到i的值是5.

l1 = [1,2,3]
def f(li=l1):
    print li
l1 = [1,2,3].append(4)
f()

这个又是打印多少呢？答案当然是1，2，3，4.因为第一个l1和第二个l1实际上指向的是同一块内存，后面已经修改了l1的值，所以打印出来的就是修改后的取值。

def f(a, L=[]):
    L.append(a)
    return L
print f(1)
print f(2)
print f(3)

而这个打印会是多少呢？依次是[1]，[2]，[3]？no，答案是[1]，[1，2]，[1，2，3]，为啥呢？因为参数的默认只计算一次（传引用）。这使得默认值是可变的对象如列表、字典或大部分类的实例时会有所不同。函数在后续调用过程中会累积传给它的参数。可以修改如下：

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

 结论：使用默认参数时，注意默认参数的类型，最好是使用不可变参数做默认值，使用可变参数做默认值，第二次调用就会存在问题。

2.7.2 关键字参数

    实际感觉关键字参数跟默认参数的定义较为类似，或者说是默认参数的一个升级版的形参列表。如上述例子中，retries和complaint也是关键字参数，函数调用时，关键字的参数必须跟随在必写参数的后面。传递的所有关键字参数必须与函数接受的某个参数相匹配，但关键字们之间的顺序并不重要。

    当最后一个形参以**name的形式出现时，表示这个函数可以接受一个字典，里面可以包含没在形参列表中出现的所有关键字参数。以下是官网给的例子，附加了一个可变参数的使用。 

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]

#以下3种调用方式均可

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

arguments=("It's very runny, sir.","It's really very, VERY runny, sir")

keywords={shopkeeper='Michael Palin',client="John Cleese",sketch="Cheese Shop Sketch"}

cheeseshop("Limburger",arguments,keywords)

cheeseshop("Limburger",*arguments,**keywords)

2.7.3 可变参数

     可变参数实际跟关键字参数的升级版有点类似，但是可变参数有个特点，就是参数个数是可变的。这也是一个最不常用的场景。这些参数被放在一个元组（见元组和序列）中。在可变个数的参数之前，可以有零到多个普通的参数。

2.7.4 参数列表的拆分

    当传递的参数已经是一个列表或元组时，怎么处理呢？ 难道手工一个个拆开，再传值？当然不是这样拆分的，python的函数调用时，可以使用 *-操作符将参数从列表或元组中分拆开来，使用**可以**-操作符让字典传递关键字参数

>>> 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]
>>> def parrot(voltage, state='a stiff', action='voom'):
...    pass
>>> d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}
>>> parrot(**d)

2.7.5 文档字符串

     下面例子中的pass前部分就是一个函数的文档字符串，查看python的标准库源码时经常能看见这样的格式。一般第一行是对函数用途简短、精确的总述。为了简单起见，不应该明确地声明对象的名字或类型，如果在文档字符串中有更多的行，第二行应该是空白，把摘要与剩余的描述分离开来。

>>> def my_function():
...     """Do nothing, but document it.
...
...     No, really, it doesn't do anything.
...     """
...     pass
...
>>> print my_function.__doc__
Do nothing, but document it.
    No, really, it doesn't do anything.

2.8 编码风格

想让自己的代码对别人更易读，真不是一件容易做到的事情，需要养成良好的编码风格。对于 Python 而言， PEP 8 已成为大多数项目遵循的风格指南；官档提取出来的最重要的要点：

• 使用 4 个空格的缩进，不要使用制表符。

  4 个空格是小缩进（允许更深的嵌套）和大缩进（易于阅读）之间很好的折衷。制表符会引起混乱，最好弃用。

• 折行以确保其不会超过 79 个字符。

  这有助于小显示器用户阅读，也可以让大显示器能并排显示几个代码文件。

• 使用空行分隔函数和类，以及函数内的大块代码。

• 如果可能，注释独占一行。

• 使用文档字符串。

• 运算符周围和逗号后面使用空格，但是括号里侧不加空格： a = f(1, 2) + g(3, 4)。

• 命名您的类和函数一致 ；惯例是使用驼峰命名法命名类和使用lower_case_with_underscores 命名函数和方法 。始终使用self作为方法的第一个参数的名称（关于类和方法的更多信息请参见初识类）。

• 如果希望你的代码在国际化环境中使用，不要使用奇特的编码。简单的 ASCII 在任何情况下永远工作得最好。

      最后一行，在python3的手册里看到提倡是使用unicode，嘿嘿，实际上，使用utf-8设置源码编码格式就能省很多事了~~~