python核心编程第二版第6章习题答案

6-1.字符串。

string模块中是否有一种字符串方法或者函数可以帮我鉴定下一个字符串是否是另一个大字符串的一部分？
答案：
成员操作符用于判断一个字符或者一个字串（中的字符）是否出现在另一个字符串中。

出现则返回True，否者返回False。

注意，成员操作符不是用来判断一个字符串是否包含另一个字符串的，这样的功能由find()，index()，rfind()和rindex()函数来完成。

>>> 'bc' in 'abcd'
True
>>> 'n' in 'abcd'
False
6-2.字符串标识符。

修改例6-1的idcheck.py脚本，使之可以检测长度为一的标识符，并且可以识别Python关键字。

对后一个要求，你可以使用keyword模块（特别是keyword.kwlist）来辅助。

答案：
#!/usr/bin/env python
import string
import keyword
alphas = string.letters + '_'
nums = string.digits
keywords = keyword.kwlist
print "Welcome to the Identifier Checker v1.0"
myInput = raw_input('Identifier to test? >>')
if myInput in keywords:
print 'Invalid: It is a keyword.'
else:
if myInput[0] not in alphas:
print '''invalid: first sysmol must be alphabetic'''
else:
for otherChar in myInput[1:]:
if otherChar not in alphas + nums:
print '''invalid: remaining sysmols must be alphabetic'''
break
else:
print "okay as an identifier"
6-3.排序。

（a）输入一串数字、并从大到小排列之。

（b）跟a一样。

不过要用字典序从大到小排列。

答案：
(a)
#coding:utf-8
L1 = raw_input('输入一串数字，以空格分隔，以回车结束：'.decode('utf-8').encode('gbk'))
L2 = []
for i in L1.split(' '):
L2.append(int(i))
L2.sort()
L2.reverse()
print L2
(b)字典序就是按字典的排列方式，比如'21'就大于'111'，因为'2'大于'1'，就是把输入的数字编程字符串。

#coding:utf-8
L1 = raw_input('输入一串数字，以空格分隔，以回车结束：'.decode('utf-8').encode('gbk'))
L2 = []
for i in L1.split(' '):
L2.append(i)
L2.sort()
L2.reverse()
print L2
6-4.算术。

更新上一章里面你的得分测试联系方案，把测试得分放到一个列表中去。

你的代码应该可以计算出一个平均分，见练习2-9和5-3。

【参考】练习2-9.
循环和操作符。

创建一个包含五个固定数值的列表或元组，输出他们的平均值。

本练习的难点之一是通过除法得到平均值。

你会发现整型除会截去小数，因此你必须使用浮点除以得到更精确的结果。

float()内建函数可以帮助你实现这一功能。

【参考】练习5-3.
标准类型操作符。

写一段脚本，输入一个测验成绩，根据下面的标准，输出他的评分成绩（A-F）。

A:90~100 B:80~89 C:70~79 D:60~69 F:<60
答案：
scorelist = []
try:
score = float(raw_input('Enter a number: '))
scorelist.append(score)
except:
print 'wrong!'
break
print scorelist
sum1 = 0
for i in scorelist:
sum1 = sum1 + i
print 'the average is %4.2f' % (sum1 /len(scorelist))
6-5.字符串。

（a）更新你在练习2-7里面的方案，使之可以每次向前向后都显示一个字符串的一个字符。

（b）通过扫描来判断两个字符串是否匹配（不能使用比较操作符或者cmp()内建函数）。

附加题：在你的方案里加入大小写区分。

（c）判断一个字符串是否重现（后面跟前面一致）。

附加题：在处理除了严格的回文之外，加入对例如控制符号和空格的支持。

（d）接受一个字符串，在其后面加一个反向的拷贝，构成一个回文字符串。

【参考】
2-7.循环和字串。

从用户那里接受一个字符串输入，然后逐字符显示该字符串。

先用while 循环实现，然后再用for循环实现。

【2-7的答案】
代码如下：
a = raw_input("Please input a string ... ")
print 'Display in for loop:'
for i in a:
print i,
print '\nDisplay in while loop:'
j = 0
while (j < len(a)):
print a[j]
j = j + 1
答案：
(a)
a = raw_input("Enter a string: ")
j = 0
print a[j] + a[j+1],
while (j < len(a) - 2):
print a[j-1] + a[j] + a[j+1],
j = len(a)
print a[j-2] + a[j-1]
(b)
#coding:utf-8
str1 = raw_input('Enter a string1: ')
str2 = raw_input('Enter a string2: ')
symbol = True
if len(str1) != len(str2):
symbol = False
else:
for i in range(len(str1)):
if str1[i] != str2[i]:
symbol = False
else:
symbol = True
if symbol:
print u'匹配'
else:
print u'不匹配'
(c)看不懂，以后补上。

