更多看個人blog

點(diǎn)擊直達(dá)makerroot

python面試題目和總結(jié)(不斷補(bǔ)充之中......)

談?wù)凪ysql事務(wù)隔離級別

事務(wù)的隔離級別分為：未提交讀(read uncommitted)、已提交讀(read committed)券躁、可重復(fù)讀(repeatable read)监徘、串行化(serializable)趾代。
1未提交讀
未提交讀的意思就是比如原先name的值是小剛，然后有一個事務(wù)Bupdate table set name = '小明' where id = 1,它還沒提交事務(wù)辟灰。同時事務(wù)A也起了，有一個select語句select name from table where id = 1，在這個隔離級別下獲取到的name的值是小明而不是小剛案疲。那萬一事務(wù)B回滾了，實(shí)際數(shù)據(jù)庫中的名字還是小剛麻养，事務(wù)A卻返回了一個小明褐啡，這就稱之為臟讀。
2已提交讀
按照上面那個例子鳖昌，在已提交讀的情況下备畦，事務(wù)A的select name 的結(jié)果是小剛，而不是小明许昨，因?yàn)樵谶@個隔離級別下懂盐，一個事務(wù)只能讀到另一個事務(wù)修改的已經(jīng)提交了事務(wù)的數(shù)據(jù)。但是有個現(xiàn)象糕档，還是拿上面的例子說莉恼。如果事務(wù)B 在這時候隱式提交了時候，然后事務(wù)A的select name結(jié)果就是小明了速那，這都沒問題俐银，但是事務(wù)A還沒結(jié)束，這時候事務(wù)B又update table set name = '小紅' where id = 1并且隱式提交了琅坡。然后事務(wù)A又執(zhí)行了一次select name from table where id = 1結(jié)果就返回了小紅悉患。這種現(xiàn)象叫不可重復(fù)讀。
3可重復(fù)讀
可重復(fù)讀就是一個事務(wù)只能讀到另一個事務(wù)修改的已提交了事務(wù)的數(shù)據(jù)榆俺，但是第一次讀取的數(shù)據(jù)售躁，即使別的事務(wù)修改的這個值坞淮，這個事務(wù)再讀取這條數(shù)據(jù)的時候還是和第一次獲取的一樣，不會隨著別的事務(wù)的修改而改變陪捷。這和已提交讀的區(qū)別就在于回窘，它重復(fù)讀取的值是不變的。所以取了個貼切的名字叫可重復(fù)讀市袖。按照這個隔離級別下那上面的例子就是：
4串行化
上面三個隔離級別對同一條記錄的讀和寫都可以并發(fā)進(jìn)行啡直，但是串行化格式下就只能進(jìn)行讀-讀并發(fā)。只要有一個事務(wù)操作一條記錄的寫苍碟，那么其他要訪問這條記錄的事務(wù)都得等著酒觅。
5串行化一般沒人用串行化，性能比較低微峰，常用的是已提交讀和可重復(fù)讀舷丹。而已提交讀和可重復(fù)讀的實(shí)現(xiàn)主要是基本版本鏈和readView。而它們之間的區(qū)別其實(shí)就是生成readView的策略不同

事務(wù)的基本要素（ACID）

1蜓肆、原子性（Atomicity）：事務(wù)開始后所有操作颜凯，要么全部做完，要么全部不做仗扬，不可能停滯在中間環(huán)節(jié)症概。事務(wù)執(zhí)行過程中出錯，會回滾到事務(wù)開始前的狀態(tài)早芭，所有的操作就像沒有發(fā)生一樣彼城。也就是說事務(wù)是一個不可分割的整體，就像化學(xué)中學(xué)過的原子逼友，是物質(zhì)構(gòu)成的基本單位精肃。
2、一致性（Consistency）：事務(wù)開始前和結(jié)束后帜乞，數(shù)據(jù)庫的完整性約束沒有被破壞 。比如A向B轉(zhuǎn)賬筐眷，不可能A扣了錢黎烈，B卻沒收到。
3匀谣、隔離性（Isolation）：同一時間照棋，只允許一個事務(wù)請求同一數(shù)據(jù)，不同的事務(wù)之間彼此沒有任何干擾武翎。比如A正在從一張銀行卡中取錢烈炭，在A取錢的過程結(jié)束前，B不能向這張卡轉(zhuǎn)賬宝恶。
4符隙、持久性（Durability）：事務(wù)完成后趴捅，事務(wù)對數(shù)據(jù)庫的所有更新將被保存到數(shù)據(jù)庫，不能回滾霹疫。

