知識點總結1

PEP8 規范 ? 每一級縮進使用4個空格。 空格是首選的縮進方式。 行限制的最大字符數為79 使用下劃線分隔的小寫字母 類名一般使用首字母大寫的約定 異常名后面加上“Error”后綴 全局變量前加下劃線的方式（表明這些全局變量是模塊內非公有）。 函數名應該小寫 None這樣的單例對象進行比較的時候應該始終用 is 或者 is not 使用with 表達式來確保這個資源使用完后被清理干凈。用try/finally也可以 10 1 每一級縮進使用4個空格。 2 空格是首選的縮進方式。 3 行限制的最大字符數為79 4 使用下劃線分隔的小寫字母 5 類名一般使用首字母大寫的約定 6 異常名后面加上“Error”后綴 7 全局變量前加下劃線的方式（表明這些全局變量是模塊內非公有）。 8 函數名應該小寫 9 None這樣的單例對象進行比較的時候應該始終用 is 或者 is not 10 使用with 表達式來確保這個資源使用完后被清理干凈。用try/finally也可以

python遞歸的最大層數
998層 獲取：sys.getrecursionlimit() 設置：sys.setrecursionlimit(3000) 3 1 ?998層 2 ?獲取：sys.getrecursionlimit() 3 ?設置：sys.setrecursionlimit(3000)

ascil,unicode,utf-8,gbk的區別
ASCII 碼一共規定了128個字符的編碼 Unicode 當然是一個很大的集合，現在的規模可以容納100多萬個符號 UTF-8 就是在互聯網上使用最廣的一種 Unicode 的實現方式。其他實現方式還包括 UTF-16（字符用兩個字節或四個字節表示）和 UTF-32（字符用四個字節表示），不過在互聯網上基本不用。重復一遍，這里的關系是，UTF-8 是 Unicode 的實現方式之一。 GBK是在國家標準GB2312基礎上擴容后兼容GB2312的標準（好像還不是國家標準）。GBK編碼專門用來解決中文編碼的，是雙字節的。不論中英文都是雙字節的 4 1 ASCII 碼一共規定了128個字符的編碼 2 Unicode 當然是一個很大的集合，現在的規模可以容納100多萬個符號 3 UTF-8 就是在互聯網上使用最廣的一種 Unicode 的實現方式。其他實現方式還包括 UTF-16（字符用兩個字節或四個字節表示）和 UTF-32（字符用四個字節表示），不過在互聯網上基本不用。重復一遍，這里的關系是，UTF-8 是 Unicode 的實現方式之一。 4 GBK是在國家標準GB2312基礎上擴容后兼容GB2312的標準（好像還不是國家標準）。GBK編碼專門用來解決中文編碼的，是雙字節的。不論中英文都是雙字節的

and or
v1 = 1 or 3 # v1=1 v1 = 1 and 3 # v1=3 v1 = 0 and 2 and 1 # v1 = 0 v1 = 0 and 2 or 1 # v1 = 1 v1 = 0 and 2 or 1 or 4 # v1 =1 v1 = 0 or False and 1 # v1 = False 6 1 v1 = 1 or 3 ? # v1=1 2 v1 = 1 and 3 ?# v1=3 3 v1 = 0 and 2 and 1 ? ? # v1 = 0 4 v1 = 0 and 2 or 1 ? ? # v1 = 1 5 v1 = 0 and 2 or 1 or 4 ? ?# v1 =1 6 v1 = 0 or False and 1 ? ?# v1 = False

三元運算符
為真時的結果 if 判斷條件 else 為假時的結果（注意，沒有冒號） a = 4 r = a if a>2 else 0 4 1 為真時的結果 if 判斷條件 else 為假時的結果（注意，沒有冒號） 2 3 a = 4 4 r = a if a>2 else 0

a ?= 1,b=2 交換值
a,b = b,a 1 1 a,b = b,a

xrange 和 range的區別
python2： range返回真實的列表，有時會很長，占用空間 xrange返回一個列表生成器，每次遍歷內部會調用.next()函數拿到下一個元素 python3： range就是python2中的xrange 5 1 python2： 2 range返回真實的列表，有時會很長，占用空間 3 xrange返回一個列表生成器，每次遍歷內部會調用.next()函數拿到下一個元素 4 python3： 5 range就是python2中的xrange

文件操作?xreadlines,readlines
<open file './test.txt', mode 'r' at 0x7f024288fe40> # xreadlines 返回一個生成器 ['1111111\n', '222222\n', '333333\n', '4444444\n', '5555555\n', '6666666\n', '7777777\n', '88888888\n'] # readlines 返回一個列表 2 1 <open file './test.txt', mode 'r' at 0x7f024288fe40> ? ? ? ? ? ? ? # xreadlines ? 返回一個生成器 2 ['1111111\n', '222222\n', '333333\n', '4444444\n', '5555555\n', '6666666\n', '7777777\n', '88888888\n'] ? ? ? # readlines ? 返回一個列表

布爾值為False的常見值
int : 0 list:[] tuple:() dict:{} None 1 1 int : 0 ? ? ?list:[] ? ?tuple:() ? dict:{} ? ?None

