前言
最近python是真的火，加上有许多公司都在招python方面的程序员，而网上的面试题又总是千篇一律复制粘贴，在这里博主打算自己写一些python的一些面试题一些是我遇到的，觉得还不错，一些是python必须知道的一些知识点。相应的，自己也在python这条路上，努力做的更好，也希望在测试自己同时帮到更多的小白和从别的语言转过来的同行们，如果大家喜欢，我会在以后继续拓展更多的面试题的篇幅，在基础篇中，我将仅仅提到关于python的基础。在python基础中，很明显我们需要了解python的特性，像面向对象思想，字符串的操作，推导式，实例化，多线程多进程以及初始化这些都是必须了解的。
1.在python中，如何交换两个变量的值？
这个问题，考了python特殊的语法，也就是a, b = b, a，这个表达式，也是其他语言所没有的，是只有python自带的。
2. 字符串的拼接–如何高效的拼接两个字符串？
我们都知道python中，拼接字符串可以用”+”来拼接，然而这个方法并不是高效的，因为如果需要拼接的字符串有很多(n个)的情况下，使用”+”的话，python解释器会申请n-1次内存空间，然后进行拷贝，因为字符串在python中是不可变的，所以当进行拼接的时候，会需要申请一个新的内存空间。所以，正确答案是，使用.join(list),因为它只使用了一次内存空间。
3. list = [a,a,a,1,2,3,4,5,A,B,C]提取出”12345”
这个考点考了python的解压赋值的知识点，即 a,b,c,*middle, e,f,g = list, *middle = [1,2,3,4,5]。注意，解压赋值提取出来的是列表。
4. python的面向对象？
类是对象的蓝图和模板，而对象是类的实例。类是抽象的概念，而对象是具体的东西。在面向对象编程的世界中，一切皆为对象，对象都有属性和行为，每个对象都是独一无二的，而且对象一定属于某个类（型）。当我们把一大堆拥有共同特征的对象的静态特征（属性）和动态特征（行为）都抽取出来后，就可以定义出一个叫做“类”的东西。
面向对象有三大支柱：封装、继承和多态。
5. 什么是元类？
同上，我们讲到在python中皆为对象，而元类即是用来创建类的”东西”。类也是元类的实例。而在python中，它们要么是类的实例，要么是元类的实例，除了type。type实际上是它自己的元类。元类主要的用途是用来创建API,比如django的ORM。
6.python的search和match知识点？
search和match都在re模块中，match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None。search匹配整个字符串，直到找到一个匹配。
7. python中深浅拷贝的区别？
浅拷贝没有拷贝子对象，所以原对象发生改变，其子对象也发生了改变，而深拷贝拷贝了子对象，原对象发生改变，其本身也不会改变。具体的可以看我之前的博客python深浅copy一分钟掌握
8. 类的初始化：new() 和 init()?
- new()方法用来实例化最终的类对象，在类创建之前被调用，它在类的主体被执行完后开始执行。
- init()方法是在类被创建之后被调用，用来执行其他的一些输出化工作
当我们构造元类的时候，通常只需要定一个init()或new()方法，但不是两个都定义。但是，如果需要接受其他的关键词参数的话，这两个方法就要同时提供，并且都要提供对应的参数签名。
9.类的初始化？
B类继承A类，在B类自己的基础上可以调用A类所有方法，如果A,B同时拥有init， B会改写A中的init方法，A类的方法失效。
Super函数可以调用A类中的属性，B类中有同名属性时，覆盖A类中的同名属性。但调用函数时，总是先查找它自身的定义，如果没有定义，则顺着继承链向上插座，知道在某个父类中找到为止。
B类 init参数需大于或等于A 父类的init方法，因为super初始化了，参数量为父类参数量。
10.多线程？
多线程可以共享进程的内存空间，因此要实现多个线程之间的通信相对简单，比如设置一个全局变量，多个线程共享这个全局变量。但是当多个线程共享一个资源的时候，可能导致程序失效甚至崩溃，如果一个资源被多个线程竞争使用，那么对临界资源的访问需要加上保护，否则会处于“混乱”状态，比如银行存100块钱，最终很可能存不到一百块多个线程得到的余额状态都是0，所有操作都是在0上面加1，从而导致错误结果。这种情况下，锁就可以得到用处了。多线程并不能发挥cpu多核特性，因为python解释器有一个gil锁，任何线程执行前必须获得GIL锁，然后每执行100条字节码，解释器就会自动释放GIL锁让别的线程有机会执行。
11.python内存管理？
python内部使用引用计数，来保持追踪内存中的对象，Python内部记录了对象有多少个引用，即引用计数，当对象被创建时就创建了一个引用计数，当对象不再需要时，这个对象的引用计数为0时，它被垃圾回收。所有这些都是自动完成，不需要像C一样，人工干预，从而提高了程序员的效率和程序的健壮性。
12.python的filter方法？
filter就像map,reduce,apply,zip等都是内置函数，用C语言实现，具有速度快，功能强大等 优点。
用于过滤与函数func()不匹配的值, 类似于SQL中select value != ‘a’
相当于一个迭代器，调用一个布尔函数func来迭代seq中的每个元素，返回一个是bool_seq返 回为True的序列
- 第一个参数: function or None, 函数或None
- 第二个参数: sequence,序列
13. 字符串的查询替换？
考点：python的find和replace函数。
给定一串字符串：
string = 'life is short, I use python'
# 返回的为0或正数时，为其索引号
>>> string.find('life')
string.replace('short','long')
# replace 将short替换为long
>life is long, I use python
14.给定一串排好序的列表，打乱这个函数?
这个题考了python里的shuffle函数的用法。
# random模块中的shuffle(洗牌函数)
import random
list = [1, 2, 3, 4]
random.shuffle(list)
print(list)
15. 装饰器？
装饰器是一个函数，接收一个函数返回另一个函数。用法如下：
import time
from functools import wraps
def timethis(func):
'''
Decorator that reports the execution time.
'''
@wraps(func)
def wrapper(*args, **kwargs):
start = time.time()
result = func(*args, **kwargs)
end = time.time()
print(func.__name__, end-start)
return result
return wrapper
@timethis
def countdown(n):
'''
Counts down
'''
while n > 0:
n -= 1
>>> countdown(100000)
countdown 0.008917808532714844
>>> countdown(10000000)
countdown 0.87188299392912”
16.给定一串字典(或列表),找出指定的（前N个）最大值？最小值？
这道题的考点是python内的heapq模块的nlargest() 和 nsmallest(), 而不是min()和max()。这两个函数都能接收关键字参数，用于复杂的结构数据中：
portfolio = [
{
'name': 'IBM', 'shares': 100, 'price': 91.1},
{
'name': 'AAPL', 'shares': 50, 'price': 543.22},
{
'name': 'FB', 'shares': 200, 'price': 21.09},
{
'name': 'HPQ', 'shares': 35, 'price': 31.75},
{
'name': 'YHOO', 'shares': 45, 'price': 16.35},
{
'name': 'ACME', 'shares': 75, 'price': 115.65}
]
# 参数3为最大的3个值(最小的3个值)
cheap = heapq.nsmallest(3, portfolio, key=lambda s: s['price'])
expensive = heapq.nlargest(3, portfolio, key=lambda s: s['price'])
# 上面代码在对每个元素进行对比的时候，会以price的值进行比较。
17. python实现单例模式？
这个题考的是python中对单例模式的理解和运用，有4个方法实现单例模式：
#方法1,实现__new__方法
#并在将一个类的实例绑定到类变量_instance上,
#如果cls._instance为None说明该类还没有实例化过,实例化该类,并返回
#如果cls._instance不为None,直接返回cls._instance
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
class MyClass(Singleton):
a = 1
one = MyClass()
two = MyClass()
two.a = 3
print(one.a)
#3
#one和two完全相同,可以用id(), ==, is检测
print(id(one))
#29097904
print(id(two))
#29097904
print(one == two)
#True
print(one is two)
#True
print('----------------------方法2--------------------------')
#方法2,共享属性;所谓单例就是所有引用(实例、对象)拥有相同的状态(属性)和行为(方法)
#同一个类的所有实例天然拥有相同的行为(方法),
#只需要保证同一个类的所有实例具有相同的状态(属性)即可
#所有实例共享属性的最简单最直接的方法就是__dict__属性指向(引用)同一个字典(dict)
#可参看:http://code.activestate.com/recipes/66531/
class Borg(object):
_state = {
}
def __new__(cls, *args, **kw):
ob = super(Borg, cls).__new__(cls, *args, **kw)
ob.__dict__ = cls._state
return ob
class MyClass2(Borg):
a = 1
one = MyClass2()
two = MyClass2()
#one和two是两个不同的对象,id, ==, is对比结果可看出
two.a = 3
print(one.a)
#3
print(id(one))
#28873680
print(id(two))
#28873712
print(one == two)
#False
print(one is two)
#False
#但是one和two具有相同的（同一个__dict__属性）,见:
print(id(one.__dict__))
#30104000
print(id(two.__dict__))
#30104000
print '----------------------方法3--------------------------'
#方法3:本质上是方法1的升级（或者说高级）版
#使用__metaclass__（元类）的高级python用法
class Singleton2(type):
def __init__(cls, name, bases, dict):
super(Singleton2, cls).__init__(name, bases, dict)
if not hasattr(cls, '_instance'):
cls._instance = None
def __call__(cls, *args, **kw):
if cls._instance is None:
cls._instance = super(Singleton2, cls).__call__(*args, **kw)
return cls._instance
class MyClass3(object):
__metaclass__ = Singleton2
one = MyClass3()
two = MyClass3()
two.a = 3
print(one.a)
#3
print(id(one))
#31495472
print(id(two))
#31495472
print(one == two)
#True
print(one is two)
#True
print '----------------------方法4--------------------------'
#方法4:也是方法1的升级（高级）版本,
#使用装饰器(decorator),
#这是一种更pythonic,更elegant的方法,
#单例类本身根本不知道自己是单例的,因为他本身(自己的代码)并不是单例的
def singleton(cls, *args, **kw):
instances = {
}
def _singleton():
if cls not in instances:
instances[cls] = cls(*args, **kw)
return instances[cls]
return _singleton
@singleton
class MyClass4(object):
a = 1
def __init__(self, x=0):
self.x = x
one = MyClass4()
two = MyClass4()
two.a = 3
print(one.a)
#3
print(id(one))
#29660784
print(id(two))
#29660784
print(one == two)
#True
print(one is two)
#True
one.x = 1
print(one.x)
#1
print(two.x)
#1
18. 实现一个斐波那契数列的生成器？
这道题的考点关键是生成器的yield关键字将一个普通函数改造成生成器函数：
def fib(n):
a, b = 0, 1
for _ in range(n):
a, b = b, a + b
yield a
def main():
for val in fib(20):
print(val)
if __name__ == '__main__':
main()
19. 使用字符串拼接达到字幕滚动效果？
import os
import time
def main():
content = '曹查理的python面试集-基础篇'
while True:
# 清理屏幕上的输出
os.system('cls') # os.system('clear')
print(content)
# 休眠200毫秒
time.sleep(0.2)
content = content[1:] + content[0]
if __name__ == '__main__':
main()
20. 设计一个函数返回给定文件名的后缀?
这道题考了正则表达式的简单知识点。代码如下：
def get_suffix(filename, has_dot=False):
"""
获取文件名的后缀名
:param filename: 文件名
:param has_dot: 返回的后缀名是否需要带点
:return: 文件的后缀名
"""
pos = filename.rfind('.')
if 0 < pos < len(filename) - 1:
index = pos if has_dot else pos + 1
return filename[index:]
else:
return ''
总结：
互联网大厂比较喜欢的人才特点：对技术有热情，强硬的技术基础实力；主动，善于团队协作，善于总结思考。无论是哪家公司，都很重视高并发高可用技术，重视基础，所以千万别小看任何知识。面试是一个双向选择的过程，不要抱着畏惧的心态去面试，不利于自己的发挥。同时看中的应该不止薪资，还要看你是不是真的喜欢这家公司，是不是能真的得到锻炼。其实我写了这么多，只是我自己的总结，并不一定适用于所有人，相信经过一些面试，大家都会有这些感触。
另外想要更多的MySQL相关的面试或其他相关的知识点的小伙伴们可以点击群1149778920 来加入我们自行领取， 暗号：Q F，本人还整理收藏了20年多家公司面试知识点以及各种技术点整理 下面有部分截图希望能对大家有所帮助。