原文鏈接

事務(wù)的并發(fā)問題

1拱绑、臟讀：事務(wù)A讀取了事務(wù)B更新的數(shù)據(jù)，然后B回滾操作丽蝎，那么A讀取到的數(shù)據(jù)是臟數(shù)據(jù)
　 2猎拨、不可重復(fù)讀：事務(wù) A 多次讀取同一數(shù)據(jù)，事務(wù) B 在事務(wù)A多次讀取的過程中屠阻，對數(shù)據(jù)作了更新并提交红省，導(dǎo)致事務(wù)A多次讀取同一數(shù)據(jù)時，結(jié)果 不一致国觉。
　 3类腮、幻讀：系統(tǒng)管理員A將數(shù)據(jù)庫中所有學(xué)生的成績從具體分?jǐn)?shù)改為ABCDE等級，但是系統(tǒng)管理員B就在這個時候插入了一條具體分?jǐn)?shù)的記錄蛉加，當(dāng)系統(tǒng)管理員A改結(jié)束后發(fā)現(xiàn)還有一條記錄沒有改過來蚜枢，就好像發(fā)生了幻覺一樣，這就叫幻讀针饥。
　　小結(jié)：不可重復(fù)讀的和幻讀很容易混淆厂抽，不可重復(fù)讀側(cè)重于修改，幻讀側(cè)重于新增或刪除丁眼。解決不可重復(fù)讀的問題只需鎖住滿足條件的行筷凤，解決幻讀需要鎖表

原文鏈接

分布式鎖（python+Redis）

1什么是分布式鎖？
要介紹分布式鎖苞七，首先要提到與分布式鎖相對應(yīng)的是線程鎖藐守、進(jìn)程鎖。

線程鎖：主要用來給方法蹂风、代碼塊加鎖卢厂。當(dāng)某個方法或代碼使用鎖，在同一時刻僅有一個線程執(zhí)行該方法或該代碼段惠啄。線程鎖只在同一JVM中有效果慎恒，因?yàn)榫€程鎖的實(shí)現(xiàn)在根本上是依靠線程之間共享內(nèi)存實(shí)現(xiàn)的，比如synchronized是共享對象頭撵渡，顯示鎖Lock是共享某個變量（state）融柬。

進(jìn)程鎖：為了控制同一操作系統(tǒng)中多個進(jìn)程訪問某個共享資源，因?yàn)檫M(jìn)程具有獨(dú)立性趋距，各個進(jìn)程無法訪問其他進(jìn)程的資源粒氧，因此無法通過synchronized等線程鎖實(shí)現(xiàn)進(jìn)程鎖。

分布式鎖：當(dāng)多個進(jìn)程不在同一個系統(tǒng)中节腐，用分布式鎖控制多個進(jìn)程對資源的訪問外盯。

2分布式鎖的使用場景摘盆。
線程間并發(fā)問題和進(jìn)程間并發(fā)問題都是可以通過分布式鎖解決的，但是強(qiáng)烈不建議這樣做门怪！因?yàn)椴捎梅植际芥i解決這些小問題是非常消耗資源的骡澈！分布式鎖應(yīng)該用來解決分布式情況下的多進(jìn)程并發(fā)問題才是最合適的。

有這樣一個情境掷空，線程A和線程B都共享某個變量X肋殴。

如果是單機(jī)情況下（單JVM），線程之間共享內(nèi)存坦弟，只要使用線程鎖就可以解決并發(fā)問題护锤。

如果是分布式情況下（多JVM），線程A和線程B很可能不是在同一JVM中酿傍，這樣線程鎖就無法起到作用了烙懦，這時候就要用到分布式鎖來解決。