字符串、列表、元組、字典每個常用的5個方法 string: string.count(str, beg=0, end=len(string)) 返回 str 在 string 里面出現的次數，如果 beg 或者 end 指定則返回指定范圍內 str 出現的次數 string.endswith(obj, beg=0, end=len(string)) 檢查字符串是否以 obj 結束，如果beg 或者 end 指定則檢查指定的范圍內是否以 obj 結束，如果是，返回 True,否則返回 False. string.find(str, beg=0, end=len(string)) 檢測 str 是否包含在 string 中，如果 beg 和 end 指定范圍，則檢查是否包含在指定范圍內，如果是返回開始的索引值，否則返回-1 string.format() 格式化字符串 string.index(str, beg=0, end=len(string)) 跟find()方法一樣，只不過如果str不在 string中會報一個異常. string.join(seq) 以 string 作為分隔符，將 seq 中所有的元素(的字符串表示)合并為一個新的字符串 string.replace(str1, str2, num=string.count(str1)) 把 string 中的 str1 替換成 str2,如果 num 指定，則替換不超過 num 次. string.split(str="", num=string.count(str)) 以 str 為分隔符切片 string，如果 num 有指定值，則僅分隔 num+ 個子字符串 string.strip([obj]) 在 string 上執行 lstrip()和 rstrip() list: list.append(obj) 在列表末尾添加新的對象 list.count(obj) 統計某個元素在列表中出現的次數 list.extend(seq) 在列表末尾一次性追加另一個序列中的多個值（用新列表擴展原來的列表） list.index(obj) 從列表中找出某個值第一個匹配項的索引位置 list.insert(index, obj) 將對象插入列表 list.pop([index=-1]) 移除列表中的一個元素（默認最后一個元素），并且返回該元素的值 list.remove(obj) 移除列表中某個值的第一個匹配項 list.reverse() 反向列表中元素 tuple: min(tuple) 返回元組中元素最小值。 tuple(seq) 將列表轉換為元組。 len(tuple) 計算元組元素個數。 cmp(tuple1, tuple2) 比較兩個元組元素。 dict: dict.clear() 刪除字典內所有元素 dict.copy() 返回一個字典的淺復制 dict.fromkeys(seq[, val]) 創建一個新字典，以序列 seq 中元素做字典的鍵，val 為字典所有鍵對應的初始值 dict.get(key, default=None) 返回指定鍵的值，如果值不在字典中返回default值 dict.has_key(key) 如果鍵在字典dict里返回true，否則返回false dict.items() 以列表返回可遍歷的(鍵, 值) 元組數組 dict.keys() 以列表返回一個字典所有的鍵 dict.values() 以列表返回字典中的所有值 dict.update(dict2)把字典dict2的鍵/值對更新到dict里 34 1 string: 2 string.count(str, beg=0, end=len(string)) 返回 str 在 string 里面出現的次數，如果 beg 或者 end 指定則返回指定范圍內 str 出現的次數 3 ? ?string.endswith(obj, beg=0, end=len(string)) 檢查字符串是否以 obj 結束，如果beg 或者 end 指定則檢查指定的范圍內是否以 obj 結束，如果是，返回 True,否則返回 False. 4 ? ?string.find(str, beg=0, end=len(string)) 檢測 str 是否包含在 string 中，如果 beg 和 end 指定范圍，則檢查是否包含在指定范圍內，如果是返回開始的索引值，否則返回-1 5 ? ?string.format() 格式化字符串 6 ? ?string.index(str, beg=0, end=len(string)) ?跟find()方法一樣，只不過如果str不在 string中會報一個異常. 7 ? ?string.join(seq) ?以 string 作為分隔符，將 seq 中所有的元素(的字符串表示)合并為一個新的字符串 8 ? ?string.replace(str1, str2, ?num=string.count(str1)) 把 string 中的 str1 替換成 str2,如果 num 指定，則替換不超過 num 次. 9 ? ?string.split(str="", num=string.count(str)) 以 str 為分隔符切片 string，如果 num 有指定值，則僅分隔 num+ 個子字符串 10 string.strip([obj]) 在 string 上執行 lstrip()和 rstrip() 11 list: 12 ? ?list.append(obj) ?在列表末尾添加新的對象 13 ? ?list.count(obj) 統計某個元素在列表中出現的次數 14 ? ?list.extend(seq) 在列表末尾一次性追加另一個序列中的多個值（用新列表擴展原來的列表） 15 ? ?list.index(obj) 從列表中找出某個值第一個匹配項的索引位置 16 ? ?list.insert(index, obj) 將對象插入列表 17 ? ?list.pop([index=-1]) 移除列表中的一個元素（默認最后一個元素），并且返回該元素的值 18 ? ?list.remove(obj) 移除列表中某個值的第一個匹配項 19 ? ?list.reverse() 反向列表中元素 20 tuple: 21 ? ?min(tuple) 返回元組中元素最小值。 22 ? ?tuple(seq) 將列表轉換為元組。 23 ? ?len(tuple) 計算元組元素個數。 24 cmp(tuple1, tuple2) 比較兩個元組元素。 25 dict: 26 dict.clear() 刪除字典內所有元素 27 ? ?dict.copy() 返回一個字典的淺復制 28 ? ?dict.fromkeys(seq[, val]) 創建一個新字典，以序列 seq 中元素做字典的鍵，val 為字典所有鍵對應的初始值 29 ? ?dict.get(key, default=None) ?返回指定鍵的值，如果值不在字典中返回default值 30 ? ?dict.has_key(key) ?如果鍵在字典dict里返回true，否則返回false 31 ? ?dict.items() 以列表返回可遍歷的(鍵, 值) 元組數組 32 ? ?dict.keys() 以列表返回一個字典所有的鍵 33 ? ?dict.values() 以列表返回字典中的所有值 34 ? ?dict.update(dict2)把字典dict2的鍵/值對更新到dict里

lambda表達式格式以及應用場景 lambda 參數(可以沒有):返回值 應用場景： 不需要被重復調用的函數 3 1 lambda 參數(可以沒有):返回值 2 應用場景： 3 不需要被重復調用的函數

