Python入门

转自：微点阅读  https://www.weidianyuedu.com/content/4717741434338.html

Python入门

第一章 课程介绍

1.Python的特点

优雅，明确，简单，用Python应该尽量写简单明确的代码，尽量写少的代码

2.Python适合的领域

Web网站和各种网络服务 系统工具和脚本

作为“胶水”语言把其他语言开发的模块包装起来方便使用

3.Python不适合的领域

贴近硬件的代码（首选c）

移动开发：IoS/Android有各自的开发语言（objc , Swift/Java） 游戏开发：c/c++ 4.Python实际应用

openstack就是用Python编写的开源云计算平台 5.Python与其他语言对比 类型 运行速度 代码量 c Java Python 编译为机器码 编译为字节码 解释执行（不需要编译） 非常快 快 慢 非常多 多 少 6.Python的缺点

运行速度慢（运行速度的瓶颈往往不在于Python代码，而是数据库的操作和网络调用） Python源码不能加密

第二章 Python变量和数据类型

2-1 数据类型

计算机程序可以处理各种数值。但是，计算机能处理的远不止数值，还可以处理文本、图形、音频、视频、网页等各种各样的数据，不同的数据，需要定义不同的数据类型。在Python中，能够直接处理的数据类型有以下几种：

一、整数

Python可以处理任意大小的整数，当然包括负整数，在Python程序中，整数的表示方法和数学上的写法一模一样，例如：1，100，-8080，0，等等。

二、浮点数

浮点数也就是小数，一个浮点数的小数点位置是可变的，比如，1.23x10^9和12.3x10^8是相等的。浮点数可以用数学写法，如1.23，3.14，-9.01，等等。但是对于很大或很小的浮点数，就必须用科学计数法表示，把10用e替代，1.23x10^9就是1.23e9，或者12.3e8，0.000012可以写成1.2e-5，等等。

整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的，而浮点数运算则可能会有四舍五入的误差。

三、字符串

字符串是以""或\括起来的任意文本，比如"abc"，\等等。请注意，""或\本身只是一种表示方式，不是字符串的一部分，因此，字符串"abc"只有a，b，c这3个字符。

四、布尔值

布尔值和布尔代数的表示完全一致，一个布尔值只有True、False两种值，要么是True，要么是False，在Python中，可以直接用True、False表示布尔值（请注意大小写），也可以通过布尔运算计算出来。

布尔值可以用and、or和not运算。

五、空值

空值是Python里一个特殊的值，用none表示。none不能理解为0，因为0是有意义的，而none是一个特殊的空值。

任务：

1. 计算十进制整数 45678 和十六进制整数 0x12fd2 之和。 print 45678+0x12fd2

2. 请用字符串表示出Learn Python in imooc。 print ‘Learn Python in imooc’

3. 请计算以下表达式的布尔值（注意==表示判断是否相等）： 100 < 99 print 100<99 0xff == 255

print 0xff == 255

2-2 print语句

print语句可以向屏幕上输出指定的文字。比如输出"hello, world"，用代码实现如下： >>>print ‘hello，world’

print语句也可以跟上多个字符串，用逗号“,”隔开，就可以连成一串输出： >>>print "The quick brown fox", "jumps over", "the lazy dog" The quick brown fox jumps over the lazy dog

print会依次打印每个字符串，遇到逗号“,”会输出一个空格，因此，输出的字符串是这样拼起来的

print也可以打印整数，或者计算结果： >>> print 300

300 #运行结果 >>> print 100 + 200

300 #运行结果

因此，我们可以把计算100 + 200的结果打印得更漂亮一点： >>> print "100 + 200 =", 100 + 200 100 + 200 = 300 #运行结果

任务：

请用两种方式打印出 hello, python print "hello, python","" print "hello, python"

2-3 注释

任何时候，我们都可以给程序加上注释。注释是用来说明代码的，给自己或别人看，而程序运行的时候，Python解释器会直接忽略掉注释，所以，有没有注释不影响程序的执行结果，但是影响到别人能不能看懂你的代码。

Python的注释以 # 开头，后面的文字直到行尾都算注释。

任务：

将代码编辑器中的 \语句修改成注释语句： print "hello" #print ‘hello’

2-4 什么是变量

在Python程序中，变量是用一个变量名表示，变量名必须是大小写英文、数字和下划线（_）的组合，且不能用数字开头，比如：

a = 1

变量a是一个整数。 t_007 = "T007"

变量t_007是一个字符串。

在Python中，等号=是赋值语句，可以把任意数据类型赋值给变量，同一个变量可以反复赋值，而且可以是不同类型的变量，例如：

a = 123 # a是整数 print a

a = "imooc" # a变为字符串 print a

这种变量本身类型不固定的语言称之为动态语言，与之对应的是静态语言。

静态语言在定义变量时必须指定变量类型，如果赋值的时候类型不匹配，就会报错。例如Java是静态语言，赋值语句如下（// 表示注释）：

int a = 123; // a是整数类型变量

a = \错误：不能把字符串赋给整型变量 和静态语言相比，动态语言更灵活，就是这个原因。

理解变量在计算机内存中的表示也非常重要。当我们写：a = "ABc"时，Python解释器干了两件事情：

1. 在内存中创建了一个"ABc"的字符串；

2. 在内存中创建了一个名为a的变量，并把它指向"ABc"。 也可以把一个变量a赋值给另一个变量b，这个操作实际上是把变量b指向变量a所指向的数据

任务：

等差数列可以定义为每一项与它的前一项的差等于一个常数，可以用变量 x1 表示等差数列的第一项，用 d 表示公差，请计算数列1 4 7 10 13 16 19 ...前 100 项的和。

x1 = 1 d = 3 n = 100

x100 = x1+(n-1)*d s =100*(x1+x100)/2 print s

2-5 定义字符串

如果字符串本身包含"怎么办？比如我们要表示字符串 I"m oK ，这时，可以用\括起来表示：\

类似的，如果字符串包含\，我们就可以用" "括起来表示："Learn \如果字符串既包含"又包含\怎么办？

这个时候，就需要对字符串的某些特殊字符进行“转义”，Python字符串用\\进行转义。要表示字符串 Bob said \由于 " 和 \会引起歧义，因此，我们在它前面插入一 个\\表示这是一个普通字符，不代表字符串的起始，因此，这个字符串又可以表示为

"Bob said \\\

注意：转义字符 \\ 不计入字符串的内容中。

常用的转义字符还有： \\n 表示换行

\\t 表示一个制表符 \\\\ 表示 \\ 字符本身

任务：