3分布式鎖的實(shí)現(xiàn)（Redis）
分布式鎖實(shí)現(xiàn)的關(guān)鍵是在分布式的應(yīng)用服務(wù)器外赤炒，搭建一個存儲服務(wù)器氯析，存儲鎖信息，這時候我們很容易就想到了Redis莺褒。首先我們要搭建一個Redis服務(wù)器掩缓，用Redis服務(wù)器來存儲鎖信息。
4在實(shí)現(xiàn)的時候要注意的幾個關(guān)鍵點(diǎn)：
1遵岩、鎖信息必須是會過期超時的你辣，不能讓一個線程長期占有一個鎖而導(dǎo)致死鎖；
2尘执、同一時刻只能有一個線程獲取到鎖舍哄。
幾個要用到的redis命令：
setnx(key, value)：“set if not exits”，若該key-value不存在誊锭，則成功加入緩存并且返回1表悬，否則返回0。
get(key)：獲得key對應(yīng)的value值炉旷，若不存在則返回nil签孔。
getset(key, value)：先獲取key對應(yīng)的value值，若不存在則返回nil窘行，然后將舊的value更新為新的value。
expire(key, seconds)：設(shè)置key-value的有效期為seconds秒图仓。

原文鏈接

代碼實(shí)現(xiàn)

class MyLock(object):
    """docstring for MyLock"""
    def __init__(self, lockID,timeout):
        self.connection=redis.Redis(host=127.0.0.1,port=6379,password=root,db=1)
        self.__lockID=lockID
        self.__timeout=timeout

    def tryLock(self.appid):
        try:
            val=self.connection.get(self.__lockID)
            if val is None:
                logging.info('the app{0} try lock {2} ok'.fomat(appid,self.__lockID))
                self.connection.set(self.__lockID,appid,ex=self.__timeout)
                return True
            else:
                logging.info('the owner of lock {0} is {1} you {2} can not get it'.fomat(self.__lockID,val,appid))
                return False
        except Exception as e:
            logging.error("Warning: Can't write log. {0}".fomat(e))
            return False
        
    def activeLock(self,appid):
        val=self.connection.get(self.__lockID)
        if val is None:
            return False
        else:
            if val==appid:
                self.connection.set(self.__lockID,appid,ex=self.__timeout)
                return True
            else:
                return False

    def relese_lock(self,key,appid):
        val=self.connection.get(self.__lockID)
        if val is None:
            return False
        else:
            if val==appid:
                self.connection.delete(self.__lockID)
                return True
            else:
                return False

線程

程序執(zhí)行的最小單位
線程是進(jìn)程中的一個實(shí)體罐盔，是被系統(tǒng)獨(dú)立調(diào)度和分派的基本單位
線程的創(chuàng)建
threading.Thread（target = 變量名）
線程的資源競爭問題
線程是可以資源共享的同時也會存在問題就是資源競爭
為了防止這種問題的出現(xiàn)，就提出了鎖的概念

互斥鎖

某個線程要更改共享數(shù)據(jù)時救崔，先將其鎖定惶看，此時資源的狀態(tài)為“鎖定”捏顺，其他線程不能更改；
直到該線程釋放資源纬黎，將資源的狀態(tài)變成“非鎖定”幅骄，其他的線程才能再次鎖定該資源

threading 模塊中定義了 Lock 類，可以方便的處理鎖定：

創(chuàng)建鎖

mutex = threading.Lock()

鎖定

mutex.acquire()

釋放

mutex.release()
鎖里的內(nèi)容越少越好
鎖的好處：確保了某段關(guān)鍵代碼只能由一個線程從頭到尾完整地執(zhí)行
鎖的壞處：阻止了多線程并發(fā)執(zhí)行本今，包含鎖的某段代碼實(shí)際上只能以單線程模式執(zhí)行拆座，效率就大大地下
降了。由于可以存在多個鎖冠息，不同的線程持有不同的鎖挪凑，并試圖獲取對方持有的鎖時，可能會造成死鎖逛艰。

死鎖

在線程間共享多個資源的時候躏碳，如果兩個線程分別占有一部分資源并且同時等待對方的資
源，就會造成死鎖

進(jìn)程

進(jìn)程是程序的一次執(zhí)行
進(jìn)程是可以和別的計算并行執(zhí)行
進(jìn)程是程序在一個數(shù)據(jù)集合上運(yùn)行的過程散怖，它是系統(tǒng)進(jìn)行資源分配和調(diào)度的一個獨(dú)立單位

