提示
自己整理的答案，很局限，如有需要改進的地方，或者有更好的答案，歡迎提出！
【合理利用 Ctrl+F 提高查找效率】
第一部分 Python基礎篇（80題）
1、為什么學習Python？
# 因為python相對其他語言非常優雅簡潔,有着豐富的第三方庫,我感覺很強大、很方便; # 還有就是，我感覺python簡單易學，生態圈龐大，例如：web開發、爬蟲、人工智能等，而且未來發展趨勢也很不錯。
2、通過什么途徑學習的Python？
# 在系里社團通過學長了解到python 根據個人情況而定…………
3、Python和Java、PHP、C、C#、C++等其他語言的對比？
# Python、PHP是解釋型語言，代碼運行期間逐行翻譯成目標機器碼，下次執行時逐行解釋 # 而C、Java是編譯型語言，編譯后再執行。
4、簡述解釋型和編譯型編程語言？
# 解釋型：邊解釋邊執行（python、PHP） # 編譯型：編譯后再執行（c、Java、C#）
5、Python解釋器種類以及特點？
# CPython:C語言開發的，官方推薦，最常用 # IPython:基於CPython之上的交互式解釋器，只是在交互上有增強 # JPython:Java寫的解釋器 # Pypy:Python寫的解釋器，目前執行速度最快的解釋器，采用JIT技術，對Python進行動態編譯 # IronPython：C#寫的解釋器
6、位和字節的關系？
#1字節=8位 #1byte=8bit （數據存儲以字節(Byte)為單位）
7、b、B、KB、MB、GB 的關系？
1B=8bit 1KB=1024B 1MB=1024KB 1G=1024MB 1T=1024G
8、請至少列舉5個 PEP8 規范（越多越好）。
#1、空格使用 a 各種右括號前不要加空格。 b 逗號、冒號、分號前不要加空格。 c 函數的左括號前不要加空格。如Func(1)。 d 序列的左括號前不要加空格。如list[2]。 e 操作符左右各加一個空格，不要為了對齊增加空格。 f 函數默認參數使用的賦值符左右省略空格。 g 不要將多句語句寫在同一行，盡管使用‘；’允許。 8 if/for/while語句中，即使執行語句只有一句，也必須另起一行。 #2、代碼編排 a 縮進，4個空格，而不是tab鍵 b 每行長度79，換行可使用反斜杠，最好使用圓括號。 c 類與類之間空兩行 d 方法之間空一行
9、通過代碼實現如下轉換：
二進制轉換成十進制：v = “0b1111011” 十進制轉換成二進制：v = 18 八進制轉換成十進制：v = “011” 十進制轉換成八進制：v = 30 十六進制轉換成十進制：v = “0x12” 十進制轉換成十六進制：v = 87 ################################ v = 0b1111011 print(int(v)) v = 18 print(bin(v)) v = '011' print(int(v)) v = 30 print(oct(v)) v = 0x12 print(int(v)) v = 87 print(hex(v))
10、請編寫一個函數實現將IP地址轉換成一個整數。
如 10.3.9.12 轉換規則為： 10 00001010 3 00000011 9 00001001 12 00001100 再將以上二進制拼接起來計算十進制結果：00001010 00000011 00001001 00001100 = ？
ip_addr = '192.168.2.10' # transfer ip to int def ip2long(ip): ip_list = ip.split('.') result = 0 for i in range(4): # 0,1,2,3 result = result + int(ip_list[i]) * 256 ** (3 - i) return result long = 3232236042 # transfer int to ip def long2ip(long): floor_list = [] yushu = long for i in reversed(range(4)): # 3,2,1,0 res = divmod(yushu, 256 ** i) floor_list.append(str(res[0])) yushu = res[1] return '.'.join(floor_list) a = long2ip(long) print(a)
11、python遞歸的最大層數？
Python中默認的遞歸層數約為998左右(會報錯)
和計算機性能有關系，我的最大數字在3210 - 3220之間浮動
12、求結果：
v1 = 1 or 3 -- 1 v2 = 1 and 3 -- 3 v3 = 0 and 2 and 1 -- 0 v4 = 0 and 2 or 1 -- 1 v5 = 0 and 2 or 1 or 4 -- 1 v6 = 0 or Flase and 1 -- False ######################## and：前后為真才為真 or：有一為真就為真 優先級：()>not>and>or 同等優先級下，從左向右
13、ascii、unicode、utf-8、gbk 區別？
#Ascii： 1個字節 支持英文 #unicode ：所有字符（無論中文、英文等）1個字符：4個字節 #gbk ： 1個字符，英文1個字節，中文2個字節。 #utf-8 ：英文1個字節，歐洲字符：2個字節， 亞洲： 3個字節。
14、字節碼和機器碼的區別？
- C代碼被編譯成機器碼（二進制），在機器上直接執行。 - Cpython編譯你的python源代碼，生成字節碼。 - 機器碼快的多，字節碼更易遷移，也安全。
15、三元運算規則以及應用場景？
# 三元運算符就是在賦值變量的時候，可以直接加判斷，然后賦值 a = 1 b = 2 c = a if a > 1 else b # 如果a大於1的話，c=a，否則c=b
16、列舉 Python2和Python3的區別？
'Print'： py2--print; py3--print()函數 '編碼'： py2默認是ascii碼； py3默認是utf-8 '字符串'： py2中分ascii(8位)、unicode(16位)； py3中所有字符串都是unicode字符串 'True和False'： py2中是兩個全局變量(1和0)可以重新賦值； py3中為兩個關鍵字，不可重新賦值 '迭代'： py2:xrange； py3:range 'Nonlocal'： py3專有的（聲明為非局部變量） '經典類&新式類'： py2：經典類和新式類並存； py3：新式類都默認繼承object 'yield'： py2：yield py3：yield/yield from '文件操作'： py2：readliens（）讀取文件的所有行，返回一個列表，包含所有行的結束符 xreadliens（）返回一個生成器，循環取值 py3: 只有readlines()
17、用一行代碼實現數值交換：
a = 1 b = 2 ########### a, b = b, a print(a, b)
18、Python3和Python2中 int 和 long的區別？
py3中沒有long整型，統一使用int，大小和py2的long類似。
py2中int最大不能超過sys.maxint，根據不同平台大小不同；
在int類型數字后加L定義成長整型，范圍比int更大。
19、xrange和range的區別？
#range產生的是一個列表，xrange產生的是生成器。 #數據較大時xrange比range好。 #Range一下把數據都返回，xrange通過yield每次返回一個。
20、文件操作時：xreadlines和readlines的區別？
# Readlines：讀取文件的所有行，返回一個列表，包含所有行的結束符 # Xreadlines：返回一個生成器，循環使用和readlines基本一致 。（py2有，py3沒有）
21、列舉布爾值為False的常見值？
# []、{}、None、’’、()、0、False
22、字符串、列表、元組、字典每個常用的5個方法？
#Str： Split：分割 Strip：去掉兩邊的空格 Startwith：以什么開頭 Endwith：以什么結尾 Lower：小寫 Upper：大寫 #List： Append：追加 Insert：插入 Reverse：反轉 Index：索引 Copy：拷貝 Pop：刪除指定索引處的值，不指定索引默認刪除最后一個。 #Tuple： Count：查看某個元素出現的次數 Index：索引 #Dict： Get：根據key取value Items：用於循環，取出所有key和value Keys：取出所有key Values：取出所有的value Clear：清空字典 Pop：刪除指定鍵對應的值，有返回值；
23、lambda表達式格式以及應用場景？
# 格式： 匿名函數：res = lambda x：i*x print(res(2)) # 應用場景： Filter(),map(),reduce(),sorted()函數中經常用到，它們都需要函數形參數； 一般定義調用一次。 （reduce()對參數序列中元素進行累積）
24、pass的作用？
# Pass一般用於站位語句，保持代碼的完整性，不會做任何操作。
25、*arg和**kwarg作用
# 他們是一種動態傳參，一般不確定需要傳入幾個參數時，可以使用其定義參數，然后從中取參 '*args'：按照位置傳參，將傳入參數打包成一個‘元組’(打印參數為元組-- tuple) '**kwargs'：按照關鍵字傳參，將傳入參數打包成一個‘字典’(打印參數為字典-- dict)
26、is和==的區別
==：判斷某些值是否一樣，比較的是值 is：比較的是內存地址（引用的內存地址不一樣，唯一標識：id）
27、簡述Python的深淺拷貝以及應用場景？
#淺拷貝： 不管多么復雜的數據結構，只copy對象最外層本身，該對象引用的其他對象不copy， 內存里兩個變量的地址是一樣的，一個改變另一個也改變。 #深拷貝： 完全復制原變量的所有數據，內存中生成一套完全一樣的內容；只是值一樣，內存地址不一樣，一方修改另一方不受影響
28、Python垃圾回收機制？
# Python垃圾回收機制 Python垃圾回收機制,主要使用'引用計數'來跟蹤和回收垃圾。 在'引用計數'的基礎上，通過'標記-清除'（mark and sweep）解決容器對象可能產生的循環引用問題. 通過'分代回收'以空間換時間的方法提高垃圾回收效率。 '引用計數' PyObject是每個對象必有的內容，其中ob_refcnt就是做為引用計數。 當一個對象有新的引用時，它的ob_refcnt就會增加，當引用它的對象被刪除， 它的ob_refcnt就會減少.引用計數為0時，該對象生命就結束了。 \優點:1.簡單 2.實時性 \缺點:1.維護引用計數消耗資源 2.循環引用 '標記-清楚機制' 基本思路是先按需分配，等到沒有空閑內存的時候從寄存器和程序棧上的引用出發， 遍歷以對象為節點、以引用為邊構成的圖，把所有可以訪問到的對象打上標記， 然后清掃一遍內存空間，把所有沒標記的對象釋放。 '分代技術' 分代回收的整體思想是： 將系統中的所有內存塊根據其存活時間划分為不同的集合，每個集合就成為一個“代”， 垃圾收集頻率隨着“代”的存活時間的增大而減小，存活時間通常利用經過幾次垃圾回收來度量。
29、Python的可變類型和不可變類型？
# 可變類型：列表、字典、集合 # 不可變類型：數字、字符串、元祖 （可變與否指內存中那塊內容value）
30、求結果：
v = dict.fromkeys(['k1', 'k2'], []) # 內存中k1和k2都指向同一個[](內存地址相同),只要指向的[]發生變化，k1和k2都要改變(保持一致) v['k1'].append(666) print(v) # {'k1': [666], 'k2': [666]} v['k1'] = 777 print(v) # {'k1': 777, 'k2': [666]}
31、求結果：
def num(): return [lambda x: i * x for i in range(4)] #返回一個列表，里面是四個函數對象 i=3 print([m(2) for m in num()])
32、列舉常見的內置函數？
# map:遍歷序列，為每一個序列進行操作，返回一個結果列表 l = [1, 2, 3, 4, 5, 6, 7] def pow2(x): return x * x res = map(pow2, l) print(list(res)) #[1, 4, 9, 16, 25, 36, 49] -------------------------------------------------------------- # reduce：對於序列里面的所有內容進行累計操作 from functools import reduce def add(x, y): return x+y print(reduce(add, [1,2,3,4])) #10 -------------------------------------------------------------- # filter：對序列里面的元素進行篩選，最終獲取符合條件的序列。 l = [1, 2, 3, 4, 5] def is_odd(x): # 求奇數 return x % 2 == 1 print(list(filter(is_odd, l))) #[1, 3, 5] -------------------------------------------------------------- #zip用於將可迭代的對象作為參數，將對象中對應的元素打包成一個個元組，然后返回由這些元組組成的列表 a = [1,2,3] b=[4,5,6] c=[4,5,6,7,8] ziped1 = zip(a,b) print('ziped1>>>',list(ziped1)) #[(1, 4), (2, 5), (3, 6)] ziped2 = zip(a,c) print('ziped2>>>',list(ziped2)) #[(1, 4), (2, 5), (3, 6)],以短的為基准
33、filter、map、reduce的作用？
# map:遍歷序列，為每一個序列進行操作，獲取一個新的序列 # reduce：對於序列里面的所有內容進行累計操作 # filter：對序列里面的元素進行篩選，最終獲取符合條件的序列。
34、一行代碼實現9*9乘法表
print('\n'.join([' '.join(['%s*%s=%2s' % (j, i, i * j) for j in range(1, i + 1)]) for i in range(1, 10)]))
35、如何安裝第三方模塊？以及用過哪些第三方模塊？
# a、可以在pycharm的settings里面手動下載添加第三方模塊 # b、可以在cmd終端下用pip insatll 安裝 # 用過的第三方模塊：requests、pymysql、DBUtils等
36、至少列舉8個常用模塊都有那些？
re：正則
os：提供了一種方便的使用操作系統函數的方法。
sys：可供訪問由解釋器使用或維護的變量和與解釋器進行交互的函數。
random：隨機數
json：序列化
time：時間
37、re的match和search區別？
# match：從字符串起始位置開始匹配，如果沒有就返回None # serch：從字符串的起始位置開始匹配，匹配到第一個符合的就不會再去匹配了
38、什么是正則的貪婪匹配？
# 匹配一個字符串沒有節制，能匹配多少就匹配多少，直到匹配完為止
39、求結果： a. [ i % 2 for i in range(10) ] b. ( i % 2 for i in range(10) )
# a結果是一個列表生成式，結果是一個列表(i % 2為生成的元素): [0, 1, 0, 1, 0, 1, 0, 1, 0, 1] # b結果是一個生成器
40、求結果： a. 1 or 2 b. 1 and 2 c. 1 < (2==2) d. 1 < 2 == 2
a=1 or 2 #1 b=1 and 2 #2 c=1 < (2==2) #False d=1 < 2 == 2 #True
41、def func(a,b=[]) 這種寫法有什么坑？
# 函數傳參為列表陷阱，列表是可變數據類型，可能會在過程中修改里面的值
42、如何實現 “1,2,3” 變成 [‘1’,’2’,’3’] ?
a = '1,2,3' a=a.replace(',','') res = [i for i in a] print(res)
43、如何實現[‘1’,’2’,’3’]變成[1,2,3] ?
l = ['1','2','3'] res = [int(i) for i in l] print(res)
44、比較： a = [1,2,3] 和 b = [(1),(2),(3) ] 以及 b = [(1,),(2,),(3,) ] 的區別？
前兩個列表內是int
最后一個列表內是元組
45、如何用一行代碼生成[1,4,9,16,25,36,49,64,81,100] ?
l = [i*i for i in range(1,11)] print(l)
46、一行代碼實現刪除列表中重復的值 ?
l = [1,1,1,2,2,3,3,3,4,4] print(list(set(l))) # [1, 2, 3, 4]
47、如何在函數中設置一個全局變量 ?
通過global指定變量，該變量會變成全局變量
48、logging模塊的作用？以及應用場景？
# 作用： 管理我們程序的執行日志，省去用print記錄操作日志的操作，並且可以將標准輸入輸出保存到日志文件 # 場景： 爬蟲爬取數據時，對爬取進行日志記錄，方便分析、排錯。
49、請用代碼簡單實現stack 。
class Stack(object): # 初始化棧 def __init__(self): self.items = [] # 判斷棧是否為空 def is_empty(self): return self.items == [] # 返回棧頂 def peek(self): return self.items[len(self.items) - 1] # 返回棧大小 def size(self): return len(self.items) # 壓棧 def push(self, item): self.items.append(item) # 出棧 def pop(self): return self.items.pop()
50、常用字符串格式化哪幾種？
# %占位符 s = 'I am %s' %'zhugaochao' print(s) #I am zhugaochao # format格式化輸出 i = "i am {}".format('zhugaochao') print(i) #i am zhugaochao
51、簡述 生成器、迭代器、可迭代對象 以及應用場景？
# 裝飾器： 能夠在不修改原函數代碼的基礎上，在執行前后進行定制操作，閉包函數的一種應用 場景： - flask路由系統 - flask before_request - csrf - django內置認證 - django緩存 # 手寫裝飾器； import functools def wrapper(func): @functools.wraps(func) #不改變原函數屬性 def inner(*args, **kwargs): 執行函數前 return func(*args, **kwargs) 執行函數后 return inner 1. 執行wapper函數，並將被裝飾的函數當做參數。 wapper(index) 2. 將第一步的返回值，重新賦值給 新index = wapper(老index) @wrapper #index=wrapper(index) def index(x): return x+100 # --------------------------------------------------------------- # 生成器： 一個函數內部存在yield關鍵字 應用場景： - rang/xrange - redis獲取值 - conn = Redis(......) - v=conn.hscan_iter() # 內部通過yield 來返回值 - stark組件中 - 前端調用后端的yield # --------------------------------------------------------------- # 迭代器： 內部有__next__和__iter__方法的對象，幫助我們向后一個一個取值，迭代器不一定是生成器 應用場景： - wtforms里面對form對象進行循環時，顯示form中包含的所有字段 - 列表、字典、元組 （可以讓一個對象被for循環）
52、用Python實現一個二分查找的函數。
li = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] def search(zhi,li,start=0,end=None): end = len(li) if end is None else end zj = (end - start) // 2+start if start<=end: if zhi>li[zj]: return search(3,li,start=zj+1,end=end) elif zhi<li[zj]: return search(3,li,start=start,end=zj-1) else: return zj return '找不到這個值' print(search(2,li))
53、談談你對閉包的理解？
# 閉包函數就是內部的函數調用外部函數的變量，常用於裝飾器。 # 判斷閉包函數的方法：__closure__，輸出的__closure__有cell元素說明是閉包函數 # 閉包的意義與應用：延遲計算：
54、os和sys模塊的作用？
# os模塊負責程序與操作系統的交互，提供了訪問操作系統底層的接口； # sys模塊負責程序與python解釋器的交互，提供了一系列的函數和變量，用於操控python運行環境
55、如何生成一個隨機數？
import random print(random.random()) print(random.randint(1, 10))
56、如何使用python刪除一個文件？
import os os.remove('文件名以及路徑')
57、談談你對面向對象的理解？
#封裝： 其實就是將很多數據封裝到一個對象中，類似於把很多東西放到一個箱子中， 如：一個函數如果好多參數，起始就可以把參數封裝到一個對象再傳遞。 #繼承： 如果多個類中都有共同的方法，那么為了避免反復編寫，就可以將方法提取到基類中實現， 讓所有派生類去繼承即可。 #多態： 指基類的同一個方法在不同派生類中有着不同功能。python天生支持多態。
58、Python面向對象中的繼承有什么特點？
#Python3的繼承機制 # 子類在調用某個方法或變量的時候，首先在自己內部查找，如果沒有找到，則開始根據繼承機制在父類里查找。 # 根據父類定義中的順序，以深度優先的方式逐一查找父類！ 繼承參數的書寫有先后順序，寫在前面的被優先繼承。
59、面向對象深度優先和廣度優先是什么？
# Python的類可以繼承多個類，Python的類如果繼承了多個類，那么其尋找方法的方式有兩種 當類是經典類時，多繼承情況下，會按照深度優先方式查找 當類是新式類時，多繼承情況下，會按照廣度優先方式查找 簡單點說就是：經典類是縱向查找，新式類是橫向查找 經典類和新式類的區別就是，在聲明類的時候，新式類需要加上object關鍵字。在python3中默認全是新式類
60、面向對象中super的作用？
主要在子類繼承父類的所有屬性和方法時來使用
61、是否使用過functools中的函數？其作用是什么？
在裝飾器中，會用到；functools.wraps()主要在裝飾器中用來裝飾函數 Stark上下文管理源碼中，走到視圖階段時有用到functools中的偏函數，request = LocalProxy(partial(_lookup_req_object, 'request'))
62、列舉面向對象中帶爽下划線的特殊方法，如：__new__、__init__
# __getattr__ CBV django配置文件 wtforms中的Form()示例化中 將"_fields中的數據封裝到From類中" # __mro__ wtform中 FormMeta中繼承類的優先級 # __dict__ 是用來存儲對象屬性的一個字典，其鍵為屬性名，值為屬性的值 # __new__ 實例化但是沒有給當前對象 wtforms，字段實例化時返回：不是StringField，而是UnboundField est frawork many=Turn 中的序列化 # __call__ flask 請求的入口app.run() 字段生成標簽時：字段.__str__ => 字段.__call__ => 插件.__call__ # __iter__ 循環對象是，自定義__iter__ wtforms中BaseForm中循環所有字段時定義了__iter__ # -metaclass 作用：用於指定當前類使用哪個類來創建 場景：在類創建之前定制操作 示例：wtforms中，對字段進行排序。
63、如何判斷是函數還是方法
# 看他的調用者是誰，如果是類，需要傳入參數self，這時就是一個函數； # 如果調用者是對象，不需要傳入參數值self，這時是一個方法。 (FunctionType/MethodType)
64、靜態方法和類方法區別？
Classmethod必須有一個指向類對象的引用作為第一個參數； @classmethod def class_func(cls): """ 定義類方法，至少有一個cls參數 """ print('類方法') --------------------------------------------------------- Staticmethod可以沒有任何參數。 @staticmethod def static_func(): """ 定義靜態方法 ，無默認參數""" print('靜態方法')
65、列舉面向對象中的特殊成員以及應用場景
1. __doc__：表示類的描述信息。 2.__module__：表示當前操作的對象在那個模塊； 3.__class__：表示當前操作的對象的類是什么。 4.__init__：構造方法，通過類創建對象時，自動觸發執行。 5.__call__：對象后面加括號，觸發執行。 6.__dict__：類或對象中的所有成員。 7.__str__：如果一個類中定義了__str__方法，那么在打印對象時，默認輸出該方法的返回值。 class Foo: def __str__(self): return 'aaa' obj = Foo() print(obj) # 輸出：aaa 8.__getitem__、__setitem__、__delitem__：用於索引操作，如字典。以上分別表示獲取、設置、刪除數據。 9.__iter__：用於迭代器，之所以列表、字典、元組可以進行for循環，是因為類型內部定義了 __iter__。
66、1、2、3、4、5 能組成多少個互不相同且無重復的三位數
import itertools print(len(list(itertools.permutations('12345',3)))) #60個
67、什么是反射？以及應用場景？
反射就是以字符串的方式導入模塊，以字符串的方式執行函數 # 應用場景： rest framework里面的CBV
68、metaclass作用？以及應用場景？
類的metaclass
默認是type。我們也可以指定類的metaclass值。
參考:點擊查看
69、用盡量多的方法實現單例模式。
# 單例模式 '''單例模式是一種常用的軟件設計模式。在它的核心結構中只包含一個被稱為單例類的特殊類。 通過單例模式可以保證系統中一個類只有一個實例而且該實例易於外界訪問，從而方便對實例個數的控制並節約系統資源。 如果希望在系統中某個類的對象只能存在一個，單例模式是最好的解決方案。''' # 1、使用__new__方法 class Singleton(object): def __new__(cls, *args, **kw): if not hasattr(cls, '_instance'): orig = super(Singleton, cls) cls._instance = orig.__new__(cls, *args, **kw) return cls._instance class MyClass(Singleton): a = 1 # 2、共享屬性 # 創建實例時把所有實例的__dict__指向同一個字典,這樣它們具有相同的屬性和方法. class Borg(object): _state = {} def __new__(cls, *args, **kw): ob = super(Borg, cls).__new__(cls, *args, **kw) ob.__dict__ = cls._state return ob class MyClass2(Borg): a = 1 # 3、裝飾器版本 def singleton(cls, *args, **kw): instances = {} def getinstance(): if cls not in instances: instances[cls] = cls(*args, **kw) return instances[cls] return getinstance @singleton class MyClass: ... # 4、import方法 # 作為python的模塊是天然的單例模式 # mysingleton.py class My_Singleton(object): def foo(self): pass my_singleton = My_Singleton() # to use from mysingleton import my_singleton my_singleton.foo()
70、裝飾器的寫法以及應用場景。
import functools def wrapper(func): @functools.wraps(func) def inner(*args, **kwargs): print('我是裝飾器') return func return inner @wrapper def index(): print('我是被裝飾函數') return None index() # 應用場景 - 高階函數 - 閉包 - 裝飾器 - functools.wraps(func)
71、異常處理寫法以及如何主動拋出異常（應用場景）
while True: try: x = int(input("Please enter a number: ")) break except ValueError: print("Oops! That was no valid number. Try again ") # raise主動拋出一個異常 參考:點擊查看
72、什么是面向對象的mro
MRO：方法解析順序
它定義了 Python 中多繼承存在的情況下，解釋器查找繼承關系的具體順序
73、isinstance作用以及應用場景？
# 來判斷一個對象是否是一個已知的類型。 # 使用isinstance函數還可以來判斷'類實例變量'屬於哪一個類產生的。
74、寫代碼並實現：
Given an array of integers, return indices of the two numbers such that they add up to a specific target.You may assume that each input would have exactly one solution, and you may not use the same element twice.Example: Given nums = [2, 7, 11, 15], target = 9, Because nums[0] + nums[1] = 2 + 7 = 9, return [0, 1]
'''Given an array of integers, return indices of the two numbers such that they add up to a specific target.You may assume that each input would have exactly one solution, and you may not use the same element twice. Example: Given nums = [2, 7, 11, 15], target = 9, Because nums[0] + nums[1] = 2 + 7 = 9, return [0, 1]''' class Solution: def twoSum(self, nums, target): """ :type nums: List[int] :type target: int :rtype: List[int] """ # 用len()方法取得nums列表長度 n = len(nums) # x從0到n取值（不包括n） for x in range(n): a = target - nums[x] # 用in關鍵字查詢nums列表中是否有a if a in nums: # 用index函數取得a的值在nums列表中的索引 y = nums.index(a) # 假如x=y,那么就跳過,否則返回x,y if x == y: continue else: return x, y break else: continue
75、json序列化時，可以處理的數據類型有哪些？如何定制支持datetime類型？
# 可序列化數據類型： 字典、列表、數字、字符串、元組；如果是元組，自動轉成列表（再轉回去的話也是列表） # 自定義時間序列化轉換器 import json from json import JSONEncoder from datetime import datetime class ComplexEncoder(JSONEncoder): def default(self, obj): if isinstance(obj, datetime): return obj.strftime('%Y-%m-%d %H:%M:%S') else: return super(ComplexEncoder,self).default(obj) d = { 'name':'alex','data':datetime.now()} print(json.dumps(d,cls=ComplexEncoder)) # {"name": "alex", "data": "2018-05-18 19:52:05"}
76、json序列化時，默認遇到中文會轉換成unicode，如果想要保留中文怎么辦？
import json a=json.dumps({"xxx":"你好"},ensure_ascii=False) print(a) #{"xxx": "你好"}
77、什么是斷言？應用場景？
#條件成立則繼續往下，否則拋出異常； #一般用於：滿足某個條件之后，才能執行，否則應該拋出異常。 '應用場景'：rest framework中GenericAPIView類里，要設置queryset，否則斷言錯誤
78、有用過with statement嗎？它的好處是什么？
with語句適用於對資源進行訪問的場合，確保不管使用過程中是否發生異常都會執行必要的“清理”操作，
釋放資源，比如文件使用后自動關閉、線程中鎖的自動獲取和釋放等。
79、使用代碼實現查看列舉目錄下的所有文件。
import os path = os.listdir('.') #查看列舉目錄下的所有文件。 # path = os.listdir(os.getcwd()) print(path)
80、簡述 yield和yield from關鍵字。
1、yield使用 1）函數中使用yield，可以使函數變成生成器。一個函數如果是生成一個數組，就必須把數據存儲在內存中，如果使用生成器，則在調用的時候才生成數據，可以節省內存。 2）生成器方法調用時，不會立即執行。需要調用next()或者使用for循環來執行。 2、yield from的使用 1）為了讓生成器（帶yield函數），能簡易的在其他函數中直接調用，就產生了yield from。 參考:點擊查看
第二部分 網絡編程和並發（34題）
1、簡述 OSI 七層協議。
物理層：主要基於電器特性發送高低電壓(1、0)，設備有集線器、中繼器、雙絞線等，單位：bit
數據鏈路層：定義了電信號的分組方式，設備：交換機、網卡、網橋，單位：幀
網絡層：主要功能是將網絡地址翻譯成對應屋里地址，設備：路由
傳輸層：建立端口之間的通信，tcp、udp協議
會話層：建立客戶端與服務端連接
表示層：對來自應用層的命令和數據進行解釋，按照一定格式傳給會話層。如編碼、數據格式轉換、加密解密、壓縮解壓
應用層：規定應用程序的數據格式
2、什么是C/S和B/S架構？
#C/S架構： client端與server端的服務架構 #B/S架構： 隸屬於C/S架構，Broswer端（網頁端）與server端； 優點：統一了所有應用的入口，方便、輕量級
3、簡述 三次握手、四次揮手的流程。
#三次握手： 1.客戶端(Client)向服務端(Server)發送一次請求 2.服務端確認並回復客戶端 3.客戶端檢驗確認請求，建立連接 #四次揮手： 1.客戶端向服務端發一次請求 2.服務端回復客戶端(斷開客戶端-->服務端) 3.服務端再次向客戶端發請求(告訴客戶端可以斷開了) 4.客戶端確認請求，連接斷開
4、什么是arp協議？
#ARP(地址解析協議) 其主要用作將IP地址翻譯為以太網的MAC地址 #在局域網中，網絡中實際傳輸的是“幀”，幀里面是有目標主機的MAC地址的。 #在以太網中，一個主機要和另一個主機進行直接通信，必須要知道目標主機的MAC地址。 #所謂“地址解析”就是主機在發送幀前將目標IP地址轉換成目標MAC地址的過程。 #ARP協議的基本功能就是通過目標設備的IP地址，查詢目標設備的MAC地址，以保證通信的順利進行。
5、TCP和UDP的區別？
#TCP協議：面向連接 - 通信之前先三次握手 - 斷開之前先四次握手 - 必須先啟動服務端，再啟動客戶端-->連接服務端 - 安全、可靠、面向連接(不會丟包) #UDP協議：無連接 - 傳輸速度快 - 先啟動哪一端都可以 - 不面向連接，不能保證數據的完整性(如：QQ聊天)
6、什么是局域網和廣域網？
局域網和廣域網是按規模大小而划分的兩種計算機網絡。 #范圍在幾千米以內的計算機網絡統稱為局域網（LAN、私網、內網）； #而連接的范圍超過10千米的，則稱為廣域網，因特網（Intenet）就是目前最大的廣域網（WAN、公網、外網）。
7、為何基於tcp協議的通信比基於udp協議的通信更可靠？
因為TCP是面向連接的
通信之前先三次握手，通過握手，確保連接成功之后再通信
斷開之前先四次揮手；雙方互相確認之后再斷開連接，這樣一來保證了數據的安全、可靠，避免丟包
8、什么是socket？簡述基於tcp協議的套接字通信流程。
#服務端： 創建套接字 綁定IP和端口 監聽 accept等待連接 通信(收recv、發send) #客戶端： 創建套接字 綁定IP和端口 鏈接服務器 通信(收revc、發send)
9、什么是粘包？ socket 中造成粘包的原因是什么？ 哪些情況會發生粘包現象？
粘包：數據粘在一起，主要因為：接收方不知道消息之間的界限，不知道一次性提取多少字節的數據造成的
數據量比較小，時間間隔比較短，就合並成了一個包，這是底層的一個優化算法（Nagle算法）
10、IO多路復用的作用？
# IO多路復用分為時間上的復用和空間上的復用， # 空間上的復用是指將內存分為幾部分，每一部分放一個程序，這樣同一時間內存中就有多道程序； # 時間上的復用是指多個程序需要在一個cpu上運行，不同的程序輪流使用cpu， # 當某個程序運行的時間過長或者遇到I/O阻塞，操作系統會把cpu分配給下一個程序， # 保證cpu處於高使用率，實現偽並發。
11、什么是防火牆以及作用？
# 什么是防火牆？ 防火牆是一個分離器，一個限制器，也是一個分析器， 有效地監控了內部網和Internet之間的任何活動,保證了內部網絡的安全。 # 作用 防火牆可通過監測、限制、更改跨越防火牆的數據流， 盡可能地對外部屏蔽網絡內部的信息、結構和運行狀況,以此來實現網絡的安全保護。
12、select、poll、epoll 模型的區別？
# select本質上是通過設置或者檢查存放fd標志位的數據結構來進行下一步處理。這樣所帶來的缺點是： # 1.單個進程可監視的fd數量被限制 # 2.需要維護一個用來存放大量fd的數據結構 # 這樣會使得用戶空間和內核空間在傳遞該結構時復制開銷大 # 3.對socket進行掃描時是線性掃描 # poll本質上和select沒有區別，它將用戶傳入的數組拷貝到內核空間， # 它沒有最大連接數的限制，原因是它是基於鏈表來存儲的但是同樣有一個缺點： # 大量的fd的數組被整體復制於用戶態和內核地址空間之間，而不管這樣的復制是不是有意義。 # epoll支持水平觸發和邊緣觸發，最大的特點在於邊緣觸發， # 它只告訴進程哪些fd剛剛變為就需態，並且只會通知一次。
13、簡述 進程、線程、協程的區別 以及應用場景？
# 進程 進程擁有自己獨立的堆和棧，既不共享堆，亦不共享棧，進程由操作系統調度。 # 線程 線程擁有自己獨立的棧和共享的堆，共享堆，不共享棧，線程亦由操作系統調度 # 協程和線程的區別 協程避免了無意義的調度，由此可以提高性能；但同時協程也失去了線程使用多CPU的能力。
14、GIL鎖是什么鬼？
# GIL 線程全局鎖(Global Interpreter Lock),即Python為了保證線程安全而采取的獨立線程運行的限制,說白了就是一個核只能在同一時間運行一個線程. 對於io密集型任務，python的多線程起到作用，但對於cpu密集型任務， python的多線程幾乎占不到任何優勢，還有可能因為爭奪資源而變慢。 解決辦法就是多進程和下面的協程(協程也只是單CPU,但是能減小切換代價提升性能).
15、Python中如何使用線程池和進程池？
進程池：就是在一個進程內控制一定個數的線程
基於concurent.future模塊的進程池和線程池 （他們的同步執行和異步執行是一樣的）
參考:點擊查看
16、threading.local的作用？
a.threading.local 作用：為每個線程開辟一塊空間進行數據存儲。 問題：自己通過字典創建一個類似於threading.local的東西。 storage = { 4740: {val: 0}, 4732: {val: 1}, 4731: {val: 3}, } b.自定義Local對象 作用：為每個線程(協程) 開辟一塊空間進行數據存儲。 try: from greenlet import getcurrent as get_ident except Exception as e: from threading import get_ident from threading import Thread import time class Local(object): def __init__(self): object.__setattr__(self, 'storage', {}) def __setattr__(self, k, v): ident = get_ident() if ident in self.storage: self.storage[ident][k] = v else: self.storage[ident] = {k: v} def __getattr__(self, k): ident = get_ident() return self.storage[ident][k] obj = Local() def task(arg): obj.val = arg obj.xxx = arg print(obj.val) for i in range(10): t = Thread(target=task, args=(i,)) t.start()
17、進程之間如何進行通信？
# 進程間通訊有多種方式，包括信號，管道，消息隊列，信號量，共享內存，socket等
18、什么是並發和並行？
# 並發：同一時刻只能處理一個任務，但一個時段內可以對多個任務進行交替處理(一個處理器同時處理多個任務) # 並行：同一時刻可以處理多個任務(多個處理器或者是多核的處理器同時處理多個不同的任務) # 類比：並發是一個人同時吃三個饅頭，而並行是三個人同時吃三個饅頭。
19、進程鎖和線程鎖的作用？
線程鎖: 大家都不陌生，主要用來給方法、代碼塊加鎖。當某個方法或者代碼塊使用鎖時，那么在同一時刻至多僅有有一個線程在執行該段代碼。當有多個線程訪問同一對象的加鎖方法 / 代碼塊時，同一時間只有一個線程在執行，其余線程必須要等待當前線程執行完之后才能執行該代碼段。但是，其余線程是可以訪問該對象中的非加鎖代碼塊的。
進程鎖: 也是為了控制同一操作系統中多個進程訪問一個共享資源，只是因為程序的獨立性，各個進程是無法控制其他進程對資源的訪問的，但是可以使用本地系統的信號量控制（操作系統基本知識）。
分布式鎖: 當多個進程不在同一個系統之中時，使用分布式鎖控制多個進程對資源的訪問。
參考:點擊查看
20、解釋什么是異步非阻塞？
'非阻塞'： 遇到IO阻塞不等待(setblooking=False),（可能會報錯->捕捉異常） - sk=socket.socket() - sk.setblooking(False) '異步'： 回調(ajax)，當達到某個指定狀態之后，自動調用特定函數
21、路由器和交換機的區別？
'交換機' 用於在同一網絡內數據快速傳輸轉發，工作在數據鏈路層； 通過MAC尋址，不能動態划分子網； 只能在一條網絡通路中運行，不能動態分配。 '路由器' 是一個網關設備，內部局域網到公網的一個關卡； 工作在網絡層； 通過IP尋址，可以划分子網； 可以在多條網絡通道中運行，可以動態分配IP地址。 '簡單說' 交換機就是把一根網線變成多根網線； 路由器就是把一個網絡變成多個網絡； 如果不上外網，只是局域網，交換機即可； 如果上外網，並且給網絡划分不同網段，就必須用路由器。
22、什么是域名解析？
# 在網上，所有的地址都是ip地址，但這些ip地址太難記了，所以就出現了域名（比如http://baidu.com）。 # 而域名解析就是將域名，轉換為ip地址的這樣一種行為。 # 例如：訪問www.baidu.com，實質是把域名解析成IP。
23、如何修改本地hosts文件？
'hosts': Hosts就是將一些常用的網址域名與其對應的IP地址建立一個關聯“數據庫” 可以用來屏蔽一些網站，或者指定一些網站(修改hosts翻牆) '修改'： # windows: 位置：C:\Windows\System32\drivers\etc 也可以通過第三方軟件，我用的火絨，可以直接進行編輯hosts # linux: 位置：/etc/hosts 修改：vi /etc/hosts
24、生產者消費者模型應用場景及優勢？
# 處理數據比較消耗時間，線程獨占，生產數據不需要即時的反饋等。
25、什么是cdn？
# 用戶獲取數據時，不需要直接從源站獲取，通過CDN對於數據的分發， # 用戶可以從一個較優的服務器獲取數據，從而達到快速訪問，並減少源站負載壓力的目的。
26、LVS是什么及作用？
# LVS即Linux虛擬服務器，是一個虛擬的四層交換器集群系統， # 根據目標地址和目標端口實現用戶請求轉發，本身不產生流量，只做用戶請求轉發。
27、Nginx是什么及作用？
28、keepalived是什么及作用?
Keepalived是Linux下一個輕量級別的高可用解決方案。
高可用，其實兩種不同的含義：廣義來講，是指整個系統的高可用行，狹義的來講就是之主機的冗余和接管，
參考:點擊查看
29、haproxy是什么以及作用？
HAProxy提供高可用性、負載均衡以及基於TCP和HTTP應用的代 理，支持虛擬主機，它是免費、快速並且可靠的一種解決方案。
HAProxy特別適用於那些負載特大的web站點，這些站點通常又需要會話保持或七層處理。HAProxy運行在當前的硬件上，
完全可以支持數以萬計的並發連接。並且它的運行模式使得它可以很簡單安全的整合進您當前的架中，
同時可以保護你的web服務器不被暴露到網絡上。
參考:點擊查看
30、什么是負載均衡？
負載均衡有兩方面的含義： # 首先，大量的並發訪問或數據流量分擔到多台節點設備上分別處理，減少用戶等待響應的時間； # 其次，單個重負載的運算分擔到多台節點設備上做並行處理，每個節點設備處理結束后， 將結果匯總，返回給用戶，系統處理能力得到大幅度提高。
31、什么是rpc及應用場景？
RPC 的全稱是 Remote Procedure Call 是一種進程間通信方式。
它允許程序調用另一個地址空間（通常是共享網絡的另一台機器上）的過程或函數，而不用程序員顯式編碼這個遠程調用的細節。
即程序員無論是調用本地的還是遠程的，本質上編寫的調用代碼基本相同
(例如QQ遠程操作)
參考：點擊查看
32、簡述 asynio模塊的作用和應用場景。
asyncio是Python 3.4版本引入的標准庫，直接內置了對異步IO的支持。
asyncio的異步操作，需要在coroutine中通過yield from完成。
參考：點擊查看
33、簡述 gevent模塊的作用和應用場景。
Gevent 是一個第三方庫，可以輕松通過gevent實現並發同步或異步編程，
在gevent中用到的主要模式是Greenlet, 它是以C擴展模塊形式接入Python的輕量級協程。
Greenlet全部運行在主程序操作系統進程的內部，但它們被協作式地調度。
參考：點擊查看
34、twisted框架的使用和應用？
Twisted是一個事件驅動型的網絡模型。
時間驅動模型編程是一種范式，這里程序的執行流由外部決定。
特點是：包含一個事件循環，當外部事件發生時，使用回調機制來觸發相應的處理。
參考：點擊查看
第三部分 數據庫和緩存（46題）
1、列舉常見的關系型數據庫和非關系型都有那些？
'關系型'： # sqllite、db2、oracle、access、SQLserver、MySQL # 注意：sql語句通用，需要有表結構 '非關系型'： # mongodb、redis、memcache # 非關系型數據庫是key-value存儲的，沒有表結構。
2、MySQL常見數據庫引擎及比較？
'Myisam': # 支持全文索引 # 查詢速度相對較快 # 支持表鎖 # 表鎖：select * from tb for update;（鎖：for update） 'InnoDB': # 支持事務 # 支持行鎖、表鎖 # 表鎖：select * from tb for update;（鎖：for update） # 行鎖: select id ,name from tb where id=2 for update;（鎖：for update）
3、簡述數據三大范式？
# 數據庫的三大特性： '實體':表 '屬性'：表中的數據(字段) '關系'：表與表之間的關系 ---------------------------------------------------- # 數據庫設計三大范式： '第一范式(1NF)' 數據表中的每一列(每個字段)，必須是不可拆分的最小單元 也就是確保每一列的原子性。 '第二范式(2NF)' 滿足第一范式后(1NF)，要求表中的所有列，都必須依賴於主鍵， 而不能有任何一列 與主鍵沒有關系，也就是說一個表只描述一件事。 '第三范式(3NF)' 必須先滿足第二范式(2NF) 要求：表中每一列只與主鍵直接相關而不是間接相關(表中每一列只能依賴於主鍵)
4、什么是事務？MySQL如何支持事務？
'什么是事務' 事務由一個或多個sql語句組成一個整體； 在事務中的操作，要么都執行修改，要么都不執行， 只有在該事務中所有的語句都執行成功才會將修改加入到數據庫中，否則回滾到上一步。 'Mysql實現事務' InnoDB支持事務，MyISAM不支持 # 啟動事務： # start transaction； # update from account set money=money-100 where name='a'; # update from account set money=money+100 where name='b'; # commit； 'start transaction 手動開啟事務，commit 手動關閉事務'
5、數據庫五大約束
'數據庫五大約束' 1.primary KEY:設置主鍵約束； 2.UNIQUE：設置唯一性約束，不能有重復值； 3.DEFAULT 默認值約束 4.NOT NULL：設置非空約束，該字段不能為空； 5.FOREIGN key :設置外鍵約束。
6、簡述數據庫設計中一對多和多對多的應用場景？
# 一對一關系示例： 一個學生對應一個學生檔案材料，或者每個人都有唯一的身份證編號。 # 一對多關系示例：(下拉單選) 一個學生只屬於一個班，但是一個班級有多名學生。 # 多對多關系示例：(下拉多選) 一個學生可以選擇多門課，一門課也有多名學生。
7、如何基於數據庫實現商城商品計數器？
參考：點擊查看
8、常見SQL（必備）
詳見：點擊查看
9、簡述觸發器、函數、視圖、存儲過程？
'觸發器'： 對數據庫某個表進行【增、刪、改】前后，自定義的一些SQL操作 '函數'： 在SQL語句中使用的函數 #例如：select sleep(2) 聚合函數：max、sam、min、avg 時間格式化：date_format 字符串拼接：concat 自定制函數：(觸發函數通過 select) '視圖'： 對某些表進行SQL查詢，將結果實時顯示出來(是虛擬表)，只能查詢不能更新 '存儲過程'： 將提前定義好的SQL語句保存到數據庫中並命名；以后在代碼中調用時直接通過名稱即可 參數類型：in、out、inout
10、MySQL索引種類
'主鍵索引(單列)'： primary key 加速查找+約束：不能重復、不能為空 '普通索引(單列)': 加速查找 '唯一索引(單列)'： unique 加速查找+約束：不能重復 '聯合索引(多列)'： 查詢時根據多列進行查詢(最左前綴) '聯合唯一索引(多列)'： 遵循最左前綴規則(命中索引) # 其他詞語 1、索引合並：利用多個單列索引查詢 2、覆蓋索引：在索引表中就能將想要的數據查詢到
11、索引在什么情況下遵循最左前綴的規則？
你可以認為聯合索引是闖關游戲的設計 例如你這個聯合索引是state/city/zipCode 那么state就是第一關 city是第二關， zipCode就是第三關 你必須匹配了第一關，才能匹配第二關，匹配了第一關和第二關，才能匹配第三關 你不能直接到第二關的 索引的格式就是第一層是state，第二層才是city 參考：點擊查看
12、主鍵和外鍵的區別？
'主鍵' 唯一標識一條記錄 用來保證數據的完整性 主鍵只能有一個 '外鍵' 表的外鍵是另一個表的主鍵，外鍵可以有重復的，可以是空值 用來和其他表建立聯系用的 一個表可以有多個外鍵 '索引' 該字段沒有重復值，但可以有一個空值 提高查詢速度 一個表可以有多個唯一索引
13、MySQL常見的函數？
'當前時間' select now(); '時間格式化' select DATE_FORMAT(NOW(), '%Y(年)-%m(月)-%d(日) %H(時):%i(分):%s(秒)') '日期加減' select DATE_ADD(DATE, INTERVAL expr unit) select DATE_ADD(NOW(), INTERVAL 1 DAY) #當前日期加一天 \expr：正數(加)、負數(減) \unit：支持毫秒microsecond、秒second、小時hour、天day、周week、年year '類型轉換' cast( expr AS TYPE) select CAST(123 AS CHAR) '字符串拼接' concat(str1,str2，……) select concat('hello','2','world') --> hellow2world '聚合函數' avg() #平均值 count() #返回指定列/行的個數 min() #最小值 max() #最大值 sum() #求和 group_concat() #返回屬於一組的列值，連接組合而成的結果 '數學函數' abs() #絕對值 bin() #二進制 rand() #隨機數
14、列舉 創建索引但是無法命中索引的8種情況。
#使用'like ‘%xx’' select * from tb1 where name like '%cn'; #使用'函數' select * from tb1 where reverse(name)='zgc'; #使用'or' select * from tb1 where nid=1 or email='zgc@gmial.com'; 特別的：當or條件中有未建立索引的列才失效，一下會走索引 # select * from tb1 where nid=1 or name='zgc'; # select * from tb1 where nid=1 or email='zgc@gmial.com' and name='zgc'; #'類型不一致' 如果列是字符串類型，傳入條件是必須用引號引起來，不然則可能會無法命中 select * from tb1 where name=666； #含有'!= ' select * from tb1 where name != 'zgc'; 特別的：如果是主鍵，還是會走索引 # select * from tb1 where nid != 123; #含有'>' select * from tb1 where name > 'zgc'; 特別的：如果是主鍵或者索引是整數類型，則還是會走索引 # select * from tb1 where nid > 123; # select * from tb1 where name > 123; #含有'order by' select email from tb1 order by name desc; 當根據索引排序時，選擇的映射如果不是索引，則不走索引 特別的：如果對主鍵排序，則還是走索引： # select * from tb1 order by nid desc; #組合索引最左前綴 如果組合索引為：（name，email） name and email #使用索引 name #使用索引 email #不使用索引
15、如何開啟慢日志查詢？
'可以通過修改配置文件開啟' slow_query_log=ON #是否開啟慢日志記錄 long_query_time=2 #時間限制，超過此時間，則記錄 slow_query_log_file=/usr/slow.log #日志文件 long_queries_not_using_indexes=ON #是否記錄使用索引的搜索
16、數據庫導入導出命令（結構+數據）？
#導出： mysqldump --no-defaults -uroot -p 數據庫名字 > 導出路徑 '--no-defaults':解決“unknown option --no-beep”報錯 #導入： 1、mysqldump -uroot -p 數據庫名稱 < 路徑 2、進入數據庫； source + 要導入數據庫文件路徑
17、數據庫優化方案？
1、創建數據表時把固定長度的放在前面 2、將固定數據放入內存：choice字段(django中用到，1,2,3對應相應內容) 3、char不可變，varchar可變 4、聯合索引遵循最左前綴(從最左側開始檢索) 5、避免使用 select * 6、讀寫分離： #利用數據庫的主從分離：主，用於刪除、修改、更新；從，用於查 #實現：兩台服務器同步數據 \原生SQL:select * from db.tb \ORM：model.User.object.all().using('default') \路由：db router 7、分庫 # 當數據庫中的表太多，將某些表分到不同數據庫，例如：1W張表時 # 代價：連表查詢跨數據庫，代碼變多 8、分表 # 水平分表：將某些列拆分到另一張表，例如：博客+博客詳情 # 垂直分表：將某些歷史信息，分到另外一張表中，例如：支付寶賬單 9、加緩存 # 利用redis、memcache(常用數據放到緩存里，提高取數據速度) # 緩存不夠可能會造成雪崩現象 10、如果只想獲取一條數據 select * from tb where name = 'zgc' limit 1;
18、char和varchar的區別？
#char類型：定長不可變 存入字符長度大於設置長度時報錯； 存入字符串長度小於設置長度時，用空格填充以達到設置字符串長度； 簡單粗暴，浪費空間，存取速度快。 #varchar類型：可變 存儲數據真實內容，不使用空格填充； 會在真實數據前加1-2Bytes的前綴，用來表示真實數據的bytes字節數； 邊長、精准、節省空間、存取速度慢。
19、簡述MySQL的執行計划？
# explain + SQL語句 # SQL在數據庫中執行時的表現情況,通常用於SQL性能分析,優化等場景。 'explain select * from rbac_userinfo where id=1;'
20、在對name做了唯一索引前提下，簡述以下區別：
select * from tb where name = ‘小明’ select * from tb where name = ‘小明’ limit 1 ------------------------------------------------------------- 沒做唯一索引的話,前者查詢會全表掃描,效率低些 limit 1,只要找到對應一條數據,就不繼續往下掃描. 然而 name 字段添加唯一索引了,加不加limit 1,意義都不大;
21、1000w條數據，使用limit offset 分頁時，為什么越往后翻越慢？如何解決？
# 例如: #limit 100000,20; 從第十萬條開始往后取二十條, #limit 20 offset 100000; limit后面是取20條數據,offset后面是從第10W條數據開始讀 因為當一個數據庫表過於龐大，LIMIT offset, length中的offset值過大，則SQL查詢語句會非常緩慢 -------------------------------------------------------------------------- '優化一' 先查看主鍵，再分頁： select * from tb where id in (select id from tb where limit 10 offset 30) -------------------------------------------------------------------------- '優化二' 記錄當前頁，數據、ID、最大值和最小值(用於where查詢) 在翻頁時，根據條件進行篩選，篩選完畢后，再根據 limit offset 查詢 select * from(select * from tb where id > 2222) as B limit 10 offset 0; \如果用戶自己修改頁碼，也可能導致變慢，此時可以對 url 頁碼進行加密，例如rest framework -------------------------------------------------------------------------- '優化三' 可以按照當前業務需求，看是否可以設置只允許看前200頁； 一般情況下，沒人會咔咔看個幾十上百頁的；
22、什么是索引合並？
# 索引合並訪問方法可以在查詢中對一個表使用多個索引,對它們同時掃描，並且合並結果。 # 此訪問方法合並來自單個表的索引掃描; 它不會將掃描合並到多個表中。
23、什么是覆蓋索引？
# 解釋一： 就是select的數據列只用從索引中就能夠取得，不必從數據表中讀取，換句話說查詢列要被所使用的索引覆蓋。 # 解釋二： 索引是高效找到行的一個方法，當能通過檢索索引就可以讀取想要的數據，那就不需要再到數據表中讀取行了。 如果一個索引包含了（或覆蓋了）滿足查詢語句中字段與條件的數據就叫做覆蓋索引。 # 注意：MySQL只能使用B-Tree索引做覆蓋索引
24、簡述數據庫讀寫分離？
#利用數據庫的主從分離：主，用於刪除、修改、更新；從，用於查 #實現：兩台服務器同步數據（減輕服務器的壓力） 原生SQL: select * from db.tb ORM：model.User.object.all().using('default') 路由：db router
25、簡述數據庫分庫分表？（水平、垂直）
# 1、分庫 當數據庫中的表太多，將某些表分到不同數據庫，例如：1W張表時 代價：連表查詢跨數據庫，代碼變多 # 2、分表 水平分表：將某些列拆分到另一張表，例如：博客+博客詳情 垂直分表：將某些歷史信息，分到另外一張表中，例如：支付寶賬單
26、redis和memcached比較？
# 1.存儲容量： memcached超過內存比例會抹掉前面的數據，而redis會存儲在磁盤 # 2.支持數據類型： memcached只支持string； redis支持更多;如：hash、list、集合、有序集合 # 3.持久化： redis支持數據持久化，可以將內存中的數據保持在磁盤中，memcached無 # 4.主從： 即master-slave模式的數據備份(主從)。 # 5.特性 Redis在很多方面具備數據庫的特征，或者說就是一個數據庫系統 Memcached只是簡單的K/V緩存
27、redis中數據庫默認是多少個db 及作用？
#redis默認有16個db，db0~db15（可以通過配置文件支持更多，無上限） #並且每個數據庫的數據是隔離的不能共享 #可以隨時使用SELECT命令更換數據庫：redis> SELECT 1 # 注意： 多個數據庫之間並不是完全隔離的 比如FLUSHALL命令可以清空一個Redis實例中所有數據庫中的數據。
28、python操作redis的模塊？
參考：點擊查看
29、如果redis中的某個列表中的數據量非常大，如果實現循環顯示每一個值？
# 通過scan_iter分片取，減少內存壓力 scan_iter(match=None, count=None)增量式迭代獲取redis里匹配的的值 # match，匹配指定key # count，每次分片最少獲取個數 r = redis.Redis(connection_pool=pool) for key in r.scan_iter(match='PREFIX_*', count=100000): print(key)
30、redis如何實現主從復制？以及數據同步機制？
# 實現主從復制 '創建6379和6380配置文件' redis.conf：6379為默認配置文件，作為Master服務配置； redis_6380.conf：6380為同步配置，作為Slave服務配置； '配置slaveof同步指令' 在Slave對應的conf配置文件中，添加以下內容： slaveof 127.0.0.1 6379 # 數據同步步驟： (1)Slave服務器連接到Master服務器. (2)Slave服務器發送同步(SYCN)命令. (3)Master服務器備份數據庫到文件. (4)Master服務器把備份文件傳輸給Slave服務器. (5)Slave服務器把備份文件數據導入到數據庫中.
31、redis中的sentinel的作用？
# 幫助我們自動在主從之間進行切換(哨兵) # 檢測主從中 主是否掛掉，且超過一半的sentinel檢測到掛了之后才進行進行切換。 # 如果主修復好了，再次啟動時候，會變成從。
32、如何實現redis集群？
#基於【分片】來完成。 - 集群是將你的數據拆分到多個Redis實例的過程 - 可以使用很多電腦的內存總和來支持更大的數據庫。 - 沒有分片，你就被局限於單機能支持的內存容量。 #redis將所有能放置數據的地方創建了 16384 個哈希槽。 #如果設置集群的話，就可以為每個實例分配哈希槽： - 192.168.1.20【0-5000】 - 192.168.1.21【5001-10000】 - 192.168.1.22【10001-16384】 #以后想要在redis中寫值時：set k1 123 - 將k1通過crc16的算法轉換成一個數字，然后再將該數字和16384求余， - 如果得到的余數 3000，那么就將該值寫入到 192.168.1.20 實例中。 #集群方案： - redis cluster：官方提供的集群方案。 - codis：豌豆莢技術團隊。 - tweproxy：Twiter技術團隊。
33、redis中默認有多少個哈希槽？
#redis中默認有 16384 個哈希槽。
34、簡述redis的有哪幾種持久化策略及比較？
#RDB：每隔一段時間對redis進行一次持久化。 - 缺點：數據不完整 - 優點：速度快 #AOF：把所有命令保存起來，如果想重新生成到redis，那么就要把命令重新執行一次。 - 缺點：速度慢，文件比較大 - 優點：數據完整
35、列舉redis支持的過期策略。
# 數據集（server.db[i].expires） a、voltile-lru： #從已設置過期時間的數據集中，挑選最近頻率最少數據淘汰 b、volatile-ttl： #從已設置過期時間的數據集中，挑選將要過期的數據淘汰 c、volatile-random：#從已設置過期時間的數據集中，任意選擇數據淘汰 d、allkeys-lru： #從數據集中，挑選最近最少使用的數據淘汰 e、allkeys-random： #從數據集中，任意選擇數據淘汰 f、no-enviction(驅逐)：#禁止驅逐數據
36、MySQL 里有 2000w 數據，redis 中只存 20w 的數據，如何保證 redis 中都是熱點數據？
# 限定Redis占用的內存，根據自身數據淘汰策略，淘汰冷數據，把熱數據加載到內存。 # 計算一下 20W 數據大約占用的內存，然后設置一下Redis內存限制即可。
37、寫代碼，基於redis的列表實現 先進先出、后進先出隊列、優先級隊列。？？？？？？？？？？？？？？？？？？？
38、如何基於redis實現消息隊列？
# 通過發布訂閱模式的PUB、SUB實現消息隊列 # 發布者發布消息到頻道了，頻道就是一個消息隊列。 # 發布者： import redis conn = redis.Redis(host='127.0.0.1',port=6379) conn.publish('104.9MH', "hahahahahaha") # 訂閱者： import redis conn = redis.Redis(host='127.0.0.1',port=6379) pub = conn.pubsub() pub.subscribe('104.9MH') while True: msg= pub.parse_response() print(msg) 對了，redis 做消息隊列不合適 業務上避免過度復用一個redis，用它做緩存、做計算，還做任務隊列，壓力太大，不好。
39、如何基於redis實現發布和訂閱？以及發布訂閱和消息隊列的區別？
# 發布和訂閱，只要有任務就所有訂閱者每人一份。 發布者： #發布一次 import redis conn = redis.Redis(host='127.0.0.1',port=6379) conn.publish('104.9MH', "hahahahahaha") 訂閱者： #'while True'一直在接收 import redis conn = redis.Redis(host='127.0.0.1',port=6379) pub = conn.pubsub() pub.subscribe('104.9MH') while True: msg= pub.parse_response() print(msg)
40、什么是codis及作用？
Codis 是一個分布式 Redis 解決方案, 對於上層的應用來說, 連接到 Codis-Proxy(redis代理服務)和連接原生的 Redis-Server 沒有明顯的區別, 上層應用可以像使用單機的 Redis 一樣使用, Codis 底層會處理請求的轉發, 不停機的數據遷移等工作, 所有后邊的一切事情, 對於前面的客戶端來說是透明的, 可以簡單的認為后邊連接的是一個內存無限大的 Redis 服務.
41、什么是twemproxy及作用？
# 什么是Twemproxy 是Twtter開源的一個 Redis 和 Memcache 代理服務器， 主要用於管理 Redis 和 Memcached 集群，減少與Cache服務器直接連接的數量。 他的后端是多台REDIS或memcached所以也可以被稱為分布式中間件。 # 作用 通過代理的方式減少緩存服務器的連接數。 自動在多台緩存服務器間共享數據。 通過配置的方式禁用失敗的結點。 運行在多個實例上，客戶端可以連接到首個可用的代理服務器。 支持請求的流式與批處理，因而能夠降低來回的消耗。
42、寫代碼實現redis事務操作。
import redis pool = redis.ConnectionPool(host='10.211.55.4', port=6379) conn = redis.Redis(connection_pool=pool) # pipe = r.pipeline(transaction=False) pipe = conn.pipeline(transaction=True) # 開始事務 pipe.multi() pipe.set('name', 'zgc') pipe.set('role', 'haha') pipe.lpush('roless', 'haha') # 提交 pipe.execute() '注意'：咨詢是否當前分布式redis是否支持事務
43、redis中的watch的命令的作用？
# 用於監視一個或多個key # 如果在事務執行之前這個/些key被其他命令改動，那么事務將被打斷
44、基於redis如何實現商城商品數量計數器？
'通過redis的watch實現' import redis conn = redis.Redis(host='127.0.0.1',port=6379) # conn.set('count',1000) val = conn.get('count') print(val) with conn.pipeline(transaction=True) as pipe: # 先監視，自己的值沒有被修改過 conn.watch('count') # 事務開始 pipe.multi() old_count = conn.get('count') count = int(old_count) print('現在剩余的商品有:%s',count) input("問媳婦讓不讓買？") pipe.set('count', count - 1) # 執行，把所有命令一次性推送過去 pipe.execute() 數據庫的鎖
45、簡述redis分布式鎖和redlock的實現機制。
# redis分布式鎖？ # 不是單機操作，又多了一/多台機器 # redis內部是單進程、單線程，是數據安全的(只有自己的線程在操作數據) ---------------------------------------------------------------- #A、B、C，三個實例(主) 1、來了一個'隔壁老王'要操作，且不想讓別人操作，so，加鎖； 加鎖：'隔壁老王'自己生成一個隨機字符串，設置到A、B、C里(xxx=666) 2、來了一個'鄰居老李'要操作A、B、C，一讀發現里面有字符串，擦，被加鎖了，不能操作了，等着吧~ 3、'隔壁老王'解決完問題，不用鎖了，把A、B、C里的key：'xxx'刪掉；完成解鎖 4、'鄰居老李'現在可以訪問，可以加鎖了 # 問題： 1、如果'隔壁老王'加鎖后突然掛了，就沒人解鎖，就死鎖了，其他人干看着沒法用咋辦？ 2、如果'隔壁老王'去給A、B、C加鎖的過程中，剛加到Ａ，'鄰居老李'就去操作C了，加鎖成功or失敗？ 3、如果'隔壁老王'去給A、B、C加鎖時，C突然掛了，這次加鎖是成功還是失敗？ 4、如果'隔壁老王'去給A、B、C加鎖時，超時時間為5秒，加一個鎖耗時3秒，此次加鎖能成功嗎？ # 解決 1、安全起見，讓'隔壁老王'加鎖時設置超時時間，超時的話就會自動解鎖(刪除key：'xxx') 2、加鎖程度達到（1/2）+1個就表示加鎖成功，即使沒有給全部實例加鎖； 3、加鎖程度達到（1/2）+1個就表示加鎖成功，即使沒有給全部實例加鎖； 4、不能成功，鎖還沒加完就過期，沒有意義了，應該合理設置過期時間 # 注意 使用需要安裝redlock-py ---------------------------------------------------------------- from redlock import Redlock dlm = Redlock( [ {"host": "localhost", "port": 6379, "db": 0}, {"host": "localhost", "port": 6379, "db": 0}, {"host": "localhost", "port": 6379, "db": 0}, ] ) # 加鎖，acquire my_lock = dlm.lock("my_resource_name",10000) if my_lock: # 進行操作 # 解鎖,release dlm.unlock(my_lock) else: print('獲取鎖失敗') #通過sever.eval(self.unlock_script)執行一個lua腳本，用來刪除加鎖時的key
46、什么是一致性哈希？Python中是否有相應模塊？
# 一致性哈希 一致性hash算法（DHT）可以通過減少影響范圍的方式，解決增減服務器導致的數據散列問題，從而解決了分布式環境下負載均衡問題； 如果存在熱點數據，可以通過增添節點的方式，對熱點區間進行划分，將壓力分配至其他服務器，重新達到負載均衡的狀態。 # 模塊：hash_ring
47、如何高效的找到redis中所有以zhugc開頭的key？
redis 有一個keys命令。 # 語法：KEYS pattern # 說明：返回與指定模式相匹配的所用的keys。 該命令所支持的匹配模式如下： 1、?：用於匹配單個字符。例如，h?llo可以匹配hello、hallo和hxllo等； 2、*：用於匹配零個或者多個字符。例如，h*llo可以匹配hllo和heeeello等； 2、[]：可以用來指定模式的選擇區間。例如h[ae]llo可以匹配hello和hallo，但是不能匹配hillo。同時，可以使用“/”符號來轉義特殊的字符 # 注意 KEYS 的速度非常快，但如果數據太大，內存可能會崩掉， 如果需要從一個數據集中查找特定的key，最好還是用Redis的集合結構(set)來代替。
48、悲觀鎖和樂觀鎖的區別？
# 悲觀鎖 從數據開始更改時就將數據鎖住，直到更改完成才釋放； 會造成訪問數據庫時間較長，並發性不好，特別是長事務。 # 樂觀鎖 直到修改完成，准備提交修改到數據庫時才會鎖住數據，完成更改后釋放； 相對悲觀鎖，在現實中使用較多。
第四部分 前端、框架和其他（155題）
1、談談你對http協議的認識。
# 通過/r/n分割 # 請求頭請求體之間：/r/n/r/n # 無狀態 # 短連接
2、談談你對websocket協議的認識。
# a.什么是websocket？ 是給瀏覽器新建的一套協議 協議規定:創建連接后不斷開 通過'\r\n'分割,讓客戶端和服務端創建連接后不斷開、驗證+數據加密 # b.本質: # 就是一個創建連接后不斷開的socket # 當連接成功后: - 客戶端(瀏覽器)會自動向服務端發送消息 - 服務端接收后,會對該數據加密:base64(sha1(swk+magic_string)) - 構造響應頭 - 發送給客戶端 # 建立雙工通道,進行收發數據 # c.框架中是如何使用websocket的？ django：channel flask：gevent-websocket tornado：內置 # d.websocket的優缺點 優點：代碼簡單，不再重復創建連接 缺點：兼容性沒有長輪詢好，如IE會有不兼容
3、什么是magic string ？
websocket里面的 # 客戶端向服務端發送消息時，會有一個'sec-websocket-key'和'magic string'的隨機字符串(魔法字符串) # 服務端接收到消息后會把他們連接成一個新的key串，進行編碼、加密，確保信息的安全性
4、如何創建響應式布局？
# a.可以通過引用Bootstrap實現 # b.通過看Bootstrap源碼文件，可知其本質就是通過CSS實現的 <style> /*瀏覽器窗口寬度大於768,背景色變為 green*/ @media (min-width: 768px) { .pg-header{ background-color: green; } } /*瀏覽器窗口寬度大於992,背景色變為 pink*/ @media (min-width: 992px) { .pg-header{ background-color: pink; } } </style> </head> <body> <div class="pg-header"></div> </body>
5、你曾經使用過哪些前端框架？
# Jquery、Vue、Bootstrap、
6、什么是ajax請求？並使用jQuery和XMLHttpRequest對象實現一個ajax請求。
1.沒用ajax：瀏覽器訪問服務器請求，用戶看得到（頁面刷新也就等同於重新發請求，刷新看得到，也就等同於請求看得到）。等請求完，頁面刷新，新內容出現，用戶看到新內容。 2.用ajax：瀏覽器訪問服務器請求，用戶看不到，是悄悄進行。等請求完，頁面不刷新，新內容也會出現，用戶看到新內容。 參考：點擊查看
7、如何在前端實現輪詢？
# 輪詢是在特定的的時間間隔（如每1秒），由瀏覽器對服務器發出HTTP request， # 然后由服務器返回最新的數據給客戶端的瀏覽器。 var xhr = new XMLHttpRequest(); setInterval(function(){ xhr.open('GET','/user'); xhr.onreadystatechange = function(){ }; xhr.send(); },1000)
8、如何在前端實現長輪詢？
# ajax實現:在發送ajax后,服務器端會阻塞請求直到有數據傳遞或超時才返回。 # 客戶端JavaScript響應處理函數會在處理完服務器返回的信息后，再次發出請求，重新建立連接。 function ajax(){ var xhr = new XMLHttpRequest(); xhr.open('GET','/user'); xhr.onreadystatechange = function(){ ajax(); }; xhr.send(); }
9、vuex的作用？
1.不同組件之間共享狀態，可以進行狀態的修改和讀取。 2.可以理解為是一個全局對象，所有頁面都可以訪問 3.還有比較重要的單一狀態樹管理，讓數據的修改脈絡更加清晰，便於定位問題。 # 比如用戶做了一些加減的操作、三個頁面都要用、可以用傳參、但是很麻煩、這種時候用vuex就簡單一些
10、vue中的路由的攔截器的作用？
# 統一處理所有http請求和響應時，可以用axios的攔截器。 # 通過配置http response inteceptor，當后端接口返回401 Unauthorized（未授權），讓用戶重新登錄。 # so可以用來做登錄攔截驗證
11、axios的作用？
# axios是vue-resource后出現的Vue請求數據的插件 # 可以做的事情： 從瀏覽器中創建 XMLHttpRequest 從 node.js 發出 http 請求 支持 Promise API 攔截請求和響應 轉換請求和響應數據 取消請求 自動轉換JSON數據 客戶端支持防止 CSRF/XSRF
12、列舉vue的常見指令。
# 1、v-if指令:判斷指令，根據表達式值得真假來插入或刪除相應的值。 # 2、v-show指令: # 條件渲染指令，無論返回的布爾值是true還是false，元素都會存在html中， # false的元素會隱藏在html中，並不會刪除. # 3、v-else指令:配合v-if或v-else使用。 # 4、v-for指令:循環指令，相當於遍歷。 # 5、v-bind:給DOM綁定元素屬性。 # 6、v-on指令:監聽DOM事件。
13、簡述jsonp及實現原理？
# 原理： 1、先在客戶端注冊一個callback, 然后把callback的名字傳給服務器。 2、此時，服務器先生成 json 數據。 3、然后以 javascript 語法的方式，生成一個function , function 名字就是傳遞上來的參數 jsonp. 4、最后將 json 數據直接以入參的方式，放置到 function 中，這樣就生成了一段 js 語法的文檔，返回給客戶端。 客戶端瀏覽器，解析script標簽，並執行返回的 javascript 文檔，此時數據作為參數， 傳入到了客戶端預先定義好的 callback 函數里.（動態執行回調函數） # 注意 # JSON 是一種數據格式 # JSONP 是一種數據調用的方式
14、是什么cors ？
# 跨域資源共享（Cross-Origin Resource Sharing） # 其本質是設置響應頭，使得瀏覽器允許跨域請求。 # 簡單請求(一次請求) 1、請求方式：HEAD、GET、POST 2、請求頭信息： Accept Accept-Language Content-Language Last-Event-ID Content-Type 對應的值是以下三個中的任意一個 application/x-www-form-urlencoded multipart/form-data text/plain # 非簡單請求(兩次請求) 在發送真正的請求之前，會默認發送一個'options'請求，做'預檢'，預檢成功后才發送真正的請求 # 預檢： 如果復雜請求是PUT等請求，則服務端需要設置允許某請求，否則“預檢”不通過 Access-Control-Request-Method 如果復雜請求設置了請求頭，則服務端需要設置允許某請求頭，否則“預檢”不通過 Access-Control-Request-Headers
15、列舉Http請求中常見的請求方式？
# http請求方法有8種: 'GET' 'POST' 'HEAD' 'OPTIONS' 'PUT' 'DELETE' 'TRACE' 'CONNECT'
16、列舉Http請求中的狀態碼？
# 2開頭（成功） 200：請求成功 202：已接受請求，尚未處理 204：請求成功，且不需返回內容 # 3開頭（重定向） 301：永久重定向 302：臨時重定向 # 4開頭（客戶端錯誤） 400（Bad Request）：請求的語義或是參數有錯 403（Forbidden）：服務器拒絕了請求(csrf) 404（Not Found）：找不到頁面(資源) # 5開頭（服務器錯誤） 500：服務器遇到錯誤，無法完成請求 502：網關錯誤，一般是服務器壓力過大導致連接超時 503：服務器宕機
17、列舉Http請求中常見的請求頭？
# 常見請求頭： User-Agent、Referer、Host、Cookie、Connection、Accept
18、看圖寫結果：
看圖寫結果：
看圖寫結果：
看圖寫結果：
看圖寫結果：
看圖寫結果：
django、flask、tornado框架的比較？
什么是wsgi？
django請求的生命周期？
列舉django的內置組件？
列舉django中間件的5個方法？以及django中間件的應用場景？
簡述什么是FBV和CBV？
django的request對象是在什么時候創建的？
如何給CBV的程序添加裝飾器？
列舉django orm 中所有的方法（QuerySet對象的所有方法）
only和defer的區別？
select_related和prefetch_related的區別？
filter和exclude的區別？
列舉django orm中三種能寫sql語句的方法。
django orm 中如何設置讀寫分離？
F和Q的作用?
values和values_list的區別？
如何使用django orm批量創建數據？
django的Form和ModeForm的作用？
django的Form組件中，如果字段中包含choices參數，請使用兩種方式實現數據源實時更新。
django的Model中的ForeignKey字段中的on_delete參數有什么作用？
django中csrf的實現機制？
django如何實現websocket？
基於django使用ajax發送post請求時，都可以使用哪種方法攜帶csrf token？
django中如何實現orm表中添加數據時創建一條日志記錄。
django緩存如何設置？
django的緩存能使用redis嗎？如果可以的話，如何配置？
django路由系統中name的作用？
django的模板中filter和simple_tag的區別？
django-debug-toolbar的作用？
django中如何實現單元測試？
解釋orm中 db first 和 code first的含義？
django中如何根據數據庫表生成model中的類？
使用orm和原生sql的優缺點？
簡述MVC和MTV
django的contenttype組件的作用？
談談你對restfull 規范的認識？
接口的冪等性是什么意思？
什么是RPC？
Http和Https的區別？
為什么要使用django rest framework框架？
django rest framework框架中都有那些組件？
django rest framework框架中的視圖都可以繼承哪些類？
簡述 django rest framework框架的認證流程。
django rest framework如何實現的用戶訪問頻率控制？
Flask框架的優勢？
Flask框架依賴組件？
Flask藍圖的作用？
列舉使用過的Flask第三方組件？
簡述Flask上下文管理流程?
Flask中的g的作用？
Flask中上下文管理主要涉及到了那些相關的類？並描述類主要作用？
為什么要Flask把Local對象中的的值stack 維護成一個列表？
Flask中多app應用是怎么完成？
在Flask中實現WebSocket需要什么組件？
wtforms組件的作用？
Flask框架默認session處理機制？
解釋Flask框架中的Local對象和threading.local對象的區別？
Flask中 blinker 是什么？
SQLAlchemy中的 session和scoped_session 的區別？
SQLAlchemy如何執行原生SQL？
ORM的實現原理？
DBUtils模塊的作用？
以下SQLAlchemy的字段是否正確？如果不正確請更正：
1
2
3
4
5
6
7
8
9
10
11
from datetime import datetime
from sqlalchemy.ext.declarative
import declarative_base
from sqlalchemy import Column, Integer, String, DateTime
Base = declarative_base()
class UserInfo(Base):
__tablename__ = 'userinfo'
id = Column(Integer, primary_key=True, autoincrement=True)
name = Column(String(64), unique=True)
ctime = Column(DateTime, default=datetime.now())
SQLAchemy中如何為表設置引擎和字符編碼？
SQLAchemy中如何設置聯合唯一索引？
簡述Tornado框架的特點。
簡述Tornado框架中Future對象的作用？
Tornado框架中如何編寫WebSocket程序？
Tornado中靜態文件是如何處理的？ 如： <link href="{{static_url("commons.css")}}" rel="stylesheet" />
Tornado操作MySQL使用的模塊？
Tornado操作redis使用的模塊？
簡述Tornado框架的適用場景？
git常見命令作用：
簡述以下git中stash命令作用以及相關其他命令。
git 中 merge 和 rebase命令 的區別。
公司如何基於git做的協同開發？
如何基於git實現代碼review？
git如何實現v1.0 、v2.0 等版本的管理？
什么是gitlab？
github和gitlab的區別？
如何為github上牛逼的開源項目貢獻代碼？
git中 .gitignore文件的作用?
什么是敏捷開發？
簡述 jenkins 工具的作用?
公司如何實現代碼發布？
簡述 RabbitMQ、Kafka、ZeroMQ的區別？
RabbitMQ如何在消費者獲取任務后未處理完前就掛掉時，保證數據不丟失？
RabbitMQ如何對消息做持久化？
RabbitMQ如何控制消息被消費的順序？
以下RabbitMQ的exchange type分別代表什么意思？如：fanout、direct、topic。
簡述 celery 是什么以及應用場景？
簡述celery運行機制。
celery如何實現定時任務？
簡述 celery多任務結構目錄？
celery中裝飾器 @app.task 和 @shared_task的區別？
簡述 requests模塊的作用及基本使用？
簡述 beautifulsoup模塊的作用及基本使用？
簡述 seleninu模塊的作用及基本使用?
scrapy框架中各組件的工作流程？
在scrapy框架中如何設置代理（兩種方法）？
scrapy框架中如何實現大文件的下載？
scrapy中如何實現限速？
scrapy中如何實現暫定爬蟲？
scrapy中如何進行自定制命令？
scrapy中如何實現的記錄爬蟲的深度？
scrapy中的pipelines工作原理？
scrapy的pipelines如何丟棄一個item對象？
簡述scrapy中爬蟲中間件和下載中間件的作用？
scrapy-redis組件的作用？
scrapy-redis組件中如何實現的任務的去重？
scrapy-redis的調度器如何實現任務的深度優先和廣度優先？
簡述 vitualenv 及應用場景?
簡述 pipreqs 及應用場景？
在Python中使用過什么代碼檢查工具？
簡述 saltstack、ansible、fabric、puppet工具的作用？
# Saltstack是一個服務器集中管理中心平台，可以幫助管理員輕松的對若干台服務器進行統一操作。 # 類似的工具還有Ansible，Puppet，func等等。相比於這些工具，salt的特點在於其用python實現，支持各種操作系統類型，采取了C/S架構，部署方便簡單， 且可擴展性很強。 # SaltStack 采用 C/S模式，server端就是salt的master，client端就是minion，minion與master之間通過ZeroMQ消息隊列通信 # minion上線后先與master端聯系，把自己的pub key發過去，這時master端通過salt-key -L命令就會看到minion的key，接受該minion-key后，也就是master與minion已經互信
B Tree和B+ Tree的區別？
請列舉常見排序並通過代碼實現任意三種。
請列舉常見查找並通過代碼實現任意三種。
請列舉你熟悉的設計模式？
有沒有刷過leetcode？
列舉熟悉的的Linux命令。
公司線上服務器是什么系統？
解釋 PV、UV 的含義？
解釋 QPS的含義？
uwsgi和wsgi的區別？
supervisor的作用？
什么是反向代理？
簡述SSH的整個過程。
有問題都去那些找解決方案？
是否有關注什么技術類的公眾號？
最近在研究什么新技術？
是否了解過領域驅動模型？
題目出處：https://www.cnblogs.com/wupeiqi/p/9078770.html