- duoniu cm
1. 写一个冒泡排序
def Bubblesort(list):
for i in range(0, len(list)-1):
for j in range(0, len(list)-1-i):
list[j] > list[j+1]
list[j],list[j+1] = list[j+1], list[j]
return list2. 写一个快速排序
def Quicksort(myList,start,end):
if start < end:
i,j = start,end
base = myList[i]
while i<j:
while (i<j) and (myList[j] >= base):
j -= 1
myList[i] = myList[j]
while (i<j) and (myList[i] <= base):
i += 1
myList[j] = myList[i]
myList[i] = base
Quicksort(myList,start,i-1)
Quicksort(myList,j+1,end)
return myList3. 二分法查找（递归，非递归）
# 递归
def bs1(nums, target):
if not nums:
return False
middle = len(nums)//2
if nums[middle] > target:
return bs1(nums[:middle], target)
elif nums[middle] < target:
return bs1(nums[middle + 1:], target)
else:
return middle
# 非递归
def bs2(nums, target):
start = 0
end = len(nums)-1
while start <= end:
middle = (start+end)//2
if nums[middle] > target:
end = middle - 1
elif nums[middle] < target:
start = middle + 1
else:
return middle
return False4. 链表反转
def reverse(self,head):
if head is None:
return None
p = head
cur = None
pre = None
while p is not None:
cur = p.next
p.next = pre
pre = p
p = cur
return pre- yunfu kj
1. 给定一个数组 a=[1,1,2,3,3,5]和一个整数n=1,找出出现大于这个整数次数的数组[1,3]
hint: 主要考察列表推导式
a = [1,1,2,3,3,5]
n = 1
b = [x for x in a if a.count(x) > n]
c = list(set(b))
print(c)2. "get_user"转换为小驼峰字符串"getUser", 将"get_used_my_id"转换为"getUsedMyId"
hint：先把'_'去掉并把str转为list；将第一个单词保持小写；其余单词首字母大写；list转为str
def convert(one_string, space_character):
string_list = str(one_string).split(space_character)
first = string_list[0].lower()
others = string_list[1:]
others_capital = [word.capitalize() for word in others]
others_capital[0:0] =[first]
final = ''.join(others_capital)
return final
print(convert('get_user','_')) # getUser
print(convert('get_used_my_id','_')) # getUsedMyId3. n=4，打印出高度为4的三角形（用*表示）
# 打印正三角
for i in range(5):
for j in range(0,5-i):
print(end=' ')
for k in range(5-i,5):
print('*',end=' ')
print('') *
* *
* * *
* * * *
- shuwang kj
1. 字符串'1.2.3.4.5'转换为'5|4|3|2|1'
hint: split()用法和join()用法
a = '1.2.3.4.5'
b = a.split('.')
b = b[::-1]
c = '|'.join(b)
print(c)2. python3.x和python2.x中，import包搜索路径顺序
hint: 没什么区别，但在python3.3以后引入了命名空间包
其特性如下：
1.优先级最低，在已有版本所有的import规则之后；
2.要导入的文件夹中不能有__init__.py文件
3.主要依赖于sys.path中从左到右的搜索顺序
当你导入一个模块，Python 解析器对模块位置的搜索顺序是：
1、当前目录
2、如果不在当前目录，Python 则搜索在 shell 变量 PYTHONPATH 下的每个目录。
3、如果都找不到，Python会察看默认路径。UNIX下，默认路径一般为/usr/local/lib/python/。
模块搜索路径存储在 system 模块的 sys.path 变量中。变量里包含当前目录，PYTHONPATH和由安装过程决定的默认目录。3. python中用正则表达式匹配时间信息
import re
t = '19:10:48'
m = re.match(r'(.*):(.*):(.*)', t)
print(m.groups()) # ('19', '10', '48')
t = '23:59:08'
p = re.compile(r'^(0?[0-9]|1[0-9]|2[0-3]):(0?[0-9]|[1-5][0-9]):(0?[0-9]|[1-5][0-9])$')
s = p.search(t)
print(s.groups()) # ('23', '59', '08')4. range和xrange区别，用python仿写一个xrange函数
After September,
- XDYH
一面基础笔试题
1.list切片
2.字符串逆序（尽可能多的方法）
3.lambda函数
4.单引号，双引号，三引号区别
5.补充缺失的代码
def print_directory_contents(sPath):
"""
这个函数接受文件夹的名称作为输入参数，
返回该文件夹中文件的路径，
以及其包含文件夹中文件的路径。
"""
# 补充代码
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)6.阅读下面的代码，写出A0，A1至An的最终值。
A0 = dict(zip(('a','b','c','d','e'),(1,2,3,4,5)))
A1 = range(10)
A2 = [i for i in A1 if i in A0]
A3 = [A0[s] for s in A0]
A4 = [i for i in A1 if i in A3]
A5 = {i:i*i for i in A1}
A6 = [[i,i*i] for i in A1]
A0 = {'a': 1, 'c': 3, 'b': 2, 'e': 5, 'd': 4}
A1 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
A2 = []
A3 = [1, 3, 2, 5, 4]
A4 = [1, 2, 3, 4, 5]
A5 = {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}
A6 = [[0, 0], [1, 1], [2, 4], [3, 9], [4, 16], [5, 25], [6, 36], [7, 49], [8, 64], [9, 81]]7.Python和多线程（multi-threading）。这是个好主意码？列举一些让Python代码以并行方式运行的方法。
Python并不支持真正意义上的多线程。Python中提供了多线程包，但是如果你想通过多线程提高代码的速度，使用多线程包并不是个好主意。Python中有一个被称为Global Interpreter Lock（GIL）的东西，它会确保任何时候你的多个线程中，只有一个被执行。线程的执行速度非常之快，会让你误以为线程是并行执行的，但是实际上都是轮流执行。经过GIL这一道关卡处理，会增加执行的开销。这意味着，如果你想提高代码的运行速度，使用threading包并不是一个很好的方法。
不过还是有很多理由促使我们使用threading包的。如果你想同时执行一些任务，而且不考虑效率问题，那么使用这个包是完全没问题的，而且也很方便。但是大部分情况下，并不是这么一回事，你会希望把多线程的部分外包给操作系统完成（通过开启多个进程），或者是某些调用你的Python代码的外部程序（例如Spark或Hadoop），又或者是你的Python代码调用的其他代码（例如，你可以在Python中调用C函数，用于处理开销较大的多线程工作）。
8.下面代码会输出什么：
def f(x,l=[]):
for i in range(x):
l.append(i*i)
print l
f(2)
f(3,[3,2,1])
f(3)
答案：
[0, 1] [3, 2, 1, 0, 1, 4] [0, 1, 0, 1, 4]
第一个函数调用十分明显，for循环先后将0和1添加至了空列表l中。l是变量的名字，指向内存中存储的一个列表。
第二个函数调用在一块新的内存中创建了新的列表。l这时指向了新生成的列表。之后再往新列表中添加0、1、2和4。很棒吧。
第三个函数调用的结果就有些奇怪了。它使用了之前内存地址中存储的旧列表。这就是为什么它的前两个元素是0和1了。
9.这两个参数是什么意思：*args，**kwargs？我们为什么要使用它们？
如果我们不确定要往函数中传入多少个参数，或者我们想往函数中以列表和元组的形式传参数时，那就使要用*args；
如果我们不知道要往函数中传入多少个关键词参数，或者想传入字典的值作为关键词参数时，那就要使用**kwargs。
10.下面这些是什么意思：@classmethod, @staticmethod, @property？
这些都是装饰器（decorator）。装饰器是一种特殊的函数，要么接受函数作为输入参数，并返回一个函数，要么接受一个类作为输入参数，并返回一个类。
@标记是语法糖（syntactic sugar），可以让你以简单易读得方式装饰目标对象。
11.写一个单例模式，保证线程安全
12.简要描述Python的垃圾回收机制（garbage collection）
- Python在内存中存储了每个对象的引用计数（reference count）。如果计数值变成0，那么相应的对象就会小时，分配给该对象的内存就会释放出来用作他用。
- 偶尔也会出现
引用循环（reference cycle）。垃圾回收器会定时寻找这个循环，并将其回收。举个例子，假设有两个对象o1和o2，而且符合o1.x == o2和o2.x == o1这两个条件。如果o1和o2没有其他代码引用，那么它们就不应该继续存在。但它们的引用计数都是1。 - Python中使用了某些启发式算法（heuristics）来加速垃圾回收。例如，越晚创建的对象更有可能被回收。对象被创建之后，垃圾回收器会分配它们所属的代（generation）。每个对象都会被分配一个代，而被分配更年轻代的对象是优先被处理的。
13.将下面的函数按照执行效率高低排序。它们都接受由0至1之间的数字构成的列表作为输入。这个列表可以很长。一个输入列表的示例如下：[random.random() for i in range(100000)]。你如何证明自己的答案是正确的。
def f1(lIn):
l1 = sorted(lIn) # 100000
l2 = [i for i in l1 if i<0.5] # 50000
return [i*i for i in l2] # 50000
def f2(lIn):
l1 = [i for i in lIn if i<0.5] # 50000
l2 = sorted(l1) # 50000
return [i*i for i in l2] # 50000
def f3(lIn):
l1 = [i*i for i in lIn] # 100000
l2 = sorted(l1) # 100000
return [i for i in l1 if i<(0.5*0.5)] # 100000
f2>f1>f3，原因如注释所写
14.赋值，深拷贝，浅拷贝区别