《Python程序设计》习题与答案

《Python程序设计》习题与参考答案
第1章基础知识
1.1简单说明如何选择正确的Python版本。

答：
在选择Python的时候，一定要先考虑清楚自己学习Python的目的是什么，打算做哪方面的开发，有哪些扩展库可用，这些扩展库最高支持哪个版本的Python，是Python2.x还是Python3.x，最高支持到Python反复安装和卸载上。

同时还应该注意，当更新的Python版本推出之后，不要急于更新，而是应该等确定自己所必须使用的扩展库也推出了较新版本之后再进行更新。

尽管如此，Python3毕竟是大势所趋，如果您暂时还没想到要做什么行业领域的应用开发，或者仅仅是为了尝试一种新的、好玩的语言，那么请毫不犹豫地选择Python3.x系列的最高版本（目前是Python3.4.3）。

1.2为什么说Python采用的是基于值的内存管理模式？
答：
Python采用的是基于值的内存管理方式，如果为不同变量赋值相同值，则在内存中只有一份该值，多个变量指向同一块内存地址，例如下面的代码。

>>>x=3
>>>id(x)
>>>y=3
>>>id(y)
>>>y=5
>>>id(y)
>>>id(x)
1.3在Python中导入模块中的对象有哪几种方式？
答：常用的有三种方式，分别为
✍import模块名[as别名]
✍from模块名import对象名[as别名]
✍frommathimport*
1.4使用pip命令安装numpy、scipy模块。

答：在命令提示符环境下执行下面的命令：
pipinstallnumpy
pipinstallscipy
1.5编写程序，用户输入一个三位以上的整数，输出其百位以上的数字。

例如用户输入1234，则程序输出12。

（提示：使用整除运算。

）
答：
1）Python
x=input('Pleaseinputanintegerofmorethan3digits:')
try:
x=int(x)
x=x//100
ifx==0:
print('Youmustinputanintegerofmorethan3digits.')
else:
print(x)
exceptBaseException:
print('Youmustinputaninteger.')
2）Python
importtypes
x=input('Pleaseinputanintegerofmorethan3digits:')
iftype(x)!=types.IntType:
print'Youmustinputaninteger.'
eliflen(str(x))!=4:
print'Youmustinputanintegerofmorethan3digits.'
else:
printx//100
第2章Python数据结构
2.1为什么应尽量从列表的尾部进行元素的增加与删除操作？
答：
当列表增加或删除元素时，列表对象自动进行内存扩展或收缩，从而保证元素之间没有缝隙，但这涉及到列表元素的移动，效率较低，应尽量从列表尾部进行元素的增加与删除操作以提高处理速度。

2.2编写程序，生成包含1000个0到100之间的随机整数，并统计每个元素的出现次数。

（提示：使用集合。

）
答：
1）Python
importrandom
x=[random.randint(0,100)foriinrange(1000)]
d=set(x)
forvind:
print(v,':',x.count(v))
2）Python
importrandom
x=[random.randint(0,100)foriinrange(1000)]
d=set(x)
forvind:
printv,':',x.count(v)
2.3编写程序，用户输入一个列表和2个整数作为下标，然后输出列表中介于2个下标之间的元素组成的子列表。

例如用户输入[1,2,3,4,5,6]和2,5，程序输出[3,4,5,6]。

答：
1）Python
x=input('Pleaseinputalist:')
x=eval(x)
start,end=eval(input('Pleaseinputthestartpositionandtheendposition:'))
print(x[start:end])
2）Python
x=input('Pleaseinputalist:')
start,end=input('Pleaseinputthestartpositionandtheendposition:')
printx[start:end]
2.4设计一个字典，并编写程序，用户输入内容作为键，然后输出字典中对应的值，如果用户输入的键不存在，则输出“您输入的键不存在！”
答：
1）Python
d={1:'a',2:'b',3:'c',4:'d'}
v=input('Pleaseinputakey:')
v=eval(v)
print(d.get(v,'您输入的的键不存在'))
2）Python
d={1:'a',2:'b',3:'c',4:'d'}
v=input('Pleaseinputakey:')
print(d.get(v,'您输入的的键不存在'))
2.5编写程序，生成包含20个随机数的列表，然后将前10个元素升序排列，后10个元素降序排列，并输出结果。

答：
1）Python
importrandom
x=[random.randint(0,100)foriinrange(20)]
print(x)
y=x[0:10]
y.sort()
x[0:10]=y
y=x[10:20]
y.sort(reverse=True)
x[10:20]=y
print(x)
2）Python
importrandom
x=[random.randint(0,100)foriinrange(20)]
printx
y=x[0:10]
y.sort()
x[0:10]=y
y=x[10:20]
y.sort(reverse=True)
x[10:20]=y
printx
2.6在Python中，字典和集合都是用一对大括号作为定界符，字典的每个元素有两部分组成，即键和值，其中键不允许重复。

