python自測100題，來看看你和月薪3萬的差距（含答案）

-------------人生苦短,必須性感!

---

一、爲何學習Python？

人生苦短？人間不值得？想一想本身的初心吧！

二、經過什麼途徑學習的Python？

官網、網上視頻、學習網站、論壇、大牛的輔導

三、Python和Java、PHP、C、C#、C++等其餘語言的對比？

（1）、python代碼，簡介，明確，優雅，簡單易懂
（2）、開發效率高
（3）、可擴展性強

四、簡述解釋型和編譯型編程語言？

解釋型：在執行程序時，計算機才一條一條的將代碼解釋成機器語言給計算機來執行
編譯型：是把源程序的每一條語句都編譯成機器語言，並保存成二進制文件，這樣計算機運行該程序時能夠直接以機器語言來運行此程序，運行速度很快。

五、Python解釋器種類以及特色？

Cpython，IPython，Jpython，pypy，Ironpython

Python是一門解釋器語言，代碼想運行，必須經過解釋器執行，Python存在多種解釋器，分別基於不一樣語言開發，每一個解釋器有不一樣的特色，但都能正常運行Python代碼，如下是經常使用的五種Python解釋器：

CPython：當 從Python官方網站下載並安裝好Python2.7後，就直接得到了一個官方版本的解

釋器：Cpython，這個解釋器是用C語言開發的，因此叫 CPython，在命名行下運行python，
    就是啓動CPython解釋器，CPython是使用最廣的Python解釋器。

IPython：IPython是基於CPython之上的一個交互式解釋器，也就是說，IPython只是在交互方

式上有所加強，可是執行Python代碼的功能和CPython是徹底同樣的，比如不少國產瀏覽器
    雖然外觀不一樣，但內核實際上是調用了IE。

PyPy：PyPy是另外一個Python解釋器，它的目標是執行速度，PyPy採用JIT技術，

對Python代進行動態編譯，因此能夠顯著提升
             Python代碼的執行速度。

Jython：Jython是運行在Java平臺上的Python解釋器，能夠直接把Python代碼編譯成Java字節碼執行。
IronPython：IronPython和Jython相似，只不過IronPython是運行在微軟.Net平臺上的Python解釋器，

能夠直接把Python代碼編譯成.Net的字節碼。 

在Python的解釋器中，使用普遍的是CPython，對於Python的編譯，除了能夠採用以上解釋器
進行編譯外，技術高超的開發者還能夠按照本身的需求自行編寫Python解釋器來執行Python代碼，十分的方便！

六、位和字節的關係？

一個字節=8位

七、b、B、KB、MB、GB 的關係？

1B(字節) = 8b(位)
1KB = 1024B
1MB = 1024KB
1GB = 1024MB

八、請至少列舉5個 PEP8 規範

（1）、縮進：每一級4個縮進。連續跨行應該使用圓括號或大括號或者使用懸掛縮進。
（2）、代碼長度約束

一行列數：PEP8 規定最大爲79列，若是拼接url很容易超限
一個函數：不能夠超過30行；直觀來說就是完整顯示一個函數一個屏幕就夠了，不須要上下拖動
一個類：不要超過200行代碼，不要超過10個方法
一個模塊：不要超過500行

（3）、import

不要在一句import中引用多個庫

（4）、命名規範
（5）、註釋

整體原則，錯誤的註釋不如沒有註釋。因此當一段代碼發生變化時，第一件事就是要修改註釋！

九、經過代碼實現以下轉換：

答案： 二進制轉換成十進制：v = 「0b1111011」

print(int('0b1111011',2)) 十進制轉換成二進制：v = 18 print(bin(18)) 八進制轉換成十進制：v = 「011」 print(int('011',8)) 十進制轉換成八進制：v = 30 print(oct(30)) 十六進制轉換成十進制：v = 「0x12」 print(int('0x12',16)) 十進制轉換成十六進制：v = 87 print(hex(87)) 

十、請編寫一個函數實現將IP地址轉換成一個整數。