请将下面两行内容用Python的字符串表示并打印出来： Python was started in 1989 by \Python is free and easy to learn.

s=’ Python was started in 1989 by \’ +"Python is free and easy to learn." print s

2-6 raw字符串与多行字符串

如果一个字符串包含很多需要转义的字符，对每一个字符都进行转义会很麻烦。为了避免这种情况，我们可以在字符串前面加个前缀 r ，表示这是一个 raw 字符串，里面的字符就不需要转义了。例如：r"\\(~_~)/ \\(~_~)/"

但是r"..."表示法不能表示多行字符串，也不能表示包含"和 \的字符串（为什么？）

如果要表示多行字符串，可以用"""..."""表示： """Line 1 Line 2 Line 3"""

上面这个字符串的表示方法和下面的是完全一样的： "Line 1\\nLine 2\\nLine 3"

还可以在多行字符串前面添加 r ，把这个多行字符串也变成一个raw字符串： r"""Python is created by \It is free and easy to learn.

Let"s start learn Python in imooc!"""

任务：

请把下面的字符串用r"""..."""的形式改写，并用print打印出来：

"\\\print r"""\Whether it"s nobler in the mind to suffer."""

任务：

假设新来一名学生Paul，Paul 同学的成绩比Bart好，但是比Lisa差，他应该排到第三名的位置，请用代码实现。

L = ["Adam", "Lisa", "Bart"] L.insert(2,"Paul") print L

3-5 从list删除元素

Paul同学刚来几天又要转走了，那么我们怎么把Paul 从现有的list中删除呢？ 如果Paul同学排在最后一个，我们可以用list的pop()方法删除： >>> L = ["Adam", "Lisa", "Bart", "Paul"] >>> L.pop() "Paul"

>>> print L

["Adam", "Lisa", "Bart"]

pop()方法总是删掉list的最后一个元素，并且它还返回这个元素，所以我们执行 L.pop() 后，会打印出 "Paul"。

如果Paul同学不是排在最后一个怎么办？比如Paul同学排在第三： >>> L = ["Adam", "Lisa", "Paul", "Bart"] 要把Paul踢出list，我们就必须先定位Paul的位置。由于Paul的索引是2，因此，用 pop(2)把Paul删掉：

>>> L.pop(2) "Paul"

>>> print L

["Adam", "Lisa", "Bart"]

任务：

注意右边编辑器代码中 list 如下： L = ["Adam", "Lisa", "Paul", "Bart"]

Paul的索引是2，Bart的索引是3，如果我们要把Paul和Bart都删掉，请解释下面的代码为什么不能正确运行：

L.pop(2) L.pop(3)

怎样调整代码可以把Paul和Bart都正确删除掉？ L = ["Adam", "Lisa", "Paul", "Bart"] L.pop(2) L.pop(2) print L

3-6 替换元素

假设现在班里仍然是3名同学：

>>> L = ["Adam", "Lisa", "Bart"]

现在，Bart同学要转学走了，碰巧来了一个Paul同学，要更新班级成员名单，我们可以先把Bart删掉，再把Paul添加进来。

另一个办法是直接用Paul把Bart给替换掉： >>> L[2] = "Paul" >>> print L

L = ["Adam", "Lisa", "Paul"]

对list中的某一个索引赋值，就可以直接用新的元素替换掉原来的元素，list包含的元素个数保持不变。

由于Bart还可以用 -1 做索引，因此，下面的代码也可以完成同样的替换工作： >>> L[-1] = "Paul"

任务：

班里的同学按照分数排名是这样的： L = ["Adam", "Lisa", "Bart"]

但是，在一次考试后，Bart同学意外取得第一，而Adam同学考了倒数第一。 请通过对list的索引赋值，生成新的排名。 L = ["Adam", "Lisa", "Bart"] L[0]="Bart" L[2]="Adam" print L

3-7 创建tuple

tuple是另一种有序的列表，中文翻译为“ 元组 ”。tuple 和 list 非常类似，但是，tuple一旦创建完毕，就不能修改了。

同样是表示班里同学的名称，用tuple表示如下： >>> t = ("Adam", "Lisa", "Bart")

创建tuple和创建list唯一不同之处是用( )替代了[ ]。

现在，这个 t 就不能改变了，tuple没有 append()方法，也没有insert()和pop()方法。所以，新同学没法直接往 tuple 中添加，老同学想退出 tuple 也不行。

获取 tuple 元素的方式和 list 是一模一样的，我们可以正常使用 t[0]，t[-1]等索引方式访问元素，但是不能赋值成别的元素。

任务：

创建一个tuple，顺序包含0 - 9这10个数。 t = (0,1,2,3,4,5,6,7,8,9) print t

3-8 创建单元素tuple

tuple和list一样，可以包含 0 个、1个和任意多个元素。

包含多个元素的 tuple，前面我们已经创建过了。

包含 0 个元素的 tuple，也就是空tuple，直接用 ()表示： >>> t = () >>> print t ()

创建包含1个元素的 tuple 呢？来试试： >>> t = (1) >>> print t 1

好像哪里不对！t 不是 tuple ，而是整数1。为什么呢？

因为()既可以表示tuple，又可以作为括号表示运算时的优先级，结果 (1) 被Python解释器计算出结果 1，导致我们得到的不是tuple，而是整数 1。

正是因为用()定义单元素的tuple有歧义，所以 Python 规定，单元素 tuple 要多加一个逗号“,”，这样就避免了歧义：

>>> t = (1,) >>> print t (1,)

Python在打印单元素tuple时，也自动添加了一个“,”，为了更明确地告诉你这是一个tuple。

多元素 tuple 加不加这个额外的“,”效果是一样的。

3-9 “可变”的tuple

前面我们看到了tuple一旦创建就不能修改。现在，我们来看一个“可变”的tuple： >>> t = ("a", "b", ["A", "B"])

注意到 t 有 3 个元素："a"，"b"和一个list：["A", "B"]。list作为一个整体是tuple的第3个元素。list对象可以通过 t[2] 拿到：

>>> L = t[2]

然后，我们把list的两个元素改一改： >>> L[0] = "X" >>> L[1] = "Y"

再看看tuple的内容：

>>> print t

("a", "b", ["X", "Y"])

不是说tuple一旦定义后就不可变了吗？怎么现在又变了？ 别急，我们先看看定义的时候tuple包含的3个元素：

当我们把list的元素"A"和"B"修改为"X"和"Y"后，tuple变为：

表面上看，tuple的元素确实变了，但其实变的不是 tuple 的元素，而是list的元素。

tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向"a"，就不能改成指向"b"，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！

