共计 8005 个字符，预计需要花费 21 分钟才能阅读完成。
首先这篇文章在我的《Python 数据结构》公众号已经提及，但是本篇文章提供的更多的实现方法，来发散大家的思维；同时为大家提供我的草稿 py 文件，大家可以关注《Python 数据结构》公众号后恢复 120 获取源代码。
1、一行代码实现 1 –100 之和？
sum(range(0, 100))
2、如何在一个函数内部修改全局变量？
num = 5
def func():
global num
num = 4
func()
print(num)
3、列出 5 个常用 Python 标准库？
os：提供了不少与操作系统相关联的函数
sys：通常用于命令行参数
re：正则匹配
math：数学运算
datetime：处理日期时间
4、如何合并两个字典？
name = {‘name’: ‘Gage’}
age = {‘age’: 25}
name.update(age)
print(name)
5、谈下 Python 的 GIL？
GIL 是 Python 的全局解释器锁，同一进程中假如有多个线程运行，一个线程在运行 Python 程序的时候会霸占 Python 解释器（加了一把锁即 GIL），使该进程内的其他线程无法运行，等该线程运行完后其他线程才能运行。如果线程运行过程中遇到耗时操作，则解释器锁解开，使其他线程运行。所以在多线程中，线程的运行仍是有先后顺序的，并不是同时进行。多进程中因为每个进程都能被系统分配资源，相当于每个进程有了一个 Python 解释器，所以多进程可以实现多个进程的同时运行，缺点是进程系统资源开销大。
6、Python 实现列表去重的方法？
num_list = [1, 3, 1, 5, 3, 6, 1]
print([num for num in set(num_list)])
7、fun(args,kwargs)中的 args,kwargs 什么意思？
如果你有其他语言基础的话，你应该听说过重载的概念，对，Python 为了避免这种繁琐的情况发送，引入了 args 和 kwargs；args 用来接受非键值对的数据，即元组类型，而 kwargs 则用来接受键值对数据，即字典类
8、Python2 和 Python3 的 range（100）的区别？
Python2 返回列表，Python3 返回迭代器，节约内存。
9、生成一个 16 位的随机字符串？
import string
print(”.join((random.choice(string.printable)) for i in range(16)))
————————————————-
X{|op?_gSM-ra%N\
10、一句话解释什么样的语言能够用装饰器?
函数可以作为参数传递的语言，可以使用装饰器。
11、Python 内建数据类型有哪些？
整型 –int
布尔型 –bool
字符串 –str
列表 –list
元组 –tuple
字典 –dict
12、简述面向对象中__new__和__init__区别？
1、__new__至少要有一个参数 cls，代表当前类，此参数在实例化时由 Python 解释器自动识别。
2、__new__必须要有返回值，返回实例化出来的实例，这点在自己实现__new__时要特别注意，可以 return 父类（通过 super(当前类名, cls)）__new__出来的实例，或者直接是 object 的__new__出来的实例。
3、__init__有一个参数 self，就是这个__new__返回的实例，__init__在__new__的基础上可以完成一些其它初始化的动作，__init__不需要返回值。
4、如果__new__创建的是当前类的实例，会自动调用__init__函数，通过 return 语句里面调用的__new__函数的第一个参数是 cls 来保证是当前类实例，如果是其他类的类名，；那么实际创建返回的就是其他类的实例，其实就不会调用当前类的__init__函数，也不会调用其他类的__init__函数。
13、简述 with 方法打开处理文件帮我我们做了什么？
打开文件在进行读写的时候可能会出现一些异常状况，如果按照常规的 f.open 写法，我们需要 try,except,finally，做异常判断，并且文件最终不管遇到什么情况，都要执行 finally f.close()关闭文件，with 方法帮我们实现了 finally 中 f.close（当然还有其他自定义功能，有兴趣可以研究 with 方法源码）。
14、列表 [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])
15、python 中生成随机整数、随机小数、0–1 之间小数方法？
import random
print(random.randint(1, 10)) # 随机整数
print(random.random()) # 0- 1 随机小数
print(random.uniform(2, 6)) # 指定随机小数
16、避免转义给字符串加哪个字母表示原始字符串？
b’input\n’ # bytes 字节符，打印以 b 开头。
输出：
b’input\n’
——-
r’input\n’ # 非转义原生字符，经处理 ’\n’ 变成了 ’\\’ 和 ’n’。也就是 \n 表示的是两个字符，而不是换行。
输出：
‘input\\n’
——-
u’input\n’ # unicode 编码字符，python3 默认字符串编码方式。
输出：
‘input\n’
17、<div class=”nam”>Python</div>，用正则匹配出标签里面的内容（“中国”），其中 class 的类名是不确定的。
import re
s = ‘<div class=”nam”>Python</div>’
print(re.findall(r'<div class=”.*”>(.*?)</div>’, s))
18、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
19、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))
21、Python2 和 Python3 区别？列举 5 个
1. 去除了 <>，全部改用!=
2.xrange() 改名为 range()
3. 内存操作 cStringIO 改为 StringIO
4. 加入 nonlocal 作用：可以引用外层非全局变量
5.zip()、map()和 filter()都返回迭代器，而不是生成器，更加节约内存
22、列出 Python 中可变数据类型和不可变数据类型，为什么？
1、可变数据类型：list、dict、set
2、不可变数据类型：int/float、str、tuple
3、原理：可变数据类型即公用一个内存空间地址，不可变数据类型即每产生一个对象就会产生一个内存地址
23、dict 的内部实现？
在 Python 中，字典是通过哈希表实现的。也就是说，字典是一个数组，而数组的索引是键经过哈希函数处理后得到的。哈希函数的目的是使键均匀地分布在数组中。由于不同的键可能具有相同的哈希值，即可能出现冲突，高级的哈希函数能够使冲突数目最小化。
24、s = “ajldjlajfdljfddd”，去重并从小到大排序输出 ”adfjl”？
s1 = “ajldjlajfdljfddd”
print(”.join(sorted(set(s1))))
25、用 lambda 函数实现两个数相乘？
mul = lambda x, y: x*y
print(mul(2, 4))
26、字典根据键从小到大排序？
info = {‘name’: ‘Gage’, ‘age’: 25, ‘sex’: ‘man’}
print(sorted(info.items(), key=lambda x: x[0]))
27、Python 获取当前日期？
import time
import datetime
print(datetime.datetime.now())
print(time.strftime(‘%Y-%m-%d %H:%M:%S’))
28、获取请求头的参数？
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
29、例举五条 PEP8 规范
不要在行尾加分号, 也不要用分号将两条命令放在同一行
不要使用反斜杠连接行
不要在返回语句或条件语句中使用括号
顶级定义之间空 2 行, 方法定义之间空 1 行，顶级定义之间空两行
如果一个类不继承自其它类, 就显式的从 object 继承
30、Python 语言的运行机制
31、Fibonacci 数列
def fab(n):
a, b = 0, 1
while n:
yield b
a, b = b, a+b
n -= 1
32、Python 三目运算
# 若果 a>b 成立 就输出 a-b 否则 a+b
h = a-b if a>b else a+b
33、单例模式
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
34、正则匹配优先级
35、递归
def digui(n):
if n == 1:
return 1
else:
return (n * digui(n-1))
36、统计字符串每个单词出现的次数
from collections import Counter
s3 = “kjalfj;ldsjafl;hdsllfdhg;lahfbl;hl;ahlf;h”
print(Counter(s3))
37、正则 re.complie 作用
re.compile 是将正则表达式编译成一个对象，加快速度，并重复使用
38、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)))
39、列表推导式求列表所有奇数并构造新列表，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
41、两个列表 [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)
42、用 python 删除文件和用 linux 命令删除文件方法
python：os.remove(文件名)
linux: rm 文件名
43、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”)
44、写一段自定义异常代码
#自定义异常用 raise 抛出异常
def fn():
try:
for i in range(5):
if i>2:
raise Exception(“ 数字大于 2 了 ”)
except Exception as ret:
print(ret)
fn() ==》数字大于 2 了
45、正则表达式匹配中，（.）和（.?）匹配区别？
#（.*）是贪婪匹配，会把满足正则的尽可能多的往后匹配
#（.*?）是非贪婪匹配，会把满足正则的尽可能少匹配
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> 呵呵 ’]
非贪婪匹配 [‘ 哈哈 ’, ‘ 呵呵 ’]
46、[[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])
47、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
48、举例说明异常模块中 try except else finally 的相关意义
try..except..else 没有捕获到异常，执行 else 语句
try..except..finally 不管是否捕获到异常，都执行 finally 语句
49、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)]
51、a=” 张明 98 分 ”，用 re.sub，将 98 替换为 100
import re
a=” 张明 98 分 ”
ret=re.sub(r”\d+”,”100″,a)
print(ret)
52、a=”hello” 和 b =” 你好 ” 编码成 bytes 类型
a=b”hello”
b=” 你好 ”.encode()
print(a,b)
print(type(a),type(b))
53、[1,2,3]+[4,5,6]的结果是多少？
print([1,2,3]+[4,5,6]) # [1, 2, 3, 4, 5, 6]
54、提高 python 运行效率的方法
1、使用生成器，因为可以节约大量内存
2、循环代码优化，避免过多重复代码的执行
3、核心模块用 Cython PyPy 等，提高效率
4、多进程、多线程、协程
5、多个 if elif 条件判断，可以把最有可能先发生的条件放到前面写，这样可以减少程序判断的次数，提高效率
55、遇到 bug 如何处理
1、细节上的错误，通过 print（）打印，能执行到 print（）说明一般上面的代码没有问题，分段检测程序是否有问题，如果是 js 的话可以 alert 或 console.log
2、如果涉及一些第三方框架，会去查官方文档或者一些技术博客。
3、对于 bug 的管理与归类总结，一般测试将测试出的 bug 用 teambin 等 bug 管理工具进行记录，然后我们会一条一条进行修改，修改的过程也是理解业务逻辑和提高自己编程逻辑缜密性的方法，我也都会收藏做一些笔记记录。
4、导包问题、城市定位多音字造成的显示错误问题
56、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])
57、两数相除保留两位小数
print(round(5/3, 2))
58、正则匹配，匹配日期 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’))
59、使用 pop 和 del 删除字典中的 ”name” 字段，dic={“name”:”zs”,”age”:18}
dic = {“name”: “zs”, “age”: 18}
dic.pop(‘name’)
del dic[‘age’]
print(dic) # {}
60、简述多线程、多进程
进程是资源（CPU、内存等）分配的基本单位，它是程序执行时的一个实例。
线程是程序执行时的最小单位，它是进程的一个执行流。
进程有自己的独立地址空间，每启动一个进程，系统就会为它分配地址空间，建立数据表来维护代码段、堆栈段和数据段，这种操作非常昂贵
线程是共享进程中的数据的，使用相同的地址空间，因此 CPU 切换一个线程的花费远比进程要小很多，同时创建一个线程的开销也比进程要小很多