進(jìn)程的創(chuàng)建

multiprocessing.Process（target=變量名）
進(jìn)程間不同享全局變量,這個時候就出現(xiàn)了Queue可以使用 multiprocessing 模塊的 Queue 實(shí)現(xiàn)多進(jìn)程之間的數(shù)據(jù)傳遞菇绵，Queue 本身是一個消息列隊程序。put() 放入元素镇眷，get()取出元素

返回當(dāng)前隊列包含的消息數(shù)量咬最；

Queue.qsize()

如果隊列為空，返回 True偏灿，反之 False 丹诀；

Queue.empty()

如果隊列滿了，返回 True,反之 False翁垂；

Queue.full()

獲取隊列中的一條消息铆遭，然后將其從列隊中移除，block 默認(rèn)

Queue.get([block[, timeout]])

進(jìn)程池 Pool

手動的去創(chuàng)建進(jìn)程的工作量巨大沿猜，此時就可以用到multiprocessing 模塊提供的 Pool 方法枚荣。初始化 Pool 時，可以指定一個最大進(jìn)程數(shù)啼肩，當(dāng)有新的請求提交到 Pool 中時橄妆，如果池還沒有滿，那么就會創(chuàng)建一個新的進(jìn)程用來執(zhí)行該請求祈坠；但如果池中的進(jìn)程數(shù)已經(jīng)達(dá)到指定的最大值害碾，那么該請求就會等待，直到池中有進(jìn)程結(jié)束赦拘，才會用之前的進(jìn)程來執(zhí)行新的任務(wù)慌随。

代碼片段

po = Pool(3) # 定義一個進(jìn)程池，最大進(jìn)程數(shù) 3
for i in range(0,10):
# Pool().apply_async(要調(diào)用的目標(biāo),(傳遞給目標(biāo)的參數(shù)元祖,))
# 每次循環(huán)將會用空閑出來的子進(jìn)程去調(diào)用目標(biāo)
po.apply_async(worker,(i,))
print("----start----")
po.close() # 關(guān)閉進(jìn)程池，關(guān)閉后 po 不再接收新的請求
po.join() # 等待 po 中所有子進(jìn)程執(zhí)行完成阁猜，必須放在 close 語句之后
print("-----end-----")
#完整片段
#進(jìn)程
from multiprocessing import Process
import os
from time import sleep
from multiprocessing import Pool

def run_pro(name):
    print('子進(jìn)程丸逸，name=%s,pid=%d'%(name,os.getpid()))


def work(test):
    print('zi%s,tes=%d'%(os.getpid(),test))

if __name__ == '__main__':
    
    # while True:
    print('父進(jìn)程%d'%os.getpid())
    #創(chuàng)建進(jìn)程
    p=Process(target=run_pro,args=('maker',))
    print('子進(jìn)程開始執(zhí)行')
    p.start()
    p.join()
    print('子進(jìn)程結(jié)束')
    print('------------------'*10)
    sleep(2)
    #進(jìn)程池最大8個進(jìn)程
    pool=Pool(8)
    for x in range(1,10):
        #非阻塞
        pool.apply_async(work,(x,))
        #阻塞
        # pool.apply(work,(x,))
    print('start')
    pool.close()
    pool.join()
    print('end')

協(xié)成

協(xié)程是一種用戶態(tài)的輕量級線程,協(xié)程的調(diào)度完全由用戶控制,協(xié)程擁有自己的寄存器和棧。
簡單點(diǎn)說協(xié)程是進(jìn)程和線程的升級版,進(jìn)程和線程都面臨著內(nèi)核態(tài)和用戶態(tài)的切換問題而耗費(fèi)許多切換時間,而協(xié)程就是用戶自己控制切換的時機(jī),不再需要陷入系統(tǒng)的內(nèi)核態(tài)剃袍。
Python里最常見的yield就是協(xié)程的思想黄刚。

線程全局鎖（GIL）

線程全局鎖(Global Interpreter Lock),即Python為了保證線程安全而采取的獨(dú)立線程運(yùn)行的限制,說白了就是一個核只能在同一時間運(yùn)行一個線程.對于io密集型任務(wù)，python的多線程起到作用民效，但對于cpu密集型任務(wù)憔维，python的多線程幾乎占不到任何優(yōu)勢，還有可能因?yàn)闋帄Z資源而變慢研铆。
解決辦法就是多進(jìn)程和下面的協(xié)程(協(xié)程也只是單CPU,但是能減小切換代價提升性能).

