2020-09-15

闭包

嵌套函数，第二层函数引用了第一层函数的变量，且返回的是第二层函数名。

装饰器

在不改变原函数情况下进行功能扩展。
这个不改变包括函数内部的逻辑，和函数的调用代码。
只需要在原来函数上方加一个魔术方法。

import time
def time_it(func):
def inner():
start = time.time()
func()
end = time.time()
print(‘用时:{}秒’.format(end-start))
return inner
@time_it
def func1():
time.sleep(2)
print(“Func1 is running.”)
if name == ‘main’:
func1()

dict实现原理

字典也被称为关联数组，还称为哈希数组等。也就是说，字典也是一个数组，但数组的索引是键经过哈希函数处理后得到的散列值。哈希函数的目的是使键均匀地分布在数组中，并且可以在内存中以O(1)的时间复杂度进行寻址，从而实现快速查找和修改。
通过键名查找对应的值会有很高的效率，时间复杂度在常数级别O(1)。
在Python2中，dict的底层是依靠哈希表(Hash Table)进行实现的，使用开放地址法解决冲突。所以其查找的时间复杂度会是O(1)，下文会具体讲解哈希表的工作原理和解决冲突时的具体方法。哈希表是key-value类型的数据结构，通过关键码值直接进行访问。
哈希函数就是一个映射。

平方取中法:先通过求关键字的平方值扩大相近数的差别，然后根据表长度取中间的几位数作为散列函数值。
除余法:它是以表长m来除关键字，取其余数作为散列地址，即 h(key)=key％m
相乘取整法:首先用关键字key乘上某个常数A（A大于0小于1）并抽取出key.A的小数部分；然后用m乘以该小数后取整
随机数法:选择一个随机函数，取关键字的随机函数值为它的散列地址

开放地址
开放地址的意思是除了哈希函数得出的地址可用，当出现冲突的时候其他的地址也一样可用，常见的开放地址思想的方法有线性探测再散列，二次探测再散列，这些方法都是在第一选择被占用的情况下的解决方法。
再哈希法
这个方法是按顺序规定多个哈希函数，每次查询的时候按顺序调用哈希函数，调用到第一个为空的时候返回不存在，调用到此键的时候返回其值。
链地址法
将所有关键字哈希值相同的记录都存在同一线性链表中，这样不需要占用其他的哈希地址，相同的哈希值在一条链表上，按顺序遍历就可以找到。

python基础数据类型 ： 可变：（list， set, dict）,不可变（int，float）

Python深拷贝和浅拷贝：

深拷贝就是将一个对象拷贝到另一个对象中，这意味着如果你对一个对象的拷贝做出改变时，不会影响原对象。深拷贝在内存中占用两块内存空间。
b=copy.deepcopy(a)

浅拷贝则是将一个对象的引用（相当于c语言的指针）拷贝到另一个对象上，所以如果我们在拷贝中改动，也会影响到原对象。浅拷贝在内存中共用一块内存空间。
b=copy.copy(a)

python中的垃圾回收机制

Python采用的是引用计数机制为主，标记-清理和分代收集两种机制为辅的策略。

1、引用计数
python中一切皆对象，所以python底层计数结构地就可以抽象为：
引用计数结构体{
引用计数;
引用的对象
}
什么情况下引用计数+1，什么情况下-1，当引用次数为0时，肯定就是需要进行回收的时刻。

引用计数+1的情况：
1、对象被创建时，例如 mark=“帅哥”
2、对象被copy引用时，例如 mark2=mark，此时mark引用计数+1
3、对象被作为参数，传入到一个函数中时
4、对象作为一个子元素，存储到容器中时，例如 list=[mark,mark2]

引用计数-1的情况：
1、对象别名被显式销毁，例如 del mark
2、对象引用被赋予新的对象，例如mark2=mark3，此时mark引用计数-1（对照引用计数+1的情况下的第二点来看）
3、一个函数离开他的作用域，例如函数执行完成，它的引用参数的引用计数-1
4、对象所在容器被销毁，或者从容器中删除。

查看引用计数
import sys
a = “mark 帅哥”
print(sys.getrefcount(a))

引用计数机制优点
1、简单、直观
2、实时性，只要没有了引用就释放资源。

引用计数机制缺点
1、维护引用计数需要消耗一定的资源
2、循环应用时，无法回收。也正是因为这个原因，才需要通过标记-清理和分代收集机制来辅助引用计数机制。