2.7假设有列表a=['name','age','sex']和b=['Dong',38,'Male']，请使用一个语句将这两个列表的内容转换为字典，并且以列表a中的元素为键，以列表b中的元素为值，这个语句可以写为c=dict(zip(a,b))。

2.8假设有一个列表a，现要求从列表a中每3个元素取1个，并且将取到的元素组成新的列表b，可以使用语句b=a[::3]。

2.9使用列表推导式生成包含10个数字5的列表，语句可以写为[5foriinrange(10)]。

2.10不可以（可以、不可以）使用del命令来删除元组中的部分元素。

第3章选择结构与循环结构
3.1分析逻辑运算符“or”的短路求值特性。

答：
假设有表达式“表达式1or表达式2”，如果表达式1的值等价于True，那么无论表达式2的值是什么，整个表达式的值总是等价于True。

因此，不需要再计算表达式2的值。

3.2编写程序，运行后用户输入4位整数作为年份，判断其是否为闰年。

如果年份能被400整除，则为闰年；
如果年份能被4整除但不能被100整除也为闰年。

答：
1）Python
x=input('Pleaseinputanintegerof4digitsmeaningtheyear:')
x=eval(x)
ifx%400==0or(x%4==0andnotx%100==0):
print('Yes')
else:
print('No')
2）Python
x=input('Pleaseinputanintegerof4digitsmeaningtheyear:')
ifx%400==0or(x%4==0andnotx%100==0):
print'Yes'
else:
print'No'
3.3编写程序，生成一个包含50个随机整数的列表，然后删除其中所有奇数。

（提示：从后向前删。

）
答：
1）Python
importrandom
x=[random.randint(0,100)foriinrange(50)]
print(x)
i=len(x)-1
whilei>=0:
ifx[i]%2==1:
delx[i]
i-=1
print(x)
2）Python
把上面的代码中第三行和最后一行改为printx即可。

34编写程序，生成一个包含20个随机整数的列表，然后对其中偶数下标的元素进行降序排列，奇数下标的元素不变。

（提示：使用切片。

）
答：
1）Python
importrandom
x=[random.randint(0,100)foriinrange(20)]
print(x)
y=x[::2]
y.sort(reverse=True)
x[::2]=y
print(x)
2）Python
把上面的代码中第三行和最后一行改为printx即可。

35编写程序，用户从键盘输入小于1000的整数，对其进行因式分解。

例如，10=2×5，60=2×2×3×5。

答：
1）Python
x=input('Pleaseinputanintegerlessthan1000:')
x=eval('x')
t=x
i=2
result=[]
whileTrue:
ift==1:
break
ift%i==0:
result.append(i)
t=t/i
else:
i+=1
Printx,'=','*'.join(map(str,result))
2）Python
x=input('Pleaseinputanintegerlessthan1000:')
t=x
i=2
result=[]
whileTrue:
ift==1:
break
ift%i==0:
result.append(i)
t=t/i
else:
i+=1
printx,'=','*'.join(map(str,result))
3.6编写程序，至少使用2种不同的方法计算100以内所有奇数的和。

答：Python
x=[iforiinrange(1,100)ifi%2==1]
print(sum(x))
print(sum(range(1,100)[::2]))
3.7编写程序，实现分段函数计算，如下表所示。

x y
x<0 0
0<=x<5 x
5<=x<10 3x-5
10<=x<20 0.5x-2
20<=x 0 答：Python
x=input('Pleaseinputx:')
x=eval(x)
ifx<0orx>=20:
print(0)
elif0<=x<5:
print(x)
elif5<=x<10:
print(3*x-5)
elif10<=x<20:
print(0.5*x-2)
第4章字符串与正则表达式
4.1假设有一段英文，其中有单独的字母“I”误写为“i”，请编写程序进行纠正。

答：这里给出Python
1）不使用正则表达式
x="iamateacher,iamman,andiam38yearsold.Iamnotabusinessman."
x=x.replace('i','I')
x=x.replace('i','I')
print(x)
2）使用正则表达式
x="iamateacher,iamman,andiam38yearsold.Iamnotabusinessman."
importre
pattern=pile(r'(?:[^\w]|\b)i(?:[^\w])')
whileTrue:
result=pattern.search(x)
ifresult:
ifresult.start(0)!=0:
x=x[:result.start(0)+1]+'I'+x[result.end(0)-1:]
else:
x=x[:result.start(0)]+'I'+x[result.end(0)-1:]
else:
break
print(x)
4.2假设有一段英文，其中有单词中间的字母“i”误写为“I”，请编写程序进行纠正。

