print a_3
29. 下列语句的执行结果是什么？ 答：3
a = 1
for i in range(5):
if i == 2:
break
a += 1
else:
a += 1
print a
30. 下列代码的运行结果是多少？ 答：4
def bar(n):
m = n
while True:
m += 1
yield m
b = bar(3)
print b.next()
一、 基础知识（7题）
题01：Python中的不可变数据类型和可变数据类型是什么意思？
难度： ★☆☆☆☆【参考答案】
不可变数据类型是指不允许变量的值发生变化，如果改变了变量的值，相当于是新建了一个对象，而对于相同的值的对象，在内存中则只有一个对象（一个地址）。数值型、字符串string和元组tuple都属于不可变数据类型。
可变数据类型是指允许变量的值发生变化，即如果对变量执行append、+=等操作，只会改变变量的值，而不会新建一个对象，变量引用的对象的地址也不会变化。不过对于相同的值的不同对象，在内存中会存在不同的对象，即每个对象都有自己的地址，相当于内存中对于同值的对象保存了多份，这里不存在引用计数，是实实在在的对象。列表list和字典dict都属于可变数据类型。
题02：请简述Python中is和==的区别。
难度：★★☆☆☆ 【参考答案】
Python中的对象包含三个要素：id、type和value。is比较的是两个对象的id。==比较的是两个对象的value。
题03：请简述function(_args, **kwargs)中的 _args, **kwargs分别是什么意思？
难度：★★☆☆☆ 【参考答案】
*args和**kwargs主要用于函数定义的参数。Python语言允许将不定数量的参数传给一个函数，其中_args表示一个非键值对的可变参数列表，kwargs则表示不定数量的键值对参数列表。注意：*args和kwargs可以同时在函数的定义中，但是_args必须在**kwargs前面。
题04：请简述面向对象中__new__和__init__的区别。
难度： ★★★☆☆【参考答案】
（1）__new__至少要有一个参数cls，代表当前类，此参数在实例化时由Python解释器自动识别。
（2） __new__返回生成的实例，可以返回父类（通过super(当前类名, cls)的方式）__new__出来的实例，
或者直接是对象的__new__出来的实例。这在自己编程实现__new__时要特别注意。
（3） __init__有一个参数self，就是这个__new__返回的实例，__init__在__new__的基础上可以完成一
些其它初始化的动作，**init__不需要返回值。
（4） 如果__new__创建的是当前类的实例，会自动调用__init**，通过返回语句里面调用的__new__函
数的第一个参数是cls来保证是当前类实例，如果是其他类的类名，那么实际创建并返回的就是其他类的实例，也就不会调用当前类或其他类的__init__函数。
题05：Python子类继承自多个父类时，如多个父类有同名方法，子类将继承自哪个方法？
难度：★☆☆☆☆
【参考答案】
Python语言中子类继承父类的方法是按照继承的父类的先后顺序确定的，例如，子类A继承自父类B、C，且B、C中具有同名方法Test()，那么A中的Test()方法实际上是继承自B中的Test()方法。
题06：请简述Python中如何避免死锁？
难度：★☆☆☆☆
【参考答案】
死锁是指不同线程获取了不同的锁，但是线程间又希望获取对方的锁，双方都在等待对方释放锁，这种相互等待资源的情况就是死锁。Python语言可以使用threading.Condition对象，基于条件事件通知的形式去协调线程的运行，即可避免死锁。
题07：什么是排序算法的稳定性？常见的排序算法如冒泡排序、快速排序、归并排序、堆排
序、Shell排序、二叉树排序等的时间、空间复杂度和稳定性如何？
难度：★★★☆☆
【参考答案】
假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。
常见排序算法的时间、空间复杂度和稳定性如下表所示。
*基数排序的复杂度中，r表示关键字的基数，d表示长度，n表示关键字的个数。
二、 字符串与数字（7题）
题08：字符串内容去重并按字母顺序排列。
难度：★☆☆☆☆
令 s = “hfkfdlsahfgdiuanvzx”，试对 s 去重并按字母顺序排列输出 “adfghiklnsuvxz”。
【参考答案】
s = “hfkfdlsahfgdiuanvzx”
s = list(set(s)) s.sort(reverse=False) print(“”.join(s))
题09：判断两个字符串是否同构。
难度：★★☆☆☆
字符串同构是指字符串s中的所有字符都可以替换为t中的所有字符。在保留字符顺序的同时，必须用另一个字符替换所有出现的字符。不能将s中的两个字符映射到t中同一个字符，但字符可以映射到自身。试判定给定的字符串s和t是否同构。 例如： s = “add” t = “apple” 输出 False s = “paper” t = “title”
输出
True 【参考答案】
print(len(set(s)) == len(set(t)) == len(set(zip(s, t))))
题10：使用Lambda表达式实现将IPv4的地址转换为int型整数。
难度：★★★☆☆
例如：ip2int(“192.168.3.5”) 输出：
3232236293
【参考答案】
ip2int = lambda x:sum([256**j*int(i) for j,i in enumerate(x.split(‘.’)[::-1])])
题11：罗马数字使用字母表示特定的数字，试编写函数romanToInt()，输入罗马数字字符
串，输出对应的阿拉伯数字。
难度：★★★☆☆
【参考答案】
罗马数字中字母与阿拉伯数字的对应关系如下：
M:1000，CM:900，D:500，CD:400，C:100，XC:90，L:50，XL: 40，X:10，IX:9，V:5，VI:4，I:1
def romanToInt(s):
table = {‘M’:1000, ‘CM’:900, ‘D’:500, ‘CD’:400, ‘C’:100, ‘XC’:90, ‘L’:50, ‘XL’: 40, ‘X’:10, ‘IX’:9, ‘V’:5, ‘VI’:4, ‘I’:1} result = 0
for i in range(len(s)):
if i > 0 and table[s[i]] > table[s[i-1]]: result += table[s[i]] result -= 2 * table[s[i-1]] else:
result += table[s[i]] return result
题12：判断括号是否成对。
难度：★★★☆☆
给定一个只包含字符“(”“)”“{”“}”“[”和“]”的字符串，试编写函数isParenthesesValid()，输入该字符串，确定输入的字符串是否有效。括号必须以正确的顺序关闭，例如“()”和“()[]{}”都是有效的，但“(]”和“([]]”不是。
【参考答案】
def isParenthesesValid(s): pars = [None]
parmap = {‘)’: ‘(’, ‘}’: ‘{’, ‘]’: ‘[’} for c in s:
if c in parmap:
if parmap[c] != pars.pop(): return False else:
pars.append© return len(pars) == 1
题13：编写函数输出count-and-say序列的第n项。
难度：★★★★☆
count-and-say序列是一个整数序列，其前五个元素如下： 1 11 21
1211 111221
1读作“1”或11。11读作“两个1”或21。21读作“一个2，然后一个1”或1211。即下一项是将上一项“读出来”再写成数字。
试编写函数CountAndSay(n)，输出count-and-say序列的第n项。 【参考答案】
def CountAndSay(n): ans = “1” n -= 1 while n > 0: res = “” pre = ans[0] count = 1
for i in range(1, len(ans)): if pre == ans[i]: count += 1 else:
res += str(count) + pre pre = ans[i] count = 1 res += str(count) + pre ans = res
n -= 1 return ans
题14：不使用sqrt
函数，试编写squareRoot()函数，输入一个正数，输出它的平方根的整
数部分
难度：★★★★☆ 【参考答案】
def squareRoot(x): result = 1.0
while abs(result * result - x) > 0.1: result = (result + x / result) / 2
return int(result)
三、 正则表达式（4题）
题15：请写出匹配中国大陆手机号且结尾不是4和7的正则表达式。
难度：★☆☆☆☆ 【参考答案】
import re
tels = [“159********”, “14456781234”, “12345678987”, “11444777”] for tel in tels:
print(“Valid”) if (re.match(r"1\d{9}[0-3,5-6,8-9]", tel) != None) else print(“Invalid”)
题16：请写出以下代码的运行结果。
难度：★★☆☆☆
import re
str = ‘
res = re.findall(r’
结果如下： 【参考答案】
['中国 ']
题17：请写出以下代码的运行结果。
难度：★★★☆☆
import re
match = re.compile(‘www…?’).match(“www.baidu.com”) if match:
print(match.group()) else:
print(“NO MATCH”)
【参考答案】
www.bai
题18：请写出以下代码的运行结果。
难度：★★☆☆☆
import re
example = “
print(“Result = %s” % Result.group())
【参考答案】
Result =
test1
test2
四、 列表、字典、元组、数组、矩阵（9题）
题19：使用递推式将矩阵转换为一维向量。
难度：★☆☆☆☆ 使用递推式将 [[ 1, 2 ], [ 3, 4 ], [ 5, 6 ]]
转换为
[1, 2, 3, 4, 5, 6]。 【参考答案】
a = [[1, 2], [3, 4], [5, 6]] print([j for i in a for j in i])
题20：写出以下代码的运行结果。
难度：★★★★☆
def testFun():
temp = [lambda x : i*x for i in range(5)]
return temp
for everyLambda in testFun(): print (everyLambda(3))
结果如下： 【参考答案】
12 12 12 12 12
题21：编写Python程序，打印星号金字塔。
难度：★★★☆☆
编写尽量短的Python程序，实现打印星号金字塔。例如n=5时输出以下金字塔图形：
参考代码如下： 【参考答案】
n = 5
for i in range(1,n+1):
print(’ ‘(n-(i-1))+'’(2i-1))
题22：获取数组的支配点。
难度：★★★☆☆
支配数是指数组中某个元素出现的次数大于数组元素总数的一半时就成为支配数，其所在下标称为支配点。编写Python
函数FindPivot(li)，输入数组，输出其中的支配点和支配数，若数组中不存在支配数，输出None。
例如：[3,3,1,2,2,1,2,2,4,2,2,1,2,3,2,2,2,2,2,4,1,3,3]中共有23个元素，其中元素2出现了12次，其支配点和支配数组合是(18, 2)。 【参考答案】
def FindPivot(li): mid = len(li)/2 for l in li: count = 0 i = 0 mark = 0 while True: if l == li[i]: count += 1 temp = i i += 1
if count > mid: mark = temp
return (mark, li[mark]) if i > len(li) - 1: break
题23：将函数按照执行效率高低排序
难度：★★★☆☆
有如下三个函数，请将它们按照执行效率高低排序。
def S1(L_in):
l1 = sorted(L_in)
l2 = [i for i in l1 if i<0.5] return [i*i for i in l2]
def S2(L_in):
l1 = [i for i in L_in if i<0.5] l2 = sorted(l1)
return [i*i for i in l2]
def S3(L_in):
l1 = [i*i for i in L_in] l2 = sorted(l1)
return [i for i in l2 if i<(0.5*0.5)]
【参考答案】
使用cProfile库即可测试三个函数的执行效率：
import random import cProfile
L_in = [random.random() for i in range(1000000)]
cProfile.run(‘S1(L_in)’) cProfile.run(‘S2(L_in)’) cProfile.run(‘S3(L_in)’)
从结果可知，执行效率从高到低依次是S2、S1、S3。
题24：螺旋式返回矩阵的元素
难度：★★★★★
给定m×n个元素的矩阵（m行，n列），编写Python
函数spiralOrder(matrix)，以螺旋顺序返回矩阵的所有元素。
例如，给定以下矩阵： [[ 1, 2, 3 ], [ 4, 5, 6 ], [ 7, 8, 9 ]]
应该返回[1,2,3,6,9,8,7,4,5]
【参考答案】
def spiralOrder(matrix):
if len(matrix) == 0 or len(matrix[0]) == 0: return [] ans = []
left, up, down, right = 0, 0, len(matrix) - 1, len(matrix[0]) - 1 while left <= right and up <= down: for i in range(left, right + 1): ans += matrix[up][i], up += 1
for i in range(up, down + 1): ans += matrix[i][right], right -= 1
for i in reversed(range(left, right + 1)): ans += matrix[down][i], down -= 1
for i in reversed(range(up, down + 1)): ans += matrix[i][left], left += 1
return ans[:(len(matrix) * len(matrix[0]))]
题25：矩阵重整
难度：★★★★☆
对于一个给定的二维数组表示的矩阵，以及两个正整数r和c，分别表示所需重新整形矩阵的行数和列数。reshape函数生成一个新的矩阵，并且将原矩阵的所有元素以与原矩阵相同的行遍历顺序填充进去，将该矩阵重新整形为一个不同大小的矩阵但保留其原始数据。对于给定矩阵和参数的reshape操作是可以完成且合法的，则输出新的矩阵；否则，输出原始矩阵。请使用Python语言实现reshape函数。 例如：
输入
r, c 输出
说明
nums = [[1,2], [3,4]] r = 1，c =
4 [[1,2,3,4]]
行遍历的是[1,2,3,4]。新的重新形状矩阵是1 * 4矩阵，使用前面的列表逐行填充。
nums = [[1,2], [3,4]]
r = 2，c =
4
[[1,2], [3,4]]
无法将2 * 2矩阵重新整形为2 * 4矩阵。所以输出原始矩阵。
注意：给定矩阵的高度和宽度在[1,100]范围内。给定的r和c都是正数。
【参考答案】
def matrixReshape(nums, r, c): “”"
if r * c != len(nums) * len(nums[0]): return nums m = len(nums) n = len(nums[0])
ans = [[0] * c for _ in range®] for i in range(r * c):
ans[i / c][i % c] = nums[i / n][i % n] return ans
题26：查找矩阵中第k个最小元素。
难度：★★★★☆
给定n×n矩阵，其中每行每列元素均按升序排列，试编写Python函数kthSmallest(matrix, k)，找到矩阵中的第k个最小元素。
注意：查找的是排序顺序中的第k个最小元素，而不是第k个不同元素。 例如： 矩阵= [[1,5,9], [10,11,13], [12,13,15]] k = 8，应返回13。
【参考答案】
import heapq
def kthSmallest(matrix, k): visited = {(0, 0)}
heap = [(matrix[0][0], (0, 0))]
while heap:
val, (i, j) = heapq.heappop(heap) k -= 1 if k == 0: return val
if i + 1 < len(matrix) and (i + 1, j) not in visited:
heapq.heappush(heap, (matrix[i + 1][j], (i + 1, j))) visited.add((i + 1, j))
if j + 1 < len(matrix) and (i, j + 1) not in visited: heapq.heappush(heap, (matrix[i][j + 1], (i, j + 1))) visited.add((i, j + 1))
题27：试编写函数largestRectangleArea()，求一幅柱状图中包含的最大矩形的面积。
难度：★★★★★ 例如对于下图：
输入：[2,1,5,6,2,3] 输出：10
【参考答案】
def largestRectangleArea(heights): stack=[] i=0 area=0
while i<len(heights):
if stack==[] or heights[i]>heights[stack[len(stack)-1]]: # 递增直接入栈
stack.append(i) else: # 不递增开始弹栈
curr=stack.pop() if stack == []: width = i else:
width = i-stack[len(stack)-1]-1 area=max(area,width*heights[curr]) i-=1 i+=1
while stack != []: curr = stack.pop() if stack == []: width = i else:
width = len(heights)-stack[len(stack)-1]-1 area = max(area,width*heights[curr]) return area
五、 设计模式（3
题）
题28：使用Python语言实现单例模式。
难度：★★★☆☆
【参考答案】
class Singleton(object):
def new(cls, *args, **kw): if not hasattr(cls, ‘_instance’): orig = super(Singleton, cls)
cls._instance = orig.new(cls, *args, **kw) return cls._instance
题29：使用Python语言实现工厂模式。
难度：★★★★☆
编写适当的Python程序，完成以下功能： 1. 定义基类Person，含有获取名字，性别的方法。 2. 定义Person类的两个子类Male和Female，含有打招呼的方法。 3. 定义工厂类，含有getPerson方法，接受两个输入参数：名字和性别。 4. 用户通过调用getPerson方法使用工厂类。
【参考答案】
class Person:
def init(self): self.name = None self.gender = None
def getName(self): return self.name
def getGender(self): return self.gender
class Male(Person):
def init(self, name): print(“Hello Mr.” + name)
class Female(Person):
def init(self, name): print(“Hello Miss.” + name)
class Factory:
def getPerson(self, name, gender): if(gender == ‘M’): return Male(name) if(gender == ‘F’): return Female(name)
if name == ‘main’: factory = Factory()
person = factory.getPerson(“Huang”, “M”)
题30：使用Python语言实现观察者模式。
难度：★★★★★
给定一个数字，现有的默认格式化显示程序以十进制格式显示此数字。请编写适当的Python程序，实现支持添加（注册）更多的格式化程序（如添加一个十六进制格式化程序和一个二进制格式化程序）。每次数值更新时，已注册的程序就会收到通知，并显示更新后的值。
【参考答案】
import itertools class Publisher: def init(self): self.observers = set()
def add(self, observer, *observers):
for observer in itertools.chain((observer, ), observers): self.observers.add(observer)
observer.update(self)
def remove(self, observer): try:
self.observers.discard(observer) except ValueError:
print(‘移除 {} 失败!’.format(observer))
def notify(self):
[observer.update(self) for observer in self.observers]
class DefaultFormatter(Publisher): def init(self, name): Publisher.init(self) self.name = name self._data = 0
def str(self):
return “{}: ‘{}’ 的值 = {}”.format(type(self).name, self.name, self._data)
@property def data(self): return self._data
@data.setter
def data(self, new_value): try:
self._data = int(new_value) except ValueError as e: print(‘错误: {}’.format(e)) else:
self.notify()
class HexFormatter:
def update(self, publisher):
print(“{}: ‘{}’ 的十六进制值 = {}”.format(type(self).name, publisher.name, hex(publisher.data)))
class BinaryFormatter:
def update(self, publisher):
print(“{}: ‘{}’ 的二进制值 = {}”.format(type(self).name, publisher.name, bin(publisher.data)))
def main():
df = DefaultFormatter(‘test1’) print(df)
hf = HexFormatter()
df.add(hf) df.data = 37 print(df)
bf = BinaryFormatter() df.add(bf) df.data = 23 print(df)
df.remove(hf) df.data = 56 print(df)
df.remove(hf) df.add(bf)
df.data = ‘hello’ print(df)
df.data = 7.2 print(df)
if name == ‘main’: main()
六、 树、二叉树、图（5题）
题31：使用Python编写实现二叉树前序遍历的函数preorder(root, res=[])。
难度：★★☆☆☆ 【参考答案】
def preorder(root, res=[]): if not root: return
res.append(root.val) preorder(root.left,res) preorder(root.right,res) return res
题32：使用Python实现一个二分查找函数。
难度：★★★☆☆
【参考答案】
def binary_search(num_list, x): num_list = sorted(num_list) left, right = 0, len(num_list) - 1 while left <= right:
mid = (left + right) // 2 if num_list[mid] > x: right = mid - 1 elif num_list[mid] < x: left = mid + 1 else:
return '待查元素{0}在排序后列表中的下标为：
{1}'.format(x, mid) return ‘待查找元素%s不存在指定列表中’ %x
题
33：编写Python函数maxDepth()，实现获取二叉树root最大深度。
难度：★★★★☆ 【参考答案】
def maxDepth(self, root): if root == None: return 0
return max(self.maxDepth(root.left),self.maxDepth(root.right))+1
题34：输入两棵二叉树Root1、Root2，判断Root2是否Root1的子结构（子树）。
难度：★★★★☆ 【参考答案】
class TreeNode:
def init(self, x): self.val = x self.left = None self.right = None
def istree(pRoot1, pRoot2): if not pRoot2: return True
if not pRoot1 and pRoot2: return False
if pRoot1.val != pRoot2.val: return False
elif pRoot1.val == pRoot2.val:
return istree(pRoot1.left, pRoot2.left) and istree(pRoot1.right, pRoot2.right)
def HasSubtree(pRoot1, pRoot2): if not pRoot1 or not pRoot2: return False
if pRoot1.val == pRoot2.val: return istree(pRoot1, pRoot2) else:
return HasSubtree(pRoot1.left, pRoot2) or HasSubtree(pRoot1.right, pRoot2)
题35：判断数组是否某棵二叉搜索树后序遍历的结果。
难度：★★★★☆
编写函数VerifySquenceOfBST(sequence)，实现以下功能：输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出True,否则输出False。假设输入数组的任意两个数字都互不相同。 【参考答案】
def VerifySquenceOfBST(sequence): if not sequence:
return False i= 0
for i in range(len(sequence)-1):
if sequence[i]>sequence[-1]: break
if i < len(sequence)-2:
for j in range(i+1,len(sequence)-1): if sequence[j]<sequence[-1]: return False left = True right = True if i>0:
left = VerifySquenceOfBST(sequence[:i]) elif i< len(sequence)-2:
right = VerifySquenceOfBST(sequence[i:-1]) return left and right
七、 文件操作（3题）
题36：计算test.txt中的大写字母数。
难度：★☆☆☆☆ 【参考答案】
import os os.chdir(‘D:\’)
with open(‘test.txt’) as test: count = 0
for i in test.read(): if i.isupper(): count+=1
print(count)
题37：补全缺失的代码。
难度：★★☆☆☆
def print_directory_contents(sPath): # 补充该函数的实现代码
print_directory_contents()函数接受文件夹路径名称作为输入参数，返回其中包含的所有子文件夹和文件的完整路径。
【参考答案】
def print_directory_contents(sPath): import os
for sChild in os.listdir(sPath):
sChildPath = os.path.join(sPath,sChild) if os.path.isdir(sChildPath):
print_directory_contents(sChildPath) else:
print(sChildPath)
题38：设计内存中的文件系统。
难度：★★★★☆
使用Python语言设计内存中的文件系统，实现以下命令。
ls：给定字符串格式的路径。如果是文件路径，则返回仅包含此文件名称的列表。如果是目录路径，则返回此目录中的文件和目录名称列表。输出结果（文件和目录名称）应按字典顺序排列。
mkdir：如果目录路径不存在，则应根据路径创建新目录。如果路径中的中间目录也不存在，则也应该创建它们。此函数具有void返回类型。 注：
可以假设所有文件或目录路径都是以/开头并且不以/结尾的绝对路径，除了路径只是“/”。 可以假设所有操作都将传递有效参数，用户不会尝试检索文件内容或列出不存在的目录或文件。 可以假设所有目录名称和文件名只包含小写字母，并且同一目录中不存在相同的名称。
【参考答案】
class FileNode(object): def init(self, name): self.isFolder = True self.childs = {} self.name = name self.data = “”
class FileSystem(object): def init(self):
self.root = FileNode(“/”)
def ls(self, path):
fd = self.lookup(path, False) if not fd: return [] if not fd.isFolder: return [fd.name] files = []
for file in fd.childs: files.append(file) files.sort() return files
def lookup(self, path, isAutoCreate): path = path.split(“/”) p = self.root for name in path: if not name: continue
if name not in p.childs: if isAutoCreate:
p.childs[name] = FileNode(name) else:
return None p = p.childs[name] return p
def mkdir(self, path):
self.lookup(path, True) # 测试
obj = FileSystem() obj.mkdir(“/test/path”) obj.ls(“/test”)
八、 网络编程（4题）
题39：请至少说出三条TCP和UDP协议的区别。
难度：★★☆☆☆
【参考答案】
（1） TCP面向连接（如打电话要先拨号建立连接）；UDP是无连接的，即发送数据之前不需要建立连
接。
（2） TCP提供可靠的服务。也就是说，通过TCP连接传送的数据，无差错，不丢失，不重复，且按序
到达；UDP尽最大努力交付，即不保证可靠交付。
（3） TCP面向字节流，实际上是TCP把数据看成一连串无结构的字节流；UDP是面向报文的，UDP没
有拥塞控制，因此网络出现拥塞不会使源主机的发送速率降低（对实时应用很有用，如IP电话，实时视频会议等）。
（4） 每一条TCP连接只能是点到点的；UDP支持一对一，一对多，多对一和多对多的交互通信。 （5） TCP首部开销20字节；UDP的首部开销小，只有8个字节。
（6） TCP的逻辑通信信道是全双工的可靠信道，UDP则是不可靠信道。
题40：请简述Cookie和Session的区别。
难度：★☆☆☆☆
【参考答案】
（1） Session在服务器端，Cookie在客户端（浏览器）。
（2） Session可以存放在文件、数据库或内存中，默认以文件方式保存。 （3） Session的运行依赖Session ID，而Session ID保存在Cookie中。因此，如果浏览器禁用了Cookie，
同时Session也会失效。
题41：请简述向服务器端发送请求时的GET方式与POST方式的区别。
难度：★☆☆☆☆
【参考答案】
（1） 在浏览器回退时GET方式没有变化，而POST会再次提交请求。 （2） GET请求会被浏览器主动缓存，而POST不会，除非手动设置。 （3） GET请求只能进行URL编码，而POST支持多种编码方式。
（4） GET请求参数会被完整保留在浏览器历史记录里，而POST中的参数不会被保留。 （5） 对参数的数据类型，GET只接受ASCII字符，而POST没有限制。
（6） GET比POST更不安全，因为参数直接暴露在URL上，所以不能用来传递敏感信息。
（7） GET参数通过URL传递且传送的参数是有长度限制的，POST放在Request body中且长度没有
限制。
（8） 对于GET方式的请求，浏览器会把http header和data一并发送出去，服务器响应200（返回数
据）；而对于POST，浏览器先发送header，服务器响应100 continue，浏览器再发送data，服务器响应200 ok（返回数据）。
题42：使用threading组件编写支持多线程的Socket服务端。
难度：★★★★☆
使用Python语言的threading组件编写支持多线程的Socket服务端，支持-x和-p参数，分别表示指定最大连接数和监听端口。
【参考答案】
import socket
import threading,getopt,sys,string
opts, args = getopt.getopt(sys.argv[1:], “hp:l:”,[“help”,“port=”,“list=”]) list=50 port=8001
for op, value in opts:
if op in (“-x”,“–maxconn”): list = int(value) elif op in (“-p”,“–port”): port = int(value)
def Config(client, address): try:
client.settimeout(500) buf = client.recv(2048) client.send(buf) except socket.timeout: print(‘time out’) client.close()
def main():
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.bind((‘localhost’, port)) sock.listen(list) while True:
client,address = sock.accept()
thread = threading.Thread(target=Config, args=(client, address)) thread.start()
if name == ‘main’: main()
九、 数据库编程（6题）
题43：简述数据库的第一、第二、第三范式的内容。
难度：★★☆☆☆
【参考答案】
范式是“符合某一种级别的关系模式的集合，表示一个关系内部各属性之间的联系的合理化程度”，实际上就是一张数据表的表结构所符合的某种设计标准的级别。
1NF的定义为：符合1NF的关系中的每个属性都不可再分。1NF是所有关系型数据库的最基本要求。 2NF在1NF的基础之上，消除了非主属性对于码的部分函数依赖。判断步骤如下。 第一步：找出数据表中所有的码。
第二步：根据第一步所得到的码，找出所有的主属性。
第三步：数据表中，除去所有的主属性，剩下的就都是非主属性了。 第四步：查看是否存在非主属性对码的部分函数依赖。
3NF在2NF的基础之上，消除了非主属性对于码的传递函数依赖。
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数Python工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年Python开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Python开发知识点，真正体系化！
由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新
如果你觉得这些内容对你有帮助，可以添加V获取：vip1024c （备注Python）
（1）Python所有方向的学习路线（新版）
这是我花了几天的时间去把Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。
最近我才对这些路线做了一下新的更新，知识体系更全面了。
（2）Python学习视频
包含了Python入门、爬虫、数据分析和web开发的学习视频，总共100多个，虽然没有那么全面，但是对于入门来说是没问题的，学完这些之后，你可以按照我上面的学习路线去网上找其他的知识资源进行进阶。
（3）100多个练手项目
我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了，只是里面的项目比较多，水平也是参差不齐，大家可以挑自己能做的项目去练练。
深知大多数Python工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！**
因此收集整理了一份《2024年Python开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
[外链图片转存中…(img-eFFSdZFQ-1711802160926)]
[外链图片转存中…(img-wA36XO49-1711802160926)]
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Python开发知识点，真正体系化！
由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新
如果你觉得这些内容对你有帮助，可以添加V获取：vip1024c （备注Python）
[外链图片转存中…(img-NM5ft9HF-1711802160926)]
（1）Python所有方向的学习路线（新版）
这是我花了几天的时间去把Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。
最近我才对这些路线做了一下新的更新，知识体系更全面了。
（2）Python学习视频
包含了Python入门、爬虫、数据分析和web开发的学习视频，总共100多个，虽然没有那么全面，但是对于入门来说是没问题的，学完这些之后，你可以按照我上面的学习路线去网上找其他的知识资源进行进阶。
（3）100多个练手项目
我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了，只是里面的项目比较多，水平也是参差不齐，大家可以挑自己能做的项目去练练。
7万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
