常見面試題總結（1）

------------------------------

一、寫一個程序交換兩個變量的值？

方法一:使用加減法進行交換

 1 #main方法
 2 def main():
 3     #提示用戶輸入的數據信息
 4     numOne=int(raw_input("請輸入第一個數字："))
 5     numTwo=int(raw_input("請輸入第二個數字："))
 6 
 7     #打印數據信息
 8     print("交換前的數據分別爲：%d,%d"%(numOne,numTwo))
 9 
10     #進行數據的交換
11     numOne=numOne+numTwo
12     numTwo=numOne-numTwo
13     numOne=numOne-numTwo
14 
15     #打印數據信息
16     print("交換後的數據分別爲：%d,%d"%(numOne,numTwo))
17 
18 #程序入口
19 if __name__ == '__main__':
20     main();

加減法實現數據的交換

方法二：使用異或法進行交換

 1 #main方法
 2 def main():
 3     #提示用戶輸入的數據信息
 4     numOne=int(raw_input("請輸入第一個數字："))
 5     numTwo=int(raw_input("請輸入第二個數字："))
 6 
 7     #打印數據信息
 8     print("交換前的數據分別爲：%d,%d"%(numOne,numTwo))
 9 
10     #進行數據的交換
11     numOne=numOne^numTwo
12      numTwo=numOne^numTwo
13      numOne=numOne^numTwo
14 
15     #打印數據信息
16     print("交換後的數據分別爲：%d,%d"%(numOne,numTwo))
17 
18 #程序入口
19 if __name__ == '__main__':
20     main();

異或法實現數據的交換

 

------------------------------

二、在Python中，類和對象有什麼區別？對象如何訪問類的方法？對象和類可否互相訪問對方的方法或者屬性？

　　答：

　　　　類是一類對象的集合，是一個模版，封裝了對象的屬性和方法，是實例對象產生的工廠，類能夠產生多個實例對象

　　　　主要特色：

　　　　　　class語句建立類對象並將其賦值給變量名；

　　　　　　class語句內的賦值語句會建立類的屬性；

　　　　　　類屬性提供對象的狀態和行爲；

　　　　對象是類的實例，由類的構造函數生成，實例化類的屬性和方法　　　　　　

　　　　主要特色：

　　　　　　像函數那樣調用對象會建立新的實例對象；

     　　　　 每一個實例對象繼承類的屬性並得到了本身的命名空間；

　　　　　　在方法內對self屬性作賦值運算會產生每一個實例本身的屬性

 

　　　　對於實例的屬性和方法，只能由實例調用，類不能夠調用

　　　　對於類的屬性和方法，類和實例對象均可以去調用

 

------------------------------