理解了“指向不变”后，要创建一个内容也不变的tuple怎么做？那就必须保证tuple的每一个元素本身也不能变。

任务:

定义了tuple： t = ("a", "b", ["A", "B"])

由于 t 包含一个list元素，导致tuple的内容是可变的。能否修改上述代码，让tuple内容不可变？

t = ("a", "b", ("A", "B"))

第四章 条件判断和循环 4-1 if语句

计算机之所以能做很多自动化的任务，因为它可以自己做条件判断。

比如，输入用户年龄，根据年龄打印不同的内容，在Python程序中，可以用if语句实现：

age = 20 if age >= 18:

print "your age is", age print "adult" print "EnD"

注意: Python代码的缩进规则。具有相同缩进的代码被视为代码块，上面的3，4行 print 语句就构成一个代码块（但不包括第5行的print）。如果 if 语句判断为 True，就会执行这个代码块。

缩进请严格按照Python的习惯写法：4个空格，不要使用Tab，更不要混合Tab和空格，否则很容易造成因为缩进引起的语法错误。

注意: if 语句后接表达式，然后用 : 表示代码块开始。

如果你在Python交互环境下敲代码，还要特别留意缩进，并且退出缩进需要多敲一行回车：

>>> age = 20 >>> if age >= 18:

... print "your age is", age ... print "adult" ...

your age is 20 adult

任务：

如果成绩达到60分或以上，视为passed。

假设Bart同学的分数是75，请用if语句判断是否能打印出 passed: score = 75 if score>=60:

print "passed"

4-2 if-else

当 if 语句判断表达式的结果为 True 时，就会执行 if 包含的代码块，如果我们想判断年龄在18岁以下时，打印出 "teenager"，怎么办？

方法是再写一个 if: ，或者用 not 运算： 。

细心的同学可以发现，这两种条件判断是“非此即彼”的，要么符合条件1，要么符合条件2，因此，完全可以用一个 if ... else ... 语句把它们统一起来：

if age >= 18: print "adult" else:

print "teenager" 利用 if ... else ... 语句，我们可以根据条件表达式的值为 True 或者 False ，分别执行 if 代码块或者 else 代码块。

注意: else 后面有个“:”。

任务：

如果成绩达到60分或以上，视为passed，否则视为failed。

假设Bart同学的分数是55，请用if语句打印出 passed 或者 failed: score = 55 if score>=60:

print "passed" else:

print "failed"

4-3 if-elif-else

有的时候，一个 if ... else ... 还不够用。比如，根据年龄的划分： 条件1：18岁或以上：adult 条件2：6岁或以上：teenager 条件3：6岁以下：kid

要避免嵌套结构的 if ... else ...，我们可以用 if ... 多个elif ... else ... 的结构，一次写完所有的规则：

if age >= 18: print "adult" elif age >= 6:

print "teenager" elif age >= 3: print "kid" else:

print "baby"

elif 意思就是 else if。这样一来，我们就写出了结构非常清晰的一系列条件判断。 特别注意: 这一系列条件判断会从上到下依次判断，如果某个判断为 True，执行完对应的代码块，后面的条件判断就直接忽略，不再执行了。

任务：

如果按照分数划定结果： 90分或以上：excellent 80分或以上：good 60分或以上：passed 60分以下：failed

请编写程序根据分数打印结果。 score = 85

if score>=90:

print "excellent" elif score>=80: print "good" elif score>=60: print "passed" else:

print "failed"

4-4 for循环

list或tuple可以表示一个有序集合。如果我们想依次访问一个list中的每一个元素呢？比如 list：

L = ["Adam", "Lisa", "Bart"] print L[0] print L[1] print L[2]

如果list只包含几个元素，这样写还行，如果list包含1万个元素，我们就不可能写1万行print。

这时，循环就派上用场了。

Python的 for 循环就可以依次把list或tuple的每个元素迭代出来： L = ["Adam", "Lisa", "Bart"] for name in L: print name

注意: name 这个变量是在 for 循环中定义的，意思是，依次取出list中的每一个元素，并把元素赋值给 name，然后执行for循环体（就是缩进的代码块）。

这样一来，遍历一个list或tuple就非常容易了。

任务：

班里考试后，老师要统计平均成绩，已知4位同学的成绩用list表示如下： L = [75, 92, 59, 68]

请利用for循环计算出平均成绩。 L = [75, 92, 59, 68] sum = 0.0 for score in L:

sum=sum+score print sum / 4

4-5 while循环

和 for 循环不同的另一种循环是 while 循环，while 循环不会迭代 list 或 tuple 的元素，而是根据表达式判断循环是否结束。

比如要从 0 开始打印不大于 n 的整数： n = 10 x = 0

while x < n: print x x = x + 1 while循环每次先判断 x < n，如果为True，则执行循环体的代码块，否则，退出循环。 在循环体内，x = x + 1 会让 x 不断增加，最终因为 x < n 不成立而退出循环。

如果没有这一个语句，while循环在判断 x < n 时总是为True，就会无限循环下去，变成死循环，所以要特别留意while循环的退出条件。

任务：

利用while循环计算100以内奇数的和。

sum = 0 x = 1

while x<100: sum=sum+x x=x+2 print sum

4-6 break退出循环

用 for 循环或者 while 循环时，如果要在循环体内直接退出循环，可以使用 break 语

句。

比如计算1至100的整数和，我们用while来实现： sum = 0 x = 1

while True:

sum = sum + x x = x + 1 if x > 100: break print sum

咋一看， while True 就是一个死循环，但是在循环体内，我们还判断了 x > 100 条件成立时，用break语句退出循环，这样也可以实现循环的结束。

任务：

利用 while True 无限循环配合 break 语句，计算 1 + 2 + 4 + 8 + 16 + ... 的前20项的和。 sum = 0 x = 1 n = 1

while True:

sum=sum+x x=2*x n=n+1 if n>20: break print sum

4-7 continue继续循环

在循环过程中，可以用break退出当前循环，还可以用continue跳过后续循环代码，继续下一次循环。

假设我们已经写好了利用for循环计算平均分的代码： L = [75, 98, 59, 81, 66, 43, 69, 85] sum = 0.0 n = 0 for x in L:

sum = sum + x n = n + 1 print sum / n

现在老师只想统计及格分数的平均分，就要把 x < 60 的分数剔除掉，这时，利用

continue，可以做到当 x < 60的时候，不继续执行循环体的后续代码，直接进入下一次循环：

for x in L: if x < 60:

continue sum = sum + x n = n + 1

任务：

