百度测试开发岗面试题（2019秋招）

百度去面试了两次，7月份提前批一次，这是我第一次去面试，果然凉的透透的，然后是正式批的时候，大概9、10月份吧，具体几号忘了，当时是在他们的食堂里，一站式面试，面试最后通过了。记录一下百度两次面试遇到的题目吧
百度测试开发岗面试

1 tcp的三次握手和四次握手

三次握手建立连接：
第一次握手：客户端发送syn包(seq=x)到服务器，并进入SYN_SEND状态，等待服务器确认;
第二次握手：服务器收到syn包，必须确认客户的SYN(ack=x+1)，同时自己也发送一个SYN包(seq=y)，即SYN+ACK包，此时服务器进入SYN_RECV状态;
第三次握手：客户端收到服务器的SYN+ACK包，向服务器发送确认包ACK(ack=y+1)，此包发送完毕，客户端和服务器进入ESTABLISHED状态，完成三次握手。
握手过程中传送的包里不包含数据，三次握手完毕后，客户端与服务器才正式开始传送数据。理想状态下，TCP连接一旦建立，在通信双方中的任何一方主动关闭连接之前，TCP 连接都将被一直保持下去。

四次挥手断开连接：
第一次挥手：
主动关闭方发送一个FIN，用来关闭主动方到被动关闭方的数据传送，也就是主动关闭方告诉被动关闭方：我已经不会再给你发数据了(当然，在fin包之前发送出去的数据，如果没有收到对应的ack确认报文，主动关闭方依然会重发这些数据)，但此时主动关闭方还可以接受数据。
第二次挥手：
被动关闭方收到FIN包后，发送一个ACK给对方，确认序号为收到序号+1(与SYN相同，一个FIN占用一个序号)。
第三次挥手：
被动关闭方发送一个FIN，用来关闭被动关闭方到主动关闭方的数据传送，也就是告诉主动关闭方，我的数据也发送完了，不会再给你发数据了。
第四次挥手：
主动关闭方收到FIN后，发送一个ACK给被动关闭方，确认序号为收到序号+1，至此，完成四次挥手。

为什么要四次挥手？确保数据能够完整传输。
当被动方收到主动方的FIN报文通知时，它仅仅表示主动方没有数据再发送给被动方了。但未必被动方所有的数据都完整的发送给了主动方，所以被动方不会马上关闭SOCKET,它可能还需要发送一些数据给主动方后，再发送FIN报文给主动方，告诉主动方同意关闭连接，所以这里的ACK报文和FIN报文多数情况下都是分开发送的。

为什么建立连接是三次握手，而关闭连接却是四次挥手呢？
这是因为服务端在LISTEN状态下，收到建立连接请求的SYN报文后，把ACK和SYN放在一个报文里发送给客户端。而关闭连接时，当收到对方的FIN报文时，仅仅表示对方不再发送数据了但是还能接收数据，己方也未必全部数据都发送给对方了，所以己方可以立即close，也可以发送一些数据给对方后，再发送FIN报文给对方来表示同意现在关闭连接，因此，己方ACK和FIN一般都会分开发送。

进程和线程的区别

• 进程是资源分配的最小单位，线程是程序执行的最小单位。
• 系统在运行的时候会为每个进程分配不同的内存空间；而对线程而言，除了CPU外，系统不会为线程分配内存（线程所使用的资源来自其所属进程的资源），线程组之间只能共享资源。
• CPU切换一个线程的花费远比进程要小很多，同时创建一个线程的开销也比进程要小很多。
• 线程是进程的一部分，所以线程也被称为轻权进程或者轻量级进程
• 线程之间的通信更方便，同一进程下的线程共享全局变量、静态变量等数据，而进程之间的通信需要以通信的方式（IPC)进行。不过如何处理好同步与互斥是编写多线程程序的难点。
• 但是多进程程序更健壮，多线程程序只要有一个线程死掉，整个进程也死掉了，而一个进程死掉并不会对另外一个进程造成影响，因为进程有自己独立的地址空间
**根本区别：**进程是操作系统资源分配的基本单位，而线程是任务调度和执行的基本单位

在开销方面：每个进程都有独立的代码和数据空间（程序上下文），程序之间的切换会有较大的开销；线程可以看做轻量级的进程，同一类线程共享代码和数据空间，每个线程都有自己独立的运行栈和程序计数器（PC），线程之间切换的开销小。

协程