三、用Python編寫一個簡單的socket程序，服務器想客戶端發送一句話「Python is not hard」，客戶端回送一句話「life is short,please use python」

  1 #coding=utf-8
  2 
  3 #引用對應的包
  4 import socket
  5 import sys
  6 import threading
  7 from time import sleep
  8 
  9 
 10 #線程：模擬udp服務器向客戶端發送一句話：Python is not hard
 11 class ServerThread(threading.Thread):
 12     #重寫對應的構造方法
 13     def __init__(self, port):
 14         threading.Thread.__init__(self)
 15         self.port = port
 16 
 17     #進行run方法的重寫操做
 18     def run(self):
 19         #建立udp服務器套接字
 20         self.serverSoc=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
 21 
 22         #元組，存儲服務器端ip地址和端口號
 23         self.locker = ('192.168.241.128',self.port)
 24 
 25         #綁定服務器ip和端口
 26         self.serverSoc.bind(self.locker)        
 27 
 28 
 29         #元組，存儲要發送的指定客戶端的ip地址和端口號,客戶端指定端口號爲8080
 30         self.sendAddr = ('192.168.241.128',8080)
 31 
 32 
 33         print("服務器開啓")
 34 
 35         sleep(1)
 36 
 37         #變量，存儲要發送的內容
 38         self.sendDate = 'Python is not hard'
 39 
 40         #進行數據向客戶的發送
 41         self.serverSoc.sendto(self.sendDate,self.sendAddr)
 42 
 43         #阻塞，接受客戶端回發回來的數據信息
 44         self.recvDate,self.recvAddr = self.serverSoc.recvfrom(1024)
 45 
 46         print("客戶端：%s"%(self.recvDate))
 47 
 48         #關閉套接字
 49         self.serverSoc.close()
 50 
 51 
 52 #線程：模擬udp客戶端接受服務器發送的數據，而且恢復一句「life is short,please use python」
 53 class ClientThread(threading.Thread):
 54     #重寫對應的構造方法
 55     def __init__(self,port):
 56         threading.Thread.__init__(self)
 57         self.port = port
 58 
 59     #重寫對應的run方法
 60     def run(self):
 61         #建立udp客戶端套接字
 62         self.clientSoc = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
 63         
 64         #元組，存儲客戶端ip地址和端口號，指定客戶端端口號爲8080
 65         self.locker = ('192.168.241.128',8080)
 66 
 67         self.sendAddr = ('192.168.241.128',self.port)
 68 
 69         #綁定
 70         self.clientSoc.bind(self.locker)
 71 
 72         print("客戶端開啓")
 73 
 74         # # #阻塞，等待接受服務器發送過來的數據信息
 75         # self.recvDate = self.clientSoc.recvfrom(1024)
 76         # print(type(self.recvDate)) #屬性測試
 77         # #服務器發送過來的數據爲：('Python is not hard', ('192.168.241.128', 8080))
 78         # print("服務器發送過來的數據爲：%s"%(str(self.recvDate)))
 79 
 80         #接受對應發送過來的數據信息
 81         self.recvDate,self.recvAddr = self.clientSoc.recvfrom(1024)
 82 
 83         print("服務器發送過來的數據爲：%s"%self.recvDate)
 84 
 85         #回發的數據信息
 86         self.sendDate = ''
 87 
 88         if(self.recvDate == 'Python is not hard'):
 89             #回發的數據信息
 90             self.sendDate = "life is short,please use python"
 91 
 92         #客戶端向服務器回覆
 93         self.clientSoc.sendto(self.sendDate,self. sendAddr)
 94 
 95         #關閉套接字
 96         self.clientSoc.close()
 97 
 98 
 99 #main函數
100 def main():
101     #變量接受udp服務器指定端口號
102     port=int(sys.argv[1])
103 
104     #多線程建立udp服務器和udp客戶端
105     serverThread=ServerThread(port)
106     clientThread=ClientThread(port)
107 
108     #開啓線程
109     serverThread.start()
110     clientThread.start()
111 
112 
113 
114 #程序入口
115 if __name__ == '__main__':
116     main()        

模擬udp服務socket通訊

 

------------------------------

四、請說明線程、進程的區別？分別說出它們通訊的方式？

答：

　　進程：是CPU資源分配的最小單位；進程是系統進行資源分配和調度的一個獨立單位，虛擬的內存空間，大小爲4G

　　線程：是CPU調度的最小單位；線程是進程的一個實體,是CPU調度和分派的基本單位,它是比進程更小的能獨立運行的基本單位.線程本身基本上不擁有系統資源,只擁有一點在運行中必不可少的資源(如程序計數器,一組寄存器和棧),可是它可與同屬一個進程的其餘的線程共享進程所擁有的所有資源.

　　

