知識點總結（基礎篇）

時間 2019-12-13

標籤知識總結基礎简体版

原文原文鏈接

知識點總結1html

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

三元運算符
爲真時的結果 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   返回一個列表

布爾值爲False的常見值

         
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裏

         
     

         
     

              
          

              
          

               
           

                
            
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裏

          
      

          
      

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

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

經常使用字符串格式化哪幾種
{}.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)

對閉包的理解
閉包是由函數及其相關的引用環境組合而成的實體(即：閉包=函數+引用環境) 閉包能夠根據外部做用域的局部變量來獲得不一樣的結果，這有點像一種相似配置功能的做用，咱們能夠修改外部的變量，閉包根據這個變量展示出不一樣的功能。好比有時咱們須要對某些文件的特殊行進行分析，先要提取出這些特殊行
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

構造方法

一、二、三、四、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)

什麼是反射？以及應用場景？
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))

         
     

         
     

              
          

              
          

               
           

                
            
#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))

          
      

          
      

裝飾器的寫法以及應用場景

         
#閉包的形式，接受一個函數，返回內部函數，內湖函數中有對接受的函數的處理。裝飾器能夠在不影響原函數的狀況下拓展自定義功能，提代碼的複用性。
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')

異常處理寫法以及如何主動跑出異常
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 # 這篇博客講的很好

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。