是一种用户态的轻量级线程，协程的调度完全由用户控制。协程拥有自己的寄存器上下文和栈。协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈，直接操作栈则基本没有内核切换的开销，可以不加锁的访问全局变量，所以上下文的切换非常快

2 死锁的原理、必要条件和避免的方法

**原理**

死锁，指的是两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，如果无外力作用，那么它们都将无法推进下去。此时，称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。
（例子：
当一个线程锁定了一个资源A，而又想去锁定资源B，而在另一个线程中，锁定了资源B，而又想去锁定资源A以完成自身的操作，两个线程都想得到对方的资源，而不愿意释放自己的资源，造成两个线程都在等待，而无法执行，此时就是死锁。）
必要条件 4个
 互斥条件：一段时间内某资源只由一个线程占用
 占有且等待：一个进程因请求资源而被阻塞时，对已经获得的资源保持占有状态；
 不可强行占有：进程已经获得的资源不会被其他进程抢占；
 循环等待：若干进程间产生一种循环等待的条件，比如A等待B释放资源，B等待A释放资源

给定两个线程，A，B两个锁，举个造成死锁的例子？
程序中使用多个互斥量时，如果允许一个线程一直占有第一个互斥量，并且在试图锁住第二个互斥量时处于阻塞状态，但是拥有第二个互斥量的线程也在试图锁住第一个互斥量，这时就会发生死锁。因为两个线程都在相互请求另一个线程拥有的资源，所以这两个线程都无法向前运行，于是就产生死锁。如果所有线程总是在对互斥量B加锁之前锁住互斥量A，那么使用这两个互斥量不会产生死锁

避免死锁的方法
 一次封锁法：每个进程（事务）将所有要使用的数据全部加锁，否则，就不能继续执行；
 顺序封锁法：预先对数据对象规定一个封锁顺序，所有进程（事务）都按这个顺序加锁；
 银行家算法：保证进程处于安全进程序列
银行家算法是从当前状态出发，按照系统各类资源剩余量逐个检查各进程需要申请的资源量，找到一个各类资源申请量均小于等于系统剩余资源量的进程P1。然后分配给该P1进程所请求的资源，假定P1完成工作后归还其占有的所有资源，更新系统剩余资源状态并且移除进程列表中的P1，进而检查下一个能完成工作的客户，…。如果所有客户都能完成工作，则找到一个安全序列，银行家才是安全的。若找不到这样的安全序列，则当前状态不安全。

预防死锁
预防死锁的方法是通过设置某些限制条件，去破坏产生死锁的四个必要条件中的一个或者几个，以避免发生死锁。
由于互斥条件是非共享设备所必须的，不仅不能改变，还应该加以保证，因此，主要是破坏产生死锁的后三个条件。
 破坏请求与保持条件：对一个进程在请求资源时，它不能持有不可剥夺资源。
 破坏不可剥夺条件：对一个已经保持了某些不可剥夺资源的进程，提出新的资源请求而不能得到满足时，它必须释放已经保持的所有资源，待以后需要时再重新申请。
 破坏循环等待条件：对系统所有资源类型进行线性排列，并赋予不同序号。规定每个进程必须按序号递增的顺序请求资源

编程题

1. 找出单向链表的倒数第n个节点。
俩指针p和q指向头部，p先走N个节点，q不动。然后p走一步，q也走一步，等到p走到终点时，q就恰好指向倒数第n

class ListNode:def __init__(self, x):self.val = xself.next = Noneclass Solution:def removeNthFromEnd(self, head, n):""":type head: ListNode:type n: int:rtype: ListNode"""fast,slow = head,headfor _ in range(n):fast = fast.nextif not fast:   #如果fast指针走了n步时指向null说明链表只有n个节点则倒数第n个节点就是头结点也就是此时slow指向的头结点，所以直接返回slow即可return slowwhile fast.next:fast = fast.nextslow = slow.nextreturn slow

延伸：给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点

class ListNode:def __init__(self, x):self.val = xself.next = Noneclass Solution:def removeNthFromEnd(self, head, n):""":type head: ListNode:type n: int:rtype: ListNode"""fast,slow = head,headfor _ in range(n):fast = fast.nextif not fast:   #如果fast指针走了n步时指向null说明链表只有n个节点则倒数第n个节点就是头结点也就是此时slow指向的头结点，所以删除头结点即返回slow.next即可return slow.nextwhile fast.next:fast = fast.nextslow = slow.nextslow.next = slow.next.nextreturn head