#程序上下文：執行一段程序代碼時，當獲得CPU的時候，相關的資源必須也已經就位，而後cpu開始執行。除了cpu之外全部的調用資源，就構成了這個程序的執行環境，及程序上下文。
#當這個程序執行完了，或者分配給他的cpu執行時間用完了，那它就要被切換出去，等待下一次cpu的資源的分配。在被切換出去的最後一步工做就是保存程序的上下文，由於這個是它下一次被分配到cpu資源執行的運行環境，必須保存。在cpu開來全部的任務都是一個一個輪流執行的，具體的輪流方法：先加載程序A的上下文-執行程序A-保存程序A的上下文，調入下一個要執行的程序B的上下文-執行程序B-保存程序B的上下文…依次執行下去
#進程和線程就是對應CPU時間段的描述。
#進程：包括上下文切換的程序執行時間總和=cpu加載上下文+cpu執行+cpu保存上下文（及cpu資源分配的最小單位）
#線程：因爲進程的顆粒度太大，每次都要有上下文的調入、保存、調出。若是咱們把進程比喻爲一個在電腦上運行的軟件，那麼一個軟件的執行不多是一條邏輯執行的，一定有多個分支和多個程序段，就比如要實現程序A，實際上分紅a、b、c等多個塊組合而成。那麼這裏具體的執行就可能變成:程序A獲得CPU--CPU加載程序A的上下文開始執行--程序A的a小段，而後執行程序A的b小段，而後執行程序A的c小段--最後CPU保存A的上下文
這裏的a、b、c就是線程，也就是說線程是共享進程的上下文環境，更爲細小的cpu時間段（及調度cpu的最小單位）

補充說明

　　區別細節：

　　　　一、調度：線程做爲調度和分配的基本單位，進程做爲擁有資源的基本單位

　　　　二、併發性：不只進程之間能夠併發執行，同一個進程的多個線程之間也可併發執行

　　　　三、擁有資源：進程是擁有資源的一個獨立單位，線程不擁有系統資源，但能夠訪問隸屬於進程的資源.

　　　　四、系統開銷：在建立或撤消進程時，因爲系統都要爲之分配和回收資源，致使系統的開銷明顯大於建立或撤消線程時的開銷 

　　進程和線程的關係：

　　　　一、一個線程只能屬於一個進程，而一個進程能夠有多個線程，但至少有一個線程。

　　　　二、資源分配給進程，同一進程的全部線程共享該進程的全部資源。

　　　　三、處理機分給線程，即真正在處理機上運行的是線程。

　　　　4　、線程在執行過程當中，須要協做同步。不一樣進程的線程間要利用消息通訊的辦法實現同步。

線程是指進程內的一個執行單元,也是進程內的可調度實體.

　　

進程通訊：
進程間的通訊方式：
    1.管道（pipe）及有名管道（named pipe）：
        管道可用於具備親緣關係的父子進程間的通訊，有名管道除了具備管道所具備的功能外，它還容許無親緣關係進程間的通訊。
    2.信號（signal）：
        信號是在軟件層次上對中斷機制的一種模擬，它是比較複雜的通訊方式，用於通知進程有某事件發生，一個進程收到一個信號與處理器收到一箇中斷請求效果上能夠說是一致的。
    3.消息隊列（message queue）：
        消息隊列是消息的連接表，它克服了上兩種通訊方式中信號量有限的缺點，具備寫權限得進程能夠按照必定得規則向消息隊列中添加新信息；對消息隊列有讀權限得進程則能夠從消息隊列中讀取信息。
    4.共享內存（shared memory）：
        能夠說這是最有用的進程間通訊方式。它使得多個進程能夠訪問同一塊內存空間，不一樣進程能夠及時看到對方進程中對共享內存中數據得更新。這種方式須要依靠某種同步操做，如互斥鎖和信號量等。
    5.信號量（semaphore）：
        主要做爲進程之間及同一種進程的不一樣線程之間得同步和互斥手段。
    6.套接字（socket）；
        這是一種更爲通常得進程間通訊機制，它可用於網絡中不一樣機器之間的進程間通訊，應用很是普遍。

線程：鎖機制、條件變量、隊列
    

應用場景

 

------------------------------

五、請說出長鏈接、短鏈接的區別？以及應用場景？

答：　　

　　TCP協議：三次握手—數據傳輸—四次揮手。

　　長鏈接：連接—傳輸數據—保持鏈接—傳輸數據--…--直到一方關閉鏈接，client向server發起鏈接，server接受client鏈接，雙方創建鏈接。Client與server完成一次讀寫以後，它們之間的鏈接並不會主動關閉，後續的讀寫操做會繼續使用這個鏈接。

　　短連接：連接—傳輸數據—關閉鏈接，client向server發起鏈接請求，server接到請求，而後雙方創建鏈接。client向server發送消息，server迴應client，而後一次讀寫就完成了，這時候雙方任何一個均可以發起close操做，不過通常都是client先發起close操做

 

