Python 【面试强化宝典】

#1. append 用于在列表末尾追加新的对象
a = [1,2,3]
a.append(4) #the result ： [1, 2, 3, 4]

#2. count 方法统计某个元素在列表中出现的次数
a = ['aa','bb','cc','aa','aa']
print(a.count('aa')) #the result ： 3

#3. extend 方法可以在列表的末尾一次性追加另一个序列中的多个值
a = [1,2,3]
b = [4,5,6]
a.extend(b) #the result ：[1, 2, 3, 4, 5, 6]

#4. index 函数用于从列表中找出某个值第一个匹配项的索引位置
a = [1,2,3,1]
print(a.index(1)) #the result ： 0

#5. insert 方法用于将对象插入到列表中
a = [1,2,3]
a.insert(0,'aa') #the result : ['aa', 1, 2, 3]

#6. pop 方法会移除列表中的一个元素（默认是最后一个），并且返回该元素的值
a = [1,2,3]
a.pop() #the result ： [1, 2] a.pop(0)

#7. remove 方法用于移除列表中某个值的第一个匹配项
a = ['aa','bb','cc','aa']
a.remove('aa') #the result ： ['bb', 'cc', 'aa']

#8. reverse 方法将列表中的元素反向存放
a = ['a','b','c']
a.reverse() #the result ： ['c', 'b', 'a']

#9. sort 方法用于在原位置对列表进行排序，意味着改变原来的列表，让其中的元素按一定顺序排列
a = ['a','b','c',1,2,3]
a.sort() #the result ：[1, 2, 3, 'a', 'b', 'c']

#10. enumrate
li = [11,22,33]
for k,v in enumerate(li, 1):
print(k,v)

#1. find 方法可以在一个较长的字符串中查找子串，他返回子串所在位置的最左端索引，如果没有找到则返回-1
a = 'abcdefghijk'
print(a.find('abc')) #the result ： 0
print(a.find('abc',10,100)) #the result ： 11 指定查找的起始和结束查找位置
#2. join 方法是非常重要的字符串方法，他是 split 方法的逆方法，用来连接序列中的元素，并且需要被连接的元素都 必须是字符串。
a = ['','','']
print('+'.join(a)) #the result ： 1+2+3
#3. split 方法,是一个非常重要的字符串，它是 join 的逆方法，用来将字符串分割成序列
print('1+2+3+4'.split('+')) #the result ： ['1', '2', '3', '4']
#4. strip 方法返回去除首位空格（不包括内部）的字符串
print(" test test ".strip()) #the result ：“test test”
#5. replace 方法返回某字符串所有匹配项均被替换之后得到字符串
print("This is a test".replace('is','is_test')) #the result ： This_test is_test a test

#1. clear 方法清除字典中所有的项，这是一个原地操作，所以无返回值（或则说返回 None）
d = {'name':"tom"}
d.clear() print(d) #the result : {}
#2. fromkeys 方法使用给定的键建立新的字典，每个键都对应一个默认的值 None
print({}.fromkeys(['name','age'])) #the result ： {'age': None, 'name': None}

#3. get 方法是个更宽松的访问字典项的方法，如果试图访问字典中不存在的项时不会报错仅会 返回：None
d = {'Tom':8777,'Jack':8888,'Fly':6666}
print(d.get('Tom')) #the result ： 8777
print(d.get('not_exist')) #the result ： None

#4. for 循环字典的三种方法
d = {'Tom':8777,'Jack':8888,'Fly':6666}
for k,v in d.items():
print(k,v)
for k in d.values():
print(k)
for k in d.keys():
print(k)#5. pop 方法用于获得对应与给定键的值，然后将这个”键-值”对从字典中移除
d = {'Tom':8777,'Jack':8888,'Fly':6666}
v = d.pop('Tom')
print(v) #8777

#6. setdefault 方法在某种程度上类似于 get 方法，能够获得与给定键相关联的值，除此之外，setdefault 还能在字典 中不含有给定键的情况下设定相应的键值
d = {'Tom':8777,'Jack':8888,'Fly':6666}
d.setdefault('Tom') #the result ： 8777
print(d.setdefault('Test')) #the result ： None
print(d) #{'Fly': 6666, 'Jack': 8888, 'Tom': 8777, 'Test': None}

#7. update 方法可以利用一个字典项更新另一个字典，提供的字典中的项会被添加到旧的字典中，如有相同的键则会被 覆盖
d = {'Tom':8777,'Jack':8888,'Fly':6666}
a = {'Tom':110,'Test':119}
d.update(a) print(d) #the result ：{'Fly': 6666, 'Test': 119, 'Jack': 8888, 'Tom': 110}

#8. 将两个列表组合成字典
keys = ['a', 'b']
values = [1, 2]
print(dict(zip(keys,values))) # {'a': 1, 'b': 2}

list_1 = [1,2,3,4,5,1,2]
#1、去重(去除 list_1 中重复元素 1,2)
list_1 = set(list_1) #去重： {1, 2, 3, 4, 5}
print(list_1)
list_2 = set([4,5,6,7,8]) #2、交集（在 list_1 和 list_2 中都有的元素 4,5）
print(list_1.intersection(list_2)) #交集： {4, 5}

