Python习题集：基础篇
【说明1】本文练习题均整理自imooc教程初识Python（课程已下架），可学习Python3 入门教程 2020全新版，答案为原创，用于个人学习与巩固，如有更好方案，欢迎大神赐教！
【说明2】本教程基于Python2.x，与Python3.7有细微差别
========================================================
1.计算十进制整数 45678 和十六进制整数 0x12fd2 之和。
print 45678+0x12fd2
2.请用两种方式打印出 hello, python.
#input code
print 'hello, python.'
print 'hello,''python.'
3.等差数列可以定义为每一项与它的前一项的差等于一个常数，可以用变量 x1 表示等差数列的第一项，用 d 表示公差，请计算数列1 4 7 10 13 16 19 …前 100 项的和。
x1 = 1
d = 3
n = 100
x100 = x1+(n-1)*d
s = n*x1+(n*(n-1)*d)/2
print s
4.请将下面两行内容用Python的字符串表示并打印出来：
Python was started in 1989 by “Guido”.
Python is free and easy to learn.
s = 'Python was started in 1989 by "Guido".\nPython is free and easy to learn.'
print s
5.请把下面的字符串用r’’’…’’'的形式改写，并用print打印出来：
‘“To be, or not to be”: that is the question.\nWhether it’s nobler in the mind to suffer.’
print r'''"To be, or not to be": that is the question.
Whether it's nobler in the mind to suffer.'''
6.用多行Unicode字符串表示下面的唐诗并打印：
静夜思
床前明月光，
疑是地上霜。
举头望明月，
低头思故乡。
# -*- coding: utf-8 -*-
print '''静夜思
床前明月光，
疑是地上霜。
举头望明月，
低头思故乡。'''
7.请计算 2.5 + 10 / 4 ,并解释计算结果为什么不是期望的 5.0 ?
请修复上述运算，使得计算结果是 5.0
print 2.5 + 10 / 4.0
整数运算的结果永远是整数；整数与浮点数的运算结果是浮点数
Python3.7中10/4结果是2.5
8.请运行如下代码，并解释打印的结果：
a = ‘python’
print ‘hello,’, a or ‘world’
b = ‘’
print ‘hello,’, b or ‘world’
布尔类型运算规律：
① Python将 0 、空字符串’' 、None 看做 False
② Python将 非0数值 、非空字符串 看做 True
9.假设班里有3名同学：Adam，Lisa和Bart，他们的成绩分别是 95.5，85 和 59，请按照 名字, 分数, 名字, 分数… 的顺序按照分数从高到低用一个list表示，然后打印出来。
L = ['Adam',95.5,'Lisa', 85, 'Bart', 59]
print L
10.三名同学的成绩可以用一个list表示：
L = [95.5, 85, 59]
请按照索引分别打印出第一名、第二名、第三名，同时测试 print L[3]。
L = [95.5,85,59]
print L[0]
print L[1]
print L[2]
11.三名同学的成绩可以用一个list表示：
L = [95.5, 85, 59]
请按照倒序索引分别打印出倒数第一、倒数第二、倒数第三。
L = [95.5, 85, 59]
print L[-1]
print L[-2]
print L[-3]
12.假设新来一名学生Paul，Paul 同学的成绩比Bart好，但是比Lisa差，他应该排到第三名的位置，请用代码实现。
L = ['Adam', 'Lisa', 'Bart']
L.insert(2,'Paul')
print L
13.注意右边编辑器代码中 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
14.班里的同学按照分数排名是这样的：
L = [‘Adam’, ‘Lisa’, ‘Bart’]
但是，在一次考试后，Bart同学意外取得第一，而Adam同学考了倒数第一。
请通过对list的索引赋值，生成新的排名。
L = ['Adam', 'Lisa', 'Bart']
L[-1]='Adam'
L[0]='Bart'
print L
15.请指出右边编辑器中代码为什么没有创建出包含一个学生的 tuple：
t = (‘Adam’)
print t
请修改代码，确保 t 是一个tuple。
t = ('Adam',)
print t
因为()既可以表示tuple，又可以作为括号表示运算时的优先级；因此单元素的tuple需在末尾多加一个逗号
16.定义了tuple：
t = (‘a’, ‘b’, [‘A’, ‘B’])
由于 t 包含一个list元素，导致tuple的内容是可变的。能否修改上述代码，让tuple内容不可变？
t = ('a', 'b', ('A', 'B'))
print t
含有list元素的tuple，list内部元素可变
17.如果按照分数划定结果：
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'
18.班里考试后，老师要统计平均成绩，已知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
python3.7中可用mod()函数计算list的平均值：
import numpy
print(numpy.mod([75,92,59,68]))
for循环
① 变量可以在for循环中定义
② for循环可以遍历list和tuple
19.利用while循环计算100以内奇数的和。
m=100
n=1
sum=0
while n < m and n%2!=0:
sum=sum+n
n=n+2
print sum
while循环
① while不会迭代list和tuple元素，而是根据表达式判断循环是否结束
② 变量需在while循环外进行定义
③ 必须要有循环的退出条件(while后边的表达式)或break
20.利用 while True 无限循环配合 break 语句，计算 1 + 2 + 4 + 8 + 16 + … 的前20项的和。
sum = 0
x = 1
n = 1
while True:
sum=sum+2**(n-1)
n=n+1
if n>20:
break
print sum
==退出循环：break ==
等差数列求和
21.对已有的计算 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 = 1
while True:
x=x+1
if x%2==0:
continue
elif x > 100:
break
else:
sum=sum+x
print sum+1
继续循环：continue
22.对100以内的两位数，请使用一个两重循环打印出所有十位数数字比个位数数字小的数，例如，23（2 < 3）。
for x in [1,2,3,4,5,6,7,8,9]:
for y in [0,1,2,3,4,5,6,7,8,9]:
if x<y:
print str(x)+str(y)
23.新来的Paul同学成绩是 75 分，请编写一个dict，把Paul同学的成绩也加进去。
d = {
‘Adam’: 95,
‘Lisa’: 85,
‘Bart’: 59
}
d = {
'Adam':95,
'Lisa':85,
'Bart':59,
}
#d['Paul']=75
d.update({'Paul':75})
print d
24.根据如下dict：
d = {
‘Adam’: 95,
‘Lisa’: 85,
‘Bart’: 59
}
请打印出：
Adam: 95
Lisa: 85
Bart: 59
d = {
'Adam': 95,
'Lisa': 85,
'Bart': 59
}
print 'Adam:'+str(d.get('Adam'))
print 'Lisa:'+str(d.get('Lisa'))
print 'Bart:'+str(d.get('Bart'))
25.请设计一个dict，可以根据分数来查找名字，已知成绩如下：
Adam: 95,
Lisa: 85,
Bart: 59.
# -*- coding: utf-8 -*-
d = {
95:'Adam',
85:'Lisa',
59:'Bart'
}
26.请根据Paul的成绩 72 更新下面的dict：
d = {
95: ‘Adam’,
85: ‘Lisa’,
59: ‘Bart’
}
d = {
95: 'Adam',
85: 'Lisa',
59: 'Bart'
}
d[72]='Paul'
27.请用 for 循环遍历如下的dict，打印出 name: score 来。
d = {
‘Adam’: 95,
‘Lisa’: 85,
‘Bart’: 59
}
d = {
'Adam': 95,
'Lisa': 85,
'Bart': 59
}
for key in d:
print str(key)+':'+str(d[key])
28.请问为什么如下不能执行?
如下 m=l 的时候不能执行
l = [‘Adam’, ‘Lisa’, ‘Bart’, ‘Paul’]
m = l
for name in l:
y=name.lower()
m.append(y)
s = set (m)
print ‘adam’ in s
print ‘bart’ in s
但是将m=l换成 m=[‘Adam’, ‘Lisa’, ‘Bart’, ‘Paul’]就可以了？
l = [‘Adam’, ‘Lisa’, ‘Bart’, ‘Paul’]
m = [‘Adam’, ‘Lisa’, ‘Bart’, ‘Paul’]
for name in l:
y=name.lower()
m.append(y)
s = set (m)
print ‘adam’ in s
print ‘bart’ in s
L和m指向同一个内存区域，往m里append 等于往 L 里 append，所以 for循环无法退出，执行一次for，就会再次添加，形成死循环。
29.针对下面的set，给定一个list，对list中的每一个元素，如果在set中，就将其删除，如果不在set中，就添加进去。
s = set([‘Adam’, ‘Lisa’, ‘Paul’])
L = [‘Adam’, ‘Lisa’, ‘Bart’, ‘Paul’]
【错误示范】：
s = set(['Adam', 'Lisa', 'Paul'])
L = ['Adam', 'Lisa', 'Bart', 'Paul']
for x in L:
for y in s:
if x==y:
s.remove(y)
else:
s.add(x)
print s
【原因】在迭代过程中，不能边遍历边修改集合大小(删除或新增)！ 上述程序第二个for循环遍历了s，并且进行了删除remove操作，因此报错
【正确答案】：
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
30.s = set([‘Adam’, ‘Lisa’, ‘Bart’, ‘Paul’])，上述set不能识别小写的名字，请改进set，使得 ‘adam’ 和 'bart’都能返回True。
s = set(['Adam', 'Lisa', 'Bart', 'Paul'])
print 'adam'.capitalize() in s
print 'bart'.capitalize() in s
或
s = set(['Adam', 'Lisa', 'Bart', 'Paul'])
s2 =set([])
for x in s:
s2.add(x.lower())
s= s2
print 'adam' in s
print 'bart' in s
31.请判断用户输入的月份是否有效。
月份可以用字符串’Jan’, ‘Feb’, …表示。
months = set(['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sept','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'
考核内容：利用set的元素不可重复的特性
32.请用 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 str(x[0])+':'+str(x[1])
33.请计算 1*1 + 2*2 + 3*3 + … + 100*100 。
L = []
x=1
while x<101:
L.insert(-1,x**2)
# L.append(x**2)
x=x+1
print sum(L)
sum()支持以list作为参数，结果为list所有元素之和
34.请定义一个 square_of_sum 函数，它接受一个list，返回list中每个元素平方的和。
def square_of_sum(L):
sum=0
for x in L:
sum=sum+x**2
return sum
print square_of_sum([1, 2, 3, 4, 5])
print square_of_sum([-5, 0, 5, 15, 25])
自定义函数，用以下格式：
def 函数名(参数名):
代码段
return x #返回值，若不写，默认返回None
35. 一元二次方程的定义是：ax² + bx + c = 0
请编写一个函数，返回一元二次方程的两个解。
注意：Python的math包提供了sqrt()函数用于计算平方根。
import math
def quadratic_equation(a, b, c):
# x1=(-b+(b*b-4*a*c)**0.5)/(2*a)
# x2=(-b-(b*b-4*a*c)**0.5)/(2*a)
x1=(-b+math.sqrt(b**2-4*a*c))/(2*a)
x2=(-b-math.sqrt(b**2-4*a*c))/(2*a)
return x1,x2
print quadratic_equation(2, 3, 0)
print quadratic_equation(1, -6, 5)
36. 给定一个坐标、位移和角度，计算位移后的新坐标
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，但写起来更方便。
37. 自定义阶乘函数
阶乘 n! = 1 * 2 * 3 * … * n
def fact(n):
if n==1:
return 1
return n * fact(n - 1)
>>> fact(1)
1
>>> fact(5)
120
>>> fact(100)
93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000L
递归函数：如果一个函数在内部调用自身本身，这个函数就是递归函数。
★使用递归函数需要注意防止栈溢出★
在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。可以试试计算 fact(10000)。
★ 38. 汉诺塔 (http://baike.baidu.com/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
#-*- coding:UTF-8 -*-
##方法一
def move(n, a, b, c):
if n == 1:
print a,'-->',c
else:
move(n-1,a,c,b)
move(1,a,b,c)
move(n-1,b,a,c)
move(4, 'A', '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')
39. 定义一个计算 x 的N次方的函数:
def power(x,n):
s=1
while n>0:
s=s*x
n=n-1
return s
print power(3,3)
40. 定义一个计算 x 的N次方的函数，当不指定幂参数时，默认为平方:
def power(x,n=2):
s=1
while n>0:
s=s*x
n=n-1
return s
print power(3,3)
由于函数的参数按从左到右的顺序匹配，所以默认参数只能定义在必需参数的后面
41. 请定义一个 greet() 函数，它包含一个默认参数，如果没有传入，打印 ‘Hello, world.’，如果传入，打印 ‘Hello, xxx.’
def greet(x='world'):
print 'Hello,',x,'.'
greet()
greet('Bart')
42. 定义一个 average() 函数，计算任意个数的平均值
使其得到以下结果：
average()
0
average(1, 2)
1.5
average(1, 2, 2, 3, 4)
2.4
# -*- coding:utf-8 -*-
#方法一
def average(*args):
if len(list(args))==0:
return 0.0
else:
x=list(args)
s=0.0
for n in x:
s=s+n
avg=s/len(x)
return avg
print average()
print average(1, 2)
print average(1, 2, 2, 3, 4)
#方法二
import numpy as np
def average(*args):
if len(list(args))==0:
return 0.0
else:
x=list(args)
s=np.mean(x)
return s
print average()
print average(1, 2)
print average(1, 2, 2, 3, 4)
可变参数：Python解释器会把传入的一组参数组装成一个tuple传递给可变参数，因此，在函数内部，直接把变量 args 看成一个 tuple 就好了。
43. 取list： L = [‘Adam’, ‘Lisa’, ‘Bart’, ‘Paul’]的前N个元素（用for循环的方式）
def first(L,n):
x=[]
for i in range(n):
x.append(L[i])
return x
print first(['Adam', 'Lisa', 'Bart', 'Paul'],2)
注意：不能写x= x.append(L[i])，否则会提示AttributeError: ‘NoneType’ object has no attribute ‘append’。原因为append会修改x本身，并返回None。因此不能将返回值再赋值给x
range(start,stop[,step])返回一个整数列表，一般用于for循环中
★解释：从start开始，以step为步长，到stop(但不包含stop)结束的整数列表
range(10) # 从 0 开始到 10
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
range(1, 11) # 从 1 开始到 11
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
range(0, 30, 5) # 步长为 5
[0, 5, 10, 15, 20, 25]
range(0, 10, 3) # 步长为 3
[0, 3, 6, 9]
range(0, -10, -1) # 负数
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
range(0)
[]
range(1, 0)
[]
44. 取list： L = [‘Adam’, ‘Lisa’, ‘Bart’, ‘Paul’]的前3个元素（用切片的方式）
L=['Adam', 'Lisa', 'Bart', 'Paul']
print L[0:3]
切片(Slice)操作符L[start: end: step]
解释：从索引start开始(默认为索引0)，每step个取一个(默认为每1个取一个，即挨着取)，直到索引end(默认取到最后)，但不包含索引end元素；索引是从0开始的
L[:]表示从头取到尾
L[:end]表示从索引0开始，取到索引end，不包含end
L=[‘Adam’, ‘Lisa’, ‘Bart’, ‘Paul’]
L[1:2] #[ ‘Lisa’]
L[:] #[‘Adam’, ‘Lisa’, ‘Bart’, ‘Paul’]
L[:3] #[‘Adam’, ‘Lisa’, ‘Bart’]
L[2:] #[ ‘Bart’, ‘Paul’]
L[::2] #[‘Adam’, ‘Bart’] 隔一取一
【倒叙切片】
L[-2:] #[ ‘Bart’, ‘Paul’]
L[:-2] #[‘Adam’, ‘Lisa’]
L[-3:-1] #[‘Lisa’, ‘Bart’]
L[-4: -1: 2] #[‘Adam’, ‘Bart’]
45. range()函数可以创建一个数列：
range(1, 101) #[1, 2, 3, …, 100]
请利用切片，取出：
- 前10个数；
- 3的倍数；
- 不大于50的5的倍数。
L = range(1, 101)
print L[:10]
print L[2::3]
print L[4:50:5]
46. 利用倒序切片对 1 - 100 的数列取出：
- 最后10个数；
- 最后10个5的倍数。
L = range(1, 101)
print L[-10:]
print L[-46::5]
# OR
L = range(1, 101)
N=L[4::5]
print N[-10:]
# OR
print(l[4::5][-10:])
47. 字符串有个方法 upper() 可以把字符变成大写字母：
‘abc’.upper()
‘ABC’
但它会把所有字母都变成大写。请设计一个函数，它接受一个字符串，然后返回一个仅首字母变成大写的字符串。
提示：利用切片操作简化字符串操作。
def firstCharUpper(s):
y=s.lower()
y=y[0:1].upper()+y[1:]
return y
print firstCharUpper('hello')
print firstCharUpper('sunday')
print firstCharUpper('september')
字符串切片
① 字符串 'xxx’和 Unicode字符串 u’xxx’也可以看成是一种list
② 每个字符就是一个元素
③ 字符串切片结果依旧是字符串
④ python没有针对字符串的截取函数，只需要进行切片即可
48. 请用for循环迭代数列 1-100 并打印出7的倍数。
L=range(1,101)
for i in L:
if i%7==0:
print i
迭代（Iteration）: 通过for…in进行的遍历
迭代操作 ：对于一个集合，无论该集合是有序还是无序，我们用 for 循环总是可以依次取出集合的每一个元素。
注意: 集合是指包含一组元素的数据结构，我们已经介绍的包括：
1.有序集合：list，tuple，str和unicode；
2.无序集合：set
3.无序集合并且具有 key-value 对：dict
迭代与按下标访问数组最大的不同是，后者是一种具体的迭代实现方式，而前者只关心迭代结果，根本不关心迭代内部是如何实现的。
Python中，迭代永远是取出元素本身，而非元素的索引
49. 请在for循环中拿到[‘Adam’, ‘Lisa’, ‘Bart’, ‘Paul’]的索引
L = ['Adam', 'Lisa', 'Bart', 'Paul']
for index,name in enumerate(L):
print index,'-',name
实际上，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，再迭代，就同时获得了索引和元素本身。
50. zip()函数可以把两个 list (/tuple)变成一个 list：
zip([10, 20, 30], [‘A’, ‘B’, ‘C’])
[(10, ‘A’), (20, ‘B’), (30, ‘C’)]
在迭代 [‘Adam’, ‘Lisa’, ‘Bart’, ‘Paul’] 时，如果我们想打印出名次 - 名字（名次从1开始)，请考虑如何在迭代中打印出来。
提示：考虑使用zip()函数和range()函数
# -*- coding:utf-8 -*-
#方法一：函数enumerate()
L = ['Adam', 'Lisa', 'Bart', 'Paul']
for index, name in enumerate(L):
print index+1, '-', name
#方法二：函数zip()
L = ['Adam', 'Lisa', 'Bart', 'Paul']
n = range(1,5)
m = zip(n,L)
for i in m:
print i[0],'-',i[1]
51. 给定一个dict：
d = { ‘Adam’: 95, ‘Lisa’: 85, ‘Bart’: 59, ‘Paul’: 74 }
请计算所有同学的平均分。
d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59, 'Paul': 74 }
sum = 0.0
for i in d.itervalues():
sum=sum+i
print sum/len(d)
52. 请根据dict：
d = { ‘Adam’: 95, ‘Lisa’: 85, ‘Bart’: 59, ‘Paul’: 74 }
打印出 name : score，最后再打印出平均分 average : score。
d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59, 'Paul': 74 }
for i in d.iteritems():
print i[0],':',i[1]
#or
# for key,value in d.iteritems():
# print key,':',value
s=0.0
for a in d.itervalues():
s=s+a
print 'average:',s/len(d)
53. 生成[1x1, 2x2, 3x3, …, 10x10]怎么做？
[x*x for x in range(1,11)]
这种写法就是Python特有的列表生成式。利用列表生成式，可以以非常简洁的代码生成 list。
若没有该生成式，只能如下繁琐循环：
L=[]
for x in range(1,11):
L.append(x*x)
L
54. 请利用列表生成式生成列表 [2, 12, 30, 56, …, 9900]
参考55
55. 请利用列表生成式生成列表 [1x2, 3x4, 5x6, 7x8, …, 99x100]
print [x*(x+1) for x in range(1,101,2)]
提示：range(1, 100, 2) 可以生成list [1, 3, 5, 7, 9,…]
56. 在生成的表格中，对于没有及格的同学，请把分数标记为红色。
提示：红色可以用 实现。
d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
def generate_tr(name, score):
if score < 60:
return '%s %s %s %s '
print 'Name Score '
print '\n'.join(tds)
print '
'
复杂表达式
字符串可以通过 % 进行格式化，用指定的参数替代 %s。字符串的join()方法可以把一个 list 拼接成一个字符串。
把打印出来的结果保存为一个html文件，就可以在浏览器中看到效果了
假设有如下的dict：
d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
完全可以通过一个复杂的列表生成式把它变成一个HTML 表格：
tds = ['%s %s '
print 'Name Score '
print '\n'.join(tds)
print '</table>
打印结果：
<table border="1">
<tr><th>Name</th><th>Score</th><tr>
<tr><td>Lisa</td><td>85</td></tr>
<tr><td>Adam</td><td>95</td></tr>
<tr><td>Bart</td><td>59</td></tr>
</table>
57. 生成一个1-100中偶数的平方list
[x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]
列表生成式的for循环后面还可以加上if条件过滤
只有 if 判断为 True 的时候，才把循环的当前元素添加到列表中。
58. 请编写一个函数，它接受一个 list，然后把list中的所有字符串变成大写后返回，非字符串元素将被忽略。
提示：
1.isinstance(x, str) 可以判断变量 x 是否是字符串；
2.字符串的 upper() 方法可以返回大写的字母。
def toUppers(L):
return [x.upper() for x in L if isinstance(x,str)==True]
print toUppers(['Hello', 'world', 101])
59. 利用 3 层for循环的列表生成式，找出对称的 3 位数。例如，121 就是对称数，因为从右到左倒过来还是 121。
#3 iteration
print [m*100+n*10+p for m in range(1,10) for n in range(0,10) for p in range(1,10) if m==p]
#2 iteration
print [m*100+n*10+m for m in range(1,10) for n in range(0,10) ]