應用場景：

　　1.長鏈接多用於操做頻繁，點對點的通信，並且鏈接數不能太多狀況，。每一個TCP鏈接都須要三步握手，這須要時間，若是每一個操做都是先鏈接，再操做的話那麼處理速度會下降不少，因此每一個操做完後都不斷開，次處理時直接發送數據包就OK了，不用創建TCP鏈接。例如：數據庫的鏈接用長鏈接， 若是用短鏈接頻繁的通訊會形成socket錯誤，並且頻繁的socket 建立也是對資源的浪費。 

　　2. 像WEB網站的http服務通常都用短連接，由於長鏈接對於服務端來講會耗費必定的資源，而像WEB網站這麼頻繁的成千上萬甚至上億客戶端的鏈接用短鏈接會更省一些資源，若是用長鏈接，並且同時有成千上萬的用戶，若是每一個用戶都佔用一個鏈接的話，那可想而知吧。因此併發量大，但每一個用戶無需頻繁操做狀況下需用短連好。

 

------------------------------

6. Mysql的經常使用的引擎用哪些？Innodb和MYSAM的區別？

答：

　　MyISAM:這個是默認類型,它是基於傳統的ISAM類型,ISAM是Indexed Sequential Access Method (有索引的順序訪問方法) 的縮寫,它是存儲記錄和文件的標準方法.與其餘存儲引擎比較,MyISAM具備檢查和修復表格的大多數工具. MyISAM表格能夠被壓縮,並且它們支持全文搜索.它們不是事務安全的,並且也不支持外鍵。若是事物回滾將形成不徹底回滾，不具備原子性。若是執行大量的SELECT，MyISAM是更好的選擇 　　

　　MEMORY：在功能等同於MyISAM，但因爲數據存儲在內存（不是磁盤）中，速度很快（特別適用於臨時表）

　　InnoDB:這種類型是事務安全的.它與BDB類型具備相同的特性,它們還支持外鍵.InnoDB表格速度很快.具備比BDB還豐富的特性,所以若是須要一個事務安全的存儲引擎,建議使用它.若是你的數據執行大量的INSERT或UPDATE,出於性能方面的考慮，應該使用InnoDB表,

 

------------------------------

7. http協議經常使用的請求方式有幾種？常見的狀態碼有哪些，各表示什麼含義？

答：

　　GET： 請求指定的頁面信息，並返回實體主體。

　　HEAD： 只請求頁面的首部。

　　POST： 請求服務器接受所指定的文檔做爲對所標識的URI的新的從屬實體。

　　PUT： 從客戶端向服務器傳送的數據取代指定的文檔的內容。

　　DELETE： 請求服務器刪除指定的頁面。

　　

 1 100   （繼續） 請求者應當繼續提出請求。 服務器返回此代碼表示已收到請求的第一部分，正在等待其他部分。  
 2 101   （切換協議） 請求者已要求服務器切換協議，服務器已確認並準備切換。
 3 
 4 2xx （成功） 
 5 表示成功處理了請求的狀態代碼。
 6 
 7 代碼   說明 
 8 200   （成功）  服務器已成功處理了請求。 一般，這表示服務器提供了請求的網頁。 
 9 201   （已建立）  請求成功而且服務器建立了新的資源。 