答：这里给出Python
importre
x="Iamateacher,Iamman,andIam38yearsold.IamnotabusInessman."
print(x)
pattern=pile(r'(?:[\w])I(?:[\w])')
whileTrue:
result=pattern.search(x)
ifresult:
ifresult.start(0)!=0:
x=x[:result.start(0)+1]+'i'+x[result.end(0)-1:]
else:
x=x[:result.start(0)]+'i'+x[result.end(0)-1:]
else:
break
print(x)
4.3有一段英文文本，其中有单词连续重复了2次，编写程序检查重复的单词并只保留一个。

例如文本内容为
“Thisisisadesk.”，程序输出为“Thisisadesk.”
答：这里给出Python
1）方法一
importre
x='Thisisaadesk.'
pattern=pile(r'\b(\w+)(\s+\1){1,}\b')
matchResult=pattern.search(x)
x=pattern.sub(matchResult.group(1),x)
print(x)
2）方法二
x='Thisisaadesk.'
pattern=pile(r'(?P<f>\b\w+\b)\s(?P=f)')
matchResult=pattern.search(x)
x=x.replace(matchResult.group(0),matchResult.group(1))
4.4简单解释Python的字符串驻留机制。

答：
Python支持字符串驻留机制，即：对于短字符串，将其赋值给多个不同的对象时，内存中只有一个副本，多个对象共享该副本。

这一点不适用于长字符串，即长字符串不遵守驻留机制，下面的代码演示了短字符串和长字符串在这方面的区别。

>>>a='1234'
>>>b='1234'
>>>id(a)==id(b)
True
>>>a='1234'*50
>>>b='1234'*50
>>>id(a)==id(b)
False
4.5编写程序，用户输入一段英文，然后输出这段英文中所有长度为3个字母的单词。

答：这里给出Python
importre
x=input('Pleaseinputastring:')
pattern=pile(r'\b[a-zA-Z]{3}\b')
print(pattern.findall(x))
第5章函数设计与使用
5.1
答：原因是对于函数的默认值参数只会被处理一次，下次再调用函数并且不为默认值参数赋值时会继续使用上一次的结果，对于列表这样的结构，如果调用函数时为默认值参数的列表插入或删除了元素，将会得到保留，从而影响下一次调用。

5.2编写函数，判断一个整数是否为素数，并编写主程序调用该函数。

答：这里给出Python
importmath
defIsPrime(v):
n=int(math.sqrt(v)+1)
foriinrange(2,n):
ifv%i==0:
return'No'
else:
return'Yes'
print(IsPrime(37))
print(IsPrime(60))
print(IsPrime(113))
5.3编写函数，接收一个字符串，分别统计大写字母、小写字母、数字、其他字符的个数，并以元组的形式返回结果。

答：这里给出Python
defdemo(v):
capital=little=digit=other=0
foriinv:
if'A'<=i<='Z':
capital+=1
elif'a'<=i<='z':
little+=1
elif'0'<=i<='9':
digit+=1
else:
other+=1
return(capital,little,digit,other)
x='capital=little=digit=other=0'
print(demo(x))
5.4在Python程序中，局部变量会隐藏同名的全局变量吗？请编写代码进行验证。

答案：会。

>>>defdemo():
a=3
printa
>>>a=5
>>>demo()
3
>>>a
5
5.5编写函数，可以接收任意多个整数并输出其中的最大值和所有整数之和。

答：这里给出Python
defdemo(*v):
print(v)
print(max(v))
print(sum(v))
demo(1,2,3)
demo(1,2,3,4)
demo(1,2,3,4,5)
5.6编写函数，模拟内置函数sum()。

答：这里给出Python
defSum(v):
s=0
foriinv:
s+=i
returns
x=[1,2,3,4,5]
print(Sum(x))
x=(1,2,3,4,5)
print(Sum(x))
5.7编写函数，模拟内置函数sorted()。

答：这里给出Python
defSorted(v):
t=v[::]
r=[]
whilet:
tt=min(t)
r.append(tt)
t.remove(tt)
returnr
x=[1,3,5,2,1,0,9,7]
print(x)
print(Sorted(x))
第6章面向对象程序设计
6.1继承6.5节例2中的Person类生成Student类，填写新的函数用来设置学生专业，然后生成该类对象并显示信息。