#3、并集（在 list_1 和 list_2 中的元素全部打印出来，重复元素仅打印一次）
print(list_1.union(list_2)) #并集： {1, 2, 3, 4, 5, 6, 7, 8}

#4、差集
print(list_1.difference(list_2)) #差集：在 list_1 中有在 list_2 中没有： {1, 2, 3}
print(list_2.difference(list_1)) #差集：在 list_1 中有在 list_2 中没有： {8, 6, 7}

from multiprocessing import Process,Pool
import time,os
def foo(i):
time.sleep(2)
print("in the process",os.getpid()) #打印子进程的 pid
return i+100 def call(arg):
print('-->exec done:',arg,os.getpid()) if __name__ == '__main__':
pool = Pool(3) #进程池最多允许 5 个进程放入进程池
print("主进程 pid：",os.getpid()) #打印父进程的 pid
for i in range(10):
#用法 1 callback 作用是指定只有当 Foo 运行结束后就执行 callback 调用的函数,父进程调用的 callback 函数
pool.apply_async(func=foo, args=(i,),callback=call)
#用法 2 串行 启动进程不在用 Process 而是直接用
pool.apply() # pool.apply(func=foo, args=(i,))
print('end')
pool.close() #关闭
pool pool.join() #进程池中进程执行完毕后再关闭，如果注释，那么程序直接关闭。

• for 循环同时启动多个线程

• t.join()： 实现所有线程都执行结束后再执行主线程

• setDaemon(): 守护线程，主线程退出时，需要子线程随主线程退出

• GIL 全局解释器锁：保证同一时间仅有一个线程对资源有操作权限
  • 作用：在一个进程内，同一时刻只能有一个线程执行
  • 说明：python 多线程中 GIL 锁只是在 CPU 操作时（如：计算）才是串行的，其他都是并行的，所以比串行快很
  • 为了解决不同线程同时访问同一资源时，数据保护问题，而产生了 GIL
  • GIL 在解释器的层面限制了程序在同一时间只有一个线程被 CPU 实际执行，而不管你的程序里实际开了多少条线程
  • 为了解决这个问题，CPython 自己定义了一个全局解释器锁，同一时间仅仅有一个线程可以拿到这个数据
  • python 之所以会产生这种不好的状况是因为 python 启用一个线程是调用操作系统原生线程，就是 C 接口
  • 但是这仅仅是 CPython 这个版本的问题，在 PyPy，中就没有这种缺陷

• 线程锁
  • 当一个线程对某个资源进行 CPU 计算的操作时加一个线程锁，只有当前线程计算完成主动释放锁，其他线程才能对其操作
  • 这样就可以防止还未计算完成，释放 GIL 锁后其他线程对这个资源操作导致混乱问题

• Semaphore(信号量)
  • 互斥锁 同时只允许一个线程更改数据，而 Semaphore 是同时允许一定数量的线程更改数据
  • 比如厕所有 3 个坑，那最多只允许 3 个人上厕所，后面的人只能等里面有人出来了才能再进去
  • 作用就是同一时刻允许运行的线程数量

• 线程池实现并发

• • 什么是协程（进入上一次调用的状态）
    • 协程，又称微线程，纤程，协程是一种用户态的轻量级线程。
    • 线程的切换会保存到 CPU 的栈里，协程拥有自己的寄存器上下文和栈，
    • 协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈
    • 协程能保留上一次调用时的状态（即所有局部状态的一个特定组合），每次过程重入时，就相当于进入上一次调用的状态
    • 协程最主要的作用是在单线程的条件下实现并发的效果，但实际上还是串行的（像 yield 一样）

• • 协程缺点(无法利用多核资源)
    • 协程的本质是个单线程,它不能同时将 单个 CPU 的多个核用上,协程需要和进程配合才能运行在多 CPU 上线程阻塞（Blocking）操作（如 IO时）会阻塞掉整个程序

• • 协程为何能处理大并发 1：Greenlet 遇到 I/O 手动切换
    • 协程之所以快是因为遇到 I/O 操作就切换（最后只有 CPU 运算）
    • 这里先演示用 greenlet 实现手动的对各个协程之间切换
    • 其实 Gevent 模块仅仅是对 greenlet 的再封装，将 I/O 间的手动切换变成自动切换

• • 协程为何能处理大并发 2：Gevent 遇到 I/O 自动切换
    • Gevent 是一个第三方库，可以轻松通过 gevent 实现并发同步或异步编程
    • 在 gevent 中用到的主要模式是 Greenlet, 它是以 C 扩展模块形式接入 Python 的轻量级协程
    • Greenlet 全部运行在主程序操作系统进程的内部，但它们被协作式地调度。
    • Gevent 原理是只要遇到 I/O 操作就会自动切换到下一个协程

• • 使用协程处理并发