*2 写一个函数实现字符串的反转，要求不能用任何系统函数，且时间复杂度最小，函数原型是：char * reverse_str(char str)
Python中：

s = "abcd"
print s[::-1]即可实现翻转
c/c++：
public static String reverse(String str) {char[] seq = str.toCharArray();int pre = 0;int end = str.length() - 1;while (pre != end) {char temp = seq[pre];seq[pre] = seq[end];seq[end] = temp;pre++;end--;}return new String(seq);}

3 实现子序列最大和
给定一个int数组，给出其中连续子序列的最大和
例如：数组[-2,11,-4,13,-5,2]中具有最大累加和的子数组为[11,-4,13],和为20

def FindGreatestSumOfSubArray(array):sum = array[0]presum = 0for i in array:if presum < 0:presum = ielse:presum += isum = max(presum,sum)return sum

linux命令

安装和登录命令：login、shutdown、halt、reboot、install、mount、umount、chsh、exit、last；
文件处理命令：file、mkdir、grep、dd、find、mv、ls、diff、cat、ln；
系统管理相关命令：df、top、free、quota、at、lp、adduser、groupadd、kill、crontab；
网络操作命令：ifconfig、ip、ping、netstat、telnet、ftp、route、rlogin、rcp、finger、mail、 nslookup；
netstat命令用于显示与IP、TCP、UDP和ICMP协议相关的统计数据，一般用于检验本机各端口的网络连接情况
netstat –i显示网卡列表
netstat –r 显示路由表信息

系统安全相关命令：passwd、su、umask、chgrp、chmod、chown、chattr、sudo ps、 who；
Chmod：（所有用户都可以操作）改变文件或目录权限
Chmod 777 1.txt 三位：第一位表示用户读写执行三种权限第二位是所属群组第三位是其他用户
其它命令：tar、unzip、gunzip、unarj、mtools、man、unendcode、uudecode
grep命令用于查找文件里符合条件的字符串
例子：grep test *file在当前目录中，查找后缀有 file 字样的文件中包含 test 字符串的文件，并打印出该字符串的行
通过"-v"参数可以打印出不符合条件行的内容

算法小问： 27个外表相同的球，只有一个是轻的，现在给你一个天平，让你用最少的次数来找到轻的那个球，天平上可以放多个球共三次

 第一次：分成三堆,一堆9个.随机取两组称重, 如果平衡,那么次品就在未被选中的一堆里.如果不平衡,那么次品在天平上较轻的那一堆里。
 第二次：再次将9个球分成三堆,一堆三个，随机取两组称重, 如果平衡,那么次品就在未被选中的一堆里.如果不平衡,那么次品在天平上较轻的那一堆里.
 第三次：最后的结果：从三个球中一个称一次将次品选出来

延伸一：给定次品是轻或重
（1）9个乒乓球中有一个次品(重量比其他的轻),一个天平,用几次才能找出这个次品？
两次,
先分成三份,任意拿两份称,如果有轻重之分,把轻的那份再分成三份,称任意两个,如果有轻重,轻的那个就是.没有的话,没称的那个就是!第一次如果没轻重之分,就把没称的那份分三份称,结果一样的!
（2）13个乒乓球,其中一个是次品,次品比正品轻一些.现在有一架天平,至少称几次就可以把次品找到?
三次可以找到.
先分为3组个数分别为 5 5 3
称5个的组如果平就在.那3个里面去.称2次就找出来了
如果不平就说明在 5个的组里
继续分为 2个 2个 1个的小组称2个的.同理
最终最少需要3次就可以把次品找到
（3）有8个外表一样的球，其中只有一个是次品，重量比正品略轻，不用砝码，用天平称至少要______次就能保证把次品找出来
两次
把8个球分成（3，3，2）三组，把两个3个一组的放在天平上称，如平衡，则次品在2个的一组中，把这2个球分成（1，1），放在天平上称，上跷的是次品．需2次
如不平衡，则把轻的一组3个球分成（1，1，1），任意两个放在天平上称，如平衡，没称的是次品，如不平衡，上跷的是次品．
所以用天平称至少要2次就能保证把次品找出来
二十个球一个较轻用天平至少称多少次能保证找出这个较轻的球
1、球分3组7、7、6，称7和7可找出轻的一组。
2、如果7个球中有较轻的，则7个球分为2、2、3，称2和2可找出轻的一组；若两组的7个球一样重，说明在剩余的6个当中，6个分为3+3或者2+2+2,
3、3个球分为1、1、1，称1和1可找出轻的一个
延伸二：不给出次品的轻重
有13个乒乓球,其中1个是次品,其质量和其他12的质量不同,现有一个天平无砝码,要求只称3次就把次品找出
分4组,前3组各4个,最后一组1个.
 第一次1组放左,2组放右.如平衡则坏在3或4组.