*arg和**kwarg作用 *arg會把多出來的位置參數轉化為tuple **kwarg會把關鍵字參數轉化為dict def exmaple2(required_arg, *arg, **kwarg): if arg: print "arg: ", arg if kwarg: print "kwarg: ", kwarg exmaple2("Hi", 1, 2, 3, keyword1 = "bar", keyword2 = "foo") >> arg: (1, 2, 3) >> kwarg: {'keyword2': 'foo', 'keyword1': 'bar'} 13 1 *arg會把多出來的位置參數轉化為tuple 2 **kwarg會把關鍵字參數轉化為dict 3 def exmaple2(required_arg, *arg, **kwarg): 4 ? ?if arg: 5 ? ? ? ?print "arg: ", arg 6 7 ? ?if kwarg: 8 ? ? ? ?print "kwarg: ", kwarg 9 10 exmaple2("Hi", 1, 2, 3, keyword1 = "bar", keyword2 = "foo") 11 12 >> arg: (1, 2, 3) 13 >> kwarg: {'keyword2': 'foo', 'keyword1': 'bar'}

is和==的區別
is 判斷id是否一樣 == 判斷值是否相等 2 1 is 判斷id是否一樣 2 == 判斷值是否相等

深淺拷貝以及應用場景
淺拷貝指僅僅拷貝數據集合的第一層數據，深拷貝指拷貝數據集合的所有層。所以對于只有一層的數據集合來說深淺拷貝的意義是一樣的，比如字符串，數字，還有僅僅一層的字典、列表、元祖等. 直接賦值: 其實就是對象的引用(別名),賦值的兩邊指向的是同一個對象 淺拷貝(copy): 拷貝父對象,不會拷貝對象的內部的子對象 深拷貝(deepcopy):拷貝父對象,同時會開辟空間,逐層拷貝內部子對象 5 1 淺拷貝指僅僅拷貝數據集合的第一層數據，深拷貝指拷貝數據集合的所有層。所以對于只有一層的數據集合來說深淺拷貝的意義是一樣的，比如字符串，數字，還有僅僅一層的字典、列表、元祖等. 2 3 直接賦值: 其實就是對象的引用(別名),賦值的兩邊指向的是同一個對象 4 淺拷貝(copy): 拷貝父對象,不會拷貝對象的內部的子對象 5 深拷貝(deepcopy):拷貝父對象,同時會開辟空間,逐層拷貝內部子對象

Python垃圾回收機制
Python垃圾回收主要以引用計數為主，分代回收為輔。引用計數法的原理是每個對象維護一個ob_ref，用來記錄當前對象被引用的次數，也就是來追蹤到底有多少引用指向了這個對象，當發生以下四種情況的時候，該對象的引用計數器+1 對象被創建 ?a=14 對象被引用? b=a 對象被作為參數,傳到函數中 ? func(a) 對象作為一個元素，存儲在容器中 ? List={a,”a”,”b”,2} 與上述情況相對應，當發生以下四種情況時，該對象的引用計數器-1 當該對象的別名被顯式銷毀時? del a 當該對象的引別名被賦予新的對象， ? a=26 一個對象離開它的作用域，例如 func函數執行完畢時，函數里面的局部變量的引用計數器就會減一（但是全局變量不會） 將該元素從容器中刪除時，或者容器被銷毀時。 當指向該對象的內存的引用計數器為0的時候，該內存將會被Python虛擬機銷毀 參考：http://python.jobbole.com/87843/ 14 1 Python垃圾回收主要以引用計數為主，分代回收為輔。引用計數法的原理是每個對象維護一個ob_ref，用來記錄當前對象被引用的次數，也就是來追蹤到底有多少引用指向了這個對象，當發生以下四種情況的時候，該對象的引用計數器+1 2 對象被創建 ?a=14 3 對象被引用? b=a 4 對象被作為參數,傳到函數中 ? func(a) 5 對象作為一個元素，存儲在容器中 ? List={a,”a”,”b”,2} 6 與上述情況相對應，當發生以下四種情況時，該對象的引用計數器-1 7 8 當該對象的別名被顯式銷毀時? del a 9 當該對象的引別名被賦予新的對象， ? a=26 10 一個對象離開它的作用域，例如 func函數執行完畢時，函數里面的局部變量的引用計數器就會減一（但是全局變量不會） 11 將該元素從容器中刪除時，或者容器被銷毀時。 12 當指向該對象的內存的引用計數器為0的時候，該內存將會被Python虛擬機銷毀 13 14 參考：http://python.jobbole.com/87843/

Python的可變類型和不可變類型 可變類型（mutable）：列表，字典 變量對應的值中的數據可以被修改，但內存地址保持不變 不可變類型（unmutable）：數字，字符串，元組，字符串，int 變量對應的值中的數據是不能被修改，如果修改就會生成一個新的值從而分配新的內存空間 4 1 可變類型（mutable）：列表，字典 2 變量對應的值中的數據可以被修改，但內存地址保持不變 3 不可變類型（unmutable）：數字，字符串，元組，字符串，int 4 變量對應的值中的數據是不能被修改，如果修改就會生成一個新的值從而分配新的內存空間

求結果：
? ?v = dict.fromkeys(['k1','k2'],[]) ?
? ?v[‘k1’].append(666)
? ?print(v)
? ?v[‘k1’] = 777
? ?print(v) {'k1': [666], 'k2': [666]} {'k1': 777, 'k2': [666]} 解釋：初始k1,k2的value都是[]，兩個[]實際指向同一個內存地址,[]是可變類型，一個修改另一個也會隨之變化，所以k1,k2的value都變成了[666]， 而v['k1'] = 777,將k1 vlaue的地址指向了777,而k2的內存地址指向不變 6 1 {'k1': [666], 'k2': [666]} 2 {'k1': 777, 'k2': [666]} 3 4 解釋：初始k1,k2的value都是[]，兩個[]實際指向同一個內存地址,[]是可變類型，一個修改另一個也會隨之變化，所以k1,k2的value都變成了[666]， 5 而v['k1'] = 777,將k1 vlaue的地址指向了777,而k2的內存地址指向不變 6

