一、关于python
① 由荷兰人Guido van Rossum（龟叔）于1989年圣诞节为打发无聊时间所编写的编程语言。
② python的特点：优雅 明确 简单。代码量少，运行速度快。
缺点：运行速度慢、源码不能加密
③ 适合的领域：Web网站和各种网络服务、系统工具和脚本、作为“胶水”语言把其他语言开发的模块包装起来方便使用。
不适合的领域：贴近硬件的代码，例如驱动程序等（首选C）、移动开发：iOS/Android有各自的开发语言（ObjC，Swift/Java）、游戏开发：首选C/C++
④ 实际应用：国外：YouTube（视频网站）、Instagram（照片墙）（社交应用）等 国内：豆瓣、搜狐邮箱等 著名的开源云计算平台openstack（国外）
广泛应用于大公司：Google、Yahoo、NASA
⑤ 和其它语言对比：类型 运行速度 代码量
C 编译为机器码 非常快 非常多
Java 编译为字节码 快 多
Python 解释执行 慢 少（开发速度快 运行速度取决于数据库的操作和网络调用）
二、变量和数据类型
1.在python中能直接处理的数据类型有以下几种：
① 整数
包括负整数。计算机使用二进制，所以使用16进制表示整数比较方便。16进制用0x前缀和0-9，a-f表示，例如：0xff00等。
② 浮点数
浮点数就是小数，按照科学计数法表示，一个浮点数的小数点位置是可变的。对于很大或者很小的浮点数，必须用科学计数法表示，10可以用e代替，1.23*10^9就是1.23e9.0.000012可以写成1.2e-5.
③ 字符串
字符串是以’’或“”括起来的任意文本，如’abc’等。
④ 布尔值
布尔值和布尔代数的表示完全一致，一个布尔值只有True，False两种值，要么是true要么是false。在python中，可以直接用True、False表示布尔值（注意大小写），也可以通过布尔运算计算出来。
布尔值可以用and、or、not运算。
And与运算：所有结果都为true，and运算结果才是true。
Or或运算：只要有一个结果是true，or运算结果就是true。
Not非运算：单目运算符，把true变成false，false变成true。
⑤ 空值
空值是python里的一个特殊值，用none表示。None并不是0，因为0是有意义的，而none是一个特殊的空值。
2.print语句
Print语句即是指定输出的文字。比如‘Hello world’,用代码表示：print ‘hello world’
Print语句可以跟上多个字符串，用逗号隔开，就可以连成一串输出。Print会依次打印每个字符串，遇到逗号‘,’会输出一个空格，因此输出的字符串是拼起来的。
>>> print 'The quick brown fox', 'jumps over', 'the lazy dog'
The quick brown fox jumps over the lazy dog
Print也可以打印整数，或者计算结果。
>>> print '100 + 200 =', 100 + 200
100 + 200 = 300 #运行结果
3.注释
Python的注释以‘#’开头，后面的文字只到行尾都算注释。
4.变量
① 变量的概念基本上和代数的方程变量是一致的。在python中，变量使用一个变量名表示，变量名必须是大小写英文、数字和下划线（-）的组合，且不能用数字开头。
② 等号=是赋值语句，可以把任意数据类型赋值给变量，同一个变量可以反复赋值，而且可以是不同类型的变量。这种变量本身类型不固定的语言称之为动态语言，相比静态语言，动态语言更加灵活。
a = 123 # a是整数
print a
a = 'imooc' # a变为字符串
print a
③ 静态语言在定义变量时必须指定变量类型，如果赋值的时候类型不匹配，就会报错。
int a = 123; // a是整数类型变量
a = "mooc"; // 错误：不能把字符串赋给整型变量
④ 变量在计算机内存中的表示。
假如写a=’ABC’,python解释器做了2件事情。
第一、在内存中创建了一个‘ABC’的字符串；
第二、在内存中创建了一个名为a的变量，并把它指向‘ABC’
5.定义字符串
字符串可以用’’和””括起来表示。
如果字符串包含””，我们可以用 ’ ’ 括起来表示。
'Learn "Python" in imooc'
如果两个都包含，需要使用转义字符进行‘转义’，python字符串用\进行转义。
如果要表示字符串 Bob said “I ‘ m OK”
由于’和”会引起歧义，因此我们在它前面插入一个\表示这是一个普通字符，不代表字符串的起始，因此这个字符串可以表示为
'Bob said \"I\'m OK\".'
注意：转义字符 \ 不计入字符串的内容中。
常用的转义字符还有：
\n 表示换行
\t 表示一个制表符
\\ 表示 \ 字符本身
6.python中的raw字符串与多行字符串
如果一个字符串包含很多需要转义的字符，对每一个字符进行转义很麻烦，为了避免这种情况，我们可以在字符串前面加个前缀r，表示这是一个raw字符串，里面的字符就不需要转义了。
r'\(~_~)/ \(~_~)/'
表示多行字符串，用'''...'''表示
'''Line 1
Line 2
Line 3'''
在多行字符串前面添加r，把这个多行字符串也变成一个raw字符串
r'''Python is created by "Guido".
It is free and easy to learn.
Let's start learn Python in imooc!'''
7.python中的unicode字符串
Python后来添加了对unicode的支持，以unicode表示的字符串用u’...’表示，比如
Print u ‘中文’
注意：不加u，中文就不能正常显示。
Unicode字符串出来多了一个u之外，同普通字符串，转义字符和多行表示法仍然有效。
转义：
u'中文\n日文\n韩文'
多行：
u'''第一行
第二行'''
raw+多行：
ur'''Python的Unicode字符串支持"中文",
"日文",
"韩文"等多种语言'''
如果中文字符串在Python环境下遇到 UnicodeDecodeError，这是因为.py文件保存的格式有问题。可以在第一行添加注释，目的是告诉Python解释器，用UTF-8编码读取源代码。然后用Notepad++ 另存为... 并选择UTF-8格式保存。
# -*- coding: utf-8 -*-
8.python中的整数和浮点数
Python支持对整数和浮点数直接进行四则混合运算，运算规则和数学上的四则运算规则完全一致。
和数学运算不同的地方是：python的整数运算结果仍然为整数，浮点数运算结果仍然是浮点数。整数和浮点数运算结果仍然是浮点数。
Python的整数除法即使除不尽，结果仍然为整数，余数被直接扔掉，不过python提供了一个求余的运算可以直接计算余数。如果要计算11/4的精确结果，按照“整数和浮点数混合运算的结果是浮点数”的法则，把两个数中的一个变成浮点数再运算。
11 / 4 # ==> 2
11 % 4 # ==> 3
11.0 / 4 # ==> 2.75
9.python中的布尔类型
在python中，布尔类型还可以与其他数据类型做and、or、not运算。
a = True
print a and 'a=T' or 'a=F'
计算结果是字符串 ‘a=T’.
这个涉及到and和or运算的一条重要法则：短路计算。
A:在计算a and b时，如果a是false，则根据与运算法则，整个结果必定是false，因此返回a；如果a是true，则整个计算结果必定取决于b，因此返回b。
B:在计算a or b时，如果a是true，则根据或运算法则，整个结果必定是true，因此返回a；如果a是false，则整个计算结果必定取决于b，因此返回b。
所以，python在做布尔运算时，只要能提前确定计算结果，它就会直接返回结果。
三．List和Tuple类型
1.创建list
List是python内置的一种数据类型，它是一种有序的集合，可以随时添加和删除元素。
List的元素是按照顺序排列的。构造list很简单，直接用 []把所有的list元素都括起来，就是一个list对象。
可以把list赋值给一个变量，可以通过变量来引用list。
>>> classmates = ['Michael', 'Bob', 'Tracy']
>>> classmates # 打印classmates变量的内容
['Michael', 'Bob', 'Tracy']
由于python是动态语言，所有list中可以包含各种数据。一个元素也没有的就是空list。
>>> L = ['Michael', 100, True]
>>> empty_list = []
2.python按照索引访问list
由于list是一个有序集合，我们可以通过索引来获取list中的指定元素。需要特别注意的是，索引从0开始。
打印第一个就是 print L[0]
当使用索引越界时候，就会报错IndexError
3.倒序访问list
倒数第一个，可以用索引-1来表示最后一个元素。倒数第二用-2表示。注意，千万不要越界。
4.添加新元素
List的append()方法，把新元素添加到list的末尾。
List的insert()方法，第一个参数是索引号，第二个参数是待添加的新元素。
>>> L = ['Adam', 'Lisa', 'Bart']
>>> L.insert(0, 'Paul')
>>> print L
['Paul', 'Adam', 'Lisa', 'Bart']
L.insert(0, 'Paul') 的意思是，'Paul'将被添加到索引为 0 的位置上（也就是第一个），而原来索引为 0 的Adam同学，以及后面的所有同学，都自动向后移动一位。
5.从list中删除元素
List的pop()方法，总是删掉list的最后一个元素，并且它还返回这个元素。
可以使用pop()方法的索引定位元素的位置，将其进行删除。
>>> L = ['Adam', 'Lisa', 'Paul', 'Bart']
>>> L.pop(2)
'Paul'
>>> print L
['Adam', 'Lisa', 'Bart']
6.替换元素
对list中的某一个索引赋值，可以直接用新的元素来替换掉原来的元素，list中包含的元素个数不变。
将Bart替换成Paul
>>> L = ['Adam', 'Lisa', 'Bart']
>>> L[2] = 'Paul'
>>> print L
由于Bart还可以用-1做索引，所以下面的同样可以完成替换工作
L = ['Adam', 'Lisa', 'Paul']
>>> L[-1] = 'Paul'
7.python之创建tuple
Tuple翻译为“元组”，是一种有序的列表，但是tuple一旦创建完毕，就不能修改了。
Tuple用()，list用[]
Tuple没有添加和删除方法，是写死的。
获取tuple元素的方式和list的方式是一模一样的。我们可以正常使用t[0]、t[-1]等索引方式访问元素，但是不能赋值成别的元素。
8.创建单元素tuple
Tuple和list一样，可以包含0个1个和任意多个元素。
包含0个元素的tuple，也就是空tuple，用()表示。
>>> t = ()
>>> print t
()
包含一个元素的tuple
>>> t = (1)
>>> print t
1
注意：()既可以表示tuple又可以作为括号表示运算时的优先级，结果(1)被python解释器计算出结果1，导致我们得到的不是tuple而是整数1
()定义单元素的tuple有歧义，所以单元素tuple要多加一个“，”，避免歧义。多元素可加可不加。
>>> t = (1,)
>>> print t
(1,)
9.“可变”的tuple
>>> t = ('a', 'b', ['A', 'B'])
>>> L = t[2]
>>> L[0] = 'X'
>>> L[1] = 'Y'
>>> print t
('a', 'b', ['X', 'Y'])
表面上看，tuple的元素确实变了，但是变得其实不是tuple的元素，而是list的元素。Tuple一开始指向的list并没有改成别的list，所以tuple所谓的“不变”是说，tuple的每个元素，指向永远不变，即指向a就不能改成指向b，指向一个list，就不能改成指向其他对象，但指向这个list本身是可变的。
四、条件判断和循环
1.if语句
Python代码的缩进规则，具有相同缩进的代码被视为代码。
缩进严格按照python的习惯写法：4个空格，不要使用Tab，更不要混合Tab和空格，否则很容易因为缩进而造成语法错误。
If语句后接表达式，然后用 ： 表示代码块的开始。
如果在python交互环境下敲代码，还有特别留意缩进，并且退出缩进需要多敲一行回车。
>>> age = 20
>>> if age >= 18:
... print 'your age is', age
... print 'adult'
...
your age is 20
adult
2.if-else语句
两种判断条件是“非此即彼”的，因此可以使用if-else语句来将它们统一
Else后面有个 ：
if age >= 18:
print 'adult'
else:
print 'teenager'
3.if-elif-else语句
Elif的意思就是else if。这一系列的条件判断会从上到下依次判断，如果某个判断为true，执行完对应的代码块，后面的条件判断就直接忽略不再执行了。
if age >= 18:
print 'adult'elif age >= 6:
print 'teenager'elif age >= 3:
print 'kid'else:
print 'baby'
4.for循环
For循环可以依次把list或者tuple中的每个元素迭代出来。
L = ['Adam', 'Lisa', 'Bart']for name in L:
print name
5.while循环
While循环不会迭代list或者tuple的元素，而是根据表达式判断循环是否结束。
N = 10
x = 0while x < N:
print x
x = x + 1
While循环每次先判断x<n,如果为true，则执行循环体的代码块，否则退出循环。在循环体内，x=x+1会不断增加，最终因为x<n不成立而退出循环。
如果没有这一个语句，while循环在判断x<n时总是为true，就会无限循环下去，变化才能死循环。
6.break退出循环
sum = 0
x = 1while True:
sum = sum + x
x = x + 1
if x > 100:
break
print sum
7.continue继续循环
在循环过程中，使用continue跳过后续循环代码，继续下一次循环。
L = [75, 98, 59, 81, 66, 43, 69, 85]
sum = 0.0
n = 0for x in L:
sum = sum + x
n = n + 1
print sum / n
如果只想取x>60的话
for x in L:
if x < 60:
continue
sum = sum + x
n = n + 1
8.多重循环
在循环内部，可以嵌套循环。
for x in ['A', 'B', 'C']:
for y in ['1', '2', '3']:
print x + y
五、Dict和Set类型
1.什么是dict
Dict就是通过key来查找value。花括号{}表示这是一个dict，然后按照key：value，写出来即可，最后一个key：value的逗号可以省略。由于dict也是集合，len()函数可以计算任意集合的大小。
Eg：d = {
'Adam': 95,
'Lisa': 85,
'Bart': 59
}
>>> len(d)
3
注意：一个key-value算一个，因此dict大小为3.
2.访问dict
使用 d[key] 的形式来查找对应的 value，这和 list 很像，不同之处是，list 必须使用索引返回对应的元素，而dict使用key。只要key存在，dict就返回对应的value。如果key不存在，会直接报错：KeyError
避免KeyError方法：
① 用in操作符，判断key是否存在。如果不存在，判断为False，便不会执行print，避免错误。
if 'Paul' in d:
print d['Paul']
② 使用dict本身提供的一个get方法，在key不存在的时候，返回None。
>>> print d.get('Bart')
59
>>> print d.get('Paul')
None
3.dict的特点
① 查找速度快。无论dict有几个元素，查找速度一样，而list查找速度会随着元素的增加而逐渐下降，但是占用内存小。缺点：dict占用内存大，浪费内容多。
② 存储的key-value序对是没有顺序的。Dict的内部是无序的，不能用dict存储有序集合。List有序。
③ 作为key的元素必须不可变。
4.更新dict
Dict是可变的，我们可以随时往dict中添加新的key-value。用赋值语句，如果key不存在，直接加入，如果key已经存在，赋值会用新的value替换原来的value。
>>> d['Paul'] = 72
5.遍历dict
Dict是一个集合，可以通过for循环遍历。由于通过key可以获取对应的value，因此在循环体内可以获取到value的值。
>>> d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
>>> for key in d:
... print key
...
Lisa
Adam
Bart
6.Set
Dict的作用是建立一组key和value的映射关系，dict的key是不能重复的。当我们只想获取到dict的key，目的是为了保证这个集合的元素不会重复，此时使用set。
Set持有一系列元素，同list，但set的元素不重复且无序，同dict的key。
创建set的方式是调用set()并传入一个list，list的元素将作为set的元素。set内部存储的元素是无序的。因为set不能包含重复的元素，所以当我们传入包含重复元素的list的时候，set会自动去掉重复的元素。
>>> s = set(['A', 'B', 'C', 'C'])
>>> print s
set(['A', 'C', 'B'])
>>> len(s)
3
7.访问set
Set存储的是无序集合，所以访问set中的某个元素实际上就是判断这个元素是否在set中。
可以用in操作符判断。
>>> s = set(['Adam', 'Lisa', 'Bart', 'Paul'])
>>> 'Bart' in s
True
8.set的特点
① 判断一个元素是否在set中的速度很快。
② 任何可变对象不能放入set中。Set存储的元素必须是不变元素。
③ Set存储的元素是没有顺序的。
应用：
weekdays = set(['MON', 'TUE', 'WED', 'THU', 'FRI', 'SAT', 'SUN'])
再判断输入是否有效，只需要判断该字符串是否在set中：
x = '???' # 用户输入的字符串if x in weekdays:
print 'input ok'else:
print 'input error'
9.遍历set
Set是一个集合，用for循环遍历set元素。元素的顺序和list的顺序是很可能不同的，而且在不同机器上运行的结果也可能不同。
请用 for 循环遍历如下的set，打印出 name: score 来。
s = set([('Adam', 95), ('Lisa', 85), ('Bart', 59)])
for x in s:
print x[0] + ':', x[1]
10.更新set
Set存储的是一组不重复的无序元素，因此更新set，一是把新的元素添加到set中，二是把已有元素从set中删除。
添加元素时，用set.add()方法，如果添加的元素已经存在于set中，add()不会报错，但是不会加进去了。Add()可以直接添加。
>>> s = set([1, 2, 3])
>>> s.add(3)
>>> print s
set([1, 2, 3])
删除set的元素，使用set的remove()方法。Remove()前需要判断，如果删除的元素不存在set中，remove()会报错。
>>> s = set([1, 2, 3])
>>> s.remove(4)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 4
六、函数
1.函数
Python不但能非常灵活地定义函数，而且本身内置了很多有用的函数，可以直接调用。
Eg：圆的面积：s = area_of_circle(x)
2.调用函数
要调用一个函数，需要知道函数的名称和参数，比如求绝对值的函数abs，它接收一个参数。
要知道函数的名称和参数，有以下途径:
① Python官方网站
shttp://docs.python.org/2/library/functions.html#abs
② 在交互式命令行通过help(abs)查看函数的帮助信息
2.1绝对值函数调用。
>>> abs(-20)
20
调用函数的时候，传入参数量不对【abs(1,2)】，会报typeError的错误；如果参数类型不能被函数接受【abs(‘a’)】，也会报TypeError的错误，并且给出错误信息；
2.2比较函数cmp(x,y)，需要两个参数，如果想x<y,返回-1，如果x==y，返回0，如果x>y,返回1.
>>> cmp(1, 2)
-1
>>> cmp(2, 1)
1
>>> cmp(3, 3)
0
2.3转换类型函数，int()函数把其他数据类型转换成证书，str()函数把其他类型扎UN哈UN成str。
>>> int(12.34)
12
>>> str(123)
'123'
3.编写函数
Python中，定义一个函数要使用def语句，依次写出函数名、括号，括号中的参数和冒号；然后，在缩进块中编写函数体，函数的返回值用return语句返回。
函数体内部的语句在执行时，一旦执行到return时，函数就执行完毕，并将结果返回。因此函数内部通过条件判断和循环可以实现非常复杂的逻辑。如果么有return语句，函数执行完毕后也会返回结果，只是结果为None。
注意：return None可以简写为return。
def my_abs(x):
if x >= 0:
return x
else:
return -x
4.返回多值
#math包提供了sin()和cos()函数，我们先用import引用它：
import math
def move(x, y, step, angle):
nx = x + step * math.cos(angle)
ny = y - step * math.sin(angle)
return nx, ny
Python函数返回的仍然是单一值，用print打印返回结果，原来返回值是一个tuple。
在语法上，返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，按位置赋给对应的值，所以python的函数返回多值其实就是返回一个tuple，但写起来更方便。
5.递归函数
定义：在函数内部，可以调用其它函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。
优点：定义简单，逻辑清晰。
理论上，所有的递归函数都可以写成循环的方式，但是循环的逻辑不如递归清晰。
注意：使用递归函数需要防止栈溢出。
函数调用是通过栈这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。
6.定义默认参数
定义函数的时候，还可以有默认参数。函数的默认参数的作用是简化调用，你只需要把必须的参传进去。但是在需要时候，又可以传入额外的参数来覆盖默认参数值。
函数的参数按照从左到右的顺序匹配，所以默认参数只能定义在必需参数的后面。
7.定义可变参数
可变参数的名字前面有个*号，我们可以传入0个，1个或者多个参数给可变参数：
Python解释器会把传入的一组参数组装成有个touple传递给可变参数。因此，在函数内部，直接把变量args看成一个touple就好了。
定义可变参数目的：简化调用。
def average(*args):
...
这样，在调用的时候，可以这样写：
>>> average()
0
>>> average(1, 2)
1.5
>>> average(1, 2, 2, 3, 4)
2.4
七、切片
1.对list进行切片
对经常取指定索引范围的造作，用循环十分的复杂，此时使用python的切片（slice）操作符，简化操作。
① 如果一个索引是0，可以省略
>>> L[:3]
['Adam', 'Lisa', 'Bart']
② 索引从1开始，取2个元素
>>> L[1:3]
['Lisa', 'Bart']
③ 只用一个： 表示从头到尾
>>> L[:]
['Adam', 'Lisa', 'Bart', 'Paul']
④ 指定第三个参数
>>> L[::2]
['Adam', 'Bart']
第三个参数表示每N个取一个，上面的L[::2]会每两个元素取出一个来，也就是隔一个取一个。
把list换成tuple，切片操作相同，只是切片的结果变成了tuple。
2.倒序切片
对于list，python支持L[-1]取倒数第一个元素，那么它同样支持倒数切片。
记住倒数第一个元素的索引是-1。倒序切片包含起始索引不包含结束索引。
>>> L = ['Adam', 'Lisa', 'Bart', 'Paul']
>>> L[-2:]
['Bart', 'Paul']
>>> L[:-2]
['Adam', 'Lisa']
>>> L[-3:-1]
['Lisa', 'Bart']
>>> L[-4:-1:2]
['Adam', 'Bart']
3.对字符串切片
字符串‘xxx’和Unicode字符串可以看做是一种list，每个元素就是一个字符。因此，字符串也可以用切片操作，只是操作结果仍然是字符串。
Python只需要切片一个操作就可以对字符串进行各种截取，非常简单。
>>> 'ABCDEFG'[:3]
'ABC'
>>> 'ABCDEFG'[-3:]
'EFG'
>>> 'ABCDEFG'[::2]
'ACEG'
八、迭代
1.定义：在python中，如果给定一个list或者tuple，我们可以通过for循环来遍历这个list或touple，这种遍历我们称为迭代。
Python中，迭代是通过for..in来完成的，而很多语言c或者java，迭代list是通过下标完成的，python的for循环抽象程度要高于java的for循环。
Python的for循环不仅可以用在list或者touple上，还可以作用于其他任何可迭代对象上。迭代操作就是对于一个集合，无论该集合是有序还是无序，我们用for循环总数可以依次取出集合的每一个元素。
注意：集合是指包含一组元素的数据结构，我们已经介绍的包括：
A：有序集合：list，touple,str和unicode；
B:无序集合：set
C:无序集合并且有key-value对：dict
2.索引迭代
迭代永远是取出元素本身，而非元素的索引。对于有序集合，元素确实是有索引的。有时候，我们想在循环中拿到索引，方法是使用enumerate()函数，使用这个可以在for循环中同时绑定索引index和元素name。因此，迭代的每一个元素实际上是一个touple。
>>> L = ['Adam', 'Lisa', 'Bart', 'Paul']
>>> for index, name in enumerate(L):
... print index, '-', name
...
0 - Adam
1 - Lisa
2 - Bart
3 - Paul
如果我们知道每个touple元素都包含两个元素，for循环又可以简写为：
for index, name in enumerate(L):
print index, '-', name
因此，索引迭代也不是真的按照索引访问，而是又enumerate()函数自动把每个元素变成（index，element）这样的tuple，再迭代就同时获得了索引和元素本身。
zip()函数可以把两个 list 变成一个 list：
>>> zip([10, 20, 30], ['A', 'B', 'C'])
[(10, 'A'), (20, 'B'), (30, 'C')]
3.迭代dict的value
Dict对象本身就是可迭代对象，用for循环直接迭代dict，可以每次拿到dict的一个key。Dict对象有一个value()方法，这个方法把dict转换成一个包含所有value的list，这样我们迭代的就是每一个dict的value。
Dict的itervalues()方法，迭代效果同values()方法。
不同点：
A:values()方法实际上把一个dict转换成了包含value的list。
B:itervalues()方法不会转换，它会在迭代过程中一次从dict中取出value，节省了生成list所需要的内存。
C:打印itervalues()返回<dictionary-valueiterator> 对象，说明任何迭代对象都可以作用于for循环。
注意：迭代是一种抽象的数据操作，它不对迭代对象内部的数据有任何要求。如果说一个对象可以迭代，可以直接使用for循环。
Eg：给定一个dict： d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59, 'Paul': 74 } 请计算所有同学的平均分
d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59, 'Paul': 74 }
sum = 0.0
for v in d.itervalues():
sum = sum + v
print sum / len(d)
4.迭代的key和value
在一个for循环中，能同时迭代key和value。使用dict对象的items()方法。Items()方法把dict对象转换成了半寒tuple的list，对这个list进行迭代，就可以同时获得key和value。
Items类似于iteritems()，它是在迭代过程中不断给出tuple，所以iteritems()不占用额外的内存。
Eg：
请根据dict：
d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59, 'Paul': 74 }
打印出 name : score，最后再打印出平均分 average : score。
九、列表生成式
1.生成列表
列表生成式可以用一行语句代替循环生成list。写列表生成式时，要把生成的元素x*x放到前面，后面跟上for循环，就可以创建list。
>>> [x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
2.复杂表达式
For循环的迭代不仅可以迭代普通的list，还可以迭代dict。
字符串可以通过%进行格式化，用指定的参数替代%s。字符串join()方法可以把一个list拼接成一个字符串。
如果我们用一个函数来替换字符串的格式化代码，可以得到更清晰的代码：
def generate_tr(name, score):
return '<tr><td>%s</td><td>%s</td></tr>' % (name, score)
tds = [generate_tr(name, score) for name, score in d.iteritems()]
这样，只需要修改 generate_tr() 函数，必要的时候把score标红。
参考代码:
d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
def generate_tr(name, score):
if score < 60:
return '<tr><td>%s</td><td style="color:red">%s</td></tr>' % (name, score)
return '<tr><td>%s</td><td>%s</td></tr>' % (name, score)
tds = [generate_tr(name, score) for name, score in d.iteritems()]
print '<table border="1">'
print '<tr><th>Name</th><th>Score</th><tr>'
print '\n'.join(tds)
print '</table>'
3.条件过滤
列表生成式的for循环后面可以加上if判断。有了if条件，只有if判断为true的时候，才把循环的当前元素添加到列表中。
>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]
4.多层表达式
For循环可以嵌套，因此在列表生成式中，可以用多层for循环来生成列表
对于字符串 'ABC' 和 '123'，可以使用两层循环，生成全排列：
>>> [m + n for m in 'ABC' for n in '123']
['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']
Eg：
利用 3 层for循环的列表生成式，找出对称的 3 位数。例如，121 就是对称数，因为从右到左倒过来还是 121。
print [100 * n1 + 10 * n2 + n3 for n1 in range(1, 10) for n2 in range(10) for n3 in range(10) if n1==n3]