(d)
str1 = raw_input("Enter a string: ")
str2 = str1[::-1]
str3 = str1+str2
print str3
6-6.字符串。

创建一个string.strip()的替代函数：接受一个字符串，去掉它前面和后面的空格（如果使用string.*strip()函数那本练习就没有意义了）
答案：
def mystring(string):
symbol = True
while symbol:
if string[0] ==' ':
string = string[1:]
elif string[-1] == ' ':
string = string[:-1]
else:
symbol = False
print string
abc = raw_input('Enter a string: ')
mystring(abc)
6-7.调试。

看一下在例6.5中给出的代码（buggy.py）
（a）研究这段代码并描述这段代码想做什么。

在所有的（#）处填写你的注释。

（b）这个程序有一个很大的问题，比如输入6、12、20、30等它会死掉，实际上它不能处理任何的偶数，找出原因。

（c）修正（b）中提出的问题。

例6.5 有bug的程序（buggy.py）
这是一个用于练习6-7的程序，判断这个程序是干什么的，在“#”处添加你的注释，找出其中的错误，并修改之。

num_str = raw_input('Enter a number: ')
num_num = int(num_str)
fac_list = range(1, num_num+1)
print "BEFORE:", 'fac_list'
i = 0
while i < len(fac_list):
if num_num % fac_list[i] == 0:
del fac_list[i]
i = i + 1
print "AFTER":, 'fac_list'
答案：
(a)输入一个数，然后生成一个序列，然后判断序列中的每个值是否被这个数整除。

(b)因为当删除1时，2的索引就变成1，而i却变成2，所以就会跳过。

(c)
num_str = raw_input('Enter a number: ')
num_num = int(num_str)
fac_list = range(1, num_num+1)
print "BEFORE: ", fac_list
i = 0
while i < len(fac_list):
if num_num % fac_list[i] == 0:
del fac_list[i]
i -= 1
i = i + 1
print "AFTER: ", fac_list
6-8.列表。

给出一个整型值，返回代表该值得英文，比如输入89会返回“eight-nine”。

附加题：能够返回符合英文语法规律的新式，比如输入89会返回“eighty-nine”。

本练习中
的值假定在0~1000。

答案：
symbol = True
while symbol:
number = int(raw_input('Enter a number between 0~1000: '))
if number >= 0 and number <= 1000:
symbol = False
list1 = ['zero','one','two','three','four','five','six','seven','eight','nine','ten',\
'eleven','twelve','thirteen','forteen','fifteen','sixteen','seventeen','eighteen','nineteen']
list2 = ['ten','twenty','thirty','forty','fifty','sixty','seventy','eighty','ninety','None']
number_hundred = number / 100
number_ten = (number - number_hundred * 100) / 10
number_units = number - number_hundred * 100 - number_ten * 10
dozens = number - number_hundred * 100
if number == 1000:
print 'one thousand'
if number == 0:
print 'zero'
if number_hundred in range(1,10):
if number % 100 == 0:
print '%s hundred' % list1[number_hundred],
else:
print '%s hundred and' % list1[number_hundred],
if number_ten in range(0,10):
if number % 10 == 0:
if list2[number_ten - 1] == 'None':
pass
else:
print '%s' % list2[number_ten - 1]
else:
if dozens >= 20:
print '%s-%s' % (list2[number_ten-1],list1[number_units])
else:
print '%s' % list1[dozens]
6-9.转换。

为练习5-13写一个姊妹函数，接受分钟数，返回小时数和分钟数。

总时间不变，并且要求小时尽可能大。

minutes = int(raw_input('Enter the minutes: '))
hours = minutes / 60
minute = minutes - hours * 60
if minutes >= 1440:
print 'wrong!'
else:
print "%02.d:%02.d" % (hours,minute)
6-10.字符串。

写一个函数，返回一个跟输入字符串相似的字符串，要求字符串的大小写反转，比如，输入“Mr.Ed”，应该返回“mR.eD”作为输出。

答案：
def toggle_case():
str1 = raw_input('Enter a string: ')
str2 = ''
for i in str1:
if ord(i) >= 97 and ord(i) <= 122:
str2 = str2 + chr(ord(i)-32)
elif ord(i) >= 65 and ord(i) <= 90:
str2 = str2 + chr(ord(i)+32)
else:
str2 = str2 + i
print str2
toggle_case()
6-11.转换。