第二次天平左放3组1号球和2号球,右边放3组的3号球和之前1组的一个好球,如平衡则坏是3组4号或者4组那个.
第三次用3组4号和1组一个好球称,如不平则坏的是3组4号,平衡则坏的是4组那个.
 第二次如果不平衡,假设3组1号球和2号球沉,3组的3号球和之前1组的一个好球轻.则两种可能,一种是3组里1号或者2号有一个球坏的而且沉,二种是3组3号是坏的而且轻.这样第三次只要把3组1号和2好各放天平两边,不平衡则沉的那边是坏的,平衡则3组3号是坏的.
 如果第一次就不平衡,假设左边1组沉,右边2组轻,则同样2种可能,一种是1组有个沉,另可能是2组有个轻.
第二次则左放1组的1,2号和3组的一个好球,右边放1组的3,4号和2组的1号.如平衡则坏在2组的2,3或4号.
第三次则用2组3和4对称,不平衡则是轻的是坏,平衡则是 2组2号坏.
 如果第二次不平衡,则两种情况,第一如果仍然是左边沉,则坏的是1组1或2而且沉,或者是2组1号坏而且轻.
这样第三次1组1号和1组2号对称,不平衡则沉的坏，平衡则2组1坏.
 第二如果左边轻了，则坏的是1组3或4而且沉。这样第三次1组3和4号对称，沉的是坏.

7. mysql数据库的特性有什么，写一个update语句

Mysql数据库事务的四大特性（ACID）
事务：把一组密不可分的操作系列集合在一起，这些操作要么全部执行，要么全部不执行。
 原子性：事务是一个整体，是不可分割的。在一个原子操作中，如果事务中的任何一个语句失败，前面执行的语句都将被返回，以保证数据的整体性不被破坏
 一致性：同一个事务，多次读取数据库中的同一个数据，读取的内容应该是一致的，不变的。
 隔离性：不同事务之间相互独立，互不干扰。
又称为孤立性：指每个事务在自己的空间发生，和其他发生在系统中的事务隔离，而且事务的结果只在它完全被执行的时候才能看到，如果该事务未提交，则其他会话看不到执行的结果。这样的话即使一个系统中同时发生多个事务，孤立性也可以保证特定的事务在完成之前，其结果是不被公布的
 持久性：事务提交后，事务内的操作对数据库的修改被永久保存在数据库文件中. MySql的持久性是通过一条记录事务过程中系统变化的二进制事务日志文件来实现的。如果遇到硬件损坏或者系统的异常关机，系统在下一次启动时，通过使用最后的备份和日志就可以恢复丢失数据
Update
更新员工编号1056的姓氏和电子邮件列：

UPDATE employees（表名）
SET lastname = 'Hill',email = 'mary.hill@yiibai.com'
WHEREemployeeNumber = 1056;

insert：INSERT INTO  tablename (列名…) VALUES(列值);
例如：INSERT INTO users(id, name, age) VALUES(123, '姚明', 25);

8. 测试的方法有哪些？代码写过的测试用例有什么？

 从软件内部结构和具体实现来划分，软件测试可以分为：
白盒测试、黑盒测试、灰盒测试
 常见的白盒测试的方法有：语句覆盖，条件覆盖，判定覆盖，条件组合覆盖，基本路径覆盖等等
 黑盒测试：又称为功能测试，不考虑程序内部结构和逻辑结构，主要是用来测试系统的功能是否满足需求规格说明书，它是站在使用软件或程序的角度，从输入数据与输出数据的对应关系出发进行的测试
常见黑盒测试的方法：等价类划分法、边界值分析法、错误推测法、因果图法、正交试验法、判定表驱动法、功能图法
等价类划分法：
例：每个学生可选修1-3门课程
•可以划分一个有效等价类：选修1-3门课程。
•可以划分两个无效等价类：未选修课；选修课超过3门。
错误推测法：工作人员根据经验进行测试，列举出系统中所有【可能的缺陷和容易发生缺陷的特殊情况】，并根据它们来设计测试用例
 .根据软件测试的阶段来划分：
　　单元测试—>集成测试—>系统测试—>验收测试

Python系统库

