120 道 Python 面试笔试题汇总（上篇）

首先这篇文章在个人《Python数据结构》公众号已经说起，可是本篇文章提供了更为高级的解法，来发散你们的思惟；同时为你们提供个人草稿py文件，你们能够关注《Python数据结构》公众号后恢复 120 获取源代码。

一、一行代码实现1--100之和？

sum(range(0, 100))

二、如何在一个函数内部修改全局变量？

num = 5
def func():
    global num
    num = 4
func()
print(num)

三、 列出5个经常使用Python标准库？

os：提供了很多与操做系统相关联的函数
sys：一般用于命令行参数
re：正则匹配
math：数学运算
datetime：处理日期时间

4 、如何合并两个字典？

name = {'name': 'Gage'}
age = {'age': 25}
name.update(age)
print(name)

五、谈下Python的GIL？

GIL是Python的全局解释器锁，同一进程中假若有多个线程运行，一个线程在运行Python程序的时候会霸占Python解释器（加了一把锁即GIL），使该进程内的其余线程没法运行，等该线程运行完后其余线程才能运行。若是线程运行过程当中遇到耗时操做，则解释器锁解开，使其余线程运行。因此在多线程中，线程的运行还是有前后顺序的，并非同时进行。
多进程中由于每一个进程都能被系统分配资源，至关于每一个进程有了一个Python解释器，因此多进程能够实现多个进程的同时运行，缺点是进程系统资源开销大。

六、Python实现列表去重的方法？

num_list = [1, 3, 1, 5, 3, 6, 1]
print([num for num in set(num_list)])

七、fun(args,kwargs)中的args,kwargs什么意思？

若是你有其余语言基础的话，你应该据说太重载的概念，对，Python为了不这种繁琐的状况发送，引入了args和kwargs；args用来接受非键值对的数据，即元组类型，而kwargs则用来接受键值对数据，即字典类

八、Python2和Python3的range（100）的区别？

Python2返回列表，Python3返回迭代器，节约内存。

九、生成一个16位的随机字符串？