答：Python
importtypes
classPerson(object):#基类必须继承于object，否则在派生类中将无法使用super()函数
def__init__(self,name='',age=20,sex='man'):
self.setName(name)
self.setAge(age)
self.setSex(sex)
defsetName(self,name):
ifnotisinstance(name,str):
print('namemustbestring.')
return
self.__name=name
defsetAge(self,age):
ifnotisinstance(age,int):
print('agemustbeinteger.')
return
self.__age=age
defsetSex(self,sex):
ifsex!='man'andsex!='woman':
print('sexmustbe"man"or"woman"')
return
self.__sex=sex
defshow(self):
print(self.__name)
print(self.__age)
print(self.__sex)
classStudent(Person):
def__init__(self,name='',age=30,sex='man',major='Computer'):
#调用基类构造方法初始化基类的私有数据成员
super(Student,self).__init__(name,age,sex)
self.setMajor(major)#初始化派生类的数据成员
defsetMajor(self,major):
ifnotisinstance(major,str):
print('majormustbeastring.')
return
self.__major=major
defshow(self):
super(Student,self).show()
print(self.__major)
if__name__=='__main__':
zhangsan=Person('ZhangSan',19,'man')
zhangsan.show()
lisi=Student('LiSi',32,'man','Math')
lisi.show()
6.2设计一个三维向量类，并实现向量的加法、减法以及向量与标量的乘法和除法运算。

答：Python
classVecter3:
def__init__(self,x=0,y=0,z=0):
self.X=x
self.Y=y
self.Z=z
def__add__(self,n):
r=Vecter3()
r.X=self.X+n.X
r.Y=self.Y+n.Y
r.Z=self.Z+n.Z
returnr
def__sub__(self,n):
r=Vecter3()
r.X=self.X-n.X
r.Y=self.Y-n.Y
r.Z=self.Z-n.Z
returnr
def__mul__(self,n):
r=Vecter3()
r.X=self.X*n
r.Y=self.Y*n
r.Z=self.Z*n
returnr
def__truediv__(self,n):
r=Vecter3()
r.X=self.X/n
r.Y=self.Y/n
r.Z=self.Z/n
returnr
def__floordiv__(self,n):
r=Vecter3()
r.X=self.X//n
r.Y=self.Y//n
r.Z=self.Z//n
returnr
defshow(self):
print((self.X,self.Y,self.Z))
v1=Vecter3(1,2,3)
v2=Vecter3(4,5,6)
v3=v1+v2
v3.show()
v4=v1-v2
v4.show()
v5=v1*3
v5.show()
v6=v1/2
v6.show()
6.3面向对象程序设计的三要素分别为封装、继承和多态。

6.4简单解释Python中以下划线开头的变量名特点。

答：
在Python中，以下划线开头的变量名有特殊的含义，尤其是在类的定义中。

用下划线作为变量前缀和后缀来表示类的特殊成员：
✍_xxx：这样的对象叫做保护变量，不能用'frommoduleimport*'导入，只有类对象和子类对象能访问这些变量；
✍__xxx__：系统定义的特殊成员名字；
✍__xxx：类中的私有成员，只有类对象自己能访问，子类对象也不能访问到这个成员，但在对象外部可以通过“对象名._类名__xxx”这样的特殊方式来访问。

Python中没有纯粹的C++意义上的私有成员。

6.5与运算符“**”对应的特殊方法名为__pow__()，与运算符“//”对应的特殊方法名为__floordiv__()。

第7章文件操作
7.1假设有一个英文文本文件，编写程序读取其内容，并将其中的大写字母变为小写字母，小写字母变为大写字母。

答：
f=open(r'd:\1.txt','r')
s=f.readlines()
f.close()
r=[i.swapcase()foriins]
f=open(r'd:\2.txt','w')
f.writelines(r)
f.close()
7.2编写程序，将包含学生成绩的字典保存为二进制文件，然后再读取内容并显示。

答：Python
importpickle
d={'张三':98,'李四':90,'王五':100}
print(d)
f=open('score.dat','wb')
pickle.dump(1,f)
pickle.dump(d,f)
f.close
f=open('score.dat','rb')
pickle.load(f)
d=pickle.load(f)
f.close()
print(d)
7.3使用shutil模块中的move()方法进行文件移动。

答：
>>>importshutil
>>>shutil.move(r'd:\1.txt',r'e:\1.txt')
'e:\\1.txt'
7.4简单解释文本文件与二进制文件的区别。

答：
（1）文本文件
文本文件存储的是常规字符串，由若干文本行组成，通常每行以换行符'\n'结尾。