2、标记-清理
python标记删除时通过l两个容器来完成的：死亡容器、存活容器。

c=[5,6]#假设此时c的引用为1
d=[7,8]#假设此时d的引用为1
#循环引用
c.append(d)#c的引用+1=2
d.append©#d的引用+1=2

首先，我们先来分析情况2，删除c、d
删除后，c的引用为1，d的引用为1，根据引用计数，还无法删除
标记删除第一步：对执行删除操作后的每个引用-1，此时c的引用为0，d的引用为0，把他们都放到死亡容器内。把那些引用仍然大于0的放到存活容器内。
标记删除第二步：遍历存活容器，查看是否有的存活容器引用了死亡容器内的对象，如果有就把该对象(注意是对象，比如0x7f94bb602f80，不是对象的引用)从死亡容器内取出，放到存活容器内。
由于c、d都没有对象引用他们了，所以经过这一步骤，他们还是在死亡组。
标记删除第三部：将死亡组所有对象删除。
这样就完成了对从c、d的删除。

3、分代回收
分代回收是建立在标记清除技术基础之上的，是一种以空间换时间的操作方式。

Python将内存根据对象的存活时间划分为不同的集合，每个集合称为一个代，Python将内存分为了3“代”，分别为年轻代（第0代）、中年代（第1代）、老年代（第2代），他们对应的是3个链表，它们的垃圾收集频率与对象的存活时间的增大而减小。新创建的对象都会分配在年轻代，年轻代链表的总数达到上限时，Python垃圾收集机制就会被触发，把那些可以被回收的对象回收掉，而那些不会回收的对象就会被移到中年代去，依此类推，老年代中的对象是存活时间最久的对象，甚至是存活于整个系统的生命周期内。

标题有三种情况会触发垃圾回收：

1.调用gc.collect(),
2.当gc模块的计数器达到阀值的时候。
3.程序退出的时候

gc模块的自动垃圾回收机制
必须要import gc模块，并且is_enable()=True才会启动自动垃圾回收。
这个机制的主要作用就是发现并处理不可达的垃圾对象。
垃圾回收=垃圾检查+垃圾回收
在Python中，采用分代收集的方法。把对象分为三代，一开始，对象在创建的时候，放在一代中，如果在一次一代的垃圾检查中，改对象存活下来，就会被放到二代中，同理在一次二代的垃圾检查中，该对象存活下来，就会被放到三代中。

gc模块里面会有一个长度为3的列表的计数器，可以通过gc.get_count()获取。
例如(488,3,0)，其中488是指距离上一次一代垃圾检查，Python分配内存的数目减去释放内存的数目，注意是内存分配，而不是引用计数的增加。

python 内存泄漏与内存溢出

内存泄漏:你使用malloc或new向 内存申请了一块内存空间,但没有用free以及delete对该块内存进行释放,造成程序失去了对该块内存的控制.
内存溢出:你申请了10个字节的内存,但写入了大于10个字节的数据.

内存泄漏解决办法:

资源性对象在不使用的时候，应该调用它的close()函数将其关闭掉。
需要在退出程序之前，将集合里的东西clear，然后置为null，再退出程序。

内存溢出的解决方案：

第一步，修改JVM启动参数，直接增加内存。

内存溢出的检查
from guppy import hpy
h = hpy()
print (h.heap())

memory_profiler是利用python的装饰器工作的，所以我们需要在进行测试的函数上添加装饰器。
通过上述两种工具guppy与memory_profiler可以很好地来监控python代码运行时的内存占用问题。

什么是python元类:

class New_Hello2(metaclass=HelloMeta2)

GIL：又叫全局解释器锁，每个线程在执行的过程中都需要先获取GIL，保证同一时刻只有一个线程在运行，目的是解决多线程同时竞争程序中的全局变量而出现的线程安全问题。

python 进程

from multiprocessing import Process
def func(name):
print(‘hello’, name)
if name == “main”:
p = Process(target=func,args=(‘zhangyanlin’,))
p.start()
p.join() # 等待进程执行完毕
start():启动进程，并调用该子进程中的p.run()
join([timeout]):让主线程等待某一子进程结束，才继续执行主进程。timeout是可选的超时时间。超过一个时间主进程就不等待了。

python 线程

import threading
import time

def worker(num):
time.sleep(1)
print(“The num is %d” % num)
return

for i in range(20):
t = threading.Thread(target=worker,args=(i,)，name=“t.%d” % i)
t.start()

进程池

#apply
from multiprocessing import Pool
import time

