初学python笔记

一、关于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]