• • select （能监控数量有限，不能告诉用户程序具体哪个连接有数据）
    • select 目前几乎在所有的平台上支持，其良好跨平台支持也是它的一个优点
    • select 的一个缺点在于单个进程能够监视的文件描述符的数量存在最大限制，在 Linux 上一般为 1024
    • select 监控 socket 连接时不能准确告诉用户是哪个，比如：现在用 socket 监控 10000 链接，如果其中有一个链接有数据了，select 就会告诉用户程序，你有 socket 来数据了，那样就只能自己循环 10000 次判断哪个活跃

• • poll（和 select 一样，仅仅去除了最大监控数量）
    • poll 和 select 在本质上没有多大差别，但是 poll 没有最大文件描述符数量的限制
    • 可以理解为 poll 是一个过渡阶段，大家也都不用他

• • epoll (不仅没有最大监控数量限制，还能告诉用户程序哪个连接有活跃)
    • 注：epoll 被认为是 linux 下性能最好的多路 io 就绪通知方法
    • epoll 直到 Linux2.6（centos6 以后）才出现了由内核直接支持
    • Epoll 没有最大文件描述符数量限制
    • epoll 最重要的优点是他可以直接告诉用户程序哪一个，比如现在用 epoll 去监控 10000 个 socket 链接，交给内核去监测，现在有一个连接有数据了，在有有一个连接有数据了，epoll 会直接高数用户程序哪个连接有数据了

• • epoll 能实现高并发原理
    • epoll() 中内核则维护一个链表，epoll_wait 直接检查链表是不是空就知道是否有文件描述符准备好了。
    • 在内核实现中 epoll 是根据每个 sockfd 上面的与设备驱动程序建立起来的回调函数实现的。
    • 某个 sockfd 上的事件发生时，与它对应的回调函数就会被调用，把这个 sockfd 加入链表。
    • epoll 上面链表中获取文件描述，这里使用内存映射（mmap）技术， 避免了复制大量文件描述符带来的开销
    • 内存映射（mmap）：内存映射文件，是由一个文件到一块内存的映射，将不必再对文件执行 I/O 操作

• • 装饰器定义
    • 不能修改被装饰函数的源代码，不能修改被装饰函数的调用方式，为其他函数添加其他功能

• • 使用高阶函数模拟装饰器

• 计算运行时间装饰器

• • 装饰器使用场景
    • 授权：装饰器能有助于检查某个人是否被授权去使用一个 web 应用的端点(endpoint)。它们被大量使用于 Flask 和 Django web 框架中
    • 日志：在记录日志的地方添加装饰器
    • 缓存：通过装饰器获取缓存中的值

• • 生成器的作用
    • 通过列表生成式，我们可以直接创建一个列表，但是，受到内存限制，列表容量肯定是有限的。
    • 而且，创建一个包含 100 万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。
    • 所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？
    • 这样就不必创建完整的 list，从而节省大量的空间。在 Python 中，这种一边循环一边计算的机制，称为生成器：generator。
  • 生成器工作原理
    • 生成器是这样一个函数，它记住上一次返回时在函数体中的位置。
    • 对生成器函数的第二次（或第 n 次）调用跳转至该函数中间，而上次调用的所有局部变量都保持不变。
    • 生成器不仅“记住”了它数据状态；生成器还“记住”了它在流控制构造中的位置。
    • 生成器是一个函数，而且函数的参数都会保留。
    • 迭代到下一次的调用时，所使用的参数都是第一次所保留下的，即是说，在整个所有函数调用的参数都是第一次所调用时保留的，而不是新创建的

• • yield 生成器运行机制
    • 在 Python 中，yield 就是这样的一个生成器。
    • 当你问生成器要一个数时，生成器会执行，直至出现 yield 语句，生成器把 yield 的参数给你，之后生成器就不会往下继续运行。
    • 当你问他要下一个数时，他会从上次的状态开始运行，直至出现 yield 语句，把参数给你，之后停下。如此反复
    • 在 python 中，当你定义一个函数，使用了 yield 关键字时，这个函数就是一个生成器
    • 它的执行会和其他普通的函数有很多不同，函数返回的是一个对象，而不是你平常所用 return 语句那样，能得到结果值。如果想取得值，那得调用 next()函数
    • 每当调用一次迭代器的 next 函数，生成器函数运行到 yield 之处，返回 yield 后面的值且在这个地方暂停，所有的状态都会被保持住，直到下次 next 函数被调用，或者碰到异常循环退出。

• • yield 实现 fib 数

• • 生成器和迭代器之间的区别
    • 在使用生成器时，我们创建一个函数；在使用迭代器时，我们使用内置函数 iter()和 next()。 在生成器中，我们使用关键字‘yield’来每次生成/返回一个对象。
    • 生成器中有多少‘yield’语句，你可以自定义。 每次‘yield’暂停循环时，生成器会保存本地变量的状态。而迭代器并不会使用局部变量，它只需要一个可迭代对象进行迭代。 使用类可以实现你自己的迭代器，但无法实现生成器。
    • 生成器运行速度快，语法简洁，更简单。 迭代器更能节约内存。

Python 面向对象

• 面向对象三大特性: 封装，继承，多态