10 202   （已接受）  服務器已接受請求，但還沒有處理。 
11 203   （非受權信息）  服務器已成功處理了請求，但返回的信息可能來自另外一來源。 
12 204   （無內容）  服務器成功處理了請求，但沒有返回任何內容。 
13 205   （重置內容） 服務器成功處理了請求，但沒有返回任何內容。 
14 206   （部份內容）  服務器成功處理了部分 GET 請求。
15 
16 3xx （重定向） 
17 表示要完成請求，須要進一步操做。 一般，這些狀態代碼用來重定向。
18 
19 代碼   說明 
20 300   （多種選擇）  針對請求，服務器可執行多種操做。 服務器可根據請求者 (user agent) 選擇一項操做，或提供操做列表供請求者選擇。 
21 301   （永久移動）  請求的網頁已永久移動到新位置。 服務器返回此響應（對 GET 或 HEAD 請求的響應）時，會自動將請求者轉到新位置。 
22 302   （臨時移動）  服務器目前從不一樣位置的網頁響應請求，但請求者應繼續使用原有位置來進行之後的請求。 
23 303   （查看其餘位置） 請求者應當對不一樣的位置使用單獨的 GET 請求來檢索響應時，服務器返回此代碼。 
24 304   （未修改） 自從上次請求後，請求的網頁未修改過。 服務器返回此響應時，不會返回網頁內容。 
25 305   （使用代理） 請求者只能使用代理訪問請求的網頁。 若是服務器返回此響應，還表示請求者應使用代理。 
26 307   （臨時重定向）  服務器目前從不一樣位置的網頁響應請求，但請求者應繼續使用原有位置來進行之後的請求。
27 
28 4xx（請求錯誤） 
29 這些狀態代碼表示請求可能出錯，妨礙了服務器的處理。
30 
31 代碼   說明 
32 400   （錯誤請求） 服務器不理解請求的語法。 
33 401   （未受權） 請求要求身份驗證。 對於須要登陸的網頁，服務器可能返回此響應。 
34 403   （禁止） 服務器拒絕請求。 
35 404   （未找到） 服務器找不到請求的網頁。 
36 405   （方法禁用） 禁用請求中指定的方法。 
37 406   （不接受） 沒法使用請求的內容特性響應請求的網頁。 
38 407   （須要代理受權） 此狀態代碼與 401（未受權）相似，但指定請求者應當受權使用代理。 
39 408   （請求超時）  服務器等候請求時發生超時。 
40 409   （衝突）  服務器在完成請求時發生衝突。 服務器必須在響應中包含有關衝突的信息。 
41 410   （已刪除）  若是請求的資源已永久刪除，服務器就會返回此響應。 
42 411   （須要有效長度） 服務器不接受不含有效內容長度標頭字段的請求。 
43 412   （未知足前提條件） 服務器未知足請求者在請求中設置的其中一個前提條件。 
44 413   （請求實體過大） 服務器沒法處理請求，由於請求實體過大，超出服務器的處理能力。 
45 414   （請求的 URI 過長） 請求的 URI（一般爲網址）過長，服務器沒法處理。 
46 415   （不支持的媒體類型） 請求的格式不受請求頁面的支持。 
47 416   （請求範圍不符合要求） 若是頁面沒法提供請求的範圍，則服務器會返回此狀態代碼。 
48 417   （未知足指望值） 服務器未知足」指望」請求標頭字段的要求。
49 
50 5xx（服務器錯誤） 
51 這些狀態代碼表示服務器在嘗試處理請求時發生內部錯誤。 這些錯誤多是服務器自己的錯誤，而不是請求出錯。
52 
53 代碼   說明 
54 500   （服務器內部錯誤）  服務器遇到錯誤，沒法完成請求。 
55 501   （還沒有實施） 服務器不具有完成請求的功能。 例如，服務器沒法識別請求方法時可能會返回此代碼。 
56 502   （錯誤網關） 服務器做爲網關或代理，從上游服務器收到無效響應。 
57 503   （服務不可用） 服務器目前沒法使用（因爲超載或停機維護）。 一般，這只是暫時狀態。 
58 504   （網關超時）  服務器做爲網關或代理，可是沒有及時從上游服務器收到請求。 
59 505   （HTTP 版本不受支持） 服務器不支持請求中所用的 HTTP 協議版本。

常見狀態碼

 

------------------------------

8．CSS中display的值，並說出他們的做用？還有position的值的區別？

display屬性:

　　none    此元素不會被顯示。

　　block   此元素將顯示爲塊級元素，此元素先後會帶有換行符。

　　inline  默認。此元素會被顯示爲內聯元素，元素先後沒有換行符。

　　inline-block    行內塊元素。（CSS2.1 新增的值）

　　list-item   此元素會做爲列表顯示。

　　run-in  此元素會根據上下文做爲塊級元素或內聯元素顯示。

　　compact CSS 中有值 compact，不過因爲缺少普遍支持，已經從 CSS2.1 中刪除。