filter、map、reduce的作用
filter用法:返回執行結果為TRUE的入參（入參是列表字符元組） print filter(lambda x:x*x-4,range(10)) #結果：[0, 1, 3, 4, 5, 6, 7, 8, 9] map的用法：對列表入參依次執行函數。入參為列表，有多少個列表，就應該有多少個入參。 print map(lambda x:x*x-4,range(10)) #結果：[-4, -3, 0, 5, 12, 21, 32, 45, 60, 77] reduce用法：先把sequence中第一個值和第二個值當參數傳給function，再把function的返回值和第三個值當參數傳給fuction,最終返回一個結果值 print reduce(lambda x,y:x*y-4,range(4)) # 結果：-40 6 1 filter用法:返回執行結果為TRUE的入參（入參是列表字符元組） 2 print filter(lambda x:x*x-4,range(10)) ? #結果：[0, 1, 3, 4, 5, 6, 7, 8, 9] 3 map的用法：對列表入參依次執行函數。入參為列表，有多少個列表，就應該有多少個入參。 4 print map(lambda x:x*x-4,range(10)) #結果：[-4, -3, 0, 5, 12, 21, 32, 45, 60, 77] 5 reduce用法：先把sequence中第一個值和第二個值當參數傳給function，再把function的返回值和第三個值當參數傳給fuction,最終返回一個結果值 6 print reduce(lambda x,y:x*y-4,range(4)) ?# 結果：-40

一行代碼實現9*9乘法表
print('\n'.join(['\t'.join(["%2s*%2s=%2s"%(j,i,i*j) for j in range(1,i+1)]) for i in range(1,10)])) 1 1 print('\n'.join(['\t'.join(["%2s*%2s=%2s"%(j,i,i*j) for j in range(1,i+1)]) for i in range(1,10)]))

常用模塊 time,os,sys,datetime,hashlib,logging,json,subprocess,random 1 1 time,os,sys,datetime,hashlib,logging,json,subprocess,random

re的match和search區別
match()函數只檢測RE是不是在string的開始位置匹配，search()會掃描整個string查找匹配； 1 1 match()函數只檢測RE是不是在string的開始位置匹配，search()會掃描整個string查找匹配；

什么是正則的貪婪匹配
貪婪匹配：正則表達式一般趨向于最大長度匹配。 非貪婪匹配：匹配到結果就好。 默認是貪婪模式。在量詞后面直接加一個問號？就是非貪婪模式 3 1 貪婪匹配：正則表達式一般趨向于最大長度匹配。 2 非貪婪匹配：匹配到結果就好。 3 默認是貪婪模式。在量詞后面直接加一個問號？就是非貪婪模式

求結果： a. [ i % 2 for i in range(10) ] b. ( i % 2 for i in range(10) )
a:[0, 1, 0, 1, 0, 1, 0, 1, 0, 1] b:<generator object <genexpr> at 0x0000008CB5BD7BA0> # 生成器 2 1 a:[0, 1, 0, 1, 0, 1, 0, 1, 0, 1] 2 b:<generator object <genexpr> at 0x0000008CB5BD7BA0> ?# 生成器

求結果： a. 1 or 2 b. 1 and 2 c. 1 < (2==2) d. 1 < 2 == 2 a:1 b:2 c:False d:True # 注意：True表示1，Flase表示0 2 1 a:1 ? ? b:2 ? c:False ?d:True 2 # 注意：True表示1，Flase表示0

def func(a,b=[]) 這種寫法有什么坑
將可變對象作為默認參數，若多次調用時使用默認參數，默認參數會保留上次調用時的狀態！ 1 1 將可變對象作為默認參數，若多次調用時使用默認參數，默認參數會保留上次調用時的狀態！

如何實現 “1,2,3” 變成 [‘1’,’2’,’3’]?
a = '1,2,3' b= a.split(',') print(b) 3 1 a = '1,2,3' 2 b= a.split(',') 3 print(b)

如何實現[‘1’,’2’,’3’]變成[1,2,3]
a = ['1','2','3'] print([int(i) for i in a]) 2 1 a = ['1','2','3'] 2 print([int(i) for i in a])

a = [1,2,3] 和 b = [(1),(2),(3) ] 以及 c = [(1,),(2,),(3,) ] 的區別？
a,b 均為整型列表， c為元組列表。 1 1 a,b 均為整型列表， c為元組列表。

如何用一行代碼生成[1,4,9,16,25,36,49,64,81,100]?
list1 = [i ** 2 for i in range(1, 11)] print(list1) 2 1 list1 = [i ** 2 for i in range(1, 11)] 2 print(list1)

一行代碼實現刪除列表中重復的值?
list2 = [1,2,3,4,4,5,5,6,6,7] print(list(set(list2))) 2 1 list2 = [1,2,3,4,4,5,5,6,6,7] 2 print(list(set(list2)))

如何在函數中設置一個全局變量
def f(): global x x = 1 f() print(x) 6 1 def f(): 2 ? ?global x 3 ? ?x = 1 4 5 f() 6 print(x)

logging模塊的作用？以及應用場景
日志存儲，異常記錄等 1 1 日志存儲，異常記錄等

請用代碼簡答實現stack
棧：先進后出，后進先出 用列表來實現： class MyStack(): def __init__(self): self.stack = [] def push(self, item): return self.stack.append(item) def pop(self): return self.stack.pop() def is_empty(self): return False if self.stack else True def size(self): return len(self.stack) def clear(self): self.stack.clear() 22 1 棧：先進后出，后進先出 2 用列表來實現： 3 4 class MyStack(): 5 ? ?def __init__(self): 6 ? ? ? ?self.stack = [] 7 8 ? ?def push(self, item): 9 ? ? ? ?return self.stack.append(item) 10 11 ? ?def pop(self): 12 ? ? ? ?return self.stack.pop() 13 14 ? ?def is_empty(self): 15 ? ? ? ?return False if self.stack else True 16 17 ? ?def size(self): 18 ? ? ? ?return len(self.stack) 19 20 ? ?def clear(self): 21 ? ? ? ?self.stack.clear() 22