常规字符串是指记事本或其他文本编辑器能正常显示、编辑并且人类能够直接阅读和理解的字符串，如英文字母、汉字、数字字符串。

文本文件可以使用字处理软件如gedit、记事本进行编辑。

（2）二进制文件
二进制文件把对象内容以字节串(bytes)进行存储，无法用记事本或其他普通字处理软件直接进行编辑，通常也无法被人类直接阅读和理解，需要使用专门的软件进行解码后读取、显示、修改或执行。

常见的如图形图像文件、音视频文件、可执行文件、资源文件、各种数据库文件、各类office文档等都属于二进制文件。

7.5编写代码，将当前工作目录修改为“c:\”，并验证，最后将当前工作目录恢复为原来的目录。

答：
>>>importos
>>>os.getcwd()
'C:\\Python34'
>>>os.chdir(r'c:\\')
>>>os.getcwd()
'c:\\'
>>>os.chdir(r'c:\Python34')
>>>os.getcwd()
'c:\\Python34'
7.6编写程序，用户输入一个目录和一个文件名，搜索该目录及其子目录中是否存在该文件。

答：
1）Python
importsys
importos
directory=sys.argv[1]
filename=sys.argv[2]
paths=os.walk(directory)
forroot,dirs,filesinpaths:
iffilenameinfiles:
print('Yes')
break
else:
print('No')
2）Python
importsys
importos
directory=sys.argv[1]
filename=sys.argv[2]
paths=os.walk(directory)
forroot,dirs,filesinpaths:
iffilenameinfiles:
print'Yes'
break
else: print'No'
第8章异常处理结构与程序调试
8.1Python异常处理结构有哪几种形式？
答：
比较常用的形式有：
1）标准异常处理结构
try:
try块#被监控的语句，可能会引发异常
exceptException[,reason]:
except块 #处理异常的代码
如果需要捕获所有异常时，可以使用BaseException，代码格式如下：
try:
……
exceptBaseException,e:
except块 #处理所有错误
上面的结构可以捕获所有异常，尽管这样做很安全，但是一般并不建议这样做。

对于异常处理结构，一般的建议是尽量显式捕捉可能会出现的异常并且有针对性地编写代码进行处理，因为在实际应用开发中，很难使用同一段代码去处理所有类型的异常。

当然，为了避免遗漏没有得到处理的异常干扰程序的正常执行，在捕捉了所有可能想到的异常之后，您也可以使用异常处理结构的最后一个except来捕捉BaseException。

2）另外一种常用的异常处理结构是try...except...else...语句。

3）在实际开发中，同一段代码可能会抛出多个异常，需要针对不同的异常类型进行相应的处理。

为了支持多个异常的捕捉和处理，Python提供了带有多个except的异常处理结构，这类似于多分支选择结构，一旦某个except捕获了异常，则后面剩余的except子句将不会再执行。

语法为：
try:
try块#被监控的语句
exceptException1:
except块1 #处理异常1的语句
exceptException2:
except块2 #处理异常2的语句
4）将要捕获的异常写在一个元组中，可以使用一个except语句捕获多个异常，并且共用同一段异常处理代码，当然，除非确定要捕获的多个异常可以使用同一段代码来处理，并不建议这样做。

5）最后一种常用的异常处理结构是try...except...finally...结构。

在该结构中，finally子句中的内存无论是否发生异常都会执行，常用来做一些清理工作以释放try子句中申请的资源。

语法如下：
try:
……
finally:
...... #无论如何都会执行的代码
8.2异常和错误有什么区别？
答：
异常是指因为程序执行过程中出错而在正常控制流以外采取的行为。

严格来说，语法错误和逻辑错误不属于异常，但有些语法错误往往会导致异常，例如由于大小写拼写错误而访问不存在的对象，或者试图访问不存在的文件，等等。

8.3使用pdb模块进行Python程序调试主要有哪几种用法？
答：主要有三种方式，
1）在交互模式下使用pdb模块提供的功能可以直接调试语句块、表达式、函数等多种脚本。

2）在程序中嵌入断点来实现调试功能
在程序中首先导入pdb模块，然后使用pdb.set_trace()在需要的位置设置断点。

如果程序中存在通过该方法调用显式插入的断点，那么在命令提示符环境下执行该程序或双击执行程序时将自动打开pdb调试环境，即使该程序当前不处于调试状态。

3）使用命令行调试程序
在命令行提示符下执行“python–mpdb脚本文件名”，则直接进入调试环境；当调试结束或程序正常结束以后，pdb将重启该程序。

8.4Python内建异常类的基类是BaseException。

8.5断言语句的语法为assert。

8.6Python上下文管理语句是with。