　　marker  CSS 中有值 marker，不過因爲缺少普遍支持，已經從 CSS2.1 中刪除。

　　table   此元素會做爲塊級表格來顯示（相似 <table>），表格先後帶有換行符。

　　inline-table    此元素會做爲內聯表格來顯示（相似 <table>），表格先後沒有換行符。

　　table-row-group 此元素會做爲一個或多個行的分組來顯示（相似 <tbody>）。

　　table-header-group  此元素會做爲一個或多個行的分組來顯示（相似 <thead>）。

　　table-footer-group  此元素會做爲一個或多個行的分組來顯示（相似 <tfoot>）。

　　table-row   此元素會做爲一個表格行顯示（相似 <tr>）。

　　table-column-group  此元素會做爲一個或多個列的分組來顯示（相似 <colgroup>）。

　　table-column    此元素會做爲一個單元格列顯示（相似 <col>）

　　table-cell  此元素會做爲一個表格單元格顯示（相似 <td> 和 <th>）

　　table-caption   此元素會做爲一個表格標題顯示（相似 <caption>）

　　inherit  規定應該從父元素繼承 display 屬性的值。

position 屬性值的含義：

　　一、static：元素框正常生成。塊級元素生成一個矩形框，做爲文檔流的一部分，行內元素則會建立一個或多個行框，置於其父元素中。

　　二、relative：元素框偏移某個距離。元素仍保持其未定位前的形狀，它本來所佔的空間仍保留。

　　三、absolute：元素框從文檔流徹底刪除，並相對於其包含塊定位。包含塊多是文檔中的另外一個元素或者是初始包含塊。元素原先在正常文檔流中所佔的空間會關閉，就好像元素原來不存在同樣。元素定位後生成一個塊級框，而不論原來它在正常流中生成何種類型的框。

　　四、fixed：元素框的表現相似於將 position 設置爲 absolute，不過其包含塊是視窗自己。　

 

------------------------------

9. 請寫出輸出結果：

class Parent(object):

    x = 1

class Child1(Parent):

    pass

class Child2(Parent):

    pass

print Parent.x, Child1.x, Child2.x

Child1.x = 2

print Parent.x, Child1.x, Child2.x

Parent.x = 3

print Parent.x, Child1.x, Child2.x

 

答：

運行結果：

1 1 1

1 2 1

3 2 3

 

------------------------------

10.請用基於隊列的方式寫出生產者消費者模型？

 1 #coding=utf-8
 2 #引入對應的包
 3 import threading
 4 
 5 from Queue import Queue
 6 
 7 from time import sleep
 8 
 9 #線程生產者
10 class Producer(threading.Thread):
11     #重寫run方法
12     def run(self):
13         global g_queue
14 
15         while True:
16             if con.acquire():
17                 #判斷是否中止生產,獲取隊列中的數量
18                 if g_queue.qsize() < 20:
19 
20                     #每次生產5個產品
21                     for i in range(5):
22                         g_queue.put("產品")
23 
24                     print("生產出5個產品，產品總量：%d"%g_queue.qsize())
25                 else:
26                     con.wait()
27                     print("中止生產")
28 
29                 con.release()
30             sleep(1)
31 
32 
33 #線程消費者
34 class Consumer(threading.Thread):
35     #重寫run方法
36     def run(self):
37         global g_queue
38 
39         while True:
40             if con.acquire():
41                 #判斷是否中止消費
42                 if g_queue.qsize()>5:
43                     #進行消費
44                     for i in range(3):
45                         g_queue.get()
46 
47                     print("消費3 總數：%d"%g_queue.qsize())
48 
49                     if g_queue.qsize()<20:
50                         con.notify()
51                 con.release()
52             sleep(1)
53 
54 #全局變量
55 con=threading.Condition()
56 #g_num=600
57 #建立一個隊列
58 g_queue=Queue()
59 
60 
61 #main函數
62 def main():
63     pro=Producer()
64     pro.start()
65     con=Consumer()
66     con.start()
67 
68 #程序入口
69 if __name__ == '__main__':
70     main()

隊列線程實現生產者消費者