（a）创建一个从整型到IP地址的转换，如下格式：www.xxx.yyy.zzz。

（b）更新你的程序，使之可以逆转换。

#coding:utf-8
def int2ip():
ints = int(raw_input('Enter a number: '))
hexs = hex(ints)[2:] #转换成16进制数，然后把开头0x去掉
while len(hexs) < 8: #hexs长度小于8，在前面补0
hexs = '0' + hexs
ip1 = int(hexs[0]+hexs[1],16) #(hexs[0]+hexs[1])是16进制数，转成10进制
ip2 = int(hexs[2]+hexs[3],16)
ip3 = int(hexs[4]+hexs[5],16)
ip4 = int(hexs[6]+hexs[7],16)
return '%03d.%03d.%03d.%03d' % (ip1,ip2,ip3,ip4)
print int2ip()
def inttoip(num):
s = []
for i in range(4):
s.append(str(num % 256))
num /= 256
return '.'.join(s[::-1])
num = int(raw_input('Enter a number: '))
print inttoip(num)
(b)
def ip2int(ip):
ipsplit = ip.split('.')
if len(ipsplit) != 4:
return 'error ip'
return int(ipsplit[0]) * (256 ** 3) + int(ipsplit[1]) * (256 ** 2) \
+ int(ipsplit[2]) * 256 + int(ipsplit[3])
ip = raw_input('Enter a ip address: ')
print ip2int(ip)
6-12.字符串。

（a）创建一个名字为findchr()的函数，函数声明如下。

def findchr(string, char)
findchr()要在字符串string中查找字符char，找到就返回该值得索引，否则返回-1。

不能用string.*find()或者string.*index()函数和方法。

（b）创建另一个叫rfindchr()的函数，查找字符char最后一次出现的位置。

它跟findchr()工作类似，不过它是从字符串的最后开始向前查找的。

（c）创建第三个函数，名字叫subchr()，声明如下。

def subchr(string, origchar, newchar)
subchr()跟findchr()类似，不同的是，如果找到匹配的字符就用新的字符替换原先字符。

返回修改后的字符串。

答案：
(a)可查看子串
def findchr(string,char):
for i in range(len(string)-len(char)+1):
if string[i:i+len(char)] == char:
return i
break
return -1
string = raw_input('Enter a string: ')
char = raw_input('Enter a character: ')
print findchr(string,char)
def findchr(string,char): #这个查找单个字符
char_index = -1
for i in string:
char_index += 1
if i == char:
return char_index
return -1
string = raw_input('Enter a string: ')
char = raw_input('Enter a character: ')
print findchr(string,char)
(b)
def rfindchr(string,char):
a = len(string)
b = len(char)
c = a - b
print a,b,c
for i in range(c + 1):
if string[c-i:c-i+b] == char:
return c-i
break
return -1
string = raw_input('Enter a string: ')
char = raw_input('Enter a character: ')
print rfindchr(string,char)
查询单个字符
def rfindchr(string,char):
char_index = -1
for i in string[::-1]:
char_index += 1
if i == char:
return (len(string) - char_index -1)
return -1
string = raw_input('Enter a string: ')
char = raw_input('Enter a character: ')
print rfindchr(string,char)
(c)
def subchr(string, origchar, newchar):
string_index = -1
newstring = ''
for i in string:
string_index += 1
if i == origchar:
newstring = string[:string_index] + newchar + string[string_index+1:]
string = newstring
return newstring
string = raw_input('Enter a string: ')
origchar = raw_input('Enter a origchar: ')
newchar = raw_input('Enter a newchar: ')
print subchr(string, origchar, newchar)
6-13.字符串.string模块包含三个函数，atoi()，atol()和atof()，他们分别负责把字符串转换成整型、长整型和浮点型数字。

从Python 1.5起，Python的内建函数int()、long()、float()也可以做同样的事了，本文来，complex()函数可以把字符串转换成复数（然而1.5之前，这些转换函数只能工作于数字之上）。

string模块中并没有实现一个atoc()函数，那么你来实现一个atoc()，接受单个字符串做参数输入，一个表示复数的字符串，例如'-1.23e+4-5.67j'，返回相应的复数对象。

你不能用eval()函数，但可以使用complex()函数，而且你只能在如下的限制之下使用：complex():complex(real, imag)的real和imag都必须是浮点值。

答案：完全看不懂
6-14.随机数。

设计一个“石头、剪子、布”游戏，有时又叫“Rochambeau”，你小时候可能玩过，下面是规则。