如 10.3.9.12 轉換規則爲：

10 00001010 3 00000011 9 00001001 12 00001100 

再將以上二進制拼接起來計算十進制結果：00001010 00000011 00001001 00001100 = ？

答案：

def func(x): lis = x.strip().split('.') li = [bin(int(i)) for i in lis] li2 = [i.replace('0b',(10-len(i))*'0') for i in li] return int(''.join(li2),2) ret = func('10.3.9.12') print(ret) 

十一、python遞歸的最大層數？

通常計算機默認的最大遞歸深度在1000左右，python最大遞歸深度通常在4000左右，跟計算
機的性能有關係，這個數不是一個定數，可經過一下方式測試

import sys
print(sys.getrecursionlimit()) print(sys.setrecursionlimit(10000)) 

十二、求結果：

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

1三、ascii、unicode、utf-八、gbk 區別？

ASCII碼：使用一個字節編碼，因此它的範圍基本是隻有英文字母、數字和一些特殊符號 ，只有256個字符。
Unicode：可以表示全世界全部的字節
GBK：是隻用來編碼漢字的，GBK全稱《漢字內碼擴展規範》，使用雙字節編碼。
UTF-8：是一種針對Unicode的可變長度字符編碼，又稱萬國碼。

1四、字節碼和機器碼的區別？

機器碼：是電腦CPU直接讀取運行的機器指令，運行速度最快，可是很是晦澀難懂
字節碼：是一種中間狀態（中間碼）的二進制代碼（文件）。須要直譯器轉譯後才能成爲機器碼。

1五、三元運算規則以及應用場景？

規則：爲真時的結果 if 斷定條件 else 爲假時的結果
`應用場景：在賦值變量的時候，能夠直接加判斷，而後賦值`

1六、列舉 Python2和Python3的區別？

一、默認編碼：2-->ascii，3-->utf-8
二、print的區別：python2中print是一個語句，不論想輸出什麼，直接放到print關鍵字後面便可。python3裏，print()是一個函數，

像其餘函數同樣，print()須要你將要輸出的東西做爲參數傳給它。

三、input的區別：

python2有兩個全局函數，用在命令行請求用戶輸入。第一個叫input()，它等待用戶輸入一個python表達式(而後返回結果)。 第二個叫作raw_input(),用戶輸入什麼他就返回什麼。python3 經過input替代了他們。

四、字符串：python2中有兩種字符串類型：Unicode字符串和非Unicode字符串。Python3中只有一種類型：Unicode字符串。
五、xrange()

python２裏，有兩種方法得到必定範圍內的數字：range(),返回一個列表，還有xrange(),返回一個迭代器。 python3　裏，range()返回迭代器，xrange()再也不存在。 

1七、用一行代碼實現數值交換：

a = 1 b = 2

答案：a = 1

b = 2
a,b = b,a

1八、Python3和Python2中 int 和 long的區別？

python2有非浮點數準備的int和long類型。int類型最大
值不能超過sys.maxint，並且這個最大值是平臺相關的。
能夠經過在數字的末尾附上一個Ｌ來定義長整型，顯然，它比int類型表示的數字範圍更大。在python3裏，
只有一種整數類型int,大多數狀況下，和python２中的長整型相似。

1九、xrange和range的區別？

python２裏，有兩種方法得到必定範圍內的數字：range(),返回一個列表，還有xrange(),返回一個迭代器。
python3　裏，range()返回迭代器，xrange()再也不存在。

20、文件操做時：xreadlines和readlines的區別？

readlines返回一個list，xreadlines方法返回一個生成器

2一、列舉布爾值爲False的常見值？

0, [] , () , {} , '' , False , None

2二、字符串、列表、元組、字典每一個經常使用的5個方法？

字符串：repleace,strip,split,reverse,upper,lower,join.....
列表：append,pop,insert,remove,sort,count,index.....
元組：index,count,__len__(),__dir__()
字典：get,keys,values,pop,popitems,clear,update,items.....