Django調(diào)試代碼的方式

開啟runserver
pycharm自帶運(yùn)行和debug設(shè)置斷點(diǎn)
使用nohup開啟runserver服務(wù)

如果主管給你一個從來沒有見過的任務(wù)給你埋同，你會怎么解決

此問題要注意，有取舍關(guān)系棵红，（主要是看那個問題是不是在你能力范圍之內(nèi)）凶赁，不是每個任務(wù)都是有結(jié)果的

部分筆試題目

筆試題

部分筆試題加面試題

django中怎么實(shí)現(xiàn)定時任務(wù)

第一種是celery
第二種是crontab

你為什么要離開上一家公司

你們公司并發(fā)量是多少，為什么要使用Redis逆甜，增加Redis之后不會增加服務(wù)器的消耗嗎虱肄？

你測試過加了Redis之后速度一定變快嗎？

varchar和char類型字段的區(qū)別

1交煞、char(n)類型
char類型時定長的類型咏窿，即當(dāng)定義的是char(10)，輸入的是"abc"這三個字符時素征，它們占的空間一樣是10個字節(jié)集嵌，包括7個空字節(jié)。當(dāng)輸入的字符長度超過指定的數(shù)時御毅，char會截取超出的字符根欧。而且，當(dāng)存儲char值時端蛆，MySQL是自動刪除輸入字符串末尾的空格凤粗。
char是適合存儲很短的、一般固定長度的字符串今豆。例如嫌拣，char非常適合存儲密碼的MD5值，因?yàn)檫@是一個定長的值呆躲。對于非常短的列异逐，char比varchar在存儲空間上也更有效率。
2插掂、varchar(n)類型
varchar(n)類型用于存儲可變長的应役，長度為n個字節(jié)的可變長度且非Unicode的字符數(shù)據(jù)。n必須是介于1和8000之間的數(shù)值燥筷，存儲大小為輸入數(shù)據(jù)的字節(jié)的實(shí)際長度+1/2. 比如varchar(10), 然后輸入abc三個字符箩祥，那么實(shí)際存儲大小為3個字節(jié)。除此之外肆氓，varchar還需要使用1或2個額外字節(jié)記錄字符串的長度袍祖，如果列的最大長度小于等于255字節(jié)（是定義的最長長度，不是實(shí)際長度）谢揪，則使用1個字節(jié)表示長度蕉陋，否則使用2個字節(jié)來表示。
所以拨扶，從空間上考慮凳鬓，varcahr較合適；從效率上考慮患民，用char合適缩举。二者之間需要權(quán)衡。
除了char和varchar之外匹颤，還有一種nchar仅孩、nvarchar(n)，包含n個字符的可變長度為unicode字符數(shù)據(jù)印蓖。n的值必須介于1~4000之間辽慕，直接的存儲大小是說輸入字符個數(shù)的兩倍，所輸入的數(shù)據(jù)字符長度可以為零赦肃。從名字上看溅蛉，多了一個n，表示存儲的是unicode數(shù)據(jù)類型的字符他宛，這是為了存儲漢字用的船侧，1個英文字母或者數(shù)字占用的字符為1個，一個漢字占用2個字符堕汞，那么對于有中英文混合的字符串勺爱，我們需要定義nvarchar類型。Unicode字符集就是為了解決字符集這種不兼容的問題而產(chǎn)生的讯检，它所有的字符都用兩個字節(jié)表示琐鲁，即英文字符也是用兩個字節(jié)表示。nchar人灼、nvarchar的長度是在1到4000之間围段。和char、varchar比較起來投放，nchar奈泪、nvarchar則最多存儲4000個字符，不論是英文還是漢字；而char涝桅、varchar最多能存儲8000個英文拜姿，4000個漢字》胨欤可以看出使用nchar蕊肥、nvarchar數(shù)據(jù)類型時不用擔(dān)心輸入的字符是英文還是漢字，較為方便蛤肌，但在存儲英文時數(shù)量上有些損失壁却。所以一般來說，如果含有中文字符裸准，用nchar/nvarchar展东，如果純英文和數(shù)字，用char/varchar炒俱。
還有盐肃，text類型。其存儲可變長度的非Unicode數(shù)據(jù)向胡，最大長度為2^31-1(2,147,483,647)個字符恼蓬。

