欧美午夜激情免费福利在线网 ,欧美,日韩,国内一区二区,精东影业麻豆A片在线看

來源：數(shù)據(jù)STUDIO

今天給大家分享一波兒 Python/ target=_blank class=infotextkey>Python學習重點，超級全面！

由于總結了太多的東西，所以篇幅有點長，這也是“縫縫補補”總結了好久的東西。

Py2 VS Py3

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

不再有unicode對象，默認str就是unicode

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

沒有了long類型

xrange不存在，range替代了xrange

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

高級解包和*解包

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

raise from

iteritems移除變成items

yield from 鏈接子生成器

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

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

不同枚舉類間不能進行比較
同一枚舉類間只能進行相等的比較
枚舉類的使用(編號默認從1開始)
為了避免枚舉類中相同枚舉值的出現(xiàn)，可以使用@unique裝飾枚舉類

#枚舉的注意事項

fromenum importEnum

classCOLOR(Enum):

YELLOW= 1

#YELLOW=2#會報錯

GREEN= 1#不會報錯,GREEN可以看作是YELLOW的別名

BLACK= 3

RED= 4

print(COLOR.GREEN) #COLOR.YELLOW,還是會打印出YELLOW

fori inCOLOR: #遍歷一下COLOR并不會有GREEN

print(i)

#COLOR.YELLOWnCOLOR.BLACKnCOLOR.REDn怎么把別名遍歷出來

fori inCOLOR.__members__.items:

print(i)

# output:('YELLOW', <COLOR.YELLOW: 1>)n('GREEN', <COLOR.YELLOW: 1>)n('BLACK', <COLOR.BLACK: 3>)n('RED', <COLOR.RED: 4>)

fori inCOLOR.__members__:

print(i)

# output:YELLOWnGREENnBLACKnRED

#枚舉轉換

#最好在數(shù)據(jù)庫存取使用枚舉的數(shù)值而不是使用標簽名字字符串

#在代碼里面使用枚舉類

a= 1

print(COLOR(a)) # output:COLOR.YELLOW

py2/3轉換工具

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

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

__future__：使用下一版本的功能

常用的庫

必須知道的collections

python排序操作及heapq模塊

itertools模塊超實用方法

不常用但很重要的庫

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

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

cProfile（性能分析）

bisect（維護有序列表）

fnmatch

fnmatch(string,"*.txt") #win下不區(qū)分大小寫
fnmatch根據(jù)系統(tǒng)決定
fnmatchcase完全區(qū)分大小寫

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

defisLen(strString):

#還是應該使用三元表達式，更快

returnTrueiflen(strString)> 6elseFalse

defisLen1(strString):

#這里注意false和true的位置

return[ False, True][len(strString)> 6]

importtimeit

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（包含了標準解釋器定義的所有類型的類型對象，可以將生成器函數(shù)修飾為異步模式）

importtypes

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

html（實現(xiàn)對html的轉義）

importhtml

html.escape( "<h1>I'm Jim</h1>") # output:'<h1>I'm Jim</h1>'

