摘要：前端設(shè)置上下無效果，因為是行內(nèi)元素，是沒有寬高的。求該青蛙跳上一個級的臺階總共有多少種跳法。

首先和大家說個對不起，由于總結(jié)了太多的東西，所以篇幅有點長，這也是我"縫縫補(bǔ)補(bǔ)"總結(jié)了好久的東西，對于Nginx的東西我沒總結(jié)在這里，大家可以Python聚焦看，點擊直達(dá)專欄哦。

span設(shè)置margin上下無效果，因為span是行內(nèi)元素，是沒有寬高的。

print成為了函數(shù)，python2是關(guān)鍵字

不再有unicode對象，默認(rèn)str就是unicode

python3除號返回浮點數(shù)

沒有了long類型

xrange不存在，range替代了xrange

可以使用中文定義函數(shù)名變量名

高級解包 和*解包

限定關(guān)鍵字參數(shù) *后的變量必須加入名字=值

raise from

iteritems移除變成items()

yield from 鏈接子生成器

asyncio,async/await原生協(xié)程支持異步編程

新增enum,mock,ipaddress,concurrent.futures,asyncio urllib，selector

不同枚舉類間不能進(jìn)行比較

同一枚舉類間只能進(jìn)行相等的比較

枚舉類的使用(編號默認(rèn)從1開始)

為了避免枚舉類中相同枚舉值的出現(xiàn)，可以使用@unique裝飾枚舉類

#枚舉的注意事項
from enum import Enum

class COLOR(Enum):
    YELLOW=1
#YELLOW=2#會報錯
    GREEN=1#不會報錯,GREEN可以看作是YELLOW的別名
    BLACK=3
    RED=4
print(COLOR.GREEN)#COLOR.YELLOW,還是會打印出YELLOW
for i in COLOR:#遍歷一下COLOR并不會有GREEN
    print(i)
#COLOR.YELLOW
COLOR.BLACK
COLOR.RED
怎么把別名遍歷出來
for i in COLOR.__members__.items():
    print(i)
# output:("YELLOW", )
("GREEN", )
("BLACK", )
("RED", )
for i in COLOR.__members__:
    print(i)
# output:YELLOW
GREEN
BLACK
RED

#枚舉轉(zhuǎn)換
#最好在數(shù)據(jù)庫存取使用枚舉的數(shù)值而不是使用標(biāo)簽名字字符串
#在代碼里面使用枚舉類
a=1
print(COLOR(a))# output:COLOR.YELLOW

six模塊：兼容pyton2和pyton3的模塊

2to3工具：改變代碼語法版本

__future__：使用下一版本的功能

必須知道的collections

python排序操作及heapq模塊

itertools模塊超實用方法

dis(代碼字節(jié)碼分析)

inspect(生成器狀態(tài))

cProfile(性能分析)

bisect(維護(hù)有序列表)

fnmatch

fnmatch根據(jù)系統(tǒng)決定

fnmatch(string,"*.txt") #win下不區(qū)分大小寫

fnmatchcase完全區(qū)分大小寫

timeit(代碼執(zhí)行時間)

    def isLen(strString):
        #還是應(yīng)該使用三元表達(dá)式，更快
        return True if len(strString)>6 else False

    def isLen1(strString):
        #這里注意false和true的位置
        return [False,True][len(strString)>6]
    import timeit
    print(timeit.timeit("isLen1("5fsdfsdfsaf")",setup="from __main__ import isLen1"))

    print(timeit.timeit("isLen("5fsdfsdfsaf")",setup="from __main__ import isLen"))

contextlib

@contextlib.contextmanager使生成器函數(shù)變成一個上下文管理器

types(包含了標(biāo)準(zhǔn)解釋器定義的所有類型的類型對象,可以將生成器函數(shù)修飾為異步模式)

    import types
    types.coroutine #相當(dāng)于實現(xiàn)了__await__