2三、lambda表達式格式以及應用場景？

表達式格式：lambda後面跟一個或多個參數，緊跟一個冒號，之後是一個表達式。冒號前是參數，冒號後是返回值。例如：lambda x : 2x
應用場景：常常與一些內置函數相結合使用，好比說map(),filter(),sorted(),reduce()等

2四、pass的做用？

一、空語句 do nothing
二、保證格式完整
三、保證語義完整

2五、arg和*kwarg做用？

萬能參數，解決了函數參數不固定的問題
*arg：會把位置參數轉化爲tuple
**kwarg：會把關鍵字參數轉化爲dict

2六、is和==的區別？

is:判斷內存地址是否相等
==：判斷數值是否相等

2七、簡述Python的深淺拷貝以及應用場景？

copy()：淺copy，淺拷貝指僅僅拷貝數據集合的第一層數據
deepcopy():深copy,深拷貝指拷貝數據集合的全部層

2八、Python垃圾回收機制？

python採用的是引用計數機制爲主，標記-清除和分代收集(隔代回收、分代回收)兩種機制爲輔的策略
計數機制

Python的GC模塊主要運用了引用計數來跟蹤和回收垃圾。在引用計數的基礎上，還能夠經過「標記-清除」
解決容器對象可能產生的循環引用的問題。經過分代回收以空間換取時間進一步提升垃圾回收的效率。

標記-清除：

標記-清除的出現打破了循環引用，也就是它只關注那些可能會產生循環引用的對象
缺點：該機制所帶來的額外操做和須要回收的內存塊成正比。

隔代回收

原理：將系統中的全部內存塊根據其存活時間劃分爲不一樣的集合，每個集合就成爲一個「代」，
垃圾收集的頻率隨着「代」的存活時間的增大而減少。也就是說，活得越長的對象，就越不多是垃圾，
就應該減小對它的垃圾收集頻率。那麼如何來衡量這個存活時間：一般是利用幾回垃圾收集動做來衡量，
若是一個對象通過的垃圾收集次數越多，能夠得出：該對象存活時間就越長。

2九、python的可變類型和不可變類型？

不可變類型（數字、字符串、元組、不可變集合）
可變類型（列表、字典、可變集合）

30、求結果：

v = dict.fromkeys(['k1','k2'],[])
v['k1'].append(666)
print(v)
v['k1'] = 777
print(v)

答案：{'k1':[666],'k2':[666]} {'k1':777,'k2':[666]} 解析：formkeys()默認參數爲可變數據類型時有坑 

3一、求結果：

def num(): return [lambda x: i*x for i in range(4)] print([m(2) for m in num()]) 答案：[6, 6, 6, 6] 解析： 問題的本質在與python中的屬性查找規則，LEGB（local，enclousing，global，bulitin）， 在上面的例子中，i就是在閉包做用域（enclousing），而Python的閉包是 遲綁定 ， 這意味着閉包中用到的變量的值，是在內部函數被調用時查詢獲得的 因此：[lambda x: i*x for i in range(4)]打印出來是含有四個內存地址的列表，每一個內存地址中的i 在在本內存中都沒有被定義，而是經過閉包做用域中的i值，當for循環執行結束後，i的值等於3，因此 再執行[m(2) for m in num()]時，每一個內存地址中的i值等於3，當x等於2時，打印出來的結果都是6， 從而獲得結果[6, 6, 6, 6]。 

3二、列舉常見的內置函數？

map,filter,zip,len,bin,oct,hex,int,float,bool,sum,min,max,str,list,tuple,dict,range,next,hash,help,id.....

3三、filter、map、reduce的做用？

filter(function，iterable)過濾函數
map(function，iterable)循環函數
reduce(function, iterable)累積函數

3四、一行代碼實現9*9乘法表。

lis = ['%s%s=%s'%(i,j,ij) for i in range(1,10) for j in range(i,10)]

3五、如何安裝第三方模塊？以及用過哪些第三方模塊？

pip3 imstall 模塊名
django，Matplotlib，Tornado，PyGame

