一、循环

1、for循环

for 循环需要预先设定好循环的次数(n)，然后执行隶属于 for 的语句n次。

基本构造是：

for 元素 in 序列: 
    statement

举例来说，我们编辑一个叫 forDemo.py 的文件：

这个循环就是每次从表 [3,4.4,‘life’] 中取出一个元素（回忆：表是一种序列），然后将这个元素赋值给a，之后执行隶属于 for 的操作(print)。

介绍一个新的 Python 函数 range()，来帮助你建立表。

idx = range(5)
print idx

可以看到 idx 是[0,1,2,3,4]

这个函数的功能是新建一个表。这个表的元素都是整数，从0开始，下一个元素比前一个大1， 直到函数中所写的上限 （不包括该上限本身）。

2、while循环

while 的用法是：

while 条件:
    statement

while 会不停地循环执行隶属于它的语句，直到条件为假(False)。

举例：

while i < 10:
    print i
    i = i + 1

3、中断循环

continue 在循环的某一次执行中，如果遇到 continue, 那么跳过这一次执行，进行下一次的操作

break 停止执行整个循环

for i in range(10):
    if i == 2: 
        continue
    print i

当循环执行到 i = 2 的时候，if 条件成立，触发 continue, 跳过本次执行(不执行print)，继续进行下一次执行(i = 3)。

for i in range(10):
    if i == 2:        
        break
    print i

当循环执行到 i = 2 的时候，if 条件成立，触发 break, 整个循环停止。

二、函数

函数最重要的目的是方便我们重复使用相同的一段程序。

将一些操作隶属于一个函数，以后你想实现相同的操作的时候，只用调用函数名就可以，而不需要重复敲所有的语句。

1、函数的定义

首先，我们要定义一个函数, 以说明这个函数的功能。

def square_sum(a,b):
    c = a**2 + b**2
    return c

这个函数的功能是求两个数的平方和。

首先，def，这个关键字通知python：我在定义一个函数。square_sum 是函数名。

括号中的 a, b 是函数的参数，是对函数的输入。参数可以有多个，也可以完全没有（但括号要保留）。

我们已经在循环和选择中见过冒号和缩进来表示的隶属关系。

• c = a2 + b2 # 这一句是函数内部进行的运算
• return c # 返回c的值，也就是输出的功能。Python 的函数允许不返回值，也就是不用 return。
• return 可以返回多个值，以逗号分隔。相当于返回一个 tuple(定值表)。
• return a,b,c # 相当于 return (a,b,c) 在 python 中#代表注释，编译器将跳过#后的内容。
• 在 Python 中，当程序执行到 return 的时候，程序将停止执行函数内余下的语句。return 并不是必须的，当没有 return, 或者 return 后面没有返回值时，函数将自动返回 None。None 是 Python 中的一个特别的数据类型，用来表示什么都没有，相当于 C 中的 NULL。None 多用于关键字参数传递的默认值。

2、函数调用和参数传递

定义过函数后，就可以在后面程序中使用这一函数：

print square_sum(3,4)

Python 通过位置，知道3对应的是函数定义中的第一个参数a， 4对应第二个参数b，然后把参数传递给函数 square_sum。

函数经过运算，返回值25, 这个25被 print 打印出来。

三、面向对象的基本概念

1、相近对象，归为类

在人类认知中，会根据属性相近把东西归类，并且给类别命名。比如说，鸟类的共同属性是有羽毛，通过产卵生育后代。任何一只特别的鸟都在鸟类的原型基础上的。

面向对象就是模拟了以上人类认知过程。在 Python 语言，为了听起来酷，我们把上面说的“东西”称为对象（object）。

先定义鸟类：

class Bird(object):
    have_feather = True
    way_of_reproduction  = 'egg'

我们定义了一个类别（class），就是鸟（Bird）。在隶属于这个类比的语句块中，我们定义了两个变量，一个是有羽毛（have_feather），一个是生殖方式（way_of_reproduction）,这两个变量对应我们刚才说的属性（attribute）。我们暂时先不说明括号以及其中的内容，记为问题1。

假设我养了一只小鸡，叫 summer。它是个对象，且属于鸟类。使用前面定义的类：

summer = Bird()
print summer.way_of_reproduction

通过第一句创建对象，并说明 summer 是类别鸟中的一个对象，summer 就有了鸟的类属性，对属性的引用是通过 对象.属性（object.attribute） 的形式实现的。

2、动作

日常认知中，我们在通过属性识别类别的时候，有时根据这个东西能做什么事情来区分类别。比如说，鸟会移动。这样，鸟就和房屋的类别区分开了。这些动作会带来一定的结果，比如移动导致位置的变化。

这样的一些“行为”属性为方法（method）。Python 中通过在类的内部定义函数，来说明方法。

class Bird(object):
    have_feather = True
    way_of_reproduction = 'egg'
    def move(self, dx, dy):
        position = [0,0]
        position[0] = position[0] + dx
        position[1] = position[1] + dy
        return position

summer = Bird()
print 'after move:',summer.move(5,8)

3、子类

类别本身还可以进一步细分成子类。

比如说，鸟类可以进一步分成鸡，大雁，黄鹂。

在 OOP 中，我们通过继承(inheritance)来表达上述概念。

class Chicken(Bird):
    way_of_move = 'walk'
    possible_in_KFC = True

class Oriole(Bird):
    way_of_move = 'fly'
    possible_in_KFC = False

summer = Chicken()
print summer.have_feather
print summer.move(5,8)

四、面向对象的进一步拓展

1、调用类的其它信息

class Human(object):
    laugh = 'hahahaha'
    def show_laugh(self):
        print self.laugh
    def laugh_100th(self):
        for i in range(100):
            self.show_laugh()

li_lei = Human()          
li_lei.laugh_100th()

2、__init__() 方法

__init__() 是一个特殊方法(special method)。Python 有一些特殊方法。Python 会特殊的对待它们。特殊方法的特点是名字前后有两个下划线。

如果你在类中定义了 __init__() 这个方法，创建对象时，Python 会自动调用这个方法。这个过程也叫初始化。

class Bird(object):
    have_feather = True
    way_of_reproduction = 'egg'
    def move(self, dx, dy):
        position = [0,0]
        position[0] = position[0] + dx
        position[1] = position[1] + dy
        return position


class happyBird(Bird):
        def __init__(self,more_words):
            print 'We are happy birds.',more_words

summer = happyBird('Happy,Happy!')

这里继承了 Bird 类。屏幕上打印：

我们看到，尽管我们只是创建了summer对象，但 __init__() 方法被自动调用了。最后一行的语句(summer = happyBird…)先创建了对象，然后执行：

summer.__init__(more_words)

‘Happy,Happy!’ 被传递给了 __init__() 的参数 more_words