前言

网上有大量的基础面试题目，但是通过面试python后台开发，掌握的一些基础面试题，觉得有必要整理出来，以便日后查阅；

正文

一、面试基础题目；

1、可迭代对象、迭代器与生成器的区别？

（1）迭代器就是用于迭代操作的对象，可以记住遍历位置，迭代器基本方法有iter()和next()；

（2）生成器是一种特殊的迭代器，返回值不通过return而是通过yield;

（3）使用iter内置函数可以获取迭代器的对象。如果对象实现了能返回迭代器的__iter__方法，那么对象就是可迭代的；

拓展：

1）斐波那契列为例实现一个迭代器：

class Fib:
    def __init__(self, n):
        self.prev = 0
        self.cur = 1
        self.n = n
    def __iter__(self):
        return self
    def __next__(self):
        if self.n > 0:
            value = self.cur
            self.cur = self.cur + self.prev
            self.prev = value
            self.n -= 1
            return value
        else:
            raise StopIteration()
# 兼容python2
    def __next__(self):
        return self.next()
        f = Fib(10)
        print([i for i in f])
#[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]                

2）什么是Python 生成器？

用关键字 yield 来返回值，这种函数叫生成器函数，函数被调用时会返回一个生成器对象，生成器本质上还是一个迭代器；

>>> def func(n):
... yield n*2
...
>>> func
<function func at 0x00000000029F6EB8>
>>> g = func(5)
>>> g
<generator object func at 0x0000000002908630>
>>>

func 就是一个生成器函数，调用该函数时返回对象就是生成器 g ，这个生成器对象的行为和迭代器是非常相似的，可以用在 for 循环等场景中；注意 yield 对应的值在函数被调用时不会立刻返回，而是调用next方法时（本质上 for 循环也是调用 next 方法）才返回。

2、redis知识点?

（1）Redis是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API；

3、三次握手四次挥手?

4、进程与线程的区别？

（1）一个进程可以管理一个及一个以上的线程；

（2）一个进程相当于一个应用程序，一个线程相当于一个应用程序的一个功能分支；

5、python里面使用线程的缺点？

（1）GIL导致python无法使用到计算机的多核，仅能使用单核；

（2）python想要提高效率，可以使用多个进程，不要使用多个线程；

6、GIL锁什么时候会释放？ 

（1）当线程等待结果的时候会释放GIL；

（2）在IO操作等可能会引起阻塞的system call之前,会暂时释放GIL；

（3）利用多解释器pypy、jpython来释放GIL锁；

7、python垃圾怎么回收的？

　　1）python什么时候触发垃圾回收？

　　（1）达到了垃圾回收的阈值，Python虚拟机自动执行；

　　（2）手动调用gc.collect()；

　　（3）Python虚拟机退出的时候；

　　2）Python主要运用GC模块的“引用计数”来跟踪和回收垃圾，在引用计数的基础上，还可以通过“标记-清除”（mark and sweep）解决容器对象可能产生的循环引用的问题，通过“分代回收”（generation collection）以空间换取时间来进一步提高垃圾回收的效率；

8、python上下文管理器？

（1）任何实现了 __enter__() 和 __exit__() 方法的对象都可称之为上下文管理器，上下文管理器对象可以使用 with 关键字。显然，文件（file）对象也实现了上下文管理器。

（2）模拟实现一个自己的文件类，让该类实现 __enter__() 和 __exit__() 方法：

class File():

    def __init__(self, filename, mode):
        self.filename = filename
        self.mode = mode

    def __enter__(self):
        print("entering")
        self.f = open(self.filename, self.mode)
        return self.f

    def __exit__(self, *args):
        print("will exit")
        self.f.close()

__enter__() 方法返回资源对象，这里就是你将要打开的那个文件对象，__exit__() 方法处理一些清除工作；

因为 File 类实现了上下文管理器，现在就可以使用 with 语句了，

with File('out.txt', 'w') as f:
    print("writing")
    f.write('test')

引用连接:https://www.cnblogs.com/zhangfengxian/p/10201400.html

9、存储引擎innodb的特性？

1:支持事务(要么全成功、要么全失败);
2:行级锁定(更新数据时一般指锁定当前行)：通过索引实现、全表扫描忍让时表锁、注意间隙所的影响;
3:读写阻塞与事务的隔离级别相关；
4:具有非常高的缓存特性(既能缓存索引、也能缓存数据)；
5:这个表和主键以组(Cluster)的方式存储、组成一颗平衡树；
6:所有的辅助索引(secondary indexes)都会保存主键信息；
7:支持分区、表空间类似与oracle 数据库；
8:支持外键约束、不支持全文检索(5.5.5之前的MyISAM支持全文检索、5.5.5之后就不在支持);
9:相对MyISAM而言、对硬件的要求比较高;

10、mysql事务有哪些特性?

四大特性：原子性、一致性、隔离性、持久性；

