实际开始看这一章节的时候，觉得都不想看了，因为每种语言都会有控制流，感觉好像我不看就会了似的。快速预览的时候，发现了原来还包含了对函数定义的一些描述，重点讲了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,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设置源码编码格式就能省很多事了~~~