Nginx的作用有哪些

關(guān)于Nginx(作為服務(wù)器使用)
Nginx是一個輕量級、高性能僵芹、穩(wěn)定性高处硬、并發(fā)性好的HTTP和反向代理服務(wù)器。也是由于其的特性拇派，其應(yīng)用非常廣
反向代理
正向代理：某些情況下荷辕，代理我們用戶去訪問服務(wù)器，需要用戶手動的設(shè)置代理服務(wù)器的ip和端口號件豌。
反向代理：是用來代理服務(wù)器的疮方，代理我們要訪問的目標(biāo)服務(wù)器。代理服務(wù)器接受請求茧彤，然后將請求轉(zhuǎn)發(fā)給內(nèi)部網(wǎng)絡(luò)的服務(wù)器(集群化),并將從服務(wù)器上得到的結(jié)果返回給客戶端骡显，此時代理服務(wù)器對外就表現(xiàn)為一個服務(wù)器。
Nginx在反向代理上曾掂，提供靈活的功能惫谤，可以根據(jù)不同的正則采用不同的轉(zhuǎn)發(fā)策略，如圖設(shè)置好后不同的請求就可以走不同的服務(wù)器珠洗。

負(fù)載均衡
多在高并發(fā)情況下需要使用溜歪。其原理就是將數(shù)據(jù)流量分?jǐn)偟蕉鄠€服務(wù)器執(zhí)行，減輕每臺服務(wù)器的壓力许蓖，多臺服務(wù)器(集群)共同完成工作任務(wù)蝴猪，從而提高了數(shù)據(jù)的吞吐量调衰。
Nginx可使用的負(fù)載均衡策略有：輪詢（默認(rèn)）、權(quán)重自阱、ip_hash嚎莉、url_hash(第三方)、fair(第三方)
動靜分離
Nginx提供的動靜分離是指把動態(tài)請求和靜態(tài)請求分離開动壤，合適的服務(wù)器處理相應(yīng)的請求萝喘，使整個服務(wù)器系統(tǒng)的性能、效率更高琼懊。
Nginx可以根據(jù)配置對不同的請求做不同轉(zhuǎn)發(fā)，這是動態(tài)分離的基礎(chǔ)爬早。靜態(tài)請求對應(yīng)的靜態(tài)資源可以直接放在Nginx上做緩沖哼丈，更好的做法是放在相應(yīng)的緩沖服務(wù)器上。動態(tài)請求由相應(yīng)的后端服務(wù)器處理筛严。

uwsgi和wsgi的區(qū)別

那么如何實(shí)現(xiàn)uWSGI和WSGI的配合呢醉旦？如何做到任意一個web服務(wù)器，都能搭配任意一個框架呢桨啃？這就產(chǎn)生了WSGI協(xié)議车胡。只要web服務(wù)器和web框架滿足WSGI協(xié)議，它們就能相互搭配照瘾。所以WSGI只是一個協(xié)議匈棘，一個約定。而不是python的模塊析命、框架等具體的功能主卫。而uWSGI，則是實(shí)現(xiàn)了WSGI協(xié)議的一個web服務(wù)器鹃愤。即用來接受客戶端請求簇搅，轉(zhuǎn)發(fā)響應(yīng)的程序。實(shí)際上软吐，一個uWSGI的web服務(wù)器瘩将，再加上Django這樣的web框架，就已經(jīng)可以實(shí)現(xiàn)網(wǎng)站的功能了凹耙。那為什么還需要Nginx呢姿现？
為什么需要Nginx
一個普通的個人網(wǎng)站，訪問量不大的話使兔，當(dāng)然可以由uWSGI和Django構(gòu)成建钥。但是一旦訪問量過大，客戶端請求連接就要進(jìn)行長時間的等待虐沥。這個時候就出來了分布式服務(wù)器熊经，我們可以多來幾臺web服務(wù)器泽艘，都能處理請求。但是誰來分配客戶端的請求連接和web服務(wù)器呢镐依？Nginx就是這樣一個管家的存在匹涮，由它來分配。這也就是由Nginx實(shí)現(xiàn)反向代理槐壳，即代理服務(wù)器然低。