常用字符串格式化哪幾種
{}.format() %s %d &f 1 1 {}.format() ? %s %d &f

簡述 生成器、迭代器、可迭代對象 以及應用場景 生成器: 常規函數定義，但是，使用yield語句而不是return語句返回結果。yield語句一次返回一個結果，在每個結果中間，掛起函數的狀態，以便下次重它離開的地方繼續執行 應用：通過生成器表達器完成對文件的讀完跟操作 迭代器：可以被next()函數調用并不斷返回下一個值的對象稱為迭代器：Iterator (x for x in range(10)) 可迭代對象： list、dict、str 把list、dict、str等可迭代對象變成迭代器可以使用iter()函數： isinstance(iter([]), Iterator) True isinstance(iter('abc'), Iterator) True 11 1 生成器: 常規函數定義，但是，使用yield語句而不是return語句返回結果。yield語句一次返回一個結果，在每個結果中間，掛起函數的狀態，以便下次重它離開的地方繼續執行 2 ? ?應用：通過生成器表達器完成對文件的讀完跟操作 3 迭代器：可以被next()函數調用并不斷返回下一個值的對象稱為迭代器：Iterator 4 (x for x in range(10)) 5 可迭代對象： 6 list、dict、str 7 把list、dict、str等可迭代對象變成迭代器可以使用iter()函數： 8 isinstance(iter([]), Iterator) 9 True 10 isinstance(iter('abc'), Iterator) 11 True

用Python實現一個二分查找的函數
def BinarySearch(seq, num): if not len(seq): print('list is none') if len(seq) == 1: if seq[0] == num: print('find:{}'.format(num)) else: print('{} not exist'.format(num)) return middle = len(seq) // 2 if seq[middle - 1] == num: print("find:{}".format(num)) elif seq[middle] < num: BinarySearch(seq[middle::], num) else: BinarySearch(seq[0:middle], num) 16 1 def BinarySearch(seq, num): 2 ? ?if not len(seq): 3 ? ? ? ?print('list is none') 4 ? ?if len(seq) == 1: 5 ? ? ? ?if seq[0] == num: 6 ? ? ? ? ? ?print('find:{}'.format(num)) 7 ? ? ? ?else: 8 ? ? ? ? ? ?print('{} not exist'.format(num)) 9 ? ? ? ? ? ?return 10 ? ?middle = len(seq) // 2 11 ? ?if seq[middle - 1] == num: 12 ? ? ? ?print("find:{}".format(num)) 13 ? ?elif seq[middle] < num: 14 ? ? ? ?BinarySearch(seq[middle::], num) 15 ? ?else: 16 ? ? ? ?BinarySearch(seq[0:middle], num)

對閉包的理解
閉包是由函數及其相關的引用環境組合而成的實體(即：閉包=函數+引用環境) 閉包可以根據外部作用域的局部變量來得到不同的結果，這有點像一種類似配置功能的作用，我們可以修改外部的變量，閉包根據這個變量展現出不同的功能。比如有時我們需要對某些文件的特殊行進行分析，先要提取出這些特殊行 2 1 閉包是由函數及其相關的引用環境組合而成的實體(即：閉包=函數+引用環境) 2 閉包可以根據外部作用域的局部變量來得到不同的結果，這有點像一種類似配置功能的作用，我們可以修改外部的變量，閉包根據這個變量展現出不同的功能。比如有時我們需要對某些文件的特殊行進行分析，先要提取出這些特殊行

os和sys模塊的作用
os模塊負責程序與操作系統的交互，提供了訪問操作系統底層的接口; sys模塊負責程序與python解釋器的交互，提供了一系列的函數和變量，用于操控python的運行時環境。 2 1 os模塊負責程序與操作系統的交互，提供了訪問操作系統底層的接口; 2 sys模塊負責程序與python解釋器的交互，提供了一系列的函數和變量，用于操控python的運行時環境。

如何生成一個隨機數
random模塊 1 1 random模塊

如何使用python刪除一個文件
os.remove('path/filename') # 刪除文件 1 1 os.remove('path/filename') # 刪除文件

對面向對象的理解
面向對象編程是種具有對象概念的程序編程范型，同時也是一種程序開發的抽象方針。它可能包含數據、屬性、代碼與方法。對象則指的是類的實例。它將對象作為程序的基本單元，將程序和數據封裝其中，以提高軟件的可重用性、靈活性和可擴展性，對象里的程序可以訪問及修改對象相關聯的數據。在面向對象編程里，計算機程序會被設計成彼此相關的對象。 1 1 面向對象編程是種具有對象概念的程序編程范型，同時也是一種程序開發的抽象方針。它可能包含數據、屬性、代碼與方法。對象則指的是類的實例。它將對象作為程序的基本單元，將程序和數據封裝其中，以提高軟件的可重用性、靈活性和可擴展性，對象里的程序可以訪問及修改對象相關聯的數據。在面向對象編程里，計算機程序會被設計成彼此相關的對象。

