2018年python基础面试题总结（持续更新）

 

• 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 list

2. 写一个快速排序

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 myList

3. 二分法查找（递归，非递归）

# 递归
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 False

4. 链表反转

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','_')) # getUsedMyId

3. 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函数

 

• 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)

答案：