第9章GUI编程
9.1设计一个窗体，并放置一个按钮，单击按钮后弹出颜色对话框，关闭颜色对话框后提示选中的颜色。

答：Python
importwx
classwxGUI(wx.App):
defOnInit(self):
frame=wx.Frame(parent=None,title='wxGUI',size=(160,140))
panel=wx.Panel(frame,-1)
buttonOK=wx.Button(panel,-1,'OK',pos=(0,0))
self.Bind(wx.EVT_BUTTON,self.OnButtonOK,buttonOK)
frame.Show()
returnTrue
defOnButtonOK(self,event):
colorDlg=wx.ColourDialog(None)
colorDlg.ShowModal()
color=colorDlg.GetColourData().Colour
wx.MessageBox(str(color))
app=wxGUI()
app.MainLoop()
9.2设计一个窗体，并放置一个按钮，按钮默认文本为“开始”，单击按钮后文本变为“结束”，再次单击后变为“开始”，循环切换。

答：Python
importwx
classwxGUI(wx.App):
defOnInit(self):
frame=wx.Frame(parent=None,title='wxGUI',size=(160,140))
panel=wx.Panel(frame,-1)
self.buttonOK=wx.Button(panel,-1,'Start',pos=(0,0))
self.Bind(wx.EVT_BUTTON,self.OnButtonOK,self.buttonOK)
frame.Show()
returnTrue
defOnButtonOK(self,event):
text=
iftext=='Start':
eliftext=='End':
app=wxGUI()
app.MainLoop()
9.3设计一个窗体，模拟QQ登录界面，当用户输入号码123456和密码654321时提示正确，否则提示错误。

答：Python
importwx
classwxGUI(wx.App):
defOnInit(self):
frame=wx.Frame(parent=None,title='Login',size=(250,150),pos=(350,350))
panel=wx.Panel(frame,-1)
label1=wx.StaticText(panel,-1,'UserName:',pos=(0,10),style=wx.ALIGN_RIGHT)
label2=wx.StaticText(panel,-1,'Password:',pos=(0,30),style=wx.ALIGN_RIGHT)
self.textName=wx.TextCtrl(panel,-1,pos=(70,10),size=(160,20))
self.textPwd=wx.TextCtrl(panel,-1,pos=(70,30),size=(160,20),style=wx.TE_PASSWORD) buttonOK=wx.Button(panel,-1,'OK',pos=(30,60))
self.Bind(wx.EVT_BUTTON,self.OnButtonOK,buttonOK)
buttonCancel=wx.Button(panel,-1,'Cancel',pos=(120,60))
self.Bind(wx.EVT_BUTTON,self.OnButtonCancel,buttonCancel)
buttonOK.SetDefault()
frame.Show()
returnTrue
defOnButtonOK(self,event):
usrName=
usrPwd=
ifusrName=='123456'andusrPwd=='654321':
wx.MessageBox('Right')
else:
wx.MessageBox('Wrong')
defOnButtonCancel(self,event):
pass
app=wxGUI()
app.MainLoop()
第10章网络程序设计
10.1简单解释TCP和UDP协议的区别。

答：
TCP协议是面向连接的、具有质量保证的可靠传输协议，但开销较大；UDP协议是尽最大能力传输的无连接协议，开销小，常用于视频在线点播（VideoOnDemand,VOD）之类的应用。

TCP协议和UDP协议并没有优劣之分，仅仅是适用场合有所不同。

10.2同学之间合作编写UDP通信程序，分别编写发送端和接收端代码，发送端发送一个字符串“Helloworld!”。

假设接收端在计算机的5000端口进行接收，并显示接收内容。

答：首先使用ipconfig/all命令查看本机IP地址，然后分别编写下面的代码，并将其中的IP地址替换为相应的IP地址。

接收端代码：
importsocket
s=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
s.bind(("",5000))#空字符串表示本机任何可用IP地址
data,addr=s.recvfrom(1024)#缓冲区大小为1024字节
print'receivedmessage:%s'%data#显示接收到的内容
s.close()
发送端代码：
importsocket
s=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
s.sendto("Hello,world!",,5000))主机的IP地址
s.close()
10.3简单介绍socket模块中用于TCP编程的常用方法。

TCP一般用于要求可靠数据传输的场合。

编写TCP程序时经常需要用到的socket模块方法主要有：
✍connect(address)：连接远程计算机
✍send(bytes[,flags])：发送数据
✍recv(bufsize[,flags])：接收数据
✍bind(address)：绑定地址
✍listen(backlog)：开始监听，等待客户端连接
✍accept()：响应客户端的请求
10.4编写代码读取搜狐网页首页内容。