html.unescape( '<h1>I'm Jim</h1>') # <h1>I'm Jim</h1>

mock（解決測試依賴）

concurrent（創(chuàng)建進程池河線程池）

fromconcurrent.futures importThreadPoolExecutor

pool = ThreadPoolExecutor

task = pool.submit(函數(shù)名，（參數(shù)）) #此方法不會阻塞，會立即返回

task.done #查看任務執(zhí)行是否完成

task.result #阻塞的方法，查看任務返回值

task.cancel #取消未執(zhí)行的任務，返回True或False,取消成功返回True

task.add_done_callback #回調函數(shù)

task.running #是否正在執(zhí)行 task就是一個Future對象

fordata inpool.map(函數(shù)，參數(shù)列表): #返回已經(jīng)完成的任務結果列表，根據(jù)參數(shù)順序執(zhí)行

print(返回任務完成得執(zhí)行結果data)

fromconcurrent.futures importas_completed

as_completed(任務列表) #返回已經(jīng)完成的任務列表，完成一個執(zhí)行一個

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

selector（封裝select,用戶多路復用io編程）

asyncio

future=asyncio.ensure_future(協(xié)程) 等于后面的方式 future=loop.create_task(協(xié)程)

future.add_done_callback添加一個完成后的回調函數(shù)

loop.run_until_complete(future)

future.result查看寫成返回結果

asyncio.wait接受一個可迭代的協(xié)程對象

asynicio.gather(*可迭代對象,*可迭代對象）兩者結果相同，但gather可以批量取消，gather對象.cancel

一個線程中只有一個loop

在loop.stop時一定要loop.run_forever否則會報錯

loop.run_forever可以執(zhí)行非協(xié)程

最后執(zhí)行 finally模塊中 loop.close

asyncio.Task.all_tasks拿到所有任務然后依次迭代并使用任務.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ù)時間的升序進行執(zhí)行

如果非要運行有阻塞的代碼

使用loop.run_in_executor(executor,函數(shù)，參數(shù))包裝成一個多線程，然后放入到一個task列表中，通過wait(task列表)來運行

通過asyncio實現(xiàn)http

reader,writer=await asyncio.open_connection(host,port)

writer.writer發(fā)送請求

async fordata inreader:

data=data.decode( "utf-8")

list.Append(data)

然后list中存儲的就是html

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

協(xié)程鎖

async withLock:

Python進階

進程間通信：

Manager(內置了好多數(shù)據(jù)結構，可以實現(xiàn)多進程間內存共享)

frommultiprocessing importManager,Process

defadd_data(p_dict, key, value):

p_dict[key] = value

if__name__ == "__main__":

progress_dict = Manager.dict

fromqueue importPriorityQueue

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(適用于兩個進程)

frommultiprocessing importPipe,Process

#pipe的性能高于queue

defproducer(pipe):

pipe.send( "bobby")

defconsumer(pipe):

print(pipe.recv)

if__name__ == "__main__":

recevie_pipe, send_pipe = Pipe

#pipe只能適用于兩個進程

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(不能用于進程池,進程池間通信需要使用Manager.Queue)

frommultiprocessing importQueue,Process

defproducer(queue):

queue.put( "a")

time.sleep( 2)

defconsumer(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

進程池

defproducer(queue):

queue.put( "a")

time.sleep( 2)

defconsumer(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)導入的所有模塊的列表
exit(0) 退出程序

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

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

# 方法一

Truein[i ins fori in[a,b,c]]

# 方法二

any(i ins fori in[a,b,c])

# 方法三

list(filter( lambdax:x ins,[a,b,c]))

set集合運用：

{1,2}.issubset({1,2,3})#判斷是否是其子集
{1,2,3}.issuperset({1,2})
{}.isdisjoint({})#判斷兩個set交集是否為空,是空集則為True

代碼中中文匹配：

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

查看系統(tǒng)默認編碼格式：

importsys

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

getattr VS getattribute：

classA(dict):

def__getattr__(self,value): #當訪問屬性不存在的時候返回

return2

def__getattribute__(self,item): #屏蔽所有的元素訪問

returnitem

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

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

globals中保存了當前模塊中所有的變量屬性與值
locals中保存了當前環(huán)境中的所有變量屬性與值

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

本地作用域(Local)
當前作用域被嵌入的本地作用域(Enclosing locals)
全局/模塊作用域(Global)
內置作用域(Built-in)

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

print([[x forx inrange( 1, 101)][i:i+ 3] fori inrange( 0, 100, 3)])

什么是元類？

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

type.__bases__ #(<class 'object'>,)

object.__bases__ #

type(object) #<class 'type'>

classYuan(type):

def__new__(cls,name,base,attr,*args,**kwargs):

returntype(name,base,attr,*args,**kwargs)

classMyClass(metaclass=Yuan):

pass

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

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

深拷貝和淺拷貝

深拷貝拷貝內容，淺拷貝拷貝地址(增加引用計數(shù))
copy模塊實現(xiàn)神拷貝

單元測試

一般測試類繼承模塊unittest下的TestCase
pytest模塊快捷測試(方法以test_開頭/測試文件以test_開頭/測試類以Test開頭，并且不能帶有 init 方法)
coverage統(tǒng)計測試覆蓋率

classMyTest(unittest.TestCase):

deftearDown(self): # 每個測試用例執(zhí)行前執(zhí)行

print( '本方法開始測試了')

defsetUp(self): # 每個測試用例執(zhí)行之前做操作

print( '本方法測試結束')

@classmethod

deftearDownClass(self): # 必須使用 @ classmethod裝飾器, 所有test運行完后運行一次

print( '開始測試')

@classmethod

defsetUpClass(self): # 必須使用@classmethod 裝飾器,所有test運行前運行一次

print( '結束測試')

deftest_a_run(self):

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

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

什么是monkey patch?

猴子補丁，在運行的時候替換掉會阻塞的語法修改為非阻塞的方法

什么是自省(Introspection)？

運行時判斷一個對象的類型的能力，id,type,isinstance

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

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

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

else在不發(fā)生異常的時候執(zhí)行，finally無論是否發(fā)生異常都會執(zhí)行
except一次可以捕獲多個異常，但一般為了對不同異常進行不同處理，我們分次捕獲處理

GIL全局解釋器鎖

同一時間只能有一個線程執(zhí)行，CPython(IPython)的特點，其他解釋器不存在
cpu密集型：多進程+進程池
io密集型：多線程/協(xié)程

什么是Cython

將python解釋成C代碼工具

生成器和迭代器

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

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

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

什么是協(xié)程

（1）yield

（2）async-awiat

比線程更輕量的多任務方式
實現(xiàn)方式

dict底層結構

為了支持快速查找使用了哈希表作為底層結構
哈希表平均查找時間復雜度為o(1)
CPython解釋器使用二次探查解決哈希沖突問題

Hash擴容和Hash沖突解決方案

（1）鏈接法

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

循環(huán)復制到新空間實現(xiàn)擴容
沖突解決：

forgevent importmonkey

monkey.patch_all #將代碼中所有的阻塞方法都進行修改，可以指定具體要修改的方法

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

co_flags = func.__code__.co_flags

# 檢查是否是協(xié)程

ifco_flags & 0x180:

returnfunc

# 檢查是否是生成器

ifco_flags & 0x20:

returnfunc

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

#一只青蛙一次可以跳上1級臺階，也可以跳上2級。求該青蛙跳上一個n級的臺階總共有多少種跳法。

#請問用n個2*1的小矩形無重疊地覆蓋一個2*n的大矩形，總共有多少種方法？

#方式一：

fib = lambdan: n ifn <= 2elsefib(n - 1) + fib(n - 2)

#方式二：

deffib(n):

a, b = 0, 1

for_ inrange(n):

a, b = b, a + b

returnb

#一只青蛙一次可以跳上1級臺階，也可以跳上2級……它也可以跳上n級。求該青蛙跳上一個n級的臺階總共有多少種跳法。

fib = lambdan: n ifn < 2else2* fib(n - 1)

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

importos

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

垃圾回收機制

引用計數(shù)
標記清除
分代回收

#查看分代回收觸發(fā)

importgc

gc.get_threshold #output:(700, 10, 10)

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

C10M/C10K

C10M：8核心cpu，64G內存，在10gbps的網(wǎng)絡上保持1000萬并發(fā)連接
C10K：1GHz CPU,2G內存，1gbps網(wǎng)絡環(huán)境下保持1萬個客戶端提供FTP服務

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

yield from跟的是一個可迭代對象，而yield后面沒有限制
GeneratorExit生成器停止時觸發(fā)

單下劃線的幾種使用

在定義變量時，表示為私有變量
在解包時，表示舍棄無用的數(shù)據(jù)
在交互模式中表示上一次代碼執(zhí)行結果
可以做數(shù)字的拼接(111_222_333)

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

10進制轉2進制

defconver_bin(num):

ifnum == 0:

returnnum

re = []

whilenum:

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']

# 方法一

fori inlist1:

globals[i] = [] # 可以用于實現(xiàn)python版反射

# 方法二

fori inlist1:

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惰性計算

classlazy(object):

def__init__(self, func):

self.func = func

def__get__(self, instance, cls):

val = self.func(instance) #其相當于執(zhí)行的area(c),c為下面的Circle對象

setattr(instance, self.func.__name__, val)

returnval

classCircle(object):

def__init__(self, radius):

self.radius = radius

@lazy

defarea(self):

print( 'evalute')

return3.14* self.radius ** 2

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

all_files = []

defgetAllFiles(directory_path):

importos

forsChild inos.listdir(directory_path):

sChildPath = os.path.join(directory_path,sChild)

ifos.path.isdir(sChildPath):

getAllFiles(sChildPath)

else:

all_files.append(sChildPath)

returnall_files

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

#secure_filename將字符串轉化為安全的文件名

fromwerkzeug importsecure_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

日期格式化

fromdatetime importdatetime

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

importtime

#這里只有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__你應該知道

classMydict(dict):

def__missing__(self,key): # 當Mydict使用切片訪問屬性不存在的時候返回的值

returnkey

+與+=

# +不能用來連接列表和元祖，而+=可以（通過iadd實現(xiàn)，內部實現(xiàn)方式為extends,所以可以增加元組），+會創(chuàng)建新對象

#不可變對象沒有__iadd__方法，所以直接使用的是__add__方法，因此元祖可以使用+=進行元祖之間的相加

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

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

wireshark抓包軟件

網(wǎng)絡知識

什么是HTTPS?

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

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

204No Content //請求成功處理，沒有實體的主體返回，一般用來表示刪除成功

206Partial Content //Get范圍請求已成功處理

303See Other //臨時重定向，期望使用get定向獲取

304Not Modified //求情緩存資源

307Temporary Redirect //臨時重定向，Post不會變成Get

401Unauthorized //認證失敗

403Forbidden //資源請求被拒絕

400//請求參數(shù)錯誤

201//添加或更改成功

503//服務器維護或者超負載

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

WSGI

# environ：一個包含所有HTTP請求信息的dict對象

# start_response：一個發(fā)送HTTP響應的函數(shù)

defapplication(environ, start_response):

start_response( '200 OK', [( 'Content-Type', 'text/html')])

return'<h1>Hello, web!</h1>'

RPC

CDN

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

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

TCP/IP

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

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

三次握手四次揮手

三次握手(SYN/SYN+ACK/ACK)
四次揮手(FIN/ACK/FIN/ACK)

為什么連接的時候是三次握手，關閉的時候卻是四次握手？

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

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

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

XSS/CSRF

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

MySQL

索引改進過程

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

MySQL面試總結基礎篇

MySQL面試總結進階篇

深入淺出MySQL

http://ningning.today/2017/02/13/database/深入淺出mysql/

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

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

什么時候索引失效

（1）以%開頭的like模糊查詢

（2）出現(xiàn)隱士類型轉換

（3）沒有滿足最左前綴原則

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

（4）失效場景：

應盡量避免在 where 子句中使用 != 或 <> 操作符，否則引擎將放棄使用索引而進行全表掃描
盡量避免在 where 子句中使用 or 來連接條件，否則將導致引擎放棄使用索引而進行全表掃描，即使其中有條件帶索引也不會使用，這也是為什么盡量少用 or 的原因
如果列類型是字符串，那一定要在條件中將數(shù)據(jù)使用引號引用起來，否則不會使用索引
應盡量避免在 where 子句中對字段進行函數(shù)操作，這將導致引擎放棄使用索引而進行全表掃描

例如：

selectid fromt wheresubstring(name, 1, 3) = 'abc'– name;

以abc開頭的，應改成：

selectid fromt wherename like'abc% '

例如：

selectid fromt wheredatediff( day, createdate, '2005-11-30') = 0– '2005-11-30';

應改為:

- - 不要在 where 子句中的 “=” 左邊進行函數(shù)、算術運算或其他表達式運算，否則系統(tǒng)將可能無法正確使用索引
  - 應盡量避免在 where 子句中對字段進行表達式操作，這將導致引擎放棄使用索引而進行全表掃描

如：

selectid fromt wherenum/ 2= 100

應改為:

selectid fromt wherenum = 100* 2；

什么是聚集索引

- - 不適合鍵值較少的列（重復數(shù)據(jù)較多的列）比如：set enum列就不適合(枚舉類型(enum)可以添加null,并且默認的值會自動過濾空格集合(set)和枚舉類似，但只可以添加64個值)
  - 如果MySQL估計使用全表掃描要比使用索引快，則不使用索引
- B+Tree葉子節(jié)點保存的是數(shù)據(jù)還是指針
- MyISAM索引和數(shù)據(jù)分離，使用非聚集
- InnoDB數(shù)據(jù)文件就是索引文件，主鍵索引就是聚集索引

redis命令總結

為什么這么快？

（1）基于內存，由C語言編寫

（2）使用多路I/O復用模型，非阻塞IO

（3）使用單線程減少線程間切換

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

（4）數(shù)據(jù)結構簡單

（5）自己構建了VM機制，減少調用系統(tǒng)函數(shù)的時間

優(yōu)勢

豐富的數(shù)據(jù)類型
原子 – Redis的所有操作都是原子性的，同時Redis還支持對幾個操作全并后的原子性執(zhí)行

什么是redis事務？

將多個請求打包，一次性、按序執(zhí)行多個命令的機制
通過multi,exec,watch等命令實現(xiàn)事務功能
Python redis-py pipeline=conn.pipeline(transaction=True)

持久化方式

（1）RDB(快照)

save(同步，可以保證數(shù)據(jù)一致性)
bgsave(異步，shutdown時，無AOF則默認使用)

（2）AOF(追加日志)

怎么實現(xiàn)隊列

push
rpop

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

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

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

（2）List(列表)：用戶的關注，粉絲列表

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

（3）Hash(哈希)：

（4）Set(集合)：用戶的關注者

intset或hashtable

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

skiplist(跳躍表)

與Memcached區(qū)別

Memcached只能存儲字符串鍵
Memcached用戶只能通過APPEND的方式將數(shù)據(jù)添加到已有的字符串的末尾，并將這個字符串當做列表來使用。但是在刪除這些元素的時候，Memcached采用的是通過黑名單的方式來隱藏列表里的元素，從而避免了對元素的讀取、更新、刪除等操作
Redis和Memcached都是將數(shù)據(jù)存放在內存中，都是內存數(shù)據(jù)庫。不過Memcached還可用于緩存其他東西，例如圖片、視頻等等
虛擬內存–Redis當物理內存用完時，可以將一些很久沒用到的Value 交換到磁盤
存儲數(shù)據(jù)安全–Memcached掛掉后，數(shù)據(jù)沒了；Redis可以定期保存到磁盤（持久化）
應用場景不一樣：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值可以是一個隨機的uuid或者特定的命名
釋放鎖的時候，通過uuid判斷是否是該鎖，是則執(zhí)行delete釋放鎖

常見問題

（1）緩存雪崩

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

（2）緩存穿透

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

（3）緩存預熱

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

（4）緩存更新

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

（5）緩存降級

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

一致性Hash算法

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

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

setnx

虛擬內存

內存抖動

Linux

Unix五種i/o模型

（1）阻塞io

（2）非阻塞io

（3）多路復用io(Python下使用selectot實現(xiàn)io多路復用)

select—— 并發(fā)不高，連接數(shù)很活躍的情況下
poll—— 比select提高的并不多
epoll—— 適用于連接數(shù)量較多，但活動鏈接數(shù)少的情況

（4）信號驅動io

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

比man更好使用的命令手冊

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

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

-15：程序立刻停止/當程序釋放相應資源后再停止/程序可能仍然繼續(xù)運行
-9：由于-15的不確定性，所以直接使用-9立即殺死進程

分頁機制（邏輯地址和物理地址分離的內存分配管理方案）：

操作系統(tǒng)為了高效管理內存，減少碎片
程序的邏輯地址劃分為固定大小的頁
物理地址劃分為同樣大小的幀
通過頁表對應邏輯地址和物理地址

分段機制

為了滿足代碼的一些邏輯需求
數(shù)據(jù)共享/數(shù)據(jù)保護/動態(tài)鏈接
每個段內部連續(xù)內存分配，段和段之間是離散分配的

查看cpu內存使用情況？

top
free 查看可用內存，排查內存泄漏問題

設計模式

單例模式

# 方式一

defSingle(cls,*args,**kwargs):

instances = {}

defget_instance(*args, **kwargs):

ifcls notininstances:

instances[cls] = cls(*args, **kwargs)

returninstances[cls]

returnget_instance

@Single

classB:

pass

# 方式二

classSingle:

def__init__(self):

print( "單例模式實現(xiàn)方式二。。。")

single = Single

delSingle # 每次調用single就可以了

# 方式三(最常用的方式)

classSingle:

def__new__(cls,*args,**kwargs):

ifnothasattr(cls, '_instance'):

cls._instance = super.__new__(cls,*args,**kwargs)

returncls._instance

工廠模式

classDog:

def__init__(self):

print( "Wang Wang Wang")

classCat:

def__init__(self):

print( "Miao Miao Miao")

deffac(animal):

ifanimal.lower == "dog":

returnDog

ifanimal.lower == "cat":

returnCat

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 #為了方便鏈式調用

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

python實現(xiàn)各種數(shù)據(jù)結構

快速排序

defquick_sort(_list):

iflen(_list) < 2:

return_list

pivot_index = 0

pivot = _list(pivot_index)

left_list = [i fori in_list[:pivot_index] ifi < pivot]

right_list = [i fori in_list[pivot_index:] ifi > pivot]

returnquick_sort(left) + [pivot] + quick_sort(right)

選擇排序

defselect_sort(seq):

n = len(seq)

fori inrange(n- 1)

min_idx = i

forj inrange(i+ 1,n):

ifseq[j] < seq[min_inx]:

min_idx = j

ifmin_idx != i:

seq[i], seq[min_idx] = seq[min_idx],seq[i]

插入排序

definsertion_sort(_list):

n = len(_list)

fori inrange( 1,n):

value = _list[i]

pos = i

whilepos > 0andvalue < _list[pos - 1]

_list[pos] = _list[pos - 1]

pos -= 1

_list[pos] = value

print(sql)

歸并排序

defmerge_sorted_list(_list1,_list2): #合并有序列表

len_a, len_b = len(_list1),len(_list2)

a = b = 0

sort = []

whilelen_a > a andlen_b > b:

if_list1[a] > _list2[b]:

sort.append(_list2[b])

b += 1

else:

sort.append(_list1[a])

a += 1

iflen_a > a:

sort.append(_list1[a:])

iflen_b > b:

sort.append(_list2[b:])

returnsort

defmerge_sort(_list):

iflen(list1)< 2:

returnlist1

else:

mid = int(len(list1)/ 2)

left = mergesort(list1[:mid])

right = mergesort(list1[mid:])

returnmerge_sorted_list(left,right)

堆排序heapq模塊

fromheapq importnsmallest

defheap_sort(_list):

returnnsmallest(len(_list),_list)

棧

fromcollections importdeque

classStack:

def__init__(self):

self.s = deque

defpeek(self):

p = self.pop

self.push(p)

returnp

defpush(self, el):

self.s.append(el)

defpop(self):

returnself.pop

隊列

fromcollections importdeque

classQueue:

def__init__(self):

self.s = deque

defpush(self, el):

self.s.append(el)

defpop(self):

returnself.popleft

二分查找

defbinary_search(_list,num):

mid = len(_list)// 2

iflen(_list) < 1:

returnFlase

ifnum > _list[mid]:

BinarySearch(_list[mid:],num)

elifnum < _list[mid]:

BinarySearch(_list[:mid],num)

else:

return_list.index(num)

面試加強題：

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

如何使用兩個棧實現(xiàn)一個隊列
反轉鏈表
合并兩個有序鏈表
刪除鏈表節(jié)點
反轉二叉樹
設計短網(wǎng)址服務？62進制實現(xiàn)
設計一個秒殺系統(tǒng)(feed流)？ https://www.jianshu.com/p/ea0259d109f9
為什么mysql數(shù)據(jù)庫的主鍵使用自增的整數(shù)比較好？使用uuid可以嗎？為什么？
- 如果InnoDB表的數(shù)據(jù)寫入順序能和B+樹索引的葉子節(jié)點順序一致的話，這時候存取效率是最高的。為了存儲和查詢性能應該使用自增長id做主鍵。
- 對于InnoDB的主索引，數(shù)據(jù)會按照主鍵進行排序，由于UUID的無序性，InnoDB會產(chǎn)生巨大的IO壓力，此時不適合使用UUID做物理主鍵，可以把它作為邏輯主鍵，物理主鍵依然使用自增ID。為了全局的唯一性，應該用uuid做索引關聯(lián)其他表或做外鍵
如果是分布式系統(tǒng)下我們怎么生成數(shù)據(jù)庫的自增id呢？
- 使用redis
基于redis實現(xiàn)一個分布式鎖，要求一個超時的參數(shù)
- setnx
- setnx + expire
如果redis單個節(jié)點宕機了，如何處理？還有其他業(yè)界的方案實現(xiàn)分布式鎖碼?
- 使用hash一致算法