你和你的对手，在同一时间做出特定的手势，必须是下面一种：石头、剪子、布。

胜利者从下面的规则产生，这个规则本身是个悖论。

(a)布包石头。

(b)石头砸剪子。

(c)剪子剪破布。

在你的计算机版本中，用户输入他/她的选项，计算机找一个随机选项，然后由你的程序来决定一个胜利者或者平手。

注意，最好的算法是尽量少使用if语句。

答案：
#coding:utf-8
import random
def Rochambeau(your_choice,cpu_choice):
determine = {'stone vs stone':'draw','stone vs scissors':'win',\
'stone vs cloth':'lose','scissors vs stone':'lose','scissors vs scissors':'draw',\
'scissors vs cloth':'win','cloth vs stone':'win','cloth vs scissors':'lose',\
'cloth vs cloth':'draw'}
result = your_choice + ' vs ' + cpu_choice
return '%s : %s' % (result,determine[result])
Stone_scissors_cloth = ['stone','scissors','cloth']
cpu_choice = random.choice(Stone_scissors_cloth)
symbol = True
while symbol:
your_choice = raw_input('Enter stone scissors or cloth: ')
if your_choice in Stone_scissors_cloth:
break
else:
symbol = False
print Rochambeau(your_choice,cpu_choice)
6-15.转换。

(a)给出两个可识别格式的日期，比如MM/DD/YY或者DD/MM/YY格式。

计算出两个日期之间的天数。

(b)给出一个人的生日，计算此人从出生到现在的天数，包括所有的闰月。

(c)还是上面的例子，计算出此人下次过生日还有多少天。

答案：
(a)
import datetime
def convertdate(date_input):
date_input = date_input.split('/')
year = int(date_input[2])
month = int(date_input[0])
day = int(date_input[1])
return year,month,day
date1 = raw_input('Enter a date like "MM/DD/YY": ')
d1 = datetime.date(convertdate(date1)[0],convertdate(date1)[1],convertdate(date1)[2])
date2 = raw_input('Enter a date like "MM/DD/YY": ')
d2 = datetime.date(convertdate(date2)[0],convertdate(date2)[1],convertdate(date2)[2])
days_count = abs(d2 - d1)
print days_count.days
(b)
import datetime
def convertdate(date_input):
date_input = date_input.split('/')
year = int(date_input[2])
month = int(date_input[0])
day = int(date_input[1])
return year,month,day
date1 = raw_input('Enter your birthdat like "MM/DD/YYYY": ')
d1 = datetime.date(convertdate(date1)[0],convertdate(date1)[1],convertdate(date1)[2])
days_count = abs(datetime.date.today() - d1)
print days_count.days
(c)
import datetime
import time
def convertdate(date_input):
date_input = date_input.split('/')
year = int(date_input[2])
month = int(date_input[0])
day = int(date_input[1])
return year,month,day
date1 = raw_input('Enter your birthdat like "MM/DD/YYYY": ')
next_year = int(time.strftime('%Y',time.localtime(time.time()))) + 1
next_birthday = datetime.date(next_year,convertdate(date1)[1],convertdate(date1)[2])
days_count = next_birthday - datetime.date.today()
print days_count.days
6-16.矩阵。

处理矩阵M和N的加和乘操作。

答案：数学忘得差不多了，以后补。

6-17.方法。

实现一个叫myPop()的函数，功能类似于列表的pop()方法，用一个列表作为输入，移除列表的最新一个元素，并返回它。

答案：
def myPop(list):
symbol = list[-1]
list.remove(list[-1])
return symbol
L = []
list = raw_input('Enter a list: ')
for i in list.split(','):
L.append(int(i))
print myPop(L)
6-18.zip()内建函数。

在6.13.2节里面关于zip()函数的例子中，zip(fn,ln)返回的是什么？
答案：
>>> fn = ['ian','stuart','david']
>>> ln = ['bairnson','elliott','paton']
>>> zip(fn,ln)
[('ian', 'bairnson'), ('stuart', 'elliott'), ('david', 'paton')]
>>> for i,j in zip(fn,ln):
print ('%s %s' % (i,j)).title()
Ian Bairnson
Stuart Elliott
David Paton
6-19.多列输出。

有任意项的序列或者其他容器，把它们等距离分列显示。

由调用者提供数据和输出格式。

例如，如果你传入100个项并定义3列输出，按照需要的模式显示这些数据。

这种情况下，应该是两列显示33个项，最后一列显示34个。

你可以让用户来选者水平排序
或者垂直排序。

答案：none。