对已有的计算 0 - 100 的while循环进行改造，通过增加 continue 语句，使得只计算奇数的和：

sum = 0 x = 1

while True:

sum = sum + x x = x + 1 if x > 100: break print sum

sum = 0 x = 0

while True: x = x + 1 if x > 100: break if x%2==0: continue sum=sum+x print sum

4-8 多重循环

在循环内部，还可以嵌套循环，我们来看一个例子： for x in ["A", "B", "c"]: for y in ["1", "2", "3"]: print x + y

x 每循环一次，y 就会循环 3 次，这样，我们可以打印出一个全排列： A1 A2 A3 B1

B2 B3 c1 c2 c3

任务：

对100以内的两位数，请使用一个两重循环打印出所有十位数数字比个位数数字小的数，例如，23（2 < 3）。

for x in [ "1","2","3","4","5","6","7","8","9" ]:

for y in [ "1","2","3","4","5","6","7","8","9" ]: if x

print x+y

第五章 Dict和set类型 5-1 什么是dict

我们已经知道，list 和 tuple 可以用来表示顺序集合，例如，班里同学的名字： ["Adam", "Lisa", "Bart"]

或者考试的成绩列表： [95, 85, 59]

但是，要根据名字找到对应的成绩，用两个 list 表示就不方便。 如果把名字和分数关联起来，组成类似的查找表： "Adam" ==> 95 "Lisa" ==> 85 "Bart" ==> 59

给定一个名字，就可以直接查到分数。

Python的 dict 就是专门干这件事的。用 dict 表示“名字”-“成绩”的查找表如下： d = {

"Adam": 95, "Lisa": 85, "Bart": 59

}

我们把名字称为key，对应的成绩称为value，dict就是通过 key 来查找 value。

花括号 {} 表示这是一个dict，然后按照 key: value, 写出来即可。最后一个 key: value 的逗号可以省略。

由于dict也是集合，len() 函数可以计算任意集合的大小： >>> len(d)

3

注意: 一个 key-value 算一个，因此，dict大小为3。

任务：

新来的Paul同学成绩是 75 分，请编写一个dict，把Paul同学的成绩也加进去。 d = {

"Adam": 95, "Lisa": 85, "Bart": 59

} d = {

"Adam": 95, "Lisa": 85, "Bart": 59, "Paul": 75 }

5-2 访问dict

我们已经能创建一个dict，用于表示名字和成绩的对应关系： d = {

"Adam": 95, "Lisa": 85, "Bart": 59 }

那么，如何根据名字来查找对应的成绩呢？

可以简单地使用 d[key] 的形式来查找对应的 value，这和 list 很像，不同之处是，list 必须使用索引返回对应的元素，而dict使用key：

>>> print d["Adam"] 95

>>> print d["Paul"]

Traceback (most recent call last):

File \ print d["Paul"] KeyError: "Paul"

注意: 通过 key 访问 dict 的value，只要 key 存在，dict就返回对应的value。如果key不存在，会直接报错：KeyError。

要避免 KeyError 发生，有两个办法：

一是先判断一下 key 是否存在，用 in 操作符： if "Paul" in d:

print d["Paul"]

如果 "Paul" 不存在，if语句判断为False，自然不会执行 print d["Paul"] ，从而避免了错误。

二是使用dict本身提供的一个 get 方法，在Key不存在的时候，返回none： >>> print d.get("Bart") 59

>>> print d.get("Paul") none

任务：

根据如下dict： d = {

"Adam": 95, "Lisa": 85, "Bart": 59 }

请打印出： Adam: 95 Lisa: 85 Bart: 59 d = {

"Adam": 95, "Lisa": 85, "Bart": 59 }

for key in ["Adam", "Lisa", "Bart"]:

print \ （%s, %d不能更改）

5-3 dict的特点

dict的第一个特点是查找速度快，无论dict有10个元素还是10万个元素，查找速度都一样。而list的查找速度随着元素增加而逐渐下降。

不过dict的查找速度快不是没有代价的，dict的缺点是占用内存大，还会浪费很多内容，list正好相反，占用内存小，但是查找速度慢。

由于dict是按 key 查找，所以，在一个dict中，key不能重复。

dict的第二个特点就是存储的key-value序对是没有顺序的！这和list不一样： d = {

"Adam": 95, "Lisa": 85, "Bart": 59 }

当我们试图打印这个dict时：

>>> print d

{"Lisa": 85, "Adam": 95, "Bart": 59}

打印的顺序不一定是我们创建时的顺序，而且，不同的机器打印的顺序都可能不同，这说明dict内部是无序的，不能用dict存储有序的集合。

dict的第三个特点是作为 key 的元素必须不可变，Python的基本类型如字符串、整数、浮点数都是不可变的，都可以作为 key。但是list是可变的，就不能作为 key。

可以试试用list作为key时会报什么样的错误。

不可变这个限制仅作用于key，value是否可变无所谓： { "123": [1, 2, 3], # key 是 str，value是list 123: "123", # key 是 int，value 是 str

("a", "b"): True # key 是 tuple，并且tuple的每个元素都是不可变对象，value是 boolean

}

最常用的key还是字符串，因为用起来最方便。

任务：

请设计一个dict，可以根据分数来查找名字，已知成绩如下： Adam: 95, Lisa: 85, Bart: 59.

# -*- coding: utf-8 -*- d = {

95:"Adam", 85:"Lisa", 59:"Bart" }

5-4 更新dict

dict是可变的，也就是说，我们可以随时往dict中添加新的 key-value。比如已有dict： d = {

"Adam": 95, "Lisa": 85, "Bart": 59 }

要把新同学"Paul"的成绩 72 加进去，用赋值语句： >>> d["Paul"] = 72

再看看dict的内容： >>> print d

{"Lisa": 85, "Paul": 72, "Adam": 95, "Bart": 59}

如果 key 已经存在，则赋值会用新的 value 替换掉原来的 value： >>> d["Bart"] = 60 >>> print d

{"Lisa": 85, "Paul": 72, "Adam": 95, "Bart": 60}

任务：

请根据Paul的成绩 72 更新下面的dict： d = {

95: "Adam", 85: "Lisa", 59: "Bart" } d = {

95: "Adam", 85: "Lisa", 59: "Bart" }

d[72]="Paul"

5-5 遍历dict

由于dict也是一个集合，所以，遍历dict和遍历list类似，都可以通过 for 循环实现。 直接使用for循环可以遍历 dict 的 key： >>> d = { "Adam": 95, "Lisa": 85, "Bart": 59 } >>> for key in d: ... print key ... Lisa Adam Bart