3六、至少列舉8個經常使用模塊都有那些？

os,sys,time,random,re,hashlib,logging,json,pickle....

3七、re的match和search區別？

match:從字符串的開頭位置匹配，必須以此爲開頭
search:從開頭開始查，找到符合的就返回結果

3八、什麼是正則的貪婪匹配？

正則表達式通常趨向於最大長度匹配

3九、求結果：

a. [ i % 2 for i in range(10) ] ===>[0,1,0,1,0,1,0,1,0,1]
b. ( i % 2 for i in range(10) )===>返回一個生成器的內存地址

40、求結果：

a. 1 or 2 =========>1
b. 1 and 2 ========>2
c. 1 < (2==2)======>false
d. 1 < 2 == 2======>ture

4一、def func(a,b=[]) 這種寫法有什麼坑？

def func(a,b=[]):

b.append(a) print(b)

函數的第二個默認參數是一個list，當第一次執行的時候實例化了一個list，
第二次執行仍是用第一次執行的時候實例化的地址存儲，之後每次實例化都是

4二、如何實現 "1,2,3" 變成 ['1','2','3'] ?

a = "1,2,3"
li = a.split(',')

4三、如何實現[‘1’,’2’,’3’]變成[1,2,3] ?

li = ['1','2','3']
lis = list(map(lambda x:int(x) li))

4四、比較： a = [1,2,3] 和 b = [(1),(2),(3) ] 以及 b = [(1,),(2,),(3,) ] 的區別？

a = [1,2,3]正常的列表
b = [(1),(2),(3)] 雖然列表的每一個元素加上了括號，可是當括號內只有一個元素而且沒有逗號時，其數據類型是元素自己的數據類型
b = [(1,),(2,),(3,)]列表中的元素類型都是元組類型

4五、如何用一行代碼生成[1,4,9,16,25,36,49,64,81,100] ?

li = [x*x for x in range(1,11)]

4六、一行代碼實現刪除列表中重複的值 ?

li = [1, 1, 1, 23, 3, 4, 4]
new_li = list(set(li))
new_li.sort(key=li.index)

4七、如何在函數中設置一個全局變量 ?

使用python的內置語法 globals 全局變量

4八、logging模塊的做用？以及應用場景？

logging模塊的做用：
一、程序調試
二、瞭解軟件程序運行狀況，是否正常
三、軟件程序運行故障分析與問題定位
應用場景：網站的運維工做，程序實時監控

4九、請用代碼簡答實現stack 。

def Stack(object):

def __init__(self): self.stack = [] def push(self,value): # 進棧 self.stack.append(value) def pop(self): # 出棧 if self.stack: self.stack.pop() else: raise LookupError('stack is empty!') def is_empty(self): # 查看stack是否爲空 reture bool(self.stack) def top(self): # 取出stack中最新的值 return self.stack[-1] 

50、經常使用字符串格式化哪幾種？

一、%s %d
二、format格式化輸出
三、print(f'內容{變量名}')

5一、簡述 生成器、迭代器、可迭代對象 以及應用場景？

生成器：在 Python 中，一邊循環一邊計算的機制，稱爲 生成器（generator），

經過next()取值，兩種表現形式一、將列表生成式的[]改成()二、含有yield關鍵字的函數 應用場景：優化代碼，節省內存

迭代器：是訪問集合元素的一種方式。迭代器同時實現了__iter__和__next__方法
可迭代對象：只要實現了__iter__方法的對象就是可迭代對象

5二、用Python實現一個二分查找的函數。

lis = [0, 1, 3, 4, 5, 6, 7, 9, 10, 11,12,16,17]

def two_find(x, lis, start=0, end=None):

if end == None:end = len(lis) - 1 num = (end - start) // 2 + start if end > start: if lis[num] > x: return two_find(x, lis, start=start, end=num) elif lis[num] < x: return two_find(x, lis, start=num + 1, end=end) elif lis[num] == x: return num elif lis[end] == x:return end else:return None 