面向對象中的繼承有什么特點
繼承更多了是為了多態，也可提升代碼的復用程度。 特點： 在繼承中基類的構造（init()方法）不會被自動調用，它需要在其派生類的構造中親自專門調用； Python總是首先查找對應類型的方法，如果它不能在派生類中找到對應的方法，它才開始到基類中逐個查找。（先在本類中查找調用的方法，找不到才去基類中找）； 4 1 繼承更多了是為了多態，也可提升代碼的復用程度。 2 特點： 3 在繼承中基類的構造（init()方法）不會被自動調用，它需要在其派生類的構造中親自專門調用； 4 Python總是首先查找對應類型的方法，如果它不能在派生類中找到對應的方法，它才開始到基類中逐個查找。（先在本類中查找調用的方法，找不到才去基類中找）；

面向對象深度優先和廣度優先是什么
當出現多重繼承并產生菱形交叉時查找屬性或方法路徑順序。 python2中多繼承是深度優先，python3找那個多繼承是廣度優先 2 1 當出現多重繼承并產生菱形交叉時查找屬性或方法路徑順序。 2 python2中多繼承是深度優先，python3找那個多繼承是廣度優先

面向對象中super的作用
super() 函數是用于調用父類(超類)的一個方法。 　　super 是用來解決多重繼承問題的，直接用類名調用父類方法在使用單繼承的時候沒問題，但是如果使用多繼承，會涉及到查找順序（MRO）、重復調用（鉆石繼承）等種種問題。 　　MRO 就是類的方法解析順序表, 其實也就是繼承父類方法時的順序表。 　　Python3.x 和 Python2.x 的一個區別是: Python 3 可以使用直接使用 super().xxx 代替 super(Class, self).xxx 4 1 super() 函數是用于調用父類(超類)的一個方法。 2 　　super 是用來解決多重繼承問題的，直接用類名調用父類方法在使用單繼承的時候沒問題，但是如果使用多繼承，會涉及到查找順序（MRO）、重復調用（鉆石繼承）等種種問題。 3 　　MRO 就是類的方法解析順序表, 其實也就是繼承父類方法時的順序表。 4 　　Python3.x 和 Python2.x 的一個區別是: Python 3 可以使用直接使用 super().xxx 代替 super(Class, self).xxx

functools中的函數?其作用是什么？
functools模塊用于高級函數：作用于或返回其他函數的函數，一般來說，任何可調用對象都可以作為這個模塊的用途來處理。 1 1 functools模塊用于高級函數：作用于或返回其他函數的函數，一般來說，任何可調用對象都可以作為這個模塊的用途來處理。

列舉面向對象中帶雙下劃線的特殊方法，如：__new__、__init__
__init__ 構造方法，當類被實例化的時候執行 __new__ 工廠函數，在類被實例前執行 __del__ 析構方法，當一個對象沒有任何引用時執行，用于銷毀對象 __call__ 允許一個類的實例像函數一樣被調用 4 1 __init__ 構造方法，當類被實例化的時候執行 2 __new__ 工廠函數，在類被實例前執行 3 __del__ 析構方法，當一個對象沒有任何引用時執行，用于銷毀對象 4 __call__ 允許一個類的實例像函數一樣被調用

如何判斷是函數還是方法
區分是否有對象來帶調用，有就是方法，沒有就是函數 1 1 區分是否有對象來帶調用，有就是方法，沒有就是函數

靜態方法和類方法區別
在使用靜態方法時，類中的self將不會再進行傳值，此時，靜態方法已經和類沒什么關系了。 用@staticmethod 聲明 類方法只能訪問類變量，不能訪問實例變量。 都能被實例和類調用 3 1 在使用靜態方法時，類中的self將不會再進行傳值，此時，靜態方法已經和類沒什么關系了。 ? 用@staticmethod 聲明 2 類方法只能訪問類變量，不能訪問實例變量。 3 都能被實例和類調用

列舉面向對象中的特殊成員以及應用場景
構造方法 1 1 構造方法

1、2、3、4、5 能組成多少個互不相同且無重復的三位數
count = 0 for i in range(1, 6): for j in range(1, 6): for k in range(1, 6): if i != j and i != j and j != k: print('{}{}{}'.format(i, j, k)) count += 1 print(count) 8 1 count = 0 2 for i in range(1, 6): 3 ? ?for j in range(1, 6): 4 ? ? ? ?for k in range(1, 6): 5 ? ? ? ? ? ?if i != j and i != j and j != k: 6 ? ? ? ? ? ? ? ?print('{}{}{}'.format(i, j, k)) 7 ? ? ? ? ? ? ? ?count += 1 8 print(count)

什么是反射？以及應用場景？
getattr() 它接收2個參數，前面的是一個對象或者模塊，后面的是一個字符串，注意了！是個字符串 例子，用戶輸入儲存在inp中，這個inp就是個字符串，getattr函數讓程序去commons這個模塊里，尋找一個叫inp的成員（是叫，不是等于），這個過程就相當于我們把一個字符串變成一個函數名的過程。然后，把獲得的結果賦值給func這個變量，實際上func就指向了commons里的某個函數。最后通過調用func函數，實現對commons里函數的調用。這完全就是一個動態訪問的過程，一切都不寫死，全部根據用戶輸入來變化。 3 1 getattr() 2 它接收2個參數，前面的是一個對象或者模塊，后面的是一個字符串，注意了！是個字符串 3 例子，用戶輸入儲存在inp中，這個inp就是個字符串，getattr函數讓程序去commons這個模塊里，尋找一個叫inp的成員（是叫，不是等于），這個過程就相當于我們把一個字符串變成一個函數名的過程。然后，把獲得的結果賦值給func這個變量，實際上func就指向了commons里的某個函數。最后通過調用func函數，實現對commons里函數的調用。這完全就是一個動態訪問的過程，一切都不寫死，全部根據用戶輸入來變化。

metaclass作用？以及應用場景
元類就是創建類對象 Django ORM 1 1 元類就是創建類對象 ? Django ORM