• • 封装
  • 在类中对数据的赋值、内部调用对外部用户是透明的
  • 这使类变成了一个胶囊或容器，里面包含着类的数据和方法
  • 作用：
    • 防止数据被随意修改
    • 使外部程序不需要关注对象内部的构造，只需要通过对外提供的接口进行直接访问

• • Inheritance 继承（代码重用）
    • 一个类可以派生出子类，在这个父类里定义的属性、方法自动被子类继承
    • 比如 CS 中的警察和恐怖分子，可以将两个角色的相同点写到一个父类中，然后同时去继承它
    • 使用经典类： Person.__init__(self,name,age) 并重写写父类 Person 的构造方法，实现，先覆盖，再继承，再重构

• • Polymorphism 多态（接口重用）
    • 多态是面向对象的重要特性,简单点说:“一个接口，多种实现”
    • 指一个基类中派生出了不同的子类，且每个子类在继承同样的方法名的同时又对父类的方法做了不同的实现
    • 这就是同一种事物表现出的多种形态
    • 比如黄种人继承了人 talk 这个功能，但是他说的是中文，而美国人的 talk 是英文，但是他们是同样的 talk
    • 作用：简单的讲就是允许父类调用子类的方法

• • 静态方法
  • 作用：静态方法可以更好的组织代码，防止代码变大后变得比较混乱。
  • 特性: 静态方法只是名义上归类管理，实际上在静态方法里访问不了类或则实例中的任何属性
  • 静态方法使用场景：
    • 我们要写一个只在类中运行而不在实例中运行的方法.
    • 经常有一些跟类有关系的功能但在运行时又不需要实例和类参与的情况下需要用到静态方法.
    • 比如更改环境变量或者修改其他类的属性等能用到静态方法.
    • 这种情况可以直接用函数解决, 但这样同样会扩散类内部的代码，造成维护困难.
    • 调用方式: 既可以被类直接调用，也可以通过实例调用

• • 类方法
  • 作用：无需实例化直接被类调用
  • 特性: 类方法只能访问类变量，不能访问实例变量
  • 类方法使用场景： 当我们还未创建实例，但是需要调用类中的方法
  • 调用方式: 既可以被类直接调用，也可以通过实例调用

• • 属性方法
  • 作用：属性方法把一个方法变成一个属性，隐藏了实现细节,调用时不必加括号直接 d.eat 即可调用 self.eat()方法

• 魔法方法
  • type 生成类调用顺序
    • __new__ : 先于__init__方法，每生成一个实例执行一次，__new__ 类方法创建实例对象
    • __init__: __init__方法每生成一个实例就会执行一次，初始化实例对象
    • __call__ :后与__init__方法，C()() 使用类再加一个括号调用， C 为类名称
    • __del__:析构方法，删除无用的内存对象（当程序结束会自动自行析构方法）

• 类实例化时魔法方法调用顺序

• • 预备知识一——python 的变量及其存储
    • python 的一切变量都是对象，变量的存储，采用了引用语义的方式，存储的只是一个变量的值所在的内存地址，而不是这个变量的只本身
    • 不管多么复杂的数据结构，浅拷贝都只会 copy 一层。
    • 理解：两个人公用一张桌子，只要桌子不变，桌子上的菜发生了变化两个人是共同感受的。

• • 浅 copy 与 deepcopy
    • 浅 copy： 不管多么复杂的数据结构，浅拷贝都只会 copy 一层
    • deepcopy : 深拷贝会完全复制原变量相关的所有数据，在内存中生成一套完全一样的内容，我们对这两个变量中任意一个修改都不会影响其他变量

• • 引用计数
    • 当一个对象的引用被创建或者复制时，对象的引用计数加 1；当一个对象的引用被销毁时，对象的引用计数减 1.
    • 当对象的引用计数减少为 0 时，就意味着对象已经再没有被使用了，可以将其内存释放掉。

• • 标记－清除
    • 它分为两个阶段：第一阶段是标记阶段，GC 会把所有的活动对象打上标记，第二阶段是把那些没有标记的对象非活动对象进行回收。
    • 对象之间通过引用（指针）连在一起，构成一个有向图3）从根对象（root object）出发，沿着有向边遍历对象，可达的（reachable）对象标记为活动对象，不可达的对象就是要被清除的非活动对象，根对象就是全局变量、调用栈、寄存器。
    • 注：像是 PyIntObject、PyStringObject 这些不可变对象是不可能产生循环引用的，因为它们内部不可能持有其它对象的引用。

• • 在上图中，可以从程序变量直接访问块 1，并且可以间接访问块 2 和 3,程序无法访问块 4 和 5
  • 第一步将标记块 1，并记住块 2 和 3 以供稍后处理。
  • 第二步将标记块 2，第三步将标记块 3，但不记得块 2，因为它已被标记。
  • 扫描阶段将忽略块 1，2 和 3，因为它们已被标记，但会回收块 4 和 5。