print(two_find(17, lis))

5三、談談你對閉包的理解？

在一個外函數中定義了一個內函數，內函數裏運用了外函數的臨時變量，而且外函數的返回值是內函數的引用。這樣就構成了一個閉包。
通常狀況下，在咱們認知當中，若是一個函數結束，函數的內部全部東西都會釋放掉，還給內存，局部變量都會消失。
可是閉包是一種特殊狀況，若是外函數在結束的時候發現有本身的臨時變量未來會在內部函數中用到，就把這個臨時變量綁定給了內部函數，而後本身再結束。

5四、os和sys模塊的做用？

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

5五、如何生成一個隨機數？

import random
def rdm(n):

lis = []
for i in range(n): n = random.randint(1,9) lis.append(str(n)) s = ''.join(lis) return int(s) 

5六、如何使用python刪除一個文件？

import os
os.remove(r'path')

5七、談談你對面向對象的理解？

面向對象的程序設計的核心是對象（上帝式思惟），要理解對象爲什麼物，必須把本身當成上帝，上帝眼裏世間存在的萬物皆爲對象，
不存在的也能夠創造出來。對象是特徵和技能的結合，其中特徵和技能分別對應對象的數據屬性和方法屬性。
優勢是：解決了程序的擴展性。對某一個對象單獨修改，會馬上反映到整個體系中，如對遊戲中一我的物參數的特徵和技能修改都很容易。
缺點：可控性差，沒法向面向過程的程序設計流水線式的能夠很精準的預測問題的處理流程與結果，
面向對象的程序一旦開始就由對象之間的交互解決問題，即使是上帝也沒法預測最終結果。
應用場景：需求常常變化的軟件，通常需求的變化都集中在用戶層，互聯網應用，企業內部軟件，遊戲等都是面向對象的程序設計大顯身手的好地方。

5八、Python面向對象中的繼承有什麼特色？

1：在繼承中基類的構造(__init__()方法)不會被自動調用，它須要在其派生類的構造中親自專門調用。
2：在調用基類的方法時，須要加上基類的類名前綴，且須要帶上self參數變量。

區別於在類中調用普通函數時並不須要帶上self參數

3：Python老是首先查找對應類型的方法，若是它不能在派生類中找到對應的方法，它纔開始到基類中逐個查找。

(先在本類中查找調用的方法，找不到纔去基類中找)。

5九、面向對象深度優先和廣度優先是什麼？

Python的類能夠繼承多個類，那麼其尋找類方法的方式有兩種：

當類是經典類時(主要在python2版本中的沒有主動繼承object的類)，多繼承狀況下，會按照深度優先方式查找 當類是新式類時(python3版本中的全部類和python2中主動繼承object的類)，多繼承狀況下，會按照廣度優先方式查找 簡單點說就是：經典類是縱向查找，新式類是橫向查找 

60、面向對象中super的做用？

一、super在面向對象繼承類中代指父類，書寫方法super(類名,self).屬性或者方法或super().屬性或者方法
二、super方法能夠增長類之間調用的靈活性，當父類名發生變化時沒必要修改
三、super方法在類的多繼承時能夠簡化代碼，避免代碼冗餘
四、super機制裏能夠保證公共父類僅被執行一次，執行的順序遵循MRO，廣度優先查詢方法

6一、是否使用過functools中的函數？其做用是什麼？

functools用於高階函數：指那些做用於函數或者返回其餘函數的函數。一般狀況下，只要是
能夠被當作函數調用的對象就是這個模塊的目標。

6二、列舉面向對象中帶雙下劃線的特殊方法，如：new、init

__new__：構造方法，建立一個對象，實例化時第一個被執行，返回一個建立好的對象及__init__(self)的self，

只有繼承了object的類纔會有這個方法

__init__：初始化方法，__init__在__new__的基礎上完成一些其它初始化的動做，__init__沒有返回值

6三、如何判斷是函數仍是方法？

函數和方法都封裝了一些獨立的功能，若是在類中定義的函數那就是方法(對象或者類名點方法名調用)，