由于通过 key 可以获取对应的 value，因此，在循环体内，可以获取到value的值。

任务：

请用 for 循环遍历如下的dict，打印出 name: score 来。 d = {

"Adam": 95, "Lisa": 85, "Bart": 59

} d = {

"Adam": 95, "Lisa": 85, "Bart": 59 }

for key in d:

print \

5-6 什么是set

dict的作用是建立一组 key 和一组 value 的映射关系，dict的key是不能重复的。 有的时候，我们只想要 dict 的 key，不关心 key 对应的 value，目的就是保证这个集合的元素不会重复，这时，set就派上用场了。

set 持有一系列元素，这一点和 list 很像，但是set的元素没有重复，而且是无序的，这点和 dict 的 key很像。

创建 set 的方式是调用 set() 并传入一个 list，list的元素将作为set的元素： >>> s = set(["A", "B", "c"])

可以查看 set 的内容： >>> print s

set(["A", "c", "B"]) 请注意，上述打印的形式类似 list， 但它不是 list，仔细看还可以发现，打印的顺序和原始 list 的顺序有可能是不同的，因为set内部存储的元素是无序的。

因为set不能包含重复的元素，所以，当我们传入包含重复元素的 list 会怎么样呢？ >>> s = set(["A", "B", "c", "c"]) >>> print s

set(["A", "c", "B"]) >>> len(s) 3

结果显示，set会自动去掉重复的元素，原来的list有4个元素，但set只有3个元素。

任务：

请用set表示班里的4位同学： Adam, Lisa, Bart, Paul

s = set(["Adam", "Lisa", "Bart", "Paul"])

5-7 访问set

由于set存储的是无序集合，所以我们没法通过索引来访问。

访问 set中的某个元素实际上就是判断一个元素是否在set中。 例如，存储了班里同学名字的set： >>> s = set(["Adam", "Lisa", "Bart", "Paul"]) 我们可以用 in 操作符判断： Bart是该班的同学吗？ >>> "Bart" in s True

Bill是该班的同学吗？ >>> "Bill" in s False

bart是该班的同学吗？ >>> "bart" in s False

看来大小写很重要，"Bart" 和 "bart"被认为是两个不同的元素。

任务：

由于上述set不能识别小写的名字，请改进set，使得 "adam" 和 "bart"都能返回True。 s = set(["Adam", "Lisa", "Bart", "Paul","adam","bart"]) print "adam" in s print "bart" in s

5-8 set的特点

set的内部结构和dict很像，唯一区别是不存储value，因此，判断一个元素是否在set中速度很快。

set存储的元素和dict的key类似，必须是不变对象，因此，任何可变对象是不能放入set中的。

最后，set存储的元素也是没有顺序的。

set的这些特点，可以应用在哪些地方呢？

星期一到星期日可以用字符串"Mon", "TUE", ... "SUn"表示。 假设我们让用户输入星期一至星期日的某天，如何判断用户的输入是否是一个有效的星期呢？

可以用 if 语句判断，但这样做非常繁琐： x = "???" # 用户输入的字符串

if x!= "Mon" and x!= "TUE" and x!= "WED" ... and x!= "SUn": print "input error" else:

print "input ok"

注意：if 语句中的...表示没有列出的其它星期名称，测试时，请输入完整。

如果事先创建好一个set，包含"Mon" ~ "SUn"：

weekdays = set(["Mon", "TUE", "WED", "THU", "FRI", "SAT", "SUn"]) 再判断输入是否有效，只需要判断该字符串是否在set中： x = "???" # 用户输入的字符串 if x in weekdays: print "input ok" else:

print "input error" 这样一来，代码就简单多了。

任务：

月份也可以用set表示，请设计一个set并判断用户输入的月份是否有效。 月份可以用字符串"Jan", "Feb", ...表示。