• 分代回收
  • 分代回收是建立在标记清除技术基础之上的，是一种以空间换时间的操作方式。
  • Python 将内存分为了 3“代”，分别为年轻代（第 0 代）、中年代（第 1 代）、老年代（第 2 代）
  • 他们对应的是 3 个链表，它们的垃圾收集频率与对象的存活时间的增大而减小。
  • 新创建的对象都会分配在年轻代，年轻代链表的总数达到上限时，Python 垃圾收集机制就会被触发
  • 把那些可以被回收的对象回收掉，而那些不会回收的对象就会被移到中年代去，依此类推
  • 老年代中的对象是存活时间最久的对象，甚至是存活于整个系统的生命周期内。

• • with 语句使用场景
    • with 语句适用于对资源进行访问的场合，确保不管使用过程中是否发生异常都会执行必要的“清理”操作，释放资源
    • 比如文件使用后自动关闭、线程中锁的自动获取和释放等。
  • with 处理文件操作的实例

• • 三元运算
    • 三元运算格式： result=值 1 if x<y else 值 2if 条件成立 result=1,否则 result=2
    • 作用：三元运算，又称三目运算，主要作用是减少代码量，是对简单的条件语句的缩写

• filter()函数可以对序列做过滤处理
  • 利用 filter、lambda 表达式 获取 l1 中元素小于 33 的所有元素 l1 = [11, 22, 33, 44, 55]

• Map 是对序列根据设定条件进行操作后返回他设置的是操作方法

• reduce 函数使用 reduce 进行求和运算
  • reduce()函数即为化简函数，它的执行过程为：每一次迭代，都将上一次的迭代结果与下一个元素一同传入二元 func 函数中去执行。
  • 在 reduce()函数中，init 是可选的，如果指定，则作为第一次迭代的第一个元素使用，如果没有指定，就取 seq 中的第一个元素。

• sorted 函数
  • sorted 对字典排序

MySQL 宝典

• • 事务的（ACID）特征
    • 原子性(Atomicity)：整个事物的所有操作要么全部提交成功，要么全部失败回滚(不会出现部分执行的情况)。
    • 一致性(Consistency)：几个并行执行的事务，其执行结果必须与按某一顺序串行执行的结果相一致。
    • 隔离性(Isolation)：事务的执行不受其他事务的干扰，事务执行的中间结果对其他事务必须是透明的。
    • 持久性(Durability): 一个事务一旦被提交了，那么对数据库中的数据的改变就是永久性的，即便是在数据库系统遇到故障的情况下也不会丢失提交事务的操作。
• 事物隔离级别
  • 未提交读: 脏读（READ UNCOMMITTED）
    • 事务 2 查询到的数据是事务 1 中修改但未提交的数据，但因为事务 1 回滚了数据
    • 所以事务 2 查询的数据是不正确的，因此出现了脏读的问题。
  • 提交读: 不可重复读（READ COMMITTED）
    • 事务 2 执行 update 语句但未提交前，事务 1 的前两个 select 操作返回结果是相同的。
    • 但事务 2 执行 commit 操作后，事务 1 的第三个 select 操作就读取到事务 2 对数据的改变。
    • 导致与前两次 select 操作返回不同的数据，因此出现了不可重复读的问题。
  • 可重复读: 幻读（REPEATABLE READ）：这是 MySQL 的默认事务隔离级别
    • 事务每开启一个实例，都会分配一个版本号给它，如果读取的数据行正在被其它事务执行 DELETE 或 UPDATE 操作（即该行上有排他锁）
    • 这时该事物的读取操作不会等待行上的锁释放，而是根据版本号去读取行的快照数据（记录在 undo log 中）
    • 这样，事务中的查询操作返回的都是同一版本下的数据，解决了不可重复读问题。
    • 虽然该隔离级别下解决了不可重复读问题，但理论上会导致另一个问题：幻读（Phantom Read）。
    • 一个事务在执行过程中，另一个事物对已有数据行的更改，MVCC 机制可保障该事物读取到的原有数据行的内容相同
    • 但并不能阻止另一个事务插入新的数据行，这就会导致该事物中凭空多出数据行，像出现了幻读一样，这便是幻读问题。
  • 可串行读（SERIALIZABLE）
    • 这是事务的最高隔离级别，通过强制事务排序，使之不可能相互冲突，就是在每个读的数据行加上共享锁来实现
    • 在该隔离级别下，可以解决前面出现的脏读、不可重复读和幻读问题，但也会导致大量的超时和锁竞争现象，一般不推荐使用

• 乐观锁实现方法
  • 每次获取商品时，不对该商品加锁。
  • 在更新数据的时候需要比较程序中的库存量与数据库中的库存量是否相等，如果相等则进行更新
  • 反之程序重新获取库存量，再次进行比较，直到两个库存量的数值相等才进行数据更新。

• 悲观锁
  • 每次获取商品时，对该商品加排他锁。
  • 也就是在用户 A 获取获取 id=1 的商品信息时对该行记录加锁，期间其他用户阻塞等待访问该记录。

• 排它锁
  • 排它锁又叫写锁，如果事务 T 对 A 加上排它锁，则其它事务都不能对 A 加任何类型的锁。获准排它锁的事务既能读数据，又能写数据。
  • 用法 ： SELECT … FOR UPDATE