不然就是函數(函數名()直接調用)

6四、靜態方法和類方法區別？

靜態方法：是既不是用類中的屬性又不使用對象中的屬性，由類或者對象調用的方法，依賴python裝飾器@staticmethod來實現
類方法：只使用類中的靜態變量，通常都是由類調用，依賴python裝飾器@classmethod來實現

6五、列舉面向對象中的特殊成員以及應用場景？

__call__：對象的構造方法，對象加上()，能夠觸發這個類的__call__方法。
__len__：內置函數的len函數是依賴類中的__len__方法
__eq__：判斷值是否相等的時候依賴__eq__方法
__hash__:判斷hash值是否相等的時候依賴__hash__方法(拓展：set的去重機制其實就是根據__hash__和__eq__方法實現的)
__str__：和str() print() %s 都是息息相關的，返回值必定是字符串類型
__repr__：和 repr() %r都是息息相關的，在沒有__str__方法時，__repr__能夠徹底取代__str__。
del 析構方法，對應着一個對象的刪除以前執行的內容

6六、一、二、三、四、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 != k) and (j != k): count += 1 if count % 6: print(f'{i}{j}{k}', end='|') else: print(f'{i}{j}{k}')

print(count)

6七、什麼是反射？以及應用場景？

定義：經過用字符串數據類型的變量名來訪問這個變量的值，在python面向對象中的反射,經過字符串的形式操做對象相關的屬性或方法.
應用場景：用於處理經過用戶輸入，文件讀取，或者網絡傳輸所獲得的字符串形式的指令來完成對應的操做

6八、metaclass做用？以及應用場景？

metaclass，直譯爲元類，簡單的解釋就是：當咱們定義了類之後，就能夠根據這個類建立出實例，
因此：先定義類，而後建立實例。可是若是咱們想建立出類呢？那就必須根據metaclass建立出類，
因此：先定義metaclass，而後建立類。換句話說，你能夠把類當作是metaclass建立出來的「實例」

6九、用盡可能多的方法實現單例模式。

一、基於__new__()方法

class Person: def __new__(cls, *args, **kwargs): if not hasattr(cls,cls._instance): # cls._instance = object.__new__(cls) cls._instance = super().__new__(cls) return cls._instance

二、基於模塊導入方式，如今一個py文件中寫好一個類，實例化一個對象。之後用這個類直接導入這個模塊就是單例模式。
三、基於裝飾器方法實現

def singleton(cls, *args, **kwargs): instance_dic = {} def inner(*args, **kwargs): if cls not in instance_dic: instance_dic['cls'] = cls(*args, **kwargs) return instance_dic['cls'] return inner @singleton class Person: pass 

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

裝飾器的寫法：

def wrapper(func): def inner(*args,**kwargs): '被裝飾以前的操做' ret = func(*args,**kwargs) '被裝飾以後的操做' return ret return inner 

裝飾器的應用場景：

好比註冊登陸、插入日誌，性能測試，事務處理，緩存等等場景

7一、異常處理寫法以及如何主動跑出異常（應用場景）

異常處理的常規寫法：

try: 執行的主體函數 except Exception as e: print(str(e)) 主動拋出異常： raise TypeError('出現了難以想象的異常')#TypeError能夠是任意的錯誤類型 

7二、什麼是面向對象的mro

MRO(Method Resolution Order 方法解析順序)是面向對象中用於查詢類的多繼承的繼承順序的方法，
它是基於算法來實現的，不一樣的算法實現的MRO的順序不一樣

7三、isinstance做用以及應用場景？

isinstance做用是來判斷一個對象是不是一個已知的類型

7四、寫代碼並實現：

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] 

代碼實現

def func(li,target):

try: for i in range(0,len(li)): num = target-li[i] if num in li: return [i,li.index(num)] except:print('li類型爲數組類型，內的元素需是整型，target也爲整型，請檢查') else:return None 

7五、json序列化時，能夠處理的數據類型有哪些？如何定製支持datetime類型？