你為何要選擇我們這個行業(yè)

什么是樹

前端怎么寫任意拖拽的組件

目前的風(fēng)口是什么

你平時關(guān)注些什么東西

什么是5G

你平時是不是看了一些什么類型的書

你是什么星座的

session和cookie的區(qū)別

1、cookie數(shù)據(jù)存放在客戶的瀏覽器上务唐，session數(shù)據(jù)放在服務(wù)器上雳攘。
2、cookie不是很安全枫笛，別人可以分析存放在本地的COOKIE并進(jìn)行COOKIE欺騙
考慮到安全應(yīng)當(dāng)使用session吨灭。
3、session會在一定時間內(nèi)保存在服務(wù)器上刑巧。當(dāng)訪問增多喧兄，會比較占用你服務(wù)器的性能
考慮到減輕服務(wù)器性能方面，應(yīng)當(dāng)使用COOKIE啊楚。
4吠冤、單個cookie保存的數(shù)據(jù)不能超過4K及刻，很多瀏覽器都限制一個站點(diǎn)最多保存20個cookie蛔钙。
5、所以個人建議：
將登陸信息等重要信息存放為SESSION
其他信息如果需要保留风纠，可以放在COOKIE中

如果突然有個頁面的加載時間很長蚯斯，你會怎么處理

從客戶端開始檢查薄风，可能是網(wǎng)絡(luò)延遲、緩存等問題拍嵌，最后再到接口遭赂、sql語句優(yōu)化上看。

小程序里當(dāng)用戶提交訂單之后横辆，怎么發(fā)消息給用戶

模板消息推送

你覺得你最擅長的是啥

你工作為什么要選杭州

數(shù)據(jù)庫除了curd撇他，你還做了啥

你使用Django最深入的是哪個部分

講一講你數(shù)據(jù)庫的設(shè)計思想

什么是裝飾器

裝飾器：本質(zhì)是函數(shù)（裝飾其它函數(shù)）就是為其它函數(shù)添加附加功能
原則
1 不能修改被裝飾的函數(shù)的源代碼
2 不能修改被裝飾的函數(shù)的調(diào)用方式
實(shí)現(xiàn)裝飾器知識儲備：
1 函數(shù)即“變量”
2 高階函數(shù)
a:把一個函數(shù)名當(dāng)做實(shí)參傳給另外一個函數(shù)（不修改被裝飾函數(shù)源代碼）
b:返回值中包含函數(shù)名（不修改函數(shù)的調(diào)用方式）
3 嵌套函數(shù)
高階函數(shù)+嵌套函數(shù)->裝飾器

什么是生成器

通過列表生成器，我們可以直接創(chuàng)建一個列表狈蚤，但是由于受到內(nèi)存限制困肩，列表容量肯定是有限的，而且脆侮，創(chuàng)建一個包含100萬個元素的列表锌畸，不僅占用很大的儲存空間，如果我們僅僅需要訪問前面幾個元素的話靖避，后面元素占用的空間都白白浪費(fèi)了潭枣。
所以比默，如果列表元素可以按照某種算法推算出來，那么我們是否可以在循環(huán)的過程中不斷推算出后續(xù)的元素盆犁？這樣就不必創(chuàng)建完整的list命咐，從而節(jié)省大量的空間。在Python中谐岁，這種一邊循環(huán)一邊計算的機(jī)制醋奠，叫做生成器：generator，要創(chuàng)建一個generator伊佃，有很多種方法窜司，第一種方法很簡單，只要把一個列表生成式的[]改為()即可锭魔，這樣就創(chuàng)建了一個generator例证，只有在調(diào)用的時候，才會形成相應(yīng)的數(shù)據(jù)迷捧。
列表的生成：
a = [i2 for i in range(10)]
print(a)
這是列表的生成，print的結(jié)果是胀葱，0,2,4,6......16,18
生成器：
b = (i2 for i in range(10))
for i in b:
print(i)
這就是一個生成器漠秋。他等價于下面一串代碼：
b = []
for i in range(10)
b.append(i*2)
print(b)
注意如果：