用盡量多的方法實現單例模式
#1. 裝飾器實現 def Singleton(cls): _instance = {} def wrapper(*args, **kwargs): if cls not in _instance: _instance[cls] = cls(*args, **kwargs) return _instance[cls] return wrapper @Singleton class A(object): def __init__(self, a): self.a = a print self.a #2. 重新__new__方法 (有坑，__init__會執行多次) import threading class B(object): lock = threading.Lock() _instance = None def __init__(self): self.b = {} def __new__(cls, *args, **kwargs): if not B._instance: with B.lock: if not B._instance: B._instance = object.__new__(cls) return B._instance #3. 元類實現 class SingletonType(type): def __init__(self, *args, **kwargs): super(SingletonType, self).__init__(*args, **kwargs) def __call__(cls, *args, **kwargs): # 這里的cls，即Foo類 print('cls', cls) obj = cls.__new__(cls, *args, **kwargs) cls.__init__(obj, *args, **kwargs) # Foo.__init__(obj) return obj metaclass = SingletonType class Foo(): # 指定創建Foo的type為SingletonType def __init__(self, name): self.name = name def __new__(cls, *args, **kwargs): return object.__new__(cls) #4.模塊實現 a.py class A(object): def __init__(self, a): self.a = a print self.a objA = A('aaa') print(id(objA)) b.py from a import objA print(id(objA)) 70 1 #1. 裝飾器實現 2 def Singleton(cls): 3 ? ?_instance = {} 4 5 ? ?def wrapper(*args, **kwargs): 6 ? ? ? ?if cls not in _instance: 7 ? ? ? ? ? ?_instance[cls] = cls(*args, **kwargs) 8 ? ? ? ?return _instance[cls] 9 10 ? ?return wrapper 11 12 @Singleton 13 class A(object): 14 ? ?def __init__(self, a): 15 ? ? ? ?self.a = a 16 ? ? ? ?print self.a 17 18 19 20 #2. 重新__new__方法 ? (有坑，__init__會執行多次) 21 import threading 22 class B(object): 23 ? ?lock = threading.Lock() 24 ? ?_instance = None 25 26 ? ?def __init__(self): 27 ? ? ? ?self.b = {} 28 29 ? ?def __new__(cls, *args, **kwargs): 30 ? ? ? ?if not B._instance: 31 ? ? ? ? ? ?with B.lock: 32 ? ? ? ? ? ? ? ?if not B._instance: 33 ? ? ? ? ? ? ? ? ? ?B._instance = object.__new__(cls) 34 ? ? ? ?return B._instance 35 36 #3. 元類實現 37 class SingletonType(type): 38 ? ?def __init__(self, *args, **kwargs): 39 ? ? ? ?super(SingletonType, self).__init__(*args, **kwargs) 40 41 ? ?def __call__(cls, *args, **kwargs): ?# 這里的cls，即Foo類 42 ? ? ? ?print('cls', cls) 43 ? ? ? ?obj = cls.__new__(cls, *args, **kwargs) 44 ? ? ? ?cls.__init__(obj, *args, **kwargs) ?# Foo.__init__(obj) 45 ? ? ? ?return obj 46 47 48 metaclass = SingletonType 49 50 51 class Foo(): ?# 指定創建Foo的type為SingletonType 52 ? ?def __init__(self, name): 53 ? ? ? ?self.name = name 54 55 ? ?def __new__(cls, *args, **kwargs): 56 ? ? ? ?return object.__new__(cls) 57 58 59 #4.模塊實現 60 a.py 61 class A(object): 62 ? ?def __init__(self, a): 63 ? ? ? ?self.a = a 64 ? ? ? ?print self.a 65 objA = A('aaa') 66 print(id(objA)) 67 68 b.py 69 from a import objA 70 print(id(objA))

裝飾器的寫法以及應用場景
#閉包的形式，接受一個函數，返回內部函數，內湖函數中有對接受的函數的處理。裝飾器可以在不影響原函數的情況下拓展自定義功能，提代碼的復用性。 def output_current_time(func): def warpper(*args,**kargs): import datetime now_time = datetime.datetime.now() print(now_time) res = func() return res return warpper @output_current_time def task(): print('do task') 13 1 #閉包的形式，接受一個函數，返回內部函數，內湖函數中有對接受的函數的處理。裝飾器可以在不影響原函數的情況下拓展自定義功能，提代碼的復用性。 2 def output_current_time(func): 3 ? ?def warpper(*args,**kargs): 4 ? ? ? ?import datetime 5 ? ? ? ?now_time = datetime.datetime.now() 6 ? ? ? ?print(now_time) 7 ? ? ? ?res = func() 8 ? ? ? ?return res 9 ? ?return warpper 10 11 @output_current_time 12 def task(): 13 ? ?print('do task')

異常處理寫法以及如何主動跑出異常
try: 可能出現異常的代碼塊 except Exception as es: 出現的異常的處理方式 主動拋出異常：raise 6 1 try: 2 ? ?可能出現異常的代碼塊 3 except Exception as es: 4 ? ?出現的異常的處理方式 5 6 主動拋出異常：raise

什么是面向對象的mro
python中至少有三種不同的MRO: 經典類(calssic class)，深度優先遍歷 在python2.2中提出了type和class的統一，出現了一個內建類型以及自定義類的公共祖先object，即新式類(new-style class)預計算 python2.3之后新式類的C3算法，這是python3唯一支持的方式 5 1 python中至少有三種不同的MRO: 2 3 經典類(calssic class)，深度優先遍歷 4 在python2.2中提出了type和class的統一，出現了一個內建類型以及自定義類的公共祖先object，即新式類(new-style class)預計算 5 python2.3之后新式類的C3算法，這是python3唯一支持的方式

