python核心编程第六章答案

def idcheck():
'''6-2 修改idcheck使之可以检测长度为一得标识符，并且可识别
Python 关键字
'''
import string
import keyword
keys = keyword.kwlist
alphas = string.letters+'_'
nums = string.digits
alphanums = alphas+nums
print 'Welcome to the Identifier Check V1.1'
myInput = raw_input('identifier to test: ')
isOne = False # 是否是一个字符
if len(myInput) == 1:isOne = False

if myInput in keys:
print '''invalid:symbol has been defined'''
return False
elif myInput[0] not in alphas:
print '''invalid:first symbol must be alphabetic'''
return False
elif not isOne:
otherInput = myInput[1:]
for otherChar in otherInput:
if otherChar not in alphanums:
print '''invalid:remainn symbols must be alphanumeric'''
return False
print "okay as an Identifier"
return True

def order(nlist):
'''6-3(a) 输入一串数字，从大到小排列
注意：输入的是一个列表，其中的值为数字
'''
newlist = []
for x in nlist:
newlist.append(int(x))
return sorted(newlist,reverse=True)


def order2(nlist):
'''6-3(b) 和a一样，不过要用字典序
注意：字典序就是按字典的排列方式，比如 21 就大于 111 ，因为 2大于1
方式就是把输入的数字变成字符串即可
'''
# 将里面的元素统统变成字符串先
newlist = []
for x in nlist:
newlist.append(str(x))
newlist = sorted(newlist,reverse=True)
for i,x in enumerate(newlist):
newlist[i] = int(x)
return newlist

def avescore():
'''输入测试得分，算出平均值'''
scorelist = [] # 分数列表
while True:
myinput = raw_input('Input the score(if No number quite): ')
try:
scorelist.append(float(myinput))
except:
break
if not len(scorelist):return False
return sum(scorelist)/len(scorelist)

def showstr():
'''6-5(a) 更新2-7 使之可以每次向前向后都显示一个字符串的一个字符'''
istr = raw_input('Input string: ')
lens = len(istr)
if lens==0:return False
if lens==1:
print istr
return True
for i,j in enumerate(istr):
if i ==0 and len(istr)!=1:
print j,istr[i+1]
elif i == len(istr)-1 and i != 0:
print istr[i-1]
else:
print istr[i-1],j,istr[i+1]
return True

def mycmp():
'''6-5(b)通过扫描判断两个字符串是否匹配,不能使用比较操作符或者 cmp()'''
str1 = raw_input('First string:')
str2 = raw_input('Second string:')
equal = len(str1) - len(str2)
if not equal:return False # 表示长度不相等
# 将字符串变成列表
for i,j in enumerate(str1):
if ord(j)-ord(str2[i]):#如

果减下来不为0
return False
return True

def isback():
'''6-5(c)判断一个字符串是否是回文，忽略控制符号和空格[支持中文]'''
import string
# 控制符表示 ASCII 码中 0~31 以及127 这33个无法输出的字符
denny = [chr(i) for i in xrange(0,32)]+list(string.whitespace)
denny.append(chr(127))

strs = raw_input('Please input string:')
# 将输入的数据解码成unicode 因为在windows上默认是gbk，所以这里是gbk
# 如果是在其他命令行中，应该以命令行输入的字符编码为主
strs = strs.decode('gbk')
new = []
for i in strs:
if i in denny:continue
new.append(i)
lens = len(new)
if lens%2:return False
else:
half = lens/2
if new[0:half] == new[-1:-half-1:-1]:return True
return False

def beback():
'''6-5(d) 输入一个字符串在后面重复一个反向拷贝，构成回文'''
strs = raw_input('Input string: ')
# 将输入的数据解码成unicode 因为在windows上默认是gbk，所以这里是gbk
# 如果是在其他命令行中，应该以命令行输入的字符编码为主
strs = strs.decode('gbk') # 解码为 unicode
lens = len(strs)