答：
>>>importurllib.request
>>>dir(urllib.request)
>>>fp=')
>>>dir(fp)
>>>print(fp.read(100))
>>>fp.close()
10.5在自己的机器上配置IIS以支持Python脚本的运行，然后使用Python编写脚本，运行后在网页上显示“Helloworld!”。

答：核心代码为
print
print'Status:200OK'
print'Content-type:text/html'
print
print'<HTML><HEAD><TITLE>PythonSampleCGI</TITLE></HEAD>'
print'<BODY>'
print'<H1>Thisisaheader</H1>'
print'<p>Helloworld!'
print'<br>'
print'</BODY>'
第11章大数据处理
11.1简单介绍常见的大数据处理框架。

答：主要有三种，
✍MapReduce：分布式计算框架，可以将单个大型计算作业分配给多台计算机执行，可以在短时间内完成大量工作，尤其适合数值型和标称型数据，但需要对行业领域具有一定理解后重写算法来完成特定的业务处理要求。

MapReduce的名字由函数式编程中常用的map和reduce两个单词组成。

MapReduce在大量节点组成的集群上运行，工作流程是：单个作业被分成很多小份，输入数据也被切片并分发到每个节点，每个节点只在本地数据上做运算，对应的运算代码称为mapper，这个过程即map阶段；每个mapper的输出通过某种方式组合，根据需要可能再进行重新排序，排序后的结果再被切分成小份并分发到各个节点进行下一步处理，这个过程被称为reduce阶段，对应的代码称为reducer。

不同类型的作业可能需要不同数量的reducer，并且，在任何时候，每个mapper或reducer之间都不进行通信，每个节点只负责处理自己的事务，并且只在分配到本地的数据集上进行运算。

✍Hadoop：Hadoop是MapReduce框架的一个免费开源实现，采用Java语言编写，支持在大量机器上分布式处理数据。

除了分布式计算之外，Hadoop还自带分布式文件系统，可以在上面运行多种不同语言编写的分布式程序。

Hadoop在可伸缩性、健壮性、计算性能和成本上具有无可替代的优势，事实上已成为当前互联网企业主流的大数据分析平台。

✍Spark：Spark是一个针对超大数据集合的低延迟集群分布式计算系统，比MapReduce快40倍左右。

Spark 是Hadoop的升级版本，兼容Hadoop的API，能够读写Hadoop的HDFSHBASE顺序文件等，与之不同的是将结果保存在内存中。

Hadoop作为第一代产品使用了HDFS，第二代加入了Cache来保存中间计算结果，第三代则是Spark倡导的流技术Streaming。

11.2运行本章中代码并理解MapReduce编程思路。

答：略
第12章Windows系统编程
12.1查阅相关资料，解释注册表几大根键的用途。

答：略
12.2选择一个编写好的Python程序，将其转换为exe可执行文件。

答：略，请参考书中相关介绍。

12.3编写代码，使用至少3中不同的方法启动Windows自带的计算器程序。

答：
第一种方法：
>>>importos
>>>os.system('calc.exe')
第二种方法：
>>>importos
>>>os.popen('calc.exe')
第三种方法：
>>>importos
>>>os.startfile('calc.exe')
第四种方法：
>>>importwin32api
>>>win32api.ShellExecute(0,'open','calc.exe','','',1)
第五种方法：
>>>importwin32process
>>>handle=win32process.CreateProcess(r'c:\windows\system32\calc.exe','',None,None,0,win32process.CREATE_NO_W INDOW,None,None,win32process.STARTUPINFO())
12.4编写代码，检测您所使用的操作系统版本。

答：略，请参考12.5节。

第13章多线程编程
13.1简单叙述创建线程的方法。

答：
Thread类支持使用两种方法来创建线程，一种是为构造函数传递一个可调用对象，另一种是继承Thread类并在派生类中重写__init__()和run()方法。

创建了线程对象以后，可以调用其start()方法来启动，该方法自动调用该类对象的run()方法，此时该线程处于alive状态，直至线程的run()方法运行结束。

13.2简单叙述Thread对象的方法。