一、能夠處理的數據類型是 string、int、list、tuple、dict、bool、null
二、定製支持datetime類型
--------------------------官方文檔的memo-----------------------------------------------

>>> import json >>> class ComplexEncoder(json.JSONEncoder): ... def default(self, obj): ... if isinstance(obj, complex): ... return [obj.real, obj.imag] ... return json.JSONEncoder.default(self, obj) ... >>> dumps(2 + 1j, cls=ComplexEncoder) '[2.0, 1.0]' >>> ComplexEncoder().encode(2 + 1j) '[2.0, 1.0]' >>> list(ComplexEncoder().iterencode(2 + 1j)) ['[', '2.0', ', ', '1.0', ']']

---

import json import datetime ret = datetime.datetime.now() class CJsonEncoder(json.JSONEncoder): def default(self, obj): if isinstance(obj, datetime.date): return obj.strftime('%Y-%m-%d %H:%M:%S') else: return json.JSONEncoder.default(self, obj) print(json.dumps(ret,cls=CJsonEncoder)) 

7六、json序列化時，默認遇到中文會轉換成unicode，若是想要保留中文怎麼辦？

在序列化是將json.dumps中的默認參數ensure_ascii改成False就能夠保留中文了
json.dumps(obj,ensure_ascii=False)

7七、什麼是斷言？應用場景？

assert 條件,'自定義錯誤提示(無關緊要)' 例：assert 1 == 0,'這是一個低級的錯誤'
合約式設計是斷言的經典應用，在一個正確的程序裏，全部的前置條件和後置條件都將獲得處理。
7八、使用代碼實現查看列舉目錄下的全部文件。
方法一：遞歸處理

import os url = r'C:\Users\Mr.Wang\PycharmProjects\untitled\前段學習' def check_file(url,li = []): if os.path.isdir(url): file_list = os.listdir(url) for ret in file_list: base_url = os.path.join(url,ret) if os.path.isfile(base_url): li.append(ret) else: check_file(base_url) return li else:return os.path.basename(url) 

方法二：堆棧的思想處理

import os url = r'C:\Users\Mr.Wang\PycharmProjects\untitled\python基礎' lis = [url] while lis: url = lis.pop() ret_list = os.listdir(url) for name in ret_list: abs_path = os.path.join(url,name) if os.path.isdir(abs_path): lis.append(abs_path) else:print(name) 

7九、簡述 yield和yield from關鍵字。

yield 是一個相似 return 的關鍵字，只是這個函數返回的是個生成器當你調用這個函數的時候，
函數內部的代碼並不立馬執行 ，這個函數只是返回一個生成器對象，當你使用for進行迭代的時候，
函數中的代碼纔會執行

yield from 的主要功能是打開雙向通道，把最外層的調用方與最內層的子生成器鏈接起來，
這樣兩者能夠直接發送和產出值，還能夠直接傳入異常，而不用在位於中間的協程中添加大量處理異常的樣板代碼。
有了這個結構，協程能夠經過之前不可能的方式委託職責。

80、代碼實現六位隨機驗證碼

import random s = '' for i in range(6): num = random.randint(0,9) alpha1 = chr(random.randint(65,90)) alpha2 = chr(random.randint(97,122)) ret = random.choice([num,alpha1,alpha2]) s += str(ret) print(s) 

8一、代碼實現隨機發紅包功能

import random def red_packge(money,num): li = random.sample(range(1,money*100),num-1) li.extend([0,money*100]) li.sort() return [(li[index+1]-li[index])/100 for index in range(num)] ret = red_packge(100,10) print(ret) --------------------------生成器版------------------------------------------- import random def red_packge(money,num): li = random.sample(range(1,money*100),num-1) li.extend([0,money*100]) li.sort() for index in range(num): yield (li[index+1]-li[index])/100 ret = red_packge(100,10) print(ret) 

8二、請儘量列舉python列表的成員方法，並給出列表操做的答案：