Os模块：内建的 open / file 函数用于创建, 打开和编辑文件 rename /remove
os.listdir列出目录下的文件
makedirs 和 removedirs 函数用于创建或删除目录层
Math
String ：string.split（text）、string.replace(text, “Python”, “Java”)、string.join(string.split(text), “+”)、string.count(text, “n”)

Copy
Sys
Array
Pprint：pprint – 美观打印作用：美观打印数据结构

Python的多线程

一个线程就是一个轻量级进程，多线程能让我们一次执行多个线程。我们都知道，Python 是多线程语言，其内置有多线程工具包。threading用于提供线程相关的操作，线程是应用程序中工作的最小单元。
Python 中的 GIL（全局解释器锁）确保一次执行单个线程。一个线程保存 GIL 并在将其传递给下个线程之前执行一些操作，这会让我们产生并行运行的错觉。但实际上，只是线程在 CPU 上轮流运行
python多线程与多进程的区别
 多线程可以共享全局变量，多进程不能
 多线程中，所有子线程的进程号相同，多进程中，不同的子进程进程号不同
 线程共享内存空间；进程的内存是独立的
 同一个进程的线程之间可以直接交流；两个进程想通信，必须通过一个中间代理来实现
 创建新线程很简单；创建新进程需要对其父进程进行一次克隆
 一个线程可以控制和操作同一进程里的其他线程；但是进程只能操作子进程

python内存管理机制

引入计数、垃圾回收、内存池机制
1）引用计数
当一个pyhton对象被引用时其引用计数增加1，当其不再被引用时引用计数减1，当引用计数等于0的时候，对象就被删除了
2）垃圾回收
Python的GC模块主要运用了引用计数来跟踪和回收垃圾。在引用计数的基础上，还可以通过“标记－清除”解决容器对象可能产生的循环引用的问题。通过分代回收以空间换取时间进一步提高垃圾回收的效率
（1）引用计数
引用计数也是一种垃圾回收机制，而且是一种最直观，最简单的垃圾回收技术。
每个对象维护一个ob_ref字段，用来记录该对象当前被引用的次数。当一个对象的引用被创建或者复制时，对象的引用计数加1；当一个对象的引用被销毁或者失效时，对象的引用计数减1，当对象的引用计数减少为0时，就意味着对象已经再没有被使用了，可以将其内存释放掉。
导致引用计数+1的情况
 对象被创建，例如a=23
 对象被引用，例如b=a
 对象被作为参数，传入到一个函数中，例如func(a)
 对象作为一个元素，存储在容器（列表、元组、字典）中，例如list1=[a,a]
导致引用计数-1的情况
 对象的别名被显式销毁，例如del a
 对象的别名被赋予新的对象，例如a=24
 一个对象离开它的作用域，例如f函数执行完毕时，func函数中的局部变量（全局变量不会）
 对象所在的容器被销毁，或从容器中删除对象

优点：引用计数有一个很大的优点，即实时性，任何内存，一旦没有指向它的引用，就会被立即回收，而其他的垃圾收集技术必须在某种特殊条件下才能进行无效内存的回收。
缺点：
 需要额外的空间维护引用计数。引用计数机制所带来的维护引用计数的额外操作与Python运行中所进行的内存分配和释放，引用赋值的次数是成正比的，这显然比其它那些垃圾收集技术所带来的额外操作只是与待回收的内存数量有关的效率要低。
 循环引用问题，因为对象之间相互引用，每个对象的引用都不会为0，所以这些对象所占用的内存始终都不会被释放掉。
循环引用实例1：

a = []
b = []
a.append(b)
b.append(a)

例子2：

def f2():'''循环引用'''while True:c1=A()c2=A()c1.t=c2c2.t=c1del c1del c2

 创建了c1，c2后，这两个对象的引用计数都是1，执行c1.t=c2和c2.t=c1后，引用计数变成2.
 在del c1后，内存c1的对象的引用计数变为1，由于不是为0，所以c1的对象不会被销毁,同理，在del c2后也是一样的。
 虽然它们两个的对象都是可以被销毁的，但是由于循环引用，导致垃圾回收器都不会回收它们，所以就会导致内存泄露

（2）标记清除
标记清除用来解决循环引用产生的问题，循环引用只有在容器对象才会产生，比如字典，元组，列表等。是一种基于追踪回收（tracing GC）技术实现的垃圾回收算法。分为两个阶段：第一阶段是标记阶段，GC会把所有的『活动对象』打上标记，第二阶段是把那些没有标记的对象『非活动对象』进行回收。
怎样确定活动对象和非活动对象？