• 共享锁(share lock)
  • 共享锁又叫读锁，如果事务 T 对 A 加上共享锁，则其它事务只能对 A 再加共享锁，不能加其它锁。
  • 获准共享锁的事务只能读数据，不能写数据。
  • 用法： SELECT … LOCK IN SHARE MODE;

• B+tree(以每个节点可存 4 个建值及指针信息为例)
  • B+Tree 的非叶子节点只存储键值信息，假设每个磁盘块能存储 4 个键值及指针信息
  • 在 B+Tree 上有两个头指针，一个指向根节点，另一个指向关键字最小的叶子节点，而且所有叶子节点（即数据节点）之间是一种链式环结构。因此可以对 B+Tree 进行两种查找运算：一种是对于主键的范围查找和分页查找，另一种是从根节点开始，进行随机查找。
  • B+tree实在B-tree基础上进行了优化。更适合外部的存储结构，InnoDB存储引擎就是利用B+tree实现的索引原理。
  • B+tree所有的数据记录节点都是按照键值大小顺序存放在同一层的叶子节点上，而非叶子节点上只存储Key值信息，这样可以大大提高了每个叶节点的key值数量，降低了B+tree的高度，自然查询比较效率。

• • master 服务器将数据的改变记录二进制 binlog 日志，当 master 上的数据发生改变时，则将其改变写入二进制日志中；
  • slave 服务器会在一定时间间隔内对 master 二进制日志进行探测其是否发生改变，如果发生改变，则开始一个 I/OThread 请求 master二进制事件
  • 同时主节点为每个 I/O 线程启动一个 dump 线程，用于向其发送二进制事件，并保存至从节点本地的中继日志中，从节点将启动 SQL 线程从中继日志中读取二进制日志，在本地重放，使得其数据和主节点的保持一致，最后 I/OThread 和 SQLThread 将进入睡眠状态，等待下一次被唤醒。

• • 参考答案
    • MySQL 的慢查询，全名是慢查询日志，是 MySQL 提供的一种日志记录，用来记录在 MySQL 中响应时间超过阀值的语句。具体环境中，运行时间超过 long_query_time 值的 SQL 语句，则会被记录到慢查询日志中。long_query_time 的默认值为 10，意思是记录运行10 秒以上的语句。默认情况下，MySQL 数据库并不启动慢查询日志，需要手动来设置这个参数。
    • 当然，如果不是调优需要的话，一般不建议启动该参数，因为开启慢查询日志会或多或少带来一定的性能影响。此外，慢查询日志支持将日志记录写入文件和数据库表。
  • MySQL 慢查询的相关参数解释：
    • slow_query_log：是否开启慢查询日志，1 表示开启，0 表示关闭。
    • log-slow-queries ：旧版（5.6 以下版本）MySQL 数据库慢查询日志存储路径。可以不设置该参数，系统则会默认给一个缺省的文件host_name-slow.log
    • slow-query-log-file：新版（5.6 及以上版本）MySQL 数据库慢查询日志存储路径。可以不设置该参数，系统则会默认给一个缺省的文件 host_name-slow.log
    • long_query_time：慢查询阈值，当查询时间多于设定的阈值时，记录日志。
    • log_queries_not_using_indexes：未使用索引的查询也被记录到慢查询日志中（可选项）。
    • log_output：日志存储方式。log_output='FILE'表示将日志存入文件，默认值是'FILE'。log_output='TABLE'表示将日志存入数据库。那么如何进行慢查询日志的配置呢？默认情况下 slow_query_log 的值为 OFF，表示慢查询日志是禁用的，可以通过设置

• 使用 set global slow_query_log=1 开启了慢查询日志只对当前数据库生效，MySQL 重启后则会失效。如果要永久生效，就必须修改
• 配置文件 my.cnf（其它系统变量也是如此）

• my.cnf 要增加或修改参数 slow_query_log 和 slow_query_log_file，如下所示：

• slow_query_log_file 这个参数用于指定慢查询日志的存放路径，缺省情况是 host_name-slow.log 文件。

• 开启了慢查询日志后，什么样的 SQL 才会记录到慢查询日志里面呢？这个是由参数 long_query_time 控制，默认情况下

• 当我们在上面执行了一次 sleep5 之后，这条操作将会被记录在慢查询日志中，我们来看看：

• 一些其他慢查询配置选项如下。
  • log-queries-not-using-indexes 该系统变量指定未使用索引的查询也被记录到慢查询日志中，调优的话，建议开启这个选项。另外，
  • 开启了这个参数，其实使用 full index scan 的 SQL 也会被记录到慢查询日志。

• • 安装所需依赖

• 安装工具

• 在进行主从校验之前，我们首先需要对主从库进行授权，来看看如何来做吧
• 主库授权

• 从库授权

• 而从库的数据于主库是不一致的，我们来欣赏下从库不一致的数据：

• 接下来，我们通过工具进行检测

• 命令会展示如下的结果

• 其中如上表所示的结果中，各字段解释如下