# 这里之所以是 -1:-lens-1:-1
# 分析如下： -1就是倒数第一个，-(lens+1) 就是长度，-1是步进
# 就是说从倒数第一个开始-1(步进)，一直减到倒数 lens+1，由于切片里是 [a:b] 是 a<=x# 所以这里是 lens+1 而不是 lens
return strs+strs[-1:-lens-1:-1]

def strip():
'''6-6 去掉输入的字符串的前面和后面的空格'''
strs = raw_input('Input string: ').decode('gbk')
new = u''
# 由于只是去掉前面和后面的空格，所以不能遍历全部
# 分析，从前面遍历到非空格停止，从后面遍历到非空格位置
# 为了方便，我首先将字符串变成了列表
strs = list(strs)
lens = len(strs)
for i in range(0,lens): # 从前面开始遍历
if strs[i] == ' ':strs[i] =''
else:break
for i in range(-1,-lens-1,-1):
if strs[i] == ' ':strs[i] = ''
else:break
# 将 list 转成字符串
nstrs = ''
for i in range(0,lens):
nstrs +=strs[i]
return nstrs

def num2eng():
'''6-8 输入一个整数，返回相应的英文，限定0~1000'''
lists = ['zero','one','two','three','four','five','six','seven','eight','nine']
new =''

while True:
try:
iput = int(raw_input('Please input a int(0~1000): '))
if iput <0 or iput >1000:
continue
except:
continue
break

iput = str(iput)
for j in iput:
new += lists[int(j)]+'-'
return new[0:-1]

