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

print w

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

for i inrange(len(words)):

print words[i]

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

# 方法1for i inrange(len(words)):if len(words[i]) > 6:

words.insert(0, words[i])

# 方法2for w inwords: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 inwords[:]: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 inrange(len(a)):

... print i, a[i]

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

2.4 break 和 continue关键字

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

2.5 pass 关键字

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

>>> whileTrue:

... pass>>> classMyEmptyClass:

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

... 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 = 5def f(arg=i):

print arg

i= 6f()

这个打印多少呢？答案是当然是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)returnL

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

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", kindfor arg inarguments:

print arg

print"-" * 40keys=sorted(keywords.keys())for kw inkeys:

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 froma 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设置源码编码格式就能省很多事了~~~