• 清晰的看到，当主从之间数据不一致时，进行一致性检查看到的结果 DIFF 为 1。此时代表一致性是错误的。

• 上面命令的各参数的意思在这里也做好事做到底来解释一下：

• 接着上面的复制情况，主和从的 t1 表数据不一致，需要修复，首先执行：

• 参数的意义：

• 没发现任何异常，然后检查主从数据的一致性：

• 再来看看对应的数据库吧：

• 最后，这些工具很给力，工作中常常在使用。注意使用该工具需要授权，一般 SELECT, PROCESS, SUPER, REPLICATION SLAVE 等权限就已经足够了。

• • 具体实现步骤
  • 首先基于 docker 拉取 mysql 镜像

• • 使用下载好的镜像，启动主从两个容器

• 配置主从

• vi my.cnf，进入/etc/mysql 目录下，对 my.cnf 进行编辑

• 创建主从所需权限用户

• 配置从数据库

• 字符串（string）
  • value 的数据结构（数组）
    • 字符串 value 数据结构类似于数组，采用与分配容易空间来减少内存频繁分配
    • 当字符串长度小于 1M 时，扩容就是加倍现有空间
    • 如果字符串长度操作 1M 时，扩容时最多扩容 1M 空间，字符串最大长度为 512M
  • 字符串的使用场景（缓存）
    • 字符串一个常见的用途是缓存用户信息，我们将用户信息使用 JSON 序列化成字符串
    • 取用户信息时会经过一次反序列化的过程
• list（列表）
  • value 的数据结构（双向链表）
    • 列表的数据结构是双向链表，这意味着插入和删除的时间复杂度是 0(1)，索引的时间复杂度位 0(n)
    • 当列表弹出最后一个元素后，该数据结构会被自动删除，内存被回手
  • 列表的使用场景（队列、栈）

• hash（字典）
  • value 的数据结构（HashMap）
    • redis 中的字典也是 HashMap（数组+列表）的二维结构
    • 不同的是 redis 的字典的值只能是字符串
  • hash 的使用场景（缓存）
    • hash 可以用来缓存用户信息，与字符串一次性全部序列化整个对象不同，hash 可以对每个字段进行单独存储
    • 这样可以部分获取用户信息，节约网络流量
    • hash 也有缺点，hash 结构的存储消耗要高于单个字符串

• watch 指令
  • watch 其实就是 redis 提供的一种乐观锁，可以解决并发修改问题
  • watch 会在事物开始前盯住一个或多个关键变量，当服务器收到 exec 指令要顺序执行缓存中的事物队列时
  • redis 会检查关键变量自 watch 后是否被修改（包括当前事物所在的客户端）
  • 如果关键变量被人改动过，exec 指令就会返回 null 回复告知客户端事物执行失败，这个时候客户端会选择重试
  • 注：redis 禁用在 multi 和 exec 之间执行 watch 指令，必须在 multi 之前盯住关键变量，否则会出错

• • • 但是这样有一个问题，如果逻辑执行到中间出现异常，可能导致 del 指令没有被调用，这样就会陷入死锁，锁永远无法释放
    • 为了解决死锁问题，我们拿到锁时可以加上一个 expire 过期时间，这样即使出现异常，当到达过期时间也会自动释放锁> setnx lock:codehole true

• • • 这样又有一个问题，setnx 和 expire 是两条指令而不是原子指令，如果两条指令之间进程挂掉依然会出现死锁
    • 为了治理上面乱象，在 redis 2.8 中加入了 set 指令的扩展参数，使 setnx 和 expire 指令可以一起执行

• • 全量同步（快照同步）
  • 注：Redis 全量复制一般发生在 Slave 初始化阶段，这时 Slave 需要将 Master 上的所有数据都复制一份。具体步骤如下：
  • 从服务器连接主服务器，发送 SYNC 命令；
  • 主服务器接收到 SYNC 命名后，开始执行 BGSAVE 命令生成 RDB 文件并使用缓冲区记录此后执行的所有写命令；
  • 主服务器 BGSAVE 执行完后，向所有从服务器发送快照文件，并在发送期间继续记录被执行的写命令；
  • 从服务器收到快照文件后丢弃所有旧数据，载入收到的快照；
  • 主服务器快照发送完毕后开始向从服务器发送缓冲区中的写命令；
  • 从服务器完成对快照的载入，开始接收命令请求，并执行来自主服务器缓冲区的写命令；
  • 完成上面几个步骤后就完成了从服务器数据初始化的所有操作，从服务器此时可以接收来自用户的读请求。