import string
print(''.join((random.choice(string.printable)) for i in range(16)))
-------------------------------------------------
X{|op?_gSM-ra%N\

十、一句话解释什么样的语言可以用装饰器?

函数能够做为参数传递的语言，可使用装饰器。

十一、Python内建数据类型有哪些？

整型--int
布尔型--bool
字符串--str
列表--list
元组--tuple
字典--dict

十二、简述面向对象中__new__和__init__区别？

一、__new__至少要有一个参数cls，表明当前类，此参数在实例化时由Python解释器自动识别。
二、__new__必需要有返回值，返回实例化出来的实例，这点在本身实现__new__时要特别注意，能够return父类（经过super(当前类名, cls)）__new__出来的实例，或者直接是object的__new__出来的实例。
三、__init__有一个参数self，就是这个__new__返回的实例，__init__在__new__的基础上能够完成一些其它初始化的动做，__init__不须要返回值。
四、若是__new__建立的是当前类的实例，会自动调用__init__函数，经过return语句里面调用的__new__函数的第一个参数是cls来保证是当前类实例，若是是其余类的类名，；那么实际建立返回的就是其余类的实例，其实就不会调用当前类的__init__函数，也不会调用其余类的__init__函数。

1三、简述with方法打开处理文件帮我咱们作了什么？

打开文件在进行读写的时候可能会出现一些异常情况，若是按照常规的f.open写法，咱们须要try,except,finally，作异常判断，而且文件最终无论遇到什么状况，都要执行finally f.close()关闭文件，with方法帮咱们实现了finally中f.close（固然还有其余自定义功能，有兴趣能够研究with方法源码）。

1四、列表[1,2,3,4,5],请使用map()函数输出[1,4,9,16,25]，并使用列表推导式提取出大于10的数，最终输出[16,25]？

num_list = [1, 2, 3, 4, 5]
print([x for x in list(map(lambda x: x * x, num_list)) if x > 10])

1五、python中生成随机整数、随机小数、0--1之间小数方法？

import random
print(random.randint(1, 10))  # 随机整数
print(random.random())  # 0-1随机小数
print(random.uniform(2, 6)) # 指定随机小数

1六、避免转义给字符串加哪一个字母表示原始字符串？

b'input\n' # bytes字节符，打印以b开头。
输出：
b'input\n'
-------
r'input\n' # 非转义原生字符，经处理'\n'变成了'\\'和'n'。也就是\n表示的是两个字符，而不是换行。
输出：
'input\\n'
-------
u'input\n' # unicode编码字符，python3默认字符串编码方式。
输出：
'input\n'

1七、<div class="nam">Python</div>，用正则匹配出标签里面的内容（“中国”），其中class的类名是不肯定的。

import re
s = '<div class="nam">Python</div>'
print(re.findall(r'<div class=".*">(.*?)</div>', s))

1八、Python中断言方法举例？

age = 10
assert 0 < age < 10
--------------------
 Traceback (most recent call last):
  File "F:/MxOnline/110/exam.py", line 69, in <module>
    assert 0 < age < 10
AssertionError

1九、dict中fromkeys的用法

keys = ('info',)
print(dict.fromkeys(keys, ['Gage', '25', 'man']))

20、请用正则表达式输出汉字

import re
a = "not 404 found 中国 2018 我爱你"
r1 = '[a-zA-Z0-9’!"#$%&\'()*+,-./:;<=>?@，。?★、…【】《》？“”‘’！[\\]^_`{|}~]+\s?'
print(re.sub(r1, '', a))

2一、Python2和Python3区别？列举5个

1.去除了<>，所有改用!=
 2.xrange() 更名为range()
 3.内存操做cStringIO改成StringIO
 4.加入nonlocal 做用：能够引用外层非全局变量
 5.zip()、map()和filter()都返回迭代器，而不是生成器，更加节约内存

2二、列出Python中可变数据类型和不可变数据类型，为何？

一、可变数据类型：list、dict、set
 二、不可变数据类型：int/float、str、tuple
 三、原理：可变数据类型即公用一个内存空间地址，不可变数据类型即每产生一个对象就会产生一个内存地址

2三、dict的内部实现？

在Python中，字典是经过哈希表实现的。也就是说，字典是一个数组，而数组的索引是键通过哈希函数处理后获得的。哈希函数的目的是使键均匀地分布在数组中。因为不一样的键可能具备相同的哈希值，便可能出现冲突，高级的哈希函数可以使冲突数目最小化。

2四、s = "ajldjlajfdljfddd"，去重并从小到大排序输出"adfjl"？

s1 = "ajldjlajfdljfddd"
print(''.join(sorted(set(s1))))

2五、用lambda函数实现两个数相乘？

mul = lambda x, y: x*y
print(mul(2, 4))

2六、字典根据键从小到大排序？

info = {'name': 'Gage', 'age': 25, 'sex': 'man'}
print(sorted(info.items(), key=lambda x: x[0]))

2七、Python获取当前日期？

import time
import datetime
print(datetime.datetime.now())
print(time.strftime('%Y-%m-%d %H:%M:%S'))

2八、获取请求头的参数？

from urllib.parse import urlparse, parse_qs
s2 = "/get_feed_list?version_name=5.0.9.0&device_id=12242channel_name=google"
def spiltline(value):
    url = {'site': urlparse(value).path}
    url.update(parse_qs(urlparse(value).query))
    return url

2九、例举五条PEP8 规范

不要在行尾加分号, 也不要用分号将两条命令放在同一行
不要使用反斜杠链接行
不要在返回语句或条件语句中使用括号
顶级定义之间空2行, 方法定义之间空1行，顶级定义之间空两行
若是一个类不继承自其它类, 就显式的从object继承

30、Python语言的运行机制

3一、Fibonacci数列

def fab(n):
    a, b = 0, 1
    while n:
        yield b
        a, b = b, a+b
        n -= 1

3二、Python三目运算

# 若果 a>b 成立  就输出  a-b  不然 a+b
h = a-b if a>b else a+b

3三、单例模式

class Single(object):
    __isstance = None
    __first_init = False
    def __new__(cls, *args, **kwargs):
        if not cls.__isstance:
            cls.__isstance = object.__new__(cls)
        return cls.__isstance
    def __init__(self, name):
        if not self.__first_init:
            self.name = name
            Singleton.__first_init = True

3四、正则匹配优先级

3五、递归

def digui(n):
    if n == 1:
        return 1
    else:
        return (n * digui(n-1))

3六、统计字符串每一个单词出现的次数

from collections import Counter
s3 = "kjalfj;ldsjafl;hdsllfdhg;lahfbl;hl;ahlf;h"
print(Counter(s3))

3七、正则re.complie做用

re.compile是将正则表达式编译成一个对象，加快速度，并重复使用

3八、filter方法求出列表全部奇数并构造新列表，a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(list(filter(lambda x: x % 2, a)))

3九、列表推导式求列表全部奇数并构造新列表，a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

print([x for x in a if x % 2])

40、a=（1，）b=(1)，c=("1") 分别是什么类型的数据？

print(type((1, ))) # tuple
print(type((1))) # int
print(type(("1"))) # str

4一、两个列表[1,5,7,9]和[2,2,6,8]合并为[1,2,2,3,6,7,8,9]

l1 = [1, 5, 7, 9]
l2 = [2, 2, 6, 8]
l1.extend(l2)

4二、用python删除文件和用linux命令删除文件方法

python：os.remove(文件名)
linux: rm 文件名

4三、logging模块的使用？

import logging
logging.basicConfig(level = logging.INFO,format = '%(asctime)s - %(name)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

logger.info("Start print log")
logger.debug("Do something")
logger.warning("Something maybe fail.")
logger.info("Finish")

4四、写一段自定义异常代码

#自定义异经常使用raise抛出异常
def fn():
    try:
        for i in range(5):
            if i>2:
                raise Exception("数字大于2了")
    except Exception as ret:
        print(ret)
fn()            ==》数字大于2了

4五、正则表达式匹配中，（.）和（.?）匹配区别？

#（.*）是贪婪匹配，会把知足正则的尽量多的日后匹配
#（.*?）是非贪婪匹配，会把知足正则的尽量少匹配
s = "<a>哈哈</a><a>呵呵</a>"
import re
res1 = re.findall("<a>(.*)</a>", s)
print("贪婪匹配", res1)
res2 = re.findall("<a>(.*?)</a>", s)
print("非贪婪匹配", res2)
-------------------------
输出：
贪婪匹配 ['哈哈</a><a>呵呵']
非贪婪匹配 ['哈哈', '呵呵']

4六、[[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])

4七、x="abc",y="def",z=["d","e","f"],分别求出x.join(y)和x.join(z)返回的结果

#join()括号里面的是可迭代对象，x插入可迭代对象中间，造成字符串，结果一致
x="abc"
y="def"
z=["d","e","f"]
a=x.join(y)
b=x.join(z)
print(a)
print(b)
均输出：
dabceabcf

4八、举例说明异常模块中try except else finally的相关意义

try..except..else没有捕获到异常，执行else语句
try..except..finally无论是否捕获到异常，都执行finally语句

4九、python中交换两个数值

a,b=1,2
a,b=b,a

50、举例说明zip()函数用法

list1 = [1, 2, 3, 5]
list2 = [4, 5, 6]
zipped = zip(list1, list2)
# print(list(zipped))  # [(1, 4), (2, 5), (3, 6)]
# print(list(zip(*zipped)))  # [(1, 2, 3), (4, 5, 6)]

5一、a="张明 98分"，用re.sub，将98替换为100

import re
a="张明 98分"
ret=re.sub(r"\d+","100",a)
print(ret)

5二、a="hello"和b="你好"编码成bytes类型

a=b"hello"        
b="你好".encode()
print(a,b)
print(type(a),type(b))

5三、[1,2,3]+[4,5,6]的结果是多少？

print([1,2,3]+[4,5,6]) # [1, 2, 3, 4, 5, 6]

5四、提升python运行效率的方法

一、使用生成器，由于能够节约大量内存
二、循环代码优化，避免过多重复代码的执行
三、核心模块用Cython  PyPy等，提升效率
四、多进程、多线程、协程
五、多个if elif条件判断，能够把最有可能先发生的条件放到前面写，这样能够减小程序判断的次数，提升效率

5五、遇到bug如何处理

一、细节上的错误，经过print（）打印，能执行到print（）说明通常上面的代码没有问题，分段检测程序是否有问题，若是是js的话能够alert或console.log
二、若是涉及一些第三方框架，会去查官方文档或者一些技术博客。
三、对于bug的管理与归类总结，通常测试将测试出的bug用teambin等bug管理工具进行记录，而后咱们会一条一条进行修改，修改的过程也是理解业务逻辑和提升本身编程逻辑缜密性的方法，我也都会收藏作一些笔记记录。
四、导包问题、城市定位多音字形成的显示错误问题

5六、list=[2,3,5,4,9,6]，从小到大排序，不准用sort，输出[2,3,4,5,6,9]

def quicksort(list):
    if len(list)<2:
        return list
    else:
        midpivot = list[0]
        lessbeforemidpivot = [i for i in list[1:] if i<=midpivot]
        biggerafterpivot = [i for i in list[1:] if i > midpivot]
        finallylist = quicksort(lessbeforemidpivot)+[midpivot]+quicksort(biggerafterpivot)
        return finallylist

print quicksort([2,3,5,4,9,6])

5七、两数相除保留两位小数

print(round(5/3, 2))

5八、正则匹配，匹配日期2018-03-20

import re
print(re.findall('((?:(?:[2468][048]00|[13579][26]00|[1-9]\d0[48]|[1-9]\d[2468][048]|[1-9]\d[13579][26])/(?:0?2/(?:0[1-9]|0?[1-9](?=\D)|[12]\d)))|(?:(?:[12]\d{3})/(?:(?:0?2/(?:0[1-9]|0?[1-9](?=\D)|1\d|2[0-8]))|(?:0?[3578]/(?:0[1-9]|0?[1-9](?=\D)|[12]\d|3[01]))|(?:0?[469]/(?:0[1-9]|0?[1-9](?=\D)|[12]\d|30))|(?:1[02]/(?:0[1-9]|0?[1-9](?=\D)|[12]\d|3[01]))|(?:11/(?:0[1-9]|0?[1-9](?=\D)|[12]\d|30))|(?:0?1/(?:0[1-9]|0?[1-9](?=\D)|[12]\d|3[01])))))', 'Date：2018/03/20'))

5九、使用pop和del删除字典中的"name"字段，dic={"name":"zs","age":18}

dic = {"name": "zs", "age": 18}
dic.pop('name')
del dic['age']
print(dic) # {}

60、简述多线程、多进程

进程是资源（CPU、内存等）分配的基本单位，它是程序执行时的一个实例。
线程是程序执行时的最小单位，它是进程的一个执行流。
进程有本身的独立地址空间，每启动一个进程，系统就会为它分配地址空间，创建数据表来维护代码段、堆栈段和数据段，这种操做很是昂贵
线程是共享进程中的数据的，使用相同的地址空间，所以CPU切换一个线程的花费远比进程要小不少，同时建立一个线程的开销也比进程要小不少