html(實現(xiàn)對html的轉(zhuǎn)義)

    import html
    html.escape("
I"m Jim
") # output:"
I'm Jim
"
    html.unescape("
I'm Jim
") # 
I"m Jim

mock(解決測試依賴)

concurrent(創(chuàng)建進(jìn)程池河線程池)

from concurrent.futures import ThreadPoolExecutor

pool = ThreadPoolExecutor()
task = pool.submit(函數(shù)名，（參數(shù)）) #此方法不會阻塞，會立即返回
task.done()#查看任務(wù)執(zhí)行是否完成
task.result()#阻塞的方法，查看任務(wù)返回值
task.cancel()#取消未執(zhí)行的任務(wù)，返回True或False,取消成功返回True
task.add_done_callback()#回調(diào)函數(shù)
task.running()#是否正在執(zhí)行     task就是一個Future對象

for data in pool.map(函數(shù)，參數(shù)列表):#返回已經(jīng)完成的任務(wù)結(jié)果列表，根據(jù)參數(shù)順序執(zhí)行
    print(返回任務(wù)完成得執(zhí)行結(jié)果data)
    
from concurrent.futures import as_completed
as_completed(任務(wù)列表)#返回已經(jīng)完成的任務(wù)列表，完成一個執(zhí)行一個

wait(任務(wù)列表,return_when=條件)#根據(jù)條件進(jìn)行阻塞主線程，有四個條件

selector(封裝select,用戶多路復(fù)用io編程)

asyncio

future=asyncio.ensure_future(協(xié)程)  等于后面的方式  future=loop.create_task(協(xié)程)
future.add_done_callback()添加一個完成后的回調(diào)函數(shù)
loop.run_until_complete(future)
future.result()查看寫成返回結(jié)果

asyncio.wait()接受一個可迭代的協(xié)程對象
asynicio.gather(*可迭代對象,*可迭代對象）    兩者結(jié)果相同，但gather可以批量取消，gather對象.cancel()

一個線程中只有一個loop

在loop.stop時一定要loop.run_forever()否則會報錯
loop.run_forever()可以執(zhí)行非協(xié)程
最后執(zhí)行finally模塊中 loop.close()

asyncio.Task.all_tasks()拿到所有任務(wù) 然后依次迭代并使用任務(wù).cancel()取消

偏函數(shù)partial(函數(shù)，參數(shù))把函數(shù)包裝成另一個函數(shù)名  其參數(shù)必須放在定義函數(shù)的前面

loop.call_soon(函數(shù),參數(shù))
call_soon_threadsafe()線程安全    
loop.call_later(時間,函數(shù),參數(shù))
在同一代碼塊中call_soon優(yōu)先執(zhí)行，然后多個later根據(jù)時間的升序進(jìn)行執(zhí)行

如果非要運(yùn)行有阻塞的代碼
使用loop.run_in_executor(executor,函數(shù)，參數(shù))包裝成一個多線程，然后放入到一個task列表中，通過wait(task列表)來運(yùn)行

通過asyncio實現(xiàn)http
reader,writer=await asyncio.open_connection(host,port)
writer.writer()發(fā)送請求
async for data in reader:
    data=data.decode("utf-8")
    list.append(data)
然后list中存儲的就是html

as_completed(tasks)完成一個返回一個,返回的是一個可迭代對象    

協(xié)程鎖
async with Lock():

進(jìn)程間通信：

Manager(內(nèi)置了好多數(shù)據(jù)結(jié)構(gòu)，可以實現(xiàn)多進(jìn)程間內(nèi)存共享)

from multiprocessing import Manager,Process
def add_data(p_dict, key, value):
    p_dict[key] = value

if __name__ == "__main__":
    progress_dict = Manager().dict()
    from queue import PriorityQueue

    first_progress = Process(target=add_data, args=(progress_dict, "bobby1", 22))
    second_progress = Process(target=add_data, args=(progress_dict, "bobby2", 23))

    first_progress.start()
    second_progress.start()
    first_progress.join()
    second_progress.join()

    print(progress_dict)

Pipe(適用于兩個進(jìn)程)

from multiprocessing import Pipe,Process
#pipe的性能高于queue
def producer(pipe):
    pipe.send("bobby")

def consumer(pipe):
    print(pipe.recv())

if __name__ == "__main__":
    recevie_pipe, send_pipe = Pipe()
    #pipe只能適用于兩個進(jìn)程
    my_producer= Process(target=producer, args=(send_pipe, ))
    my_consumer = Process(target=consumer, args=(recevie_pipe,))

    my_producer.start()
    my_consumer.start()
    my_producer.join()
    my_consumer.join()

Queue(不能用于進(jìn)程池,進(jìn)程池間通信需要使用Manager().Queue())

from multiprocessing import Queue,Process
def producer(queue):
    queue.put("a")
    time.sleep(2)

def consumer(queue):
    time.sleep(2)
    data = queue.get()
    print(data)

if __name__ == "__main__":
    queue = Queue(10)
    my_producer = Process(target=producer, args=(queue,))
    my_consumer = Process(target=consumer, args=(queue,))
    my_producer.start()
    my_consumer.start()
    my_producer.join()
    my_consumer.join()

進(jìn)程池

def producer(queue):
    queue.put("a")
    time.sleep(2)

def consumer(queue):
    time.sleep(2)
    data = queue.get()
    print(data)

if __name__ == "__main__":
    queue = Manager().Queue(10)
    pool = Pool(2)

    pool.apply_async(producer, args=(queue,))
    pool.apply_async(consumer, args=(queue,))

    pool.close()
    pool.join()

sys模塊幾個常用方法

argv 命令行參數(shù)list,第一個是程序本身的路徑

path 返回模塊的搜索路徑

modules.keys() 返回已經(jīng)導(dǎo)入的所有模塊的列表

exit(0) 退出程序

a in s or b in s or c in s簡寫

采用any方式：all() 對于任何可迭代對象為空都會返回True

    # 方法一
    True in [i in s for i in [a,b,c]]
    # 方法二
    any(i in s for i in [a,b,c])
    # 方法三
    list(filter(lambda x:x in s,[a,b,c]))

set集合運(yùn)用

{1,2}.issubset({1,2,3})#判斷是否是其子集

{1,2,3}.issuperset({1,2})

{}.isdisjoint({})#判斷兩個set交集是否為空,是空集則為True

代碼中中文匹配

[u4E00-u9FA5]匹配中文文字區(qū)間[一到龥]

查看系統(tǒng)默認(rèn)編碼格式

    import sys
    sys.getdefaultencoding()    # setdefaultencodeing()設(shè)置系統(tǒng)編碼方式

getattr VS getattribute

class A(dict):
    def __getattr__(self,value):#當(dāng)訪問屬性不存在的時候返回
        return 2
    def __getattribute__(self,item):#屏蔽所有的元素訪問
        return item

類變量是不會存入實例__dict__中的，只會存在于類的__dict__中

globals/locals(可以變相操作代碼)

globals中保存了當(dāng)前模塊中所有的變量屬性與值

locals中保存了當(dāng)前環(huán)境中的所有變量屬性與值

python變量名的解析機(jī)制(LEGB)

本地作用域(Local)

當(dāng)前作用域被嵌入的本地作用域(Enclosing locals)

全局/模塊作用域(Global)

內(nèi)置作用域(Built-in)

實現(xiàn)從1-100每三個為一組分組

    print([[x for x in range(1,101)][i:i+3] for i in range(0,100,3)])

什么是元類？

即創(chuàng)建類的類，創(chuàng)建類的時候只需要將metaclass=元類，元類需要繼承type而不是object,因為type就是元類

type.__bases__  #(,)
object.__bases__    #()
type(object)    #

    class Yuan(type):
        def __new__(cls,name,base,attr,*args,**kwargs):
            return type(name,base,attr,*args,**kwargs)
    class MyClass(metaclass=Yuan):
        pass

什么是鴨子類型(即:多態(tài))？

Python在使用傳入?yún)?shù)的過程中不會默認(rèn)判斷參數(shù)類型，只要參數(shù)具備執(zhí)行條件就可以執(zhí)行

深拷貝和淺拷貝

深拷貝拷貝內(nèi)容，淺拷貝拷貝地址(增加引用計數(shù))

copy模塊實現(xiàn)神拷貝

單元測試

一般測試類繼承模塊unittest下的TestCase

pytest模塊快捷測試(方法以test_開頭/測試文件以test_開頭/測試類以Test開頭，并且不能帶有 init 方法)

coverage統(tǒng)計測試覆蓋率

    class MyTest(unittest.TestCase):
        def tearDown(self):# 每個測試用例結(jié)束后執(zhí)行
            print("本方法結(jié)束測試了")

        def setUp(self):# 每個測試用例執(zhí)行之前做操作
            print("本方法測試開始了")

        @classmethod
        def tearDownClass(self):# 必須使用 @ classmethod裝飾器, 所有test運(yùn)行完后運(yùn)行一次
            print("開始測試")
        @classmethod
        def setUpClass(self):# 必須使用@classmethod 裝飾器,所有test運(yùn)行前運(yùn)行一次
            print("結(jié)束測試")

        def test_a_run(self):
            self.assertEqual(1, 1)  # 測試用例

gil會根據(jù)執(zhí)行的字節(jié)碼行數(shù)以及時間片釋放gil，gil在遇到io的操作時候主動釋放

什么是monkey patch?

猴子補(bǔ)丁，在運(yùn)行的時候替換掉會阻塞的語法修改為非阻塞的方法

什么是自省(Introspection)？

運(yùn)行時判斷一個對象的類型的能力，id,type,isinstance

python是值傳遞還是引用傳遞？

都不是，python是共享傳參，默認(rèn)參數(shù)在執(zhí)行時只會執(zhí)行一次

try-except-else-finally中else和finally的區(qū)別

else在不發(fā)生異常的時候執(zhí)行，finally無論是否發(fā)生異常都會執(zhí)行

except一次可以捕獲多個異常，但一般為了對不同異常進(jìn)行不同處理，我們分次捕獲處理

GIL全局解釋器鎖

同一時間只能有一個線程執(zhí)行，CPython(IPython)的特點，其他解釋器不存在

cpu密集型：多進(jìn)程+進(jìn)程池

io密集型：多線程/協(xié)程

什么是Cython

將python解釋成C代碼工具

生成器和迭代器

實現(xiàn)__next__和__iter__方法的對象就是迭代器

可迭代對象只需要實現(xiàn)__iter__方法

使用生成器表達(dá)式或者yield的生成器函數(shù)(生成器是一種特殊的迭代器)

什么是協(xié)程

比線程更輕量的多任務(wù)方式

實現(xiàn)方式

yield

async-awiat

dict底層結(jié)構(gòu)

為了支持快速查找使用了哈希表作為底層結(jié)構(gòu)

哈希表平均查找時間復(fù)雜度為o(1)

CPython解釋器使用二次探查解決哈希沖突問題

Hash擴(kuò)容和Hash沖突解決方案

循環(huán)復(fù)制到新空間實現(xiàn)擴(kuò)容

沖突解決：

鏈接法

二次探查(開放尋址法)：python使用

    for gevent import monkey
    monkey.patch_all()  #將代碼中所有的阻塞方法都進(jìn)行修改，可以指定具體要修改的方法

判斷是否為生成器或者協(xié)程

    co_flags = func.__code__.co_flags

    # 檢查是否是協(xié)程
    if co_flags & 0x180:
        return func

    # 檢查是否是生成器
    if co_flags & 0x20:
        return func  

斐波那契解決的問題及變形

#一只青蛙一次可以跳上1級臺階，也可以跳上2級。求該青蛙跳上一個n級的臺階總共有多少種跳法。
#請問用n個2*1的小矩形無重疊地覆蓋一個2*n的大矩形，總共有多少種方法？
#方式一：
fib = lambda n: n if n <= 2 else fib(n - 1) + fib(n - 2)
#方式二：
def fib(n):
    a, b = 0, 1
    for _ in range(n):
        a, b = b, a + b
    return b

#一只青蛙一次可以跳上1級臺階，也可以跳上2級……它也可以跳上n級。求該青蛙跳上一個n級的臺階總共有多少種跳法。
fib = lambda n: n if n < 2 else 2 * fib(n - 1)

獲取電腦設(shè)置的環(huán)境變量

    import os
    os.getenv(env_name,None)#獲取環(huán)境變量如果不存在為None

垃圾回收機(jī)制

引用計數(shù)

標(biāo)記清除

分代回收

    #查看分代回收觸發(fā)
    import gc
    gc.get_threshold()  #output:(700, 10, 10)

True和False在代碼中完全等價于1和0,可以直接和數(shù)字進(jìn)行計算，inf表示無窮大

C10M/C10K

C10M:8核心cpu，64G內(nèi)存，在10gbps的網(wǎng)絡(luò)上保持1000萬并發(fā)連接

C10K：1GHz CPU,2G內(nèi)存，1gbps網(wǎng)絡(luò)環(huán)境下保持1萬個客戶端提供FTP服務(wù)

yield from與yield的區(qū)別：

yield from跟的是一個可迭代對象，而yield后面沒有限制

GeneratorExit生成器停止時觸發(fā)

單下劃線的幾種使用

在定義變量時，表示為私有變量

在解包時，表示舍棄無用的數(shù)據(jù)

在交互模式中表示上一次代碼執(zhí)行結(jié)果

可以做數(shù)字的拼接(111_222_333)

使用break就不會執(zhí)行else

10進(jìn)制轉(zhuǎn)2進(jìn)制

    def conver_bin(num):
        if num == 0:
            return num
        re = []
        while num:
            num, rem = divmod(num,2)
            re.append(str(rem))
        return "".join(reversed(re))
    conver_bin(10)

list1 = ["A", "B", "C", "D"] 如何才能得到以list中元素命名的新列表 A=[],B=[],C=[],D=[]呢

    list1 = ["A", "B", "C", "D"]

    # 方法一
    for i in list1:
        globals()[i] = []   # 可以用于實現(xiàn)python版反射

    # 方法二
    for i in list1:
        exec(f"{i} = []")   # exec執(zhí)行字符串語句

memoryview與bytearray$color{#000}(不常用，只是看到了記載一下)$

    # bytearray是可變的，bytes是不可變的,memoryview不會產(chǎn)生新切片和對象
    a = "aaaaaa"
    ma = memoryview(a)
    ma.readonly  # 只讀的memoryview
    mb = ma[:2]  # 不會產(chǎn)生新的字符串

    a = bytearray("aaaaaa")
    ma = memoryview(a)
    ma.readonly  # 可寫的memoryview
    mb = ma[:2]      # 不會會產(chǎn)生新的bytearray
    mb[:2] = "bb"    # 對mb的改動就是對ma的改動

Ellipsis類型

# 代碼中出現(xiàn)...省略號的現(xiàn)象就是一個Ellipsis對象
L = [1,2,3]
L.append(L)
print(L)    # output:[1,2,3,[…]]

lazy惰性計算

    class lazy(object):
        def __init__(self, func):
            self.func = func
    
        def __get__(self, instance, cls):
            val = self.func(instance)    #其相當(dāng)于執(zhí)行的area(c),c為下面的Circle對象
            setattr(instance, self.func.__name__, val)
            return val`
 
    class Circle(object):
        def __init__(self, radius):
            self.radius = radius
    
        @lazy
        def area(self):
            print("evalute")
            return 3.14 * self.radius ** 2

遍歷文件，傳入一個文件夾，將里面所有文件的路徑打印出來(遞歸)

all_files = []    
def getAllFiles(directory_path):
    import os                                       
    for sChild in os.listdir(directory_path):                
        sChildPath = os.path.join(directory_path,sChild)
        if os.path.isdir(sChildPath):
            getAllFiles(sChildPath)
        else:
            all_files.append(sChildPath)
    return all_files

文件存儲時，文件名的處理

#secure_filename將字符串轉(zhuǎn)化為安全的文件名
from werkzeug import secure_filename
secure_filename("My cool movie.mov") # output:My_cool_movie.mov
secure_filename("../../../etc/passwd") # output:etc_passwd
secure_filename(u"i contain cool xfcmlxe4uts.txt") # output:i_contain_cool_umlauts.txt

日期格式化

from datetime import datetime

datetime.now().strftime("%Y-%m-%d")

import time
#這里只有l(wèi)ocaltime可以被格式化，time是不能格式化的
time.strftime("%Y-%m-%d",time.localtime())

tuple使用+=奇怪的問題

# 會報錯，但是tuple的值會改變，因為t[1]id沒有發(fā)生變化
t=(1,[2,3])
t[1]+=[4,5]
# t[1]使用appendextend方法并不會報錯，并可以成功執(zhí)行

__missing__你應(yīng)該知道

class Mydict(dict):
    def __missing__(self,key): # 當(dāng)Mydict使用切片訪問屬性不存在的時候返回的值
        return key

+與+=

# +不能用來連接列表和元祖，而+=可以（通過iadd實現(xiàn)，內(nèi)部實現(xiàn)方式為extends(),所以可以增加元組），+會創(chuàng)建新對象
不可變對象沒有__iadd__方法，所以直接使用的是__add__方法，因此元祖可以使用+=進(jìn)行元祖之間的相加

如何將一個可迭代對象的每個元素變成一個字典的所有鍵？

dict.fromkeys(["jim","han"],21) # output:{"jim": 21, "han": 21}

wireshark抓包軟件

什么是HTTPS?

安全的HTTP協(xié)議，https需要cs證書，數(shù)據(jù)加密，端口為443，安全，同一網(wǎng)站https seo排名會更高

常見響應(yīng)狀態(tài)碼

    204 No Content //請求成功處理，沒有實體的主體返回，一般用來表示刪除成功
    206 Partial Content //Get范圍請求已成功處理
    303 See Other //臨時重定向，期望使用get定向獲取
    304 Not Modified //求情緩存資源
    307 Temporary Redirect //臨時重定向，Post不會變成Get
    401 Unauthorized //認(rèn)證失敗
    403 Forbidden //資源請求被拒絕
    400 //請求參數(shù)錯誤
    201 //添加或更改成功
    503 //服務(wù)器維護(hù)或者超負(fù)載

http請求方法的冪等性及安全性

WSGI

    # environ：一個包含所有HTTP請求信息的dict對象
    # start_response：一個發(fā)送HTTP響應(yīng)的函數(shù)
    def application(environ, start_response):
        start_response("200 OK", [("Content-Type", "text/html")])
        return "
Hello, web!
"

RPC

CDN

SSL(Secure Sockets Layer 安全套接層),及其繼任者傳輸層安全（Transport Layer Security，TLS）是為網(wǎng)絡(luò)通信提供安全及數(shù)據(jù)完整性的一種安全協(xié)議。

SSH（安全外殼協(xié)議） 為 Secure Shell 的縮寫，由 IETF 的網(wǎng)絡(luò)小組（Network Working Group）所制定；SSH 為建立在應(yīng)用層基礎(chǔ)上的安全協(xié)議。SSH 是目前較可靠，專為遠(yuǎn)程登錄會話和其他網(wǎng)絡(luò)服務(wù)提供安全性的協(xié)議。利用 SSH 協(xié)議可以有效防止遠(yuǎn)程管理過程中的信息泄露問題。SSH最初是UNIX系統(tǒng)上的一個程序，后來又迅速擴(kuò)展到其他操作平臺。SSH在正確使用時可彌補(bǔ)網(wǎng)絡(luò)中的漏洞。SSH客戶端適用于多種平臺。幾乎所有UNIX平臺—包括HP-UX、Linux、AIX、Solaris、Digital UNIX、Irix，以及其他平臺，都可運(yùn)行SSH。

TCP/IP

TCP:面向連接/可靠/基于字節(jié)流

UDP:無連接/不可靠/面向報文

三次握手四次揮手

三次握手(SYN/SYN+ACK/ACK)

四次揮手(FIN/ACK/FIN/ACK)

為什么連接的時候是三次握手，關(guān)閉的時候卻是四次握手？

因為當(dāng)Server端收到Client端的SYN連接請求報文后，可以直接發(fā)送SYN+ACK報文。其中ACK報文是用來應(yīng)答的，SYN報文是用來同步的。但是關(guān)閉連接時，當(dāng)Server端收到FIN報文時，很可能并不會立即關(guān)閉SOCKET，所以只能先回復(fù)一個ACK報文，告訴Client端，"你發(fā)的FIN報文我收到了"。只有等到我Server端所有的報文都發(fā)送完了，我才能發(fā)送FIN報文，因此不能一起發(fā)送。故需要四步握手。

為什么TIME_WAIT狀態(tài)需要經(jīng)過2MSL(最大報文段生存時間)才能返回到CLOSE狀態(tài)？

雖然按道理，四個報文都發(fā)送完畢，我們可以直接進(jìn)入CLOSE狀態(tài)了，但是我們必須假象網(wǎng)絡(luò)是不可靠的，有可以最后一個ACK丟失。所以TIME_WAIT狀態(tài)就是用來重發(fā)可能丟失的ACK報文。

XSS/CSRF

HttpOnly禁止js腳本訪問和操作Cookie,可以有效防止XSS

索引改進(jìn)過程

線性結(jié)構(gòu)->二分查找->hash->二叉查找樹->平衡二叉樹->多路查找樹->多路平衡查找樹(B-Tree)

Mysql面試總結(jié)基礎(chǔ)篇

Mysql面試總結(jié)進(jìn)階篇

深入淺出Mysql

清空整個表時，InnoDB是一行一行的刪除，而MyISAM則會從新刪除建表

text/blob數(shù)據(jù)類型不能有默認(rèn)值，查詢時不存在大小寫轉(zhuǎn)換

什么時候索引失效

以%開頭的like模糊查詢

出現(xiàn)隱士類型轉(zhuǎn)換

沒有滿足最左前綴原則

對于多列索引，不是使用的第一部分，則不會使用索引

失效場景：

應(yīng)盡量避免在 where 子句中使用 != 或 <> 操作符，否則引擎將放棄使用索引而進(jìn)行全表掃描

盡量避免在 where 子句中使用 or 來連接條件，否則將導(dǎo)致引擎放棄使用索引而進(jìn)行全表掃描，即使其中有條件帶索引也不會使用，這也是為什么盡量少用 or 的原因

如果列類型是字符串，那一定要在條件中將數(shù)據(jù)使用引號引用起來，否則不會使用索引

應(yīng)盡量避免在 where 子句中對字段進(jìn)行函數(shù)操作，這將導(dǎo)致引擎放棄使用索引而進(jìn)行全表掃描

例如：
select id from t where substring(name,1,3) = "abc" – name;
以abc開頭的，應(yīng)改成：
select id from t where name like ‘a(chǎn)bc%’ 
例如：
select id from t where datediff(day, createdate, "2005-11-30") = 0 – "2005-11-30";
應(yīng)改為:

不要在 where 子句中的 “=” 左邊進(jìn)行函數(shù)、算術(shù)運(yùn)算或其他表達(dá)式運(yùn)算，否則系統(tǒng)將可能無法正確使用索引

應(yīng)盡量避免在 where 子句中對字段進(jìn)行表達(dá)式操作，這將導(dǎo)致引擎放棄使用索引而進(jìn)行全表掃描

如：
select id from t where num/2 = 100 
應(yīng)改為:
select id from t where num = 100*2；

不適合鍵值較少的列（重復(fù)數(shù)據(jù)較多的列）比如：set enum列就不適合(枚舉類型(enum)可以添加null,并且默認(rèn)的值會自動過濾空格集合(set)和枚舉類似，但只可以添加64個值)

如果MySQL估計使用全表掃描要比使用索引快，則不使用索引

什么是聚集索引

B+Tree葉子節(jié)點保存的是數(shù)據(jù)還是指針

MyISAM索引和數(shù)據(jù)分離，使用非聚集

InnoDB數(shù)據(jù)文件就是索引文件，主鍵索引就是聚集索引

為什么這么快？

基于內(nèi)存，由C語言編寫

使用多路I/O復(fù)用模型，非阻塞IO

使用單線程減少線程間切換

因為Redis是基于內(nèi)存的操作，CPU不是Redis的瓶頸，Redis的瓶頸最有可能是機(jī)器內(nèi)存的大小或者網(wǎng)絡(luò)帶寬。既然單線程容易實現(xiàn)，而且CPU不會成為瓶頸，那就順理成章地采用單線程的方案了（畢竟采用多線程會有很多麻煩！）。

數(shù)據(jù)結(jié)構(gòu)簡單

自己構(gòu)建了VM機(jī)制，減少調(diào)用系統(tǒng)函數(shù)的時間

優(yōu)勢

性能高 – Redis能讀的速度是110000次/s,寫的速度是81000次/s

豐富的數(shù)據(jù)類型

原子 – Redis的所有操作都是原子性的，同時Redis還支持對幾個操作全并后的原子性執(zhí)行

豐富的特性 – Redis還支持 publish/subscribe（發(fā)布/訂閱）, 通知, key 過期等等特性

什么是redis事務(wù)？

將多個請求打包，一次性、按序執(zhí)行多個命令的機(jī)制

通過multi,exec,watch等命令實現(xiàn)事務(wù)功能

Python redis-py pipeline=conn.pipeline(transaction=True)

持久化方式

RDB(快照)

save(同步，可以保證數(shù)據(jù)一致性)

bgsave(異步，shutdown時，無AOF則默認(rèn)使用)

AOF(追加日志)

怎么實現(xiàn)隊列

push

rpop

常用的數(shù)據(jù)類型(Bitmaps,Hyperloglogs,范圍查詢等不常用)

String(字符串):計數(shù)器

整數(shù)或sds(Simple Dynamic String)

List(列表)：用戶的關(guān)注，粉絲列表

ziplist(連續(xù)內(nèi)存塊，每個entry節(jié)點頭部保存前后節(jié)點長度信息實現(xiàn)雙向鏈表功能)或double linked list

Hash(哈希)：

Set(集合)：用戶的關(guān)注者

intset或hashtable

Zset(有序集合)：實時信息排行榜

skiplist(跳躍表)

與Memcached區(qū)別

Memcached只能存儲字符串鍵

Memcached用戶只能通過APPEND的方式將數(shù)據(jù)添加到已有的字符串的末尾，并將這個字符串當(dāng)做列表來使用。但是在刪除這些元素的時候，Memcached采用的是通過黑名單的方式來隱藏列表里的元素，從而避免了對元素的讀取、更新、刪除等操作

Redis和Memcached都是將數(shù)據(jù)存放在內(nèi)存中，都是內(nèi)存數(shù)據(jù)庫。不過Memcached還可用于緩存其他東西，例如圖片、視頻等等

虛擬內(nèi)存–Redis當(dāng)物理內(nèi)存用完時，可以將一些很久沒用到的Value 交換到磁盤

存儲數(shù)據(jù)安全–Memcached掛掉后，數(shù)據(jù)沒了；Redis可以定期保存到磁盤（持久化）

應(yīng)用場景不一樣：Redis出來作為NoSQL數(shù)據(jù)庫使用外，還能用做消息隊列、數(shù)據(jù)堆棧和數(shù)據(jù)緩存等；Memcached適合于緩存SQL語句、數(shù)據(jù)集、用戶臨時性數(shù)據(jù)、延遲查詢數(shù)據(jù)和Session等

Redis實現(xiàn)分布式鎖

使用setnx實現(xiàn)加鎖，可以同時通過expire添加超時時間

鎖的value值可以是一個隨機(jī)的uuid或者特定的命名

釋放鎖的時候，通過uuid判斷是否是該鎖，是則執(zhí)行delete釋放鎖

常見問題

緩存雪崩

短時間內(nèi)緩存數(shù)據(jù)過期，大量請求訪問數(shù)據(jù)庫

緩存穿透

請求訪問數(shù)據(jù)時，查詢緩存中不存在，數(shù)據(jù)庫中也不存在

緩存預(yù)熱

初始化項目，將部分常用數(shù)據(jù)加入緩存

緩存更新

數(shù)據(jù)過期，進(jìn)行更新緩存數(shù)據(jù)

緩存降級

當(dāng)訪問量劇增、服務(wù)出現(xiàn)問題（如響應(yīng)時間慢或不響應(yīng)）或非核心服務(wù)影響到核心流程的性能時，仍然需要保證服務(wù)還是可用的，即使是有損服務(wù)。系統(tǒng)可以根據(jù)一些關(guān)鍵數(shù)據(jù)進(jìn)行自動降級，也可以配置開關(guān)實現(xiàn)人工降級

一致性Hash算法

使用集群的時候保證數(shù)據(jù)的一致性

基于redis實現(xiàn)一個分布式鎖，要求一個超時的參數(shù)

setnx

虛擬內(nèi)存

內(nèi)存抖動

Unix五種i/o模型

阻塞io

非阻塞io

多路復(fù)用io(Python下使用selectot實現(xiàn)io多路復(fù)用)

select

并發(fā)不高，連接數(shù)很活躍的情況下

poll

比select提高的并不多

epoll

適用于連接數(shù)量較多，但活動鏈接數(shù)少的情況

信號驅(qū)動io

異步io(Gevent/Asyncio實現(xiàn)異步)

比man更好使用的命令手冊

tldr:一個有命令示例的手冊

kill -9和-15的區(qū)別

-15：程序立刻停止/當(dāng)程序釋放相應(yīng)資源后再停止/程序可能仍然繼續(xù)運(yùn)行

-9：由于-15的不確定性，所以直接使用-9立即殺死進(jìn)程

分頁機(jī)制（邏輯地址和物理地址分離的內(nèi)存分配管理方案）：

操作系統(tǒng)為了高效管理內(nèi)存，減少碎片

程序的邏輯地址劃分為固定大小的頁

物理地址劃分為同樣大小的幀

通過頁表對應(yīng)邏輯地址和物理地址

分段機(jī)制

為了滿足代碼的一些邏輯需求

數(shù)據(jù)共享/數(shù)據(jù)保護(hù)/動態(tài)鏈接

每個段內(nèi)部連續(xù)內(nèi)存分配，段和段之間是離散分配的

查看cpu內(nèi)存使用情況？

top

free 查看可用內(nèi)存，排查內(nèi)存泄漏問題

    # 方式一
    def Single(cls,*args,**kwargs):
        instances = {}
        def get_instance (*args, **kwargs):
            if cls not in instances:
                instances[cls] = cls(*args, **kwargs)
            return instances[cls]
        return get_instance
    @Single
    class B:
        pass
    # 方式二
    class Single:
        def __init__(self):
            print("單例模式實現(xiàn)方式二。。。")

    single = Single()
    del Single  # 每次調(diào)用single就可以了
    # 方式三(最常用的方式)
    class Single:
        def __new__(cls,*args,**kwargs):
            if not hasattr(cls,"_instance"):
                cls._instance = super().__new__(cls,*args,**kwargs)
            return cls._instance    

    class Dog:
        def __init__(self):
            print("Wang Wang Wang")
    class Cat:
        def __init__(self):
            print("Miao Miao Miao")
    
    
    def fac(animal):
        if animal.lower() == "dog":
            return Dog()
        if animal.lower() == "cat":
            return Cat()
        print("對不起，必須是：dog,cat")

    class Computer:
        def __init__(self,serial_number):
            self.serial_number = serial_number
            self.memory = None
            self.hadd = None
            self.gpu = None
        def __str__(self):
            info = (f"Memory:{self.memoryGB}",
            "Hard Disk:{self.hadd}GB",
            "Graphics Card:{self.gpu}")
            return "".join(info)
    class ComputerBuilder：
        def __init__(self):
            self.computer = Computer("Jim1996")
        def configure_memory(self,amount):
            self.computer.memory = amount
            return self #為了方便鏈?zhǔn)秸{(diào)用
        def configure_hdd(self,amount):
            pass
        def configure_gpu(self,gpu_model):
            pass
    class HardwareEngineer:
        def __init__(self):
            self.builder = None
        def construct_computer(self,memory,hdd,gpu)
            self.builder = ComputerBuilder()
            self.builder.configure_memory(memory).configure_hdd(hdd).configure_gpu(gpu)
        @property
        def computer(self):
            return self.builder.computer

    def quick_sort(_list):
            if len(_list) < 2:
                return _list
            pivot_index = 0
            pivot = _list(pivot_index)
            left_list = [i for i in _list[:pivot_index] if i < pivot]
            right_list = [i for i in _list[pivot_index:] if i > pivot]
        return quick_sort(left) + [pivot] + quick_sort(right)

    def select_sort(seq):
        n = len(seq)
        for i in range(n-1)
        min_idx = i
            for j in range(i+1,n):
                if seq[j] < seq[min_inx]:
                    min_idx = j
            if min_idx != i:
                seq[i], seq[min_idx] = seq[min_idx],seq[i]

    def insertion_sort(_list):
        n = len(_list)
        for i in range(1,n):
            value = _list[i]
            pos = i
            while pos > 0 and value < _list[pos - 1]
                _list[pos] = _list[pos - 1]
                pos -= 1
            _list[pos] = value
            print(sql)

    def merge_sorted_list(_list1,_list2):   #合并有序列表
        len_a, len_b = len(_list1),len(_list2)
        a = b = 0
        sort = []
        while len_a > a and len_b > b:
            if _list1[a] > _list2[b]:
                sort.append(_list2[b])
                b += 1
            else:
                sort.append(_list1[a])
                a += 1
        if len_a > a:
            sort.append(_list1[a:])
        if len_b > b:
            sort.append(_list2[b:])
        return sort

    def merge_sort(_list):
        if len(list1)<2:
            return list1
        else:
            mid = int(len(list1)/2)
            left = mergesort(list1[:mid])
            right = mergesort(list1[mid:])
            return merge_sorted_list(left,right)

    from heapq import nsmallest
    def heap_sort(_list):
        return nsmallest(len(_list),_list)

    from collections import deque
    class Stack:
        def __init__(self):
            self.s = deque()
        def peek(self):
            p = self.pop()
            self.push(p)
            return p
        def push(self, el):
            self.s.append(el)
        def pop(self):
            return self.pop()

    from collections import deque
    class Queue:
        def __init__(self):
            self.s = deque()
        def push(self, el):
            self.s.append(el)
        def pop(self):
            return self.popleft()

    def binary_search(_list,num):
        mid = len(_list)//2
        if len(_list) < 1:
            return Flase
        if num > _list[mid]:
            BinarySearch(_list[mid:],num)
        elif num < _list[mid]:
            BinarySearch(_list[:mid],num)
        else:
            return _list.index(num)

關(guān)于數(shù)據(jù)庫優(yōu)化及設(shè)計

如何使用兩個棧實現(xiàn)一個隊列

反轉(zhuǎn)鏈表

合并兩個有序鏈表

刪除鏈表節(jié)點

反轉(zhuǎn)二叉樹

設(shè)計短網(wǎng)址服務(wù)？62進(jìn)制實現(xiàn)

設(shè)計一個秒殺系統(tǒng)(feed流)？

為什么mysql數(shù)據(jù)庫的主鍵使用自增的整數(shù)比較好？使用uuid可以嗎？為什么？

如果InnoDB表的數(shù)據(jù)寫入順序能和B+樹索引的葉子節(jié)點順序一致的話，這時候存取效率是最高的。為了存儲和查詢性能應(yīng)該使用自增長id做主鍵。

對于InnoDB的主索引，數(shù)據(jù)會按照主鍵進(jìn)行排序，由于UUID的無序性，InnoDB會產(chǎn)生巨大的IO壓力，此時不適合使用UUID做物理主鍵，可以把它作為邏輯主鍵，物理主鍵依然使用自增ID。為了全局的唯一性，應(yīng)該用uuid做索引關(guān)聯(lián)其他表或做外鍵

如果是分布式系統(tǒng)下我們怎么生成數(shù)據(jù)庫的自增id呢？

使用redis

基于redis實現(xiàn)一個分布式鎖，要求一個超時的參數(shù)

setnx

setnx + expire

如果redis單個節(jié)點宕機(jī)了，如何處理？還有其他業(yè)界的方案實現(xiàn)分布式鎖碼?

使用hash一致算法

LRU(least-recently-used):替換最近最少使用的對象

LFU(Least frequently used):最不經(jīng)常使用，如果一個數(shù)據(jù)在最近一段時間內(nèi)使用次數(shù)很少，那么在將來一段時間內(nèi)被使用的可能性也很小

使用數(shù)據(jù)結(jié)構(gòu)和算法

數(shù)據(jù)庫

索引優(yōu)化

慢查詢消除

slow_query_log_file開啟并且查詢慢查詢?nèi)罩?/p>

通過explain排查索引問題

調(diào)整數(shù)據(jù)修改索引

批量操作，從而減少io操作

使用NoSQL:比如Redis

網(wǎng)絡(luò)io

批量操作

pipeline

緩存

Redis

異步

Asyncio實現(xiàn)異步操作

使用Celery減少io阻塞

并發(fā)

多線程

Gevent