def f1(i):
time.sleep(0.5)
print(i)
return i + 100
if name == “main”:
pool = Pool(5)
for i in range(1,31):
pool.apply(func=f1,args=(i,))

#apply_async
def f1(i):
time.sleep(0.5)
print(i)
return i + 100
def f2(arg):
print(arg)
if name == “main”:
pool = Pool(5)
for i in range(1,31):
pool.apply_async(func=f1,args=(i,),callback=f2)
pool.close()
pool.join()

python迭代器

class MyNumbers:
def iter(self):
self.a = 1
return self

def next(self):
x = self.a
self.a += 1
return x

myclass = MyNumbers()
myiter = iter(myclass)
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))

python生成器

在 Python 中，使用了 yield 的函数被称为生成器。
在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。
import sys

def fibonacci(n): # 生成器函数 - 斐波那契
a, b, counter = 0, 1, 0
while True:
if (counter > n):
return
yield a
a, b = b, a + b
counter += 1
f = fibonacci(10) # f 是一个迭代器，由生成器返回生成

while True:
try:
print (next(f), end=" ")
except StopIteration:
sys.exit(）

标题Python 中的__new__和__init__的区别

同
二者均是Python面向对象语言中的函数，__new__比较少用，__init__则用的比较多。

异
__new__是在实例创建之前被调用的，因为它的任务就是创建实例然后返回该实例对象，是个静态方法。
__init__是当实例对象创建完成后被调用的，然后设置对象属性的一些初始值，通常用在初始化一个类实例的时候。是一个实例方法。
也就是： __new__先被调用，__init__后被调用，__new__的返回值（实例）将传递给__init__方法的第一个参数，然后__init__给这个实例设置一些参数。

Python 中的__new__和__init__的区别
同
二者均是Python面向对象语言中的函数，__new__比较少用，__init__则用的比较多。

异
__new__是在实例创建之前被调用的，因为它的任务就是创建实例然后返回该实例对象，是个静态方法。
__init__是当实例对象创建完成后被调用的，然后设置对象属性的一些初始值，通常用在初始化一个类实例的时候。是一个实例方法。
也就是： __new__先被调用，__init__后被调用，__new__的返回值（实例）将传递给__init__方法的第一个参数，然后__init__给这个实例设置一些参数。

标题线程间的通信方式

锁机制：包括互斥锁、条件变量、读写锁
*互斥锁提供了以排他方式防止数据结构被并发修改的方法。
*读写锁允许多个线程同时读共享数据，而对写操作是互斥的。
*条件变量可以以原子的方式阻塞进程，直到某个特定条件为真为止。对条件的测试是在互斥锁的保护下进行的。条件变量始终与互斥锁一起使用。

信号量机制(Semaphore)：包括无名线程信号量和命名线程信号量

信号机制(Signal)：类似进程间的信号处理

线程间的通信目的主要是用于线程同步，所以线程没有像进程通信中的用于数据交换的通信机制。

staticmethod()静态方法和classmethod类方法

一般来说，要使用某个类的方法，需要先实例化一个对象再调用方法。
而使用@staticmethod或@classmethod，就可以不需要实例化，直接类名.方法名()来调用。

那他们有什么区别呢，从它们的使用上来看：
@staticmethod不需要表示自身对象的self和自身类的cls参数，就跟使用函数一样。
@classmethod也不需要self参数，但第一个参数需要是表示自身类的cls参数。
如果在@staticmethod中要调用到这个类的一些属性方法，只能直接类名.属性名或类名.方法名。
而@classmethod因为持有cls参数，可以来调用类的属性，类的方法，实例化对象等，避免硬编码。

mysql索引用了何种数据结构？用b树和b+树有什么特点？

b+树：
(1).如果非叶子节点包含n个关键码，则这个节点有n个子树。
(2).非叶子节点仅包含关键码信息，叶子节点包含关键码以及含有这个关键码的记录的指针。所以查找时，B+树必须到达叶子节点才会命中。
(3).叶子节点包含有兄弟叶子节点的指针，而且叶子节点的关键码值是有序的，有利于遍历。
(4).所有的非叶子节点可看成是索引部分(稀疏索引)

2.为什么说B+树比B树更适合实际应用中作为操作系统的文件索引和数据库索引？
(1)B+树的磁盘读写代价更低
非叶子节点包含的信息更少，如果把同一节点的所有信息放在一个磁盘块中，则可以比B树放入更多的关键码。一次读入内存当中(读一个块)就能读入更多的关键码，所以降低了磁盘I/O总数。
(2)查询效率更加稳定
对任何关键字的查找都必须从根节点走到叶子节点，路径长度相同，所以对每条数据的查询效率相当。
(3)B树在提高磁盘I/O性能的同时并没有解决元素遍历效率低下的问题。而B+树因为叶子节点有链指针存在，所以遍历叶子节点即可以实现对整棵树的遍历。而在数据库中基于范围的查询是非常频繁的，B+树就能更好的支持。

一个m阶的B树具有如下几个特征：
1.根结点至少有两个子女。
2.每个中间节点都至少包含ceil(m / 2)个孩子，最多有m个孩子。
3.每一个叶子节点都包含k-1个元素，其中 m/2 <= k <= m。
4.所有的叶子结点都位于同一层。
5.每个节点中的元素从小到大排列，节点当中k-1个元素正好是k个孩子包含的元素的值域分划。

红黑树：
每个节点或者是黑色，或者是红色。
（2）根节点是黑色。
（3）每个叶子节点（NIL）是黑色。 [注意：这里叶子节点，是指为空(NIL或NULL)的叶子节点！]
（4）如果一个节点是红色的，则它的子节点必须是黑色的。
（5）从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑节点。

假设不采用“三次握手”，那么只要server发出确认，新的连接就建立了。

由于现在client并没有发出建立连接的请求，因此不会理睬server的确认，也不会向server发送数据,但server却以为新的运输连接已经建立，并一直等待client发来数据。
这样，server的很多资源就白白浪费掉了。
采用“三次握手”的办法可以防止上述现象发生。

什么是索引？

索引在MySQL中也叫做“键”或者"key"（primary key，unique key，还有一个index key），是存储引擎用于快速找到记录的一种数据结构。

主键（PRIMARY KEY）”的完整称呼是“主键约束”。MySQL主键约束是一个列或者列的组合，其值能唯一地标识表中的每一行。这样的一列或多列称为表的主键，通过它可以强制表的实体完整性。

事务

事务只和DML(insert、update、delete)语句有关，或者说DML语句才有事务
事务四大特征(ACID)
原子性(A)：事务是最小单位，不可再分
一致性©：事务要求所有的DML语句操作的时候，必须保证同时成功或者同时失败
隔离性(I)：事务A和事务B之间具有隔离性
持久性(D)：是事务的保证，事务终结的标志(内存的数据持久到硬盘文件中)

start transaction
DML语句
commit

回滚操作(事务失败)
start transaction
DML语句
rollback

HTTP协议和HTTPS协议区别如下：

1）HTTP协议是以明文的方式在网络中传输数据，而HTTPS协议传输的数据则是经过TLS加密后的，HTTPS具有更高的安全性
2）HTTPS在TCP三次握手阶段之后，还需要进行SSL 的handshake，协商加密使用的对称加密密钥
3）HTTPS协议需要服务端申请证书，浏览器端安装对应的根证书
4）HTTP协议端口是80，HTTPS协议端口是443

列表的数据结构

列表实现可以是数组和链表，在CPython中，列表被实现为长度可变的数组。

平衡二叉树

且具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。这个方案很好的解决了二叉查找树退化成链表的问题，把插入，查找，删除的时间复杂度最好情况和最坏情况都维持在O(logN)。但是频繁旋转会使插入和删除牺牲掉O(logN)左右的时间，不过相对二叉查找树来说，时间上稳定了很多。

二叉树的实际应用

1哈夫曼编码，哈夫曼树，在数据压缩上有重要应用，提高了传输的有效性。
2海量数据并发查询，二叉树复杂度是O(K+LgN)。二叉排序树就既有链表的好处，也有数组的好处，在处理大批量的动态的数据是比较有用。
3.C++ STL中的set/multiset、map，以及Linux虚拟内存的管理，都是通过红黑树去实现的。查找最大（最小）的k个数，红黑树，红黑树中查找/删除/插入，都只需要O(logk)。
4 B-Tree，B±Tree在文件系统中的目录应用。
5路由器中的路由搜索引擎。

如何在 1000 万个整数中快速查找某个整数？

我们的内存限制是100MB，每个数据大小是 8 字节，最简单的办法就是将数据存储在数组中，内存占用差不多是 80MB，符合内存的限制。我们可以先对这 1000 万数据从小到大排序，然后再利用二分查找算法，就可以快速地查找想要的数据了。