months = set(["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "oct", "nov", "Dec"]) x1 = "Feb" x2 = "Sun"

if x1 in months: print "x1: ok" else:

print "x1: error"

if x2 in months: print "x2: ok" else:

print "x2: error"

5-9 遍历set

由于 set 也是一个集合，所以，遍历 set 和遍历 list 类似，都可以通过 for 循环实现。 直接使用 for 循环可以遍历 set 的元素： >>> s = set(["Adam", "Lisa", "Bart"]) >>> for name in s: ... print name ... Lisa Adam Bart

注意: 观察 for 循环在遍历set时，元素的顺序和list的顺序很可能是不同的，而且不

同的机器上运行的结果也可能不同。

任务：

请用 for 循环遍历如下的set，打印出 name: score 来。 s = set([("Adam", 95), ("Lisa", 85), ("Bart", 59)]) s = set([("Adam", 95), ("Lisa", 85), ("Bart", 59)]) for x in s:

print x[0],":",x[1]

5-10 更新set

由于set存储的是一组不重复的无序元素，因此，更新set主要做两件事： 一是把新的元素添加到set中，二是把已有元素从set中删除。 添加元素时，用set的add()方法： >>> s = set([1, 2, 3]) >>> s.add(4) >>> print s set([1, 2, 3, 4])

如果添加的元素已经存在于set中，add()不会报错，但是不会加进去了： >>> s = set([1, 2, 3]) >>> s.add(3) >>> print s set([1, 2, 3])

删除set中的元素时，用set的remove()方法： >>> s = set([1, 2, 3, 4]) >>> s.remove(4) >>> print s set([1, 2, 3])

如果删除的元素不存在set中，remove()会报错： >>> s = set([1, 2, 3]) >>> s.remove(4)

Traceback (most recent call last): File \KeyError: 4

所以用add()可以直接添加，而remove()前需要判断。

任务：

针对下面的set，给定一个list，对list中的每一个元素，如果在set中，就将其删除，如果不在set中，就添加进去。

s = set(["Adam", "Paul"])

L = ["Adam", "Lisa", "Bart", "Paul"] s = set(["Adam", "Lisa", "Paul"]) L = ["Adam", "Lisa", "Bart", "Paul"] for x in L: if x in s:

s.remove(x) else:

s.add(x) print s

第六章 函数 6-1 调用函数

Python内置了很多有用的函数，我们可以直接调用。

要调用一个函数，需要知道函数的名称和参数，比如求绝对值的函数 abs，它接收一个参数。

可以直接从Python的官方网站查看文档：

docs.python.org/2/library/functions.html#abs

也可以在交互式命令行通过 help(abs) 查看abs函数的帮助信息。

调用 abs 函数： >>> abs(100) 100

>>> abs(-20) 20

>>> abs(12.34) 12.34

调用函数的时候，如果传入的参数数量不对，会报TypeError的错误，并且Python会明确地告诉你：abs()有且仅有1个参数，但给出了两个：

>>> abs(1, 2)

Traceback (most recent call last): File \

TypeError: abs() takes exactly one argument (2 given)

如果传入的参数数量是对的，但参数类型不能被函数所接受，也会报TypeError的错误，

并且给出错误信息：str是错误的参数类型：

>>> abs("a")

Traceback (most recent call last): File \

TypeError: bad operand type for abs(): "str"

而比较函数 cmp(x, y) 就需要两个参数，如果 xy，返回 1：

>>> cmp(1, 2) -1

>>> cmp(2, 1) 1

>>> cmp(3, 3) 0

Python内置的常用函数还包括数据类型转换函数，比如 int()函数可以把其他数据类型转换为整数：

>>> int("123") 123

>>> int(12.34) 12

str()函数把其他类型转换成 str： >>> str(123) "123"

>>> str(1.23) "1.23"

任务：

sum()函数接受一个list作为参数，并返回list所有元素之和。请计算 1*1 + 2*2 + 3*3 + ... + 100*100。

L = [] n=100 x=1

while x<=n: m=x*x

L.append(m) x=x+1 print sum(L)

6-2 编写函数

在Python中，定义一个函数要使用 def 语句，依次写出函数名、括号、括号中的参数

和冒号:，然后，在缩进块中编写函数体，函数的返回值用 return 语句返回。

我们以自定义一个求绝对值的 my_abs 函数为例： def my_abs(x): if x >= 0: return x else:

return -x

请注意，函数体内部的语句在执行时，一旦执行到return时，函数就执行完毕，并将结果返回。因此，函数内部通过条件判断和循环可以实现非常复杂的逻辑。

如果没有return语句，函数执行完毕后也会返回结果，只是结果为 none。 return none可以简写为return。

任务：

请定义一个 square_of_sum 函数，它接受一个list，返回list中每个元素平方的和。 def square_of_sum(L):

return sum([i*i for i in L])

print square_of_sum([1, 2, 3, 4, 5]) print square_of_sum([-5, 0, 5, 15, 25])

6-3 返回多值

函数可以返回多个值吗？答案是肯定的。

比如在游戏中经常需要从一个点移动到另一个点，给出坐标、位移和角度，就可以计算出新的坐标：

# 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

这样我们就可以同时获得返回值： >>> x, y = move(100, 100, 60, math.pi / 6) >>> print x, y

151.961524227 70.0

但其实这只是一种假象，Python函数返回的仍然是单一值： >>> r = move(100, 100, 60, math.pi / 6) >>> print r

(151.96152422706632, 70.0)

用print打印返回结果，原来返回值是一个tuple！

但是，在语法上，返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，按位置赋给对应的值，所以，Python的函数返回多值其实就是返回一个tuple，但写起来更方便。

任务：

一元二次方程的定义是：ax2 + bx + c = 0

请编写一个函数，返回一元二次方程的两个解。

注意：Python的math包提供了sqrt()函数用于计算平方根。 import math

def quadratic_equation(a, b, c): de=b**2-4*a*c if de>=0:

x1=(-b+math.sqrt(de))/(2*a) x2=(-b-math.sqrt(de))/(2*a) return x1,x2 else:

return

print quadratic_equation(2, 3, 0) print quadratic_equation(1, -6, 5)

6-4 递归函数

在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

举个例子，我们来计算阶乘 n! = 1 * 2 * 3 * ... * n，用函数 fact(n)表示，可以看出： fact(n) = n! = 1 * 2 * 3 * ... * (n-1) * n = (n-1)! * n = fact(n-1) * n 所以，fact(n)可以表示为 n * fact(n-1)，只有n=1时需要特殊处理。 于是，fact(n)用递归的方式写出来就是： def fact(n): if n==1:

return 1

return n * fact(n - 1)

递归函数的优点是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。

使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。

任务：

汉诺塔 (baike.//view/191666.htm) 的移动也可以看做是递归函数。 我们对柱子编号为a, b, c，将所有圆盘从a移到c可以描述为： 如果a只有一个圆盘，可以直接移动到c；

如果a有n个圆盘，可以看成a有1个圆盘（底盘） + (n-1)个圆盘，首先需要把 (n-1) 个圆盘移动到 b，然后，将 a的最后一个圆盘移动到c，再将b的(n-1)个圆盘移动到c。

请编写一个函数，给定输入 n, a, b, c，打印出移动的步骤： move(n, a, b, c)

例如，输入 move(2, "A", "B", "c")，打印出： A --> B A --> c B --> c

def move(n, a, b, c): if n == 1:

print a, "-->", c return

move(n-1, a, c, b) print a, "-->", c move(n-1, b, a, c)

move(4, "A", "B", "c")

6-5 定义默认参数

定义函数的时候，还可以有默认参数。

例如Python自带的 int() 函数，其实就有两个参数，我们既可以传一个参数，又可以传两个参数：

>>> int("123") 123

>>> int("123", 8) 83

int()函数的第二个参数是转换进制，如果不传，默认是十进制 (base=10)，如果传了，就用传入的参数。

可见，函数的默认参数的作用是简化调用，你只需要把必须的参数传进去。但是在需要的时候，又可以传入额外的参数来覆盖默认参数值。

我们来定义一个计算 x 的n次方的函数: def power(x, n): s = 1

while n > 0: n = n - 1 s = s * x

return s

假设计算平方的次数最多，我们就可以把 n 的默认值设定为 2： def power(x, n=2): s = 1

while n > 0: n = n - 1 s = s * x return s

这样一来，计算平方就不需要传入两个参数了： >>> power(5) 25

由于函数的参数按从左到右的顺序匹配，所以默认参数只能定义在必需参数的后面： # oK:

def fn1(a, b=1, c=2): pass # Error:

def fn2(a=1, b): pass

任务：

请定义一个 greet() 函数，它包含一个默认参数，如果没有传入，打印 "Hello, world."，如果传入，打印 "Hello, xxx."

def greet(n="world"): print "hello,",n,"."

greet()

greet("Bart")

6-6 定义可变参数

如果想让一个函数能接受任意个参数，我们就可以定义一个可变参数： def fn(*args): print args

可变参数的名字前面有个 * 号，我们可以传入0个、1个或多个参数给可变参数： >>> fn() ()

>>> fn("a") ("a",)

>>> fn("a", "b") ("a", "b")

>>> fn("a", "b", "c") ("a", "b", "c")

可变参数也不是很神秘，Python解释器会把传入的一组参数组装成一个tuple传递给可变参数，因此，在函数内部，直接把变量 args 看成一个 tuple 就好了。

定义可变参数的目的也是为了简化调用。假设我们要计算任意个数的平均值，就可以定义一个可变参数：

def average(*args): ...

这样，在调用的时候，可以这样写： >>> average() 0

>>> average(1, 2) 1.5

>>> average(1, 2, 2, 3, 4) 2.4

任务：

请编写接受可变参数的 average() 函数。 def average(*args): if len(args)!=0:

return sum(args)*1.0/len(args) else:

return 0.0

print average() print average(1, 2)

print average(1, 2, 2, 3, 4)

第七章 切片 7-1 对list进行切片

取一个list的部分元素是非常常见的操作。比如，一个list如下： >>> L = ["Adam", "Lisa", "Bart", "Paul"] 取前3个元素，应该怎么做？ 笨办法：

>>> [L[0], L[1], L[2]] ["Adam", "Lisa", "Bart"]

之所以是笨办法是因为扩展一下，取前n个元素就没辙了。

取前n个元素，也就是索引为0-(n-1)的元素，可以用循环： >>> r = [] >>> n = 3

>>> for i in range(n): ... r.append(L[i]) ... >>> r

["Adam", "Lisa", "Bart"]

对这种经常取指定索引范围的操作，用循环十分繁琐，因此，Python提供了切片（Slice）操作符，能大大简化这种操作。

对应上面的问题，取前3个元素，用一行代码就可以完成切片： >>> L[0:3]

["Adam", "Lisa", "Bart"]

L[0:3]表示，从索引0开始取，直到索引3为止，但不包括索引3。即索引0，1，2，正好是3个元素。

如果第一个索引是0，还可以省略： >>> L[:3]

["Adam", "Lisa", "Bart"]

也可以从索引1开始，取出2个元素出来： >>> L[1:3] ["Lisa", "Bart"]

只用一个 : ，表示从头到尾： >>> L[:]

["Adam", "Lisa", "Bart", "Paul"]

因此，L[:]实际上复制出了一个新list。

切片操作还可以指定第三个参数： >>> L[::2]

["Adam", "Bart"]

第三个参数表示每n个取一个，上面的 L[::2] 会每两个元素取出一个来，也就是隔一个取一个。

把list换成tuple，切片操作完全相同，只是切片的结果也变成了tuple。

任务：

range()函数可以创建一个数列：

>>> range(1, 101) [1, 2, 3, ..., 100]

请利用切片，取出： 1. 前10个数； 2. 3的倍数；

3. 不大于50的5的倍数。

L = range(1, 101)

print L[:10] print L[2::3] print L[4:51:5]

7-2 倒序切片

对于list，既然Python支持L[-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"]

记住倒数第一个元素的索引是-1。倒序切片包含起始索引，不包含结束索引。

任务：

利用倒序切片对 1 - 100 的数列取出： * 最后10个数；

* 最后10个5的倍数。 L = range(1, 101) print L[-10:] print L[-46::5]

7-3 对字符串切片

字符串 "xxx"和 Unicode字符串 u"xxx"也可以看成是一种list，每个元素就是一个字符。

因此，字符串也可以用切片操作，只是操作结果仍是字符串：

>>> "ABcDEFG"[:3] "ABc"

>>> "ABcDEFG"[-3:] "EFG"

>>> "ABcDEFG"[::2] "AcEG"

在很多编程语言中，针对字符串提供了很多各种截取函数，其实目的就是对字符串切片。 Python没有针对字符串的截取函数，只需要切片一个操作就可以完成，非常简单。

任务：

字符串有个方法 upper() 可以把字符变成大写字母： >>> "abc".upper() "ABc"

但它会把所有字母都变成大写。请设计一个函数，它接受一个字符串，然后返回一个仅 首字母变成大写的字符串。

提示：利用切片操作简化字符串操作。 def firstcharUpper(s):

return s[0].upper()+s[1:]

print firstcharUpper("hello") print firstcharUpper("sunday") print firstcharUpper("september")

第八章 迭代 8-1 什么是迭代

在Python中，如果给定一个list或tuple，我们可以通过for循环来遍历这个list或tuple， 这种遍历我们成为迭代（Iteration）。

在Python中，迭代是通过 for ... in 来完成的，而很多语言比如c或者Java，迭代list是 通过下标完成的，比如Java代码：

for (i=0; i

可以看出，Python的for循环抽象程度要高于Java的for循环。

因为 Python 的 for循环不仅可以用在list或tuple上，还可以作用在其他任何可迭代 对象上。

因此，迭代操作就是对于一个集合，无论该集合是有序还是无序，我们用 for 循环总是可以依次取出集合的每一个元素。

注意: 集合是指包含一组元素的数据结构，我们已经介绍的包括： 1. 有序集合：list，tuple，str和unicode； 2. 无序集合：set

3. 无序集合并且具有 key-value 对：dict

而迭代是一个动词，它指的是一种操作，在Python中，就是 for 循环。

迭代与按下标访问数组最大的不同是，后者是一种具体的迭代实现方式，而前者只关心 迭代结果，根本不关心迭代内部是如何实现的。

任务：

请用for循环迭代数列 1-100 并打印出7的倍数。 for i in range(1,101): if i%7==0: print i

8-2 索引迭代

Python中，迭代永远是取出元素本身，而非元素的索引。 对于有序集合，元素确实是有索引的。有的时候，我们确实想在 for 循环中拿到索引， 怎么办？

方法是使用 enumerate() 函数： >>> L = ["Adam", "Lisa", "Bart", "Paul"] >>> for index, name in enumerate(L): ... print index, "-", name ...

0 - Adam 1 - Lisa 2 - Bart 3 - Paul 使用 enumerate() 函数，我们可以在for循环中同时绑定索引index和元素name。但是， 这不是 enumerate() 的特殊语法。实际上，enumerate() 函数把：

["Adam", "Lisa", "Bart", "Paul"] 变成了类似：

[(0, "Adam"), (1, "Lisa"), (2, "Bart"), (3, "Paul")]

因此，迭代的每一个元素实际上是一个tuple： for t in enumerate(L): index = t[0]

name = t[1]

print index, "-", name

如果我们知道每个tuple元素都包含两个元素，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")]

在迭代 ["Adam", "Lisa", "Bart", "Paul"] 时，如果我们想打印出名次 - 名字（名次从1开始)， 请考虑如何在迭代中打印出来。

提示：考虑使用zip()函数和range()函数 L = ["Adam", "Lisa", "Bart", "Paul"] for index, name in zip(range(1,5),L): print index, "-", name

8-3 迭代dict的value

迭代dict的value

我们已经了解了dict对象本身就是可迭代对象，用 for 循环直接迭代 dict，可以每次 拿到dict的一个key。

如果我们希望迭代 dict 对象的value，应该怎么做？

dict 对象有一个 values() 方法，这个方法把dict转换成一个包含所有value的list，这 样，我们迭代的就是 dict的每一个 value：

d = { "Adam": 95, "Lisa": 85, "Bart": 59 } print d.values() # [85, 95, 59] for v in d.values(): print v # 85 # 95 # 59

如果仔细阅读Python的文档，还可以发现，dict除了values()方法外，还有一个 itervalues() 方法，用 itervalues() 方法替代 values() 方法，迭代效果完全一样：

d = { "Adam": 95, "Lisa": 85, "Bart": 59 } print d.itervalues()

# for v in d.itervalues(): print v # 85 # 95 # 59

那这两个方法有何不同之处呢？

1. values() 方法实际上把一个 dict 转换成了包含 value 的list。

2. 但是 itervalues() 方法不会转换，它会在迭代过程中依次从 dict 中取出 value，所以 itervalues() 方法比 values() 方法节省了生成 list 所需的内存。

3. 打印 itervalues() 发现它返回一个 对象，这说明在Python 中，for 循环可作用的迭代对象远不止 list，tuple，str，unicode，dict等，任何可迭代对象都可以作用于for循环，而内部如何迭代我们通常并不用关心。

如果一个对象说自己可迭代，那我们就直接用 for 循环去迭代它，可见，迭代是一种 抽象的数据操作，它不对迭代对象内部的数据有任何要求。

任务：

给定一个dict：

d = { "Adam": 95, "Lisa": 85, "Bart": 59, "Paul": 74 } 请计算所有同学的平均分。

d = { "Adam": 95, "Lisa": 85, "Bart": 59, "Paul": 74 }

sum = 0.0

for x in d.values(): sum=sum+x sum/=len(d) print sum

8-4 迭代dict的Key和value

我们了解了如何迭代 dict 的key和value，那么，在一个 for 循环中，能否同时迭代 key 和value？答案是肯定的。

首先，我们看看 dict 对象的 items() 方法返回的值： >>> d = { "Adam": 95, "Lisa": 85, "Bart": 59 } >>> print d.items()

[("Lisa", 85), ("Adam", 95), ("Bart", 59)] 可以看到，items() 方法把dict对象转换成了包含tuple的list，我们对这个list进行迭 代，可以同时获得key和value：

>>> for key, value in d.items(): ... print key, ":", value ...

Lisa : 85 Adam : 95 Bart : 59

和 values() 有一个 itervalues() 类似， items() 也有一个对应的 iteritems()，iteritems() 不把dict转换成list，而是在迭代过程中不断给出 tuple，所以， iteritems() 不占用额外的内存。

任务:

请根据dict：

d = { "Adam": 95, "Lisa": 85, "Bart": 59, "Paul": 74 }

打印出 name : score，最后再打印出平均分 average : score。 d = { "Adam": 95, "Lisa": 85, "Bart": 59, "Paul": 74 }

sum = 0.0

for k, v in d.items(): sum = sum + v print k,":",v

print "average", ":", sum/len(d)

第九章 列表生成式 9-1 生成列表

要生成list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]，我们可以用range(1, 11)： >>> range(1, 11)

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

但如果要生成[1x1, 2x2, 3x3, ..., 10x10]怎么做？方法一是循环： >>> L = []

>>> for x in range(1, 11): ... L.append(x * x) ... >>> L

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

但是循环太繁琐，而列表生成式则可以用一行语句代替循环生成上面的list： >>> [x * x for x in range(1, 11)] [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

这种写法就是Python特有的列表生成式。利用列表生成式，可以以非常简洁的代码生 成 list。

写列表生成式时，把要生成的元素 x * x 放到前面，后面跟 for 循环，就可以把list创

建出来，十分有用，多写几次，很快就可以熟悉这种语法。

任务：

请利用列表生成式生成列表 [1x2, 3x4, 5x6, 7x8, ..., 99x100] print [x*(x+1) for x in range(1,100,2)]

9-2 复杂表达式

使用for循环的迭代不仅可以迭代普通的list，还可以迭代dict。 假设有如下的dict：

d = { "Adam": 95, "Lisa": 85, "Bart": 59 }

完全可以通过一个复杂的列表生成式把它变成一个 HTML 表格：

tds = ["%s%s" % (name, score) for name, score in d.iteritems()] print ""

print "nameScore" print "\\n".join(tds) print ""

注：字符串可以通过 % 进行格式化，用指定的参数替代 %s。字符串的join()方法可以 把一个 list 拼接成一个字符串。

任务：

在生成的表格中，对于没有及格的同学，请把分数标记为红色。 提示：红色可以用

return "%s%s%s" % (name, score) tds = [generate_tr(name, score) for name, score in d.iteritems()] print "

print "nameScore" print "\\n".join(tds) print ""

9-3 条件过滤

列表生成式的 for 循环后面还可以加上 if 判断。例如： >>> [x * x for x in range(1, 11)] [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

如果我们只想要偶数的平方，不改动 range()的情况下，可以加上 if 来筛选： >>> [x * x for x in range(1, 11) if x % 2 == 0] [4, 16, 36, 64, 100]

有了 if 条件，只有 if 判断为 True 的时候，才把循环的当前元素添加到列表中。

任务：

请编写一个函数，它接受一个 list，然后把list中的所有字符串变成大写后返回，非字 符串元素将被忽略。

提示：

1. isinstance(x, str) 可以判断变量 x 是否是字符串； 2. 字符串的 upper() 方法可以返回大写的字母。 def toUppers(L):

return [x.upper() for x in L if isinstance(x,str)]

print toUppers(["Hello", "world", 101])

9-4 多层表达式

for循环可以嵌套，因此，在列表生成式中，也可以用多层 for 循环来生成列表。 对于字符串 "ABc" 和 "123"，可以使用两层循环，生成全排列： >>> [m + n for m in "ABc" for n in "123"]

["A1", "A2", "A3", "B1", "B2", "B3", "c1", "c2", "c3"] 翻译成循环代码就像下面这样： L = []

for m in "ABc": for n in "123":

L.append(m + n)

任务：

利用 3 层for循环的列表生成式，找出对称的 3 位数。例如，121 就是对称数，因为 从右到左倒过来还是 121。

print [100*m+10*n+m for m in range(1,10) for n in range (0,10)]