b = (i*2 for i in range(10))
print(b)
print(type(b))
我們就會發(fā)現(xiàn)，第一個print出來的是b這個生成器的內(nèi)存地址
而第二個會print出來<class 'generator'>
yield 是一個類似 return 的關(guān)鍵字抵屿，只是這個函數(shù)返回的是個生成器庆锦。

*args和 **kwgs的區(qū)別

這兩個是python中的可變參數(shù)。args 表示任何多個無名參數(shù)轧葛，它是一個tuple搂抒；kwargs 表示關(guān)鍵字參數(shù)，它是一個dict尿扯。并且同時使用args和kwargs時求晶，必須args參數(shù)列要在kwargs前
代碼如下
def test(args,kwargs):
print(args,kwargs)
a={'a':1,'b':2}
test(a)
print(''30)
test(a)
print('-'30)
test(**a)
執(zhí)行結(jié)果如下：
C:\Users\maker0\Desktop\free_work>python args.py
({'a': 1, 'b': 2},) {}
******************************
('a', 'b') {}
------------------------------
() {'a': 1, 'b': 2}

面試總結(jié)

linux查找某個文件中單詞出現(xiàn)的次數(shù)

文件名稱：list
查找單詞名稱：test
操作命令：

           （1）more list | grep -o test | wc -l

           （2）cat list | grep -o test | wc -l

           （3） grep -o test list | wc -l

Linux怎么查看進(jìn)程號，端口衷笋，內(nèi)存占用量芳杏，文件大小，文件有多少行辟宗。

磁盤空間：df -h
內(nèi)存：free -g
netstat -anp | grep 8080 根據(jù)端口號查找相應(yīng)的進(jìn)程號爵赵，必須以root用戶執(zhí)行
使用wc命令 具體通過wc --help 可以查看。
如： wc -l filename 就是查看文件里有多少行
wc -w filename 看文件里有多少個word泊脐。
wc -L filename 文件里最長的那一行是多少個字空幻。
wc命令
　　wc命令的功能為統(tǒng)計指定文件中的字節(jié)數(shù)、字?jǐn)?shù)容客、行數(shù), 并將統(tǒng)計結(jié)果顯示輸出秕铛。
查看系統(tǒng)中文件的使用情況
df -h
查看當(dāng)前目錄下各個文件及目錄占用空間大小
du -sh *
獲取進(jìn)程名约郁、進(jìn)程號以及用戶 ID
netstat -nlpt

Python 為什么list不能作為字典的key

1 字典的鍵是需要不可變類型的，而列表是可變的如捅，列表可以通過索引賦值棍现，所以不能作為字典的鍵，元組最有意思镜遣，元組是不可變但有是可變的己肮，之所以這么說，是因?yàn)樵M不能像列表一樣通過索引賦值悲关，但是如果組成元組的是多個列表的話谎僻，那么ok，列表可變寓辱，元組內(nèi)列表變了艘绍，元組也就變了

2 字典的key是字符串，list是數(shù)據(jù)集合

關(guān)于python中列表的遍歷和多層嵌套拆開

假設(shè)存在列表形如num=[1,[2],[[3]],[[4,[5],6]],7,8,[9,[85,[65,[2,6,[96,35]]]]]]
輸出結(jié)果為：[1, 2, 3, 4, 5, 6, 7, 8, 9, 85, 65, 2, 6, 96, 35]
代碼如下：

def test(num):
    nums=[]
    for x in num:
        if isinstance(x,list):
            nums.extend(test(x))
        else:
            nums.append(x)
    return nums


if __name__ == '__main__':
    num=[1,[2],[[3]],[[4,[5],6]],7,8,[9,[85,[65,[2,6,[96,35]]]]]]
    print(test(num))

列表秫筏、字典面試題之一

a=[]
b={'k1':a,'k2':a}
b['k1'].append(777)
print(b)
b['k1']=666
print(b)


b={'k1':[],'k2':[]}
b['k1'].append(777)
print(b)
b['k1']=666
print(b)
輸出結(jié)果：
{'k1': [777], 'k2': [777]}
{'k1': 666, 'k2': [777]}
{'k1': [777], 'k2': []}
{'k1': 666, 'k2': []}