isinstance作用以及應用場景
isinstance用于類型判斷： 接受兩個參數：第一個為:object對象，第二個為類型類型 比如，要判斷3是不是int類型： isinstance(3,int) 如果時返回True，否則返回False 5 1 isinstance用于類型判斷： 2 接受兩個參數：第一個為:object對象，第二個為類型類型 3 比如，要判斷3是不是int類型： 4 isinstance(3,int) 5 如果時返回True，否則返回False

寫代碼并實現：
給定一個整數數和一個目標值，找出數組中和為目標值的兩個數, 你可以假設每個輸入只對應一種答案，且元素不能被重復利用 # 例子: #nums = [2,7,11,15],target=9 #因為nums[0]+nums[1]=2+7=9 #所以返回[0,1] # code： list1 = [1, 4, 6, 8, 9] target_num = 15 def twoSum(listobj, target_num): d = {} # 用來存放元素與下標的對應關系 for i, v in enumerate(listobj): if target_num - v in d: return [d[target_num - v], i] d[v] = i print(twoSum(list1, target_num)) 18 1 # 例子: 2 #nums = [2,7,11,15],target=9 3 #因為nums[0]+nums[1]=2+7=9 4 #所以返回[0,1] 5 6 # code： 7 8 list1 = [1, 4, 6, 8, 9] 9 target_num = 15 10 11 def twoSum(listobj, target_num): 12 ? ?d = {}# 用來存放元素與下標的對應關系 13 ? ?for i, v in enumerate(listobj): 14 ? ? ? ?if target_num - v in d: 15 ? ? ? ? ? ?return [d[target_num - v], i] 16 ? ? ? ?d[v] = i 17 ? ? ? ? 18 print(twoSum(list1, target_num))

json序列化時，可以處理的數據類型有哪些？如何定制支持datetime類型
# 可以處理 : list,dict,int,str,float,object # 支持datetime? #關鍵在于重寫JSONEncoder的default方法 import json from json import JSONEncoder from datetime import datetime class ComplexEncoder(JSONEncoder): def default(self, obj): if isinstance(obj, datetime): # 如果obj是datatime類型 就將obj格式化為字符串 return obj.strftime('%Y-%m-%d %H:%M:%S') else: # 否則交給父類的delault處理 return super(ComplexEncoder, self).default(obj) d = {'name': 'alex', 'data': datetime.now()} print(json.dumps(d, cls=ComplexEncoder)) 19 1 # 可以處理 : list,dict,int,str,float,object 2 3 # 支持datetime? 4 #關鍵在于重寫JSONEncoder的default方法 5 ? 6 import json 7 from json import JSONEncoder 8 from datetime import datetime 9 10 11 class ComplexEncoder(JSONEncoder): 12 ? ?def default(self, obj): 13 ? ? ? ?if isinstance(obj, datetime): ? # 如果obj是datatime類型 就將obj格式化為字符串 14 ? ? ? ? ? ?return obj.strftime('%Y-%m-%d %H:%M:%S') 15 ? ? ? ?else: # 否則交給父類的delault處理 16 ? ? ? ? ? ?return super(ComplexEncoder, self).default(obj) 17 ? ? ? ? 18 d = {'name': 'alex', 'data': datetime.now()} 19 print(json.dumps(d, cls=ComplexEncoder))

json序列化時，默認遇到中文會轉換成unicode，如果想要保留中文怎么辦
# 這是因為json.dumps 序列化時對中文默認使用的ascii編碼 jsonData = json.dumps({'name': '小明同學'}, ensure_ascii=False) print(jsonData) 3 1 # 這是因為json.dumps 序列化時對中文默認使用的ascii編碼 2 jsonData = json.dumps({'name': '小明同學'}, ensure_ascii=False) 3 print(jsonData)

什么是斷言？應用場景
# Python的assert是用來檢查一個條件，如果它為真，就不做任何事。如果它為假，則會拋出AssertError并且包含錯誤信息。例如： x = 23 assert x > 0, "x is not zero or negative" assert x%2 == 0, "x is not an even number" #場景： """ 　　☆防御型的編程 　　☆運行時檢查程序邏輯 　　☆檢查約定 　　☆程序常量 　　☆檢查文檔 """ # 在unittest中很常用 x 1 # Python的assert是用來檢查一個條件，如果它為真，就不做任何事。如果它為假，則會拋出AssertError并且包含錯誤信息。例如： 2 x = 23 3 assert x > 0, "x is not zero or negative" 4 assert x%2 == 0, "x is not an even number" 5 6 #場景： 7 """ 8 　　☆防御型的編程 9 　　☆運行時檢查程序邏輯 10 　　☆檢查約定 11 　　☆程序常量 12 　　☆檢查文檔 13 """ 14 # 在unittest中很常用

with語句 # with語句的作用是通過某種方式簡化異常處理，它是所謂的上下文管理器的一種 # 例如： with open(filepath,'r') as f : ······· # 自動管理文件關閉 不用我們先open再close 5 1 # with語句的作用是通過某種方式簡化異常處理，它是所謂的上下文管理器的一種 2 # 例如： 3 with open(filepath,'r') ?as f : 4 ? ?······· 5 # 自動管理文件關閉 不用我們先open再close

使用代碼實現查看列舉目錄下的所有文件,過濾文件夾 import os for file in os.listdir(): if os.path.isfile(file): print(file) 4 1 import os 2 for file in os.listdir(): 3 ? ?if os.path.isfile(file): 4 ? ? ? ?print(file)

簡述 yield和yield from關鍵字
https://www.cnblogs.com/gqtcgq/p/8126124.html # 這篇博客講的很好 1 https://www.cnblogs.com/gqtcgq/p/8126124.html ? # 這篇博客講的很好

轉載于:https://www.cnblogs.com/wangbaojun/p/11000391.html

總結

以上是生活随笔為你收集整理的知识点总结（基础篇）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。