（1）原子性：原子性是指事务包含的所有操作要么全部成功，要么全部失败回滚，因此事务的操作如果成功就必须要完全应用到数据库，如果操作失败则不能对数据库有任何影响；

（2）一致性：一致性是指事务必须使数据库从一个一致性状态变换到另一个一致性状态，也就是说一个事务执行之前和执行之后都必须处于一致性状态。举例来说，假设用户A和用户B两者的钱加起来一共是1000，那么不管A和B之间如何转账、转几次账，事务结束后两个用户的钱相加起来应该还得是1000，这就是事务的一致性；

（3）隔离性是当多个用户并发访问数据库时，比如同时操作同一张表时，数据库为每一个用户开启的事务，不能被其他事务的操作所干扰，多个并发事务之间要相互隔离；

（4）持久性：持久性是指一个事务一旦被提交了，那么对数据库中的数据的改变就是永久性的，即便是在数据库系统遇到故障的情况下也不会丢失提交事务的操作；

拓展：什么是悲观锁、乐观锁：

1）悲观锁，它指的是对数据被外界（包括本系统当前的其他事务，以及来自外部系统的事务处理）修改持保守态度。因此，在整个数据处理过程中，将数据处于锁定状态；

2）乐观锁：相对悲观锁而言，乐观锁假设认为数据一般情况下不会造成冲突，所以只会在数据进行提交更新的时候，才会正式对数据的冲突与否进行检测，如果发现冲突了，则返回用户错误的信息，让用户决定如何去做。

3）聚簇索引：在innodb中，主键的索引结构中，既存储了主键值，有存储了行数据，这种数据成为‘聚簇索引’；

11、数据库索引的功能是什么?

（1）数据库索引是对数据库表中一列或多列的值进行排序的一种结构，使用索引可快速访问数据库表中的特定信息；

（2）加快数据库的信息查询与检索，缩短搜索数据库信息的时间；

12、innodb索引数据结构是什么样的?

（1）B+树结构；

（2）扁平特性，节省内存；

（3）B+树除了叶子节点其他节点并不存储数据，节点小，磁盘IO次数就少，而磁盘IO次数少，就说明mysql的查询效率高；

拓展：

关系型数据库与非关系型数据库的区别：

1）关系型数据库通过外键关联来建立表与表之间的关系，非关系型数据库通常指数据以对象的形式存储在数据库中，而对象之间的关系通过每个对象自身的属性来决定，即使用键值对存储数据；

2）MongoDB为什么使用B-树而不是B+树，可以从它的设计角度来考虑，它并不是传统的关系型数据库，而是以json格式作为存储的nosql,目的就是高性能，高可用，易扩展；

13、mysql建索引需要注意哪些事项?

（1）更新频繁的列不应设置索引；

（2）数据量小的表不要使用索引；

（3）重复数据多的字段不应设为索引；

（4）首先应该考虑对where 和 order by 涉及的列上建立索引；

14、数据库怎么优化慢查询?

15、表的拆分有哪些纬度?

16、什么情况下会用上读写分离?

17、mysql的binlog主要有哪些信息?

18、kafka和rabbitmq的区别?

（1）功能上，两者都是实现了AMQP协议。那么在使用上的最大区别是什么呢？如何根据自己的需求进行选型？

（2）kafka是严格顺序保证的消息队列。即使在分布式环境下，也保证在同一分区内消息的顺序性。既然是顺序的，那么在同一个Topic下面，如果前面的消息没有消费完毕（收到回应），则不能读取下一条消息。那么在消费端，就变成了一个单线程操作，无法并发。虽然kafka可以通过分区实现并发，不过这个需要用多台kafka实现。

（3）Rabbitmq不承诺消息的顺序性，因此可以并发多线程处理。在队列中不必排队。如果你对顺序处理没有要求，可以用Rabbitmq实现较大的并发。

19、数据结构算法，常用十大排序算法，时间复杂度、空间复杂度简单说下?

20、二叉树镜像反转代码，手写?

class Node(object):
    def __init__(self, value=None, lchild=None, rchild=None):
        self.value = value
        self.lchild = lchild
        self.rchild = rchild


def mirror(root):
    """翻转镜像"""
    if not root:
        return
    root.lchild, root.rchild = root.rchild, root.lchild
    mirror(root.lchild)
    mirror(root.rchild)


def in_order_traverse(root):
    """中序遍历"""
    if not root:
        return
    in_order_traverse(root.lchild)
    print(root.value)
    in_order_traverse(root.rchild)


if __name__ == '__main__':
    root = Node(1, Node(2, Node(4), Node(5)), Node(3))

    mirror(root)  # 翻转二叉树
    in_order_traverse(root)  # 中序遍历

21、hadoop怎么进行容错的?

22、http协议常见请求方法有哪些？状态码有哪些？

23、https和http的区别，https怎么进行加密的?

https通过TLS进行加密，

24、tcp与udp协议的区别?

25、tcp协议如何进行流量控制?

滑窗控制

26、git如何管理分支?

参考资料