（1） a=[1, 2, 3, 4, 5], a[::2]=？ a[-2:]=？ a[::2]=[1,3,5], a[-2:] = [4,5] （2）一行代碼實現對列表a中的偶數位置的元素進行加3後求和？ sum([i+3 for i in a[::2]]) （3）將列表a的元素順序打亂，再對a進行排序獲得列表b，而後把a和b按元素順序構造一個字典d。 import random random.shuffle(a) b=a.sort() d={} for i in range(len(a)):d[a[i]] = b[i]

8三、Python自省

自省就是面向對象的語言所寫的程序在運行時，就能知道對象的類型。也就是程序運行時可以得到對象的類型。好比type()，dir()，getattr()，hasattr()，isinstance()。

8四、Python是如何進行內存管理的？

從三個方面來講,一對象的引用計數機制,二垃圾回收機制,三內存池機制

1、對象的引用計數機制

Python內部使用引用計數，來保持追蹤內存中的對象，全部對象都有引用計數。
引用計數增長的狀況：
1，一個對象分配一個新名稱
2，將其放入一個容器中（如列表、元組或字典）
引用計數減小的狀況：
1，使用del語句對對象別名顯示的銷燬
2，引用超出做用域或被從新賦值
sys.getrefcount( )函數能夠得到對象的當前引用計數
多數狀況下，引用計數比你猜想得要大得多。對於不可變數據（如數字和字符串），解釋器會在程序的不一樣部分共享內存，以便節約內存。

2、垃圾回收

1，當一個對象的引用計數歸零時，它將被垃圾收集機制處理掉。
2，當兩個對象a和b相互引用時，del語句能夠減小a和b的引用計數，並銷燬用於引用底層對象的名稱。然而因爲每一個對象都包含一個對其餘對象的應用，所以引用計數不會歸零，對象也不會銷燬。（從而致使內存泄露）。爲解決這一問題，解釋器會按期執行一個循環檢測器，搜索不可訪問對象的循環並刪除它們。

3、內存池機制

Python提供了對內存的垃圾收集機制，可是它將不用的內存放到內存池而不是返回給操做系統。
1，Pymalloc機制。爲了加速Python的執行效率，Python引入了一個內存池機制，用於管理對小塊內存的申請和釋放。
2，Python中全部小於256個字節的對象都使用pymalloc實現的分配器，而大的對象則使用系統的malloc。
3，對於Python對象，如整數，浮點數和List，都有其獨立的私有內存池，對象間不共享他們的內存池。也就是說若是你分配又釋放了大量的整數，用於緩存這些整數的內存就不能再分配給浮點數。

8五、介紹一下except的用法和做用？

try…except…except…else…
-- 執行try下的語句，若是引起異常，則執行過程會跳到except語句。對每一個except分支順序嘗試執行，若是引起的異常與except中的異常組匹配，執行相應的語句。若是全部的except都不匹配，則異常會傳遞到下一個調用本代碼的最高層try代碼中。
-- try下的語句正常執行，則執行else塊代碼。若是發生異常，就不會執行
-- 若是存在finally語句，最後老是會執行。

8六、如何用Python來進行查詢和替換一個文本字符串？

可使用re模塊中的sub()函數或者subn()函數來進行查詢和替換，比replace的功能更強大！！！
格式：sub(replacement, string[,count=0])（replacement是被替換成的文本，string是須要被替換的文本，count是一個可選參數，指最大被替換的數量）

import re
p=re.compile("blue|white|red") print(p.sub('colour','blue socks and red shoes')) print(p.sub('colour','blue socks and red shoes',count=1))

subn()方法執行的效果跟sub()同樣，不過它會返回一個二維數組，包括替換後的新的字符串和總共替換的數量

8七、有沒有一個工具能夠幫助查找python的bug和進行靜態的代碼分析？

PyChecker是一個python代碼的靜態分析工具，它能夠幫助查找python代碼的bug, 會對代碼的複雜度和格式提出警告Pylint是另一個工具能夠進行codingstandard檢查