• • 配置传播
  • 一旦一个 sentinel 成功地对一个 master 进行了 failover，它将会把关于 master 的最新配置通过广播形式通知其它 sentinel，其它的sentinel 则更新对应 master 的配置。
  • 一个 faiover 要想被成功实行，sentinel 必须能够向选为 master 的 slave 发送 SLAVE OF NO ONE 命令，然后能够通过 INFO 命令看到新 master 的配置信息。
  • 当将一个 slave 选举为 master 并发送 SLAVE OF NO ONE`后，即使其它的 slave 还没针对新 master 重新配置自己，failover 也被认为是成功了的。
  • 因为每一个配置都有一个版本号，所以以版本号最大的那个为标准：
  • 假设有一个名为 mymaster 的地址为 192.168.1.50:6379。
  • 一开始，集群中所有的 sentinel 都知道这个地址，于是为 mymaster 的配置打上版本号 1。
  • 一段时候后 mymaster 死了，有一个 sentinel 被授权用版本号 2 对其进行 failover。
  • 如果 failover 成功了，假设地址改为了 192.168.1.50:9000，此时配置的版本号为 2
  • 进行 failover 的 sentinel 会将新配置广播给其他的 sentinel，发现新配置的版本号为 2 时，版本号变大了，说明配置更新了，于是 就会采用最新的版本号为 2 的配置。

• • 进入从库发现 6380 之前的角色是 slave，现在已经是 master 了。也就是成功了。

l = list(range(1,101))
def bin_search(data_set,val):
low = 0
high = len(data_set) - 1
while low <= high:
mid = (low+high)//2
if data_set[mid] == val:
return mid
elif data_set[mid] < val:
low = mid + 1
else:
high = mid - 1
return
n = bin_search(l,11)
print(n) # 返回结果是： 10

#! /usr/bin/env pythonf
# -*- coding: utf-8 -*-
def bubble_sort(li):
for i in range(len(li)-1):
for j in range(len(li)-i-1):
if li[j] > li[j+1]:
li[j],li[j+1]=li[j+1],li[j]
li = [1,5,2,6,3,7,4,8,9,0]
bubble_sort(li)
print(li) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

#! /usr/bin/env python
# -*- coding: utf-8 -*-
def quick(list):
if len(list) < 2:
return list tmp = list[0] # 临时变量 可以取随机值
left = [x for x in list[1:] if x <= tmp] # 左列表
right = [x for x in list[1:] if x > tmp] # 右列表
return quick(left) + [tmp] + quick(right) li = [4,3,7,5,8,2]
print quick(li) # [2, 3, 4, 5, 7, 8]
#### 对[4,3,7,5,8,2]排序
'''
[3, 2] + [4] + [7, 5, 8] # tmp = [4]
[2] + [3] + [4] + [7, 5, 8] # tmp = [3] 此时对[3, 2]这个列表进行排序
[2] + [3] + [4] + [5] + [7] + [8] # tmp = [7] 此时对[7, 5, 8]这个列表进行排序 '''
# 注：快排代码实现（类似于二叉树 递归调用）----右手左手一个慢动作，右手左手一个慢动作重播

def fun(i):
if i == 0:
return 0
elif i == 1:
return 1
else:
return fun(i-2) + fei(i-1)
if __name__ == '__main__':
for i in range(10):
print(fun(i),end=" ")

# 一只青蛙一次可以跳上 1 级台阶，也可以跳上 2 级……它也可以跳上 n 级。求该青蛙跳上一个 n 级的台阶
总共有多少种跳法。
fib = lambda n: n if n < 2 else 2 * fib(n - 1)

• 为了解决这些问题，我们需要有一个程序来监听 ASP.NET Core 应用程序的状况。并在应用程序停止运行的时候立即重新启动

1、系统命令 runlevel # 查看当前的运行级别
systemctl status firewalld # 开启网络服务功能
stop # 关闭
restart # 重启
reload # 重载
reboot # 重启
halt # 关机
poweroff # 关机 2、查看文件常用指令
cat # 在命令提示符下查看文件内容
more # 在命令提示符中分页查看文件内容
less # 命令行中查看文件可以上下翻页反复浏览
head # 命令行中查看文件头几行
tail # 命令行中查看文件尾几行
wc # 统计文件的单词数 行数等信息 3、目录管理常用指令
pwd # 查看你当前所在的目录
cd # 切换目录
ls # 查看显示目录的内容
du # 统计目录和文件空间的占用情况
mkdir # 创建新目录
rmdir # 删除空目录
touch # 创建文件
rm # 删除文件
ln # 创建硬链接
ln -s # 创建软链接
cp # 复制文件或目录
mv # 移动文件或目录
which # 查看 linux 命令所在的目录 复制代码 4、账号与权限
'''1.组管理'''
groupadd group_name # 创建一个新用户组
groupdel group_name # 删除一个用户组
groupmod -n new_group_name old_group_name # 重命名一个用户组
'''2.用户管理'''
useradd zhangsan # 创建账户张三
passwd zhangsan # 给用户设置密码
userdel -r zhangsan # 删除张三及他的宿主目录
'''3.用户组管理'''
gpasswd -a zhangsan root # 将张三用户加入 root 组
groups zhangsan # 确认 zhangsan 用户在 root 组
gpasswd -d lisi root # 将李 zhangsan 户从 root 组中删除
'''4.权限管理'''
chown -R zhangsan /aaa # 将文件夹/aaa 的多有者修改为 zhangsan
chown root:root /aaa # 将/aaa 文件夹的属主和属组都改成 root
chmod 777 /aaa # 给文件夹文件/aaa 设置权限为 777