答：
（1）join([timeout]：阻塞当前线程，等待被调线程结束或超时后再继续执行当前线程的后续代码，参数timeout用来指定最长等待时间，单位为秒。

（2）isAlive()：测试线程是否处于运行状态
（3）start()：自动调用run()方法，启动线程，执行线程代码。

（4）run()：线程代码，用来实现线程的功能与业务逻辑，可以在子类中重写该方法来自定义线程的行为。

13.3简单叙述线程对象的daemon属性的作用和影响。

答：
在脚本运行过程中有一个主线程，若在主线程中创建了子线程，当主线程结束时根据子线程daemon属性值的不同可能会发生下面的两种情况之一：1）当某子线程的daemon属性为False时，主线程结束时会检测该子线程是否结束，如果该子线程尚未完成，则主线程会等待它完成后再退出；2）当某子线程的daemon属性为True时，主线程运行结束时不对该子线程进行检查而直接退出，同时所有daemon值为True的子线程将随主线程一起结束，而不论是否运行完成。

daemon属性的值默认为False，如果需要修改，则必须在调用start()方法启动线程之前进行修改。

13.4解释至少3种线程同步方法。

答：
（1）使用Condition对象可以在某些事件触发后才处理数据，可以用于不同线程之间的通信或通知，以实现更高级别的同步。

Condition对象除了具有acquire()和release()方法之外，还有wait()、notify()、notify_all()等方法。

下面通过经典生产者/消费者问题来演示Condition对象的用法。

（2）Queue模块（在Python3中为queue模块）实现了多生产者/多消费者队列，尤其适合需要在多个线程之间进行信息交换的场合，该模块的Queue对象实现了多线程编程所需要的所有锁语义。

（3）Event对象是一种简单的线程通信技术，一个线程设置Event对象，另一个线程等待Event对象。

Event
对象的set()方法可以设置Event对象内部的信号标志为真；clear()方法可以清除Event对象内部的信号标志，将其设置为假；isSet()方法用来判断其内部信号标志的状态；wait()方法只有在其内部信号状态为真时将很快地执行并返回，若Event对象的内部信号标志为假，wait()方法将一直等待至超时或内部信号状态为真。

第14章数据库编程
14.1简单介绍SQLite数据库。

答：
SQLite是内嵌在Python中的轻量级、基于磁盘文件的数据库管理系统，不需要服务器进程，支持使用SQL 语句来访问数据库。

该数据库使用C语言开发，支持大多数SQL91标准，支持原子的、一致的、独立的和持久的事务，不支持外键限制；通过数据库级的独占性和共享锁定来实现独立事务，当多个线程同时访问同一个数据库并试图写入数据时，每一时刻只有一个线程可以写入数据。

SQLite支持2TB大小的单个数据库，每个数据库完全存储在单个磁盘文件中，以B+树数据结构的形式存储，一个数据库就是一个文件，通过简单复制即可实现数据库的备份。

14.2使用Python内置函数dir()查看Cursor对象中的方法，并使用内置函数help()查看其用法。

答：略。

14.3叙述使用Python操作Access数据库的步骤。

答：
（1）建立数据库连接
importwin32com.client
conn=
DSN=SOURCE=C:/MyDB.mdb;'
conn.Open(DSN)
（2）打开记录集
rs=
rs_name='MyRecordset'#表名
rs.Open('['+rs_name+']',conn,1,3)
（3）操作记录集
rs.AddNew()
='data'
rs.Update()
（4）操作数据
conn=
DSN=SOURCE=C:/MyDB.mdb;'
sql_statement="InsertINTO[Table_Name]([Field_1],[Field_2])VALUES('data1','data2')"
conn.Open(DSN)
conn.Execute(sql_statement)
conn.Close()
（5）遍历记录
rs.MoveFirst()
count=0
while1:
ifrs.EOF:
break
else:
count=count+1
rs.MoveNext()
14.4叙述使用Python操作MSSQLServer数据库的步骤。

答：
可以使用pywin32和pymssql两种不同的方式来访问MSSQLServer数据库。

先来了解一下pywin32模块访问MSSQLServer数据库的步骤。

（1）添加引用:
importadodbapi
=False#addsdetailstothesampleprintout
importadodbapi.ado_constsasadc
（2）创建连接:
Cfg=
constr=r"Provider=SQLOLEDB.1;InitialCatalog=%s;DataSource=%s;userID=%s;Password=%s;"%(Cfg['db'],Cfg['server'] ,'sa',Cfg['password'])
conn=adodbapi.connect(constr)
（3）执行sql语句:
cur=conn.cursor()
sql='''select*fromsoftextBookwheretitle='{0}'andremark3!='{1}''''.format(bookName,flag)
cur.execute(sql)
data=cur.fetchall()
cur.close()
（4）执行存储过程:
#假设proName有三个参数,最后一个参数传了null
ret=cur.callproc('procName',(parm1,parm2,None))
mit()
（5）关闭连接
conn.close()
接下来再通过一个示例来简单了解一下使用pymssql模块访问MSSQLServer数据库的方法。