对象之间通过引用（指针）连在一起，构成一个有向图，对象构成这个有向图的节点，而引用关系构成这个有向图的边。从根对象（root object）出发，沿着有向边遍历对象，可达的（reachable）对象标记为活动对象，不可达的对象就是要被清除的非活动对象。根对象就是全局变量、调用栈、寄存器。 mark-sweepg 在上图中，我们把小黑圈视为全局变量，也就是把它作为root object，从小黑圈出发，对象1可直达，那么它将被标记，对象2、3可间接到达也会被标记，而4和5不可达，那么1、2、3就是活动对象，4和5是非活动对象会被GC回收
具体操作实现：
为了追踪对象，需要每个容器对象维护两个额外的指针，用来将容器对象组成一个链表，指针分别指向前后两个容器对象，这样可以将对象的循环引用摘除，就可以得出两个对象的有效计数。
两个链表：root链表和unreachable链表

寻找根对象（root object）的集合作为垃圾检测动作的起点，根对象也就是一些全局引用和函数栈中的引用，这些引用所指向的对象是不可被删除的；
从root object集合出发，沿着root object集合中的每一个引用，如果能够到达某个对象，则说明这个对象是可达的，那么就不会被删除，这个过程就是垃圾检测阶段；
当检测阶段结束以后，所有的对象就分成可达和不可达两部分，所有的可达对象都进行保留，其它的不可达对象所占用的内存将会被回收，这就是垃圾回收阶段。（底层采用的是链表将这些集合的对象连接在一起）

为什么要搞这两个链表？
之所以要剖成两个链表，是基于这样的一种考虑：现在的unreachable可能存在被root链表中的对象直接或间接引用的对象，这些对象是不能被回收的，一旦在标记的过程中，发现这样的对象，就将其从unreachable链表中移到root链表中；当完成标记后，unreachable链表中剩下的所有对象就是名副其实的垃圾对象了，接下来的垃圾回收只需限制在unreachable链表中即可

（3）分代回收—以空间换时间
Python解释器保持对新创建的对象，以及因为引用计数为零而被释放掉的对象的追踪。从理论上说，创建==释放数量应该是这样子。但是如果存在循环引用的话，肯定是创建>释放数量，当创建数与释放数量的差值达到规定的阈值的时候，分代回收机制发挥作用
分代回收思想将对象分为三代（generation 0,1,2），对应3个链表
0代表幼年对象，
1代表青年对象，
2代表老年对象。
根据弱代假说（越年轻的对象越容易死掉，老的对象通常会存活更久。）
将系统中的所有内存块根据其存活时间划分为不同的集合，每一个集合就成为一个“代”，Python默认定义了三代对象集合，垃圾收集的频率随着“代”的存活时间的增大而减小。也就是说，活得越长的对象，就越不可能是垃圾，就应该减少对它的垃圾收集频率。
新创建的对象都会分配在年轻代，年轻代链表的总数达到上限时，Python垃圾收集机制就会被触发，把那些可以被回收的对象回收掉，而那些不会回收的对象就会被移到中年代去，依此类推，老年代中的对象是存活时间最久的对象，甚至是存活于整个系统的生命周期内

有三种情况会触发垃圾回收：
 调用gc.collect(),需要先导入gc模块。
 当gc模块的计数器达到阀值的时候。
 程序退出的时候。

gc模块：提供一个接口给开发者设置垃圾回收的选项
3）内存池
Python为了避免频繁的申请和删除内存所造成系统切换于用户态和核心态的开销，从而引入了内存池机制，专门用来管理小内存的申请和释放。整个小块内存的内存池可以视为一个层次结构，其一共分为4层，从下之上分别是block、pool、arena和内存池。需要说明的是：block、pool和area都是代码中可以找到的实体，而最顶层的内存池只是一个概念上的东西，表示Python对于整个小块内存分配和释放行为的内存管理机制。

注意，内存大小以256字节为界限，大于则通过malloc进行分配，小于则通过内存池分配

block：最小的内存单元，大小为8的整数倍。有很多种类的block，不同种类的block都有不同的内存大小，申请内存的时候只需要找到适合自身大小的block即可，当然申请的内存也是存在一个上限，如果超过这个上限，则退化到使用最底层的malloc进行申请。
pool：一个pool管理着一堆有固定大小的内存块，其大小通常为一个系统内存页的大小。
arena：多个pool组合成一个arena。
内存池：一个整体的概念