def minute2time():
'''6-9 输入分钟，返回小时数和分钟'''
minute = int(raw_input('Please input a min

utes: '))
hours = minute/60
newminute = minute-hours*60
return '%d:%02d' % (hours,newminute)

def like():
'''6-10 写一个函数，返回一个跟输入字符串相似的字符串，要求字符串的大小写反转
例如： Mr.Ed 返回 mR.eD
'''
import string
import random
Letter = string.ascii_uppercase # 大写字母字符串
letter = string.ascii_lowercase # 小写字母字符串
name = raw_input('Input string: ')
newname = ''
for i in name:
if i in Letter:
newname += random.choice(letter)
continue
if i in letter:
newname += random.choice(Letter)
continue
newname +=i
return newname

def int2ip():
'''6-11(a) 创建一个整数到IP地址的转换'''
ints = raw_input('Input Int:')
# 分析ip地址和整数的关系
# ip地址是由4个字节组成，每个字节8位，换成16进制就是 8 位
# FF.FF.FF.FF ===> 11111111 11111111 11111111 11111111
# 那么后面就是一个4位的二进制了
# 我们要做的就是将十进制的长整数换成4个字节的二进制或者4个16进制，然后再将每个字节转成独立的十进制
# 整数转成四个字节其实就是整数转16进制
hexs = hex(int(ints))[2:] # hex转换后把最前面一个 0x 先去掉，然后在前面填0
while len(hexs)<8:
hexs = '0'+hexs
ip1 = int(hexs[0]+hexs[1], 16)
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)

def ip2int():
'''6-11(b) 将ip地址转成整数'''
ip = raw_input('Input Ip:')
# 分析：
# 首先将ip转成列表
# 然后变成十六进制，合并在一起
# 然后将十六进制转成十进制
ips = ip.split('.')
ip = []
for i in xrange(0,4):
ip.append(int(ips[i]))
ip[i] = hex(ip[i])[2:]
if len(ip[i]) == 1:
ip[i] = '0'+ip[i]

return int(ip[0]+ip[1]+ip[2]+ip[3], 16)

def findchr(string, char):
'''6-12(a) 在string 中寻找char 找到返回索引，找不到返回-1
不能使用 find 或者 index方法'''
#strs = raw_input('Input string:')
#char = raw_input('Input char:') # 书中并没有说是找一个字符还是多个，我们假设为多个
lens = len(char) # 计算出char的长度
# 我们可以用 in 来指导是否存在
if char not in string:return -1
for i,j in enumerate(string):
if j in char:# 找到一个首字母哦~~~
if string[i:i+lens] == char: # 检查是否匹配
return i
return -1

def rfindchr(string, char):
'''6-12(b) 和findchr类似，不过是从后面往前面找'''
lens = len(char)
lenstr = len(string)
if char not in string:return -1
rstring = string[::-1] #倒置的string
for i,j i

n enumerate(rstring):
if j in char:
# 索引比长度小1，所以 lenstr -1
# 因为 i 是倒数的，所以整数就是
# lenstr-1-i
if string[lenstr-1-i:lenstr-1-i+lens] == char:
return lenstr-1-i
return -1

def subchr(string, origchar, newchar):
'''6-12(c) 和findchr类似
只不过找到匹配的字符就用新字符替换掉原来的字符
并且返回修改后字符串'''
# 这里注意了，是要替换掉第一个，还是替换掉所有的呢？我这里默认是替换掉所有的
lens = len(origchar)
while True:
index = string.find(origchar)
if index >-1:
# 我的做法是将字符串分割开两段，然后中间加入新字符串
string = string[0:index] + newchar + string[index+lens:]
else:
break
return string

def atoc(string):
'''6-13 输入字符串返回复数，只能用complex不能用eval'''
cindex = string.rfind('-')
if cindex <= 0:
cindex = string.rfind('+')
if cindex >0 :
real = float(string[0:cindex])
compl = float(string[cindex:-1])
return complex(real,compl)

def rochambeau():
'''6-14 石头剪子布，输入一个行为，计算机随即产生一个对应的行为，并进行比较看谁赢'''
import random
select = ['paper','shears','rock'] # 定个规则 0>1>2
cli = int(raw_input('Input your select[1.paper 2.shears 3.rock]: '))-1
print ' --- You VS Computer ---'
print '\nYou[ %s ]' % select[cli],
cup = random.choice([0,1,2])
print '\tComputer[ %s ]\n'% select[cup]
youwin = ' --- You Win!!! ---'
cupwin = ' --- Computer Win!!! ---'
eq = ' --- Nobody Win ---'
if cup == cli:
print eq
return
if (cup-cli)==-2 or (cup > cli and (cli-cup != -2)):
print cupwin
else:
print youwin

def date2date():
'''6-15 计算两个日期间的天数'''
# 由于现在已经是2000年后了，所以我这里不用 DD/MM/YY 用 DD/MM/YYYY 日/月/年
# 这里用到了上面的 isleapyear(year) 函数
import datetime
month = {1:31,2:28,3:31,4:30,5:31,6:30,7:31,8:31,9:30,10:31,11:30,12:31} # 默认的月份和天数
while True:# 这里做循环的目的是怕用户输入的日期不存在
sdate = raw_input('Input Start Date[DD/MM/YYYY]: ').split('/')
dd,mm,yyyy = 0,1,2
sdate[dd],sdate[mm],sdate[yyyy] = int(sdate[0]),int(sdate[1]),int(sdate[2])
if sdate[mm] > 12 or sdate[mm]<1:continue
if isleapyear(sdate[yyyy]):month[2]=29
if sdate[dd]<1 or sdate[dd] > month[sdate[mm]]:continue
break;
while True:
edate = raw_input('Input End Date[DD/MM/YYYY]: ').split('/')
edate[dd],edate[mm],edate[yyyy] = int(edate[0]),int(edate[1]),int(edate[2])
if edate[mm] > 12 or edate[mm]<1:continue

if isleapyear(sdate[yyyy]):month[2]=29
if edate[dd]<1 or edate[dd] > month[edate[mm]]:continue
break;

# 挑简单的先解决，如果是同一天，返回0
if sdate == edate:return 0
# 如果是同年同月，直接相减
if sdate[yyyy] == edate[yyyy] and sdate[mm]==edate[mm]:return edate[dd] - sdate[dd]

# 如果是同一年，那么就要判断当年是不是闰年
if sdate[yyyy] == edate[yyyy]:
# 是闰年，则2月事29天
if isleapyear(sdate[yyyy]):month[2] = 29
# 然后开始计算月到月
days = 0
for i in xrange(sdate[mm]+1,edate[mm]): # 开始月到中止月之间的日期
days+=month[i]
# 最后加上开始日当月过了几天+结束月当月过了几天
days += month[sdate[mm]]-sdate[dd] + edate[dd]
return days

# 如果不是同一年，先计算年与年之间的日期
days = 0
for year in xrange(sdate[yyyy]+1,edate[yyyy]):
if isleapyear(year):days+=366
else:days+=365
# 然后计算起始年到年终的日期
if isleapyear(sdate[yyyy]):month[2] = 29
sdays = 0
for i in xrange(sdate[mm]+1, 13):
sdays+=month[i]
sdays += month[sdate[mm]]-sdate[dd]
# 最后计算终止年年头到结束日期
if isleapyear(sdate[yyyy]):month[2]=29
else:month[2] = 28
edays = 0
for i in xrange(1,edate[mm]):
edays+=month[i]
edays += edate[dd]
return edays+sdays+days

class matrix:
'''6-16 矩阵东西比较多，我在这里做成了类来处理'''
# 我用一个列表来表示初始矩阵
# 这个矩阵式一个平面，包括纵向和横向
# 我这里用横向表示二级
# 例如
# matrix = [[1,2,3],[2,3,4],[3,5,6]] 转成矩阵就是这样
#
# | 1 2 3 |
# | 2 3 4 |
# | 3 5 6 |
#
matrix = []
def __init__(self, matrix):
self.matrix = matrix
self.ylens = len(matrix)
self.xlens = len(matrix[0])

def ji(self,matrix2):
'''6-16 求两个矩阵的积'''
import copy
if len(matrix2) != self.xlens:return False
if len(matrix2[0]) != self.ylens:return False
new = copy.deepcopy(self.matrix) # 这里主要是复制格式
for i in xrange(0, self.ylens):
for j in xrange(0, self.xlens):
new[i][j] += self.matrix[i][j]*matrix2[j][i]
self.matrix = new
return self.matrix


def add(self,matrix2):
'''6-16 求两个矩阵的和'''
if len(matrix2) != self.ylens:return False
if len(matrix2[0])!=self.xlens:return False
for i in xrange(0, self.ylens):
for j in xrange(0, self.xlens):
self.matrix[i][j] += matrix2[i][j]
return self.matrix

def sub(self,matrix2):
'''矩阵减法'''
if len(matrix2) != self.ylens:return F

alse
if len(matrix2[0]) != self.xlens:return False
for i in xrange(0, self.ylens):
for j in xrange(0, self.xlens):
self.matrix[i][j] -= matrix2[i][j]
return self.matrix


def change(self):
'''6-16 转置矩阵'''
# 所谓转置就是将横和纵交换
new_matrix = []

for i in xrange(0,self.xlens):
new_matrix.append([])
for j in xrange(0,self.ylens):
new_matrix[i].append([])
new_matrix[i][j] = self.matrix[j][i]
self.matrix = new_matrix
return self.matrix

def mypop(inlist):
'''6-17 功能类似pop'''
del inlist[len(inlist)-1]
return inlist

def showlist(inlist,row,xorder=True):
'''6-19 输入任意项序列，把它们等距离分列显示，
由调用者提供数据和输出格式以及排序方式是水平还是垂直'''
numl = len(inlist)*1./row
if numl.is_integer : numl = int(numl)
else:numl = int(numl)+1
outlist = []

x=0
# 建立一个list,用来格式化输出
col,row = numl,row
for i in xrange(0, col):
outlist.append([])
for j in xrange(0, row):
outlist[i].append([])
outlist[i][j] = inlist[x]
x+=1
if xorder:outlist[i] = sorted(outlist[i])
line =[x for x in xrange(0,col)]
if not xorder: # 如果是垂直排序，处理一下
for i in xrange(0, row):
for j in xrange(0,col):
line[j] = outlist[j][i]
line = sorted(line)
for x in xrange(0, col):
outlist[x][i] = line[x]

o = ''
for i in xrange(0, col):
for j in xrange(0,row):
if j == row-1:o = '%d' % outlist[i][j]
else: o='%d\t' %outlist[i][j]
print o,
if i!=col-1:
print '\n'