python基礎題目大全，測試你的水平，鞏固知識（含答案）

1、為什麼學習Python？

人生苦短？人間不值得？想想自己的初心吧！

2、透過什麼途徑學習的Python？

官網、網上影片、學習網站、論壇、大牛的輔導

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

（1）、python程式碼，簡介，明確，優雅，簡單易懂
（2）、開發效率高
（3）、可擴充套件性強

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

解釋型：在執行程式時，計算機才一條一條的將程式碼解釋成機器語言給計算機來執行
編譯型：是把源程式的每一條語句都編譯成機器語言，並儲存成二進位制檔案，這樣計算機執行該程式時可以直接以機器語言來執行此程式，執行速度很快。

5、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程式碼，十分的方便！

6、位和位元組的關係？

一個位元組=8位

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

1B(位元組) = 8b(位)
1KB = 1024B
1MB = 1024KB
1GB = 1024MB

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

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

一行列數：PEP8 規定最大為79列，如果拼接url很容易超限
一個函式：不可以超過30行；直觀來講就是完整顯示一個函式一個螢幕就夠了，不需要上下拖動
一個類：不要超過200行程式碼，不要超過10個方法
一個模組：不要超過500行

（3）、import
不要在一句import中引用多個庫
（4）、命名規範
（5）、註釋
總體原則，錯誤的註釋不如沒有註釋。所以當一段程式碼發生變化時，第一件事就是要修改註釋！

9、透過程式碼實現如下轉換：

答案： 二進位制轉換成十進位制：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))

10、請編寫一個函式實現將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)

11、python遞迴的最大層數？

一般計算機預設的最大遞迴深度在1000左右，python最大遞迴深度一般在4000左右，跟計算
機的效能有關係，這個數不是一個定數，可透過一下方式測試

import sys

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

12、求結果：

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

13、ascii、unicode、utf-8、gbk 區別？

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

14、位元組碼和機器碼的區別？

機器碼：是電腦CPU直接讀取執行的機器指令，執行速度最快，但是非常晦澀難懂
位元組碼：是一種中間狀態（中間碼）的二進位制程式碼（檔案）。需要直譯器轉譯後才能成為機器碼。

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

規則：為真時的結果 if 判定條件 else 為假時的結果
應用場景：在賦值變數的時候，可以直接加判斷，然後賦值`

16、列舉 Python2和Python3的區別？

1、預設編碼：2-->ascii，3-->utf-8
2、print的區別：python2中print是一個語句，不論想輸出什麼，直接放到print關鍵字後面即可。python3裡，print()是一個函式，
像其他函式一樣，print()需要你將要輸出的東西作為引數傳給它。
3、input的區別：
python2有兩個全域性函式，用在命令列請求使用者輸入。第一個叫input()，它等待使用者輸入一個python表示式(然後返回結果)。
第二個叫做raw_input(),使用者輸入什麼他就返回什麼。python3 透過input替代了他們。
4、字串：python2中有兩種字串型別：Unicode字串和非Unicode字串。Python3中只有一種型別：Unicode字串。
5、xrange()
python２裡，有兩種方法獲得一定範圍內的數字：range(),返回一個列表，還有xrange(),返回一個迭代器。
python3　裡，range()返回迭代器，xrange()不再存在。

17、用一行程式碼實現數值交換：

a = 1
b = 2

答案：a = 1
b = 2
a,b = b,a

18、Python3和Python2中 int 和 long的區別？

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

19、xrange和range的區別？

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

20、檔案操作時：xreadlines和readlines的區別？

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

21、列舉布林值為False的常見值？

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

22、字串、列表、元組、字典每個常用的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.....

23、lambda表示式格式以及應用場景？

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

24、pass的作用？

1、空語句 do nothing
2、保證格式完整
3、保證語義完整

25、arg和*kwarg作用？

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

26、is和==的區別？

is:判斷記憶體地址是否相等
==：判斷數值是否相等

27、簡述Python的深淺複製以及應用場景？

copy()：淺copy，淺複製指僅僅複製資料集合的第一層資料  deepcopy():深copy,深複製指複製資料集合的所有層

28、Python垃圾回收機制？

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

Python的GC模組主要運用了引用計數來跟蹤和回收垃圾。在引用計數的基礎上，還可以透過“標記-清除”

解決容器物件可能產生的迴圈引用的問題。透過分代回收以空間換取時間進一步提高垃圾回收的效率。

標記-清除：
標記-清除的出現打破了迴圈引用，也就是它只關注那些可能會產生迴圈引用的物件

缺點：該機制所帶來的額外操作和需要回收的記憶體塊成正比。

隔代回收

原理：將系統中的所有記憶體塊根據其存活時間劃分為不同的集合，每一個集合就成為一個“代”，垃圾收集的頻率隨著“代”的存活時間的增大而減小。也就是說，活得越長的物件，就越不可能是垃圾，就應該減少對它的垃圾收集頻率。那麼如何來衡量這個存活時間：通常是利用幾次垃圾收集動作來衡量，如果一個物件經過的垃圾收集次數越多，可以得出：該物件存活時間就越長。

29、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()預設引數為可變資料型別時有坑

31、求結果：

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]。

32、列舉常見的內建函式？

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

33、filter、map、reduce的作用？

filter(function，iterable)過濾函式
map(function，iterable)迴圈函式
reduce(function, iterable)累積函式

34、一行程式碼實現9*9乘法表。

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

35、如何安裝第三方模組？以及用過哪些第三方模組？

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

36、至少列舉8個常用模組都有那些？

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

37、re的match和search區別？

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

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

正規表示式一般趨向於最大長度匹配

39、求結果：

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

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

def func(a,b=[]):
b.append(a)
print(b)

函式的第二個預設引數是一個list，當第一次執行的時候例項化了一個list，
第二次執行還是用第一次執行的時候例項化的地址儲存，以後每次例項化都是

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

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

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

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

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

a = [1,2,3]正常的列表
b = [(1),(2),(3)] 雖然列表的每個元素加上了括號，但是當括號內只有一個元素並且沒有逗號時，其資料型別是元素本身的資料型別
b = [(1,),(2,),(3,)]列表中的元素型別都是元組型別

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

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

46、一行程式碼實現刪除列表中重複的值 ?

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

47、如何在函式中設定一個全域性變數 ?

使用python的內建語法 globals 全域性變數

48、logging模組的作用？以及應用場景？

logging模組的作用：

1、程式除錯
2、瞭解軟體程式執行情況，是否正常
3、軟體程式執行故障分析與問題定位
應用場景：網站的運維工作，程式實時監控

49、請用程式碼簡答實現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、常用字串格式化哪幾種？

1、%s %d
2、format格式化輸出
3、print(f'內容{變數名}')

51、簡述 生成器、迭代器、可迭代物件 以及應用場景？

生成器：在 Python 中，一邊迴圈一邊計算的機制，稱為 生成器（generator），
透過next()取值，兩種表現形式1、將列表生成式的[]改為()2、含有yield關鍵字的函式
應用場景：最佳化程式碼，節省記憶體
迭代器：是訪問集合元素的一種方式。迭代器同時實現了iter和next方法
可迭代物件：只要實現了iter方法的物件就是可迭代物件

52、用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) - 1num = (end - start) // 2 + startif 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 numelif lis[end] == x:return endelse:return None
print(two_find(17, lis))

53、談談你對閉包的理解？

在一個外函式中定義了一個內函式，內函式里運用了外函式的臨時變數，並且外函式的返回值是內函式的引用。這樣就構成了一個閉包。

一般情況下，在我們認知當中，如果一個函式結束，函式的內部所有東西都會釋放掉，還給記憶體，區域性變數都會消失。
但是閉包是一種特殊情況，如果外函式在結束的時候發現有自己的臨時變數將來會在內部函式中用到，就把這個臨時變數繫結給了內部函式，然後自己再結束。

54、os和sys模組的作用？

os模組負責程式與作業系統的互動，提供了訪問作業系統底層的介面;
sys模組負責程式與python直譯器的互動，提供了一系列的函式和變數，用於操控python的執行時環境。

55、如何生成一個隨機數？

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

56、如何使用python刪除一個檔案？

import os
os.remove(r'path')

57、談談你對物件導向的理解？

物件導向的程式設計的核心是物件（上帝式思維），要理解物件為何物，必須把自己當成上帝，上帝眼裡世間存在的萬物皆為物件，不存在的也可以創造出來。物件是特徵和技能的結合，其中特徵和技能分別對應物件的資料屬性和方法屬性。

優點是：解決了程式的擴充套件性。對某一個物件單獨修改，會立刻反映到整個體系中，如對遊戲中一個人物引數的特徵和技能修改都很容易。

缺點：可控性差，無法向程式導向的程式設計流水線式的可以很精準的預測問題的處理流程與結果，物件導向的程式一旦開始就由物件之間的互動解決問題，即便是上帝也無法預測最終結果。

應用場景：需求經常變化的軟體，一般需求的變化都集中在使用者層，網際網路應用，企業內部軟體，遊戲等都是物件導向的程式設計大顯身手的好地方。

58、Python物件導向中的繼承有什麼特點？

1：在繼承中基類的構造(init()方法)不會被自動呼叫，它需要在其派生類的構造中親自專門呼叫。
2：在呼叫基類的方法時，需要加上基類的類名字首，且需要帶上self引數變數。
區別於在類中呼叫普通函式時並不需要帶上self引數
3：Python總是首先查詢對應型別的方法，如果它不能在派生類中找到對應的方法，它才開始到基類中逐個查詢。
(先在本類中查詢呼叫的方法，找不到才去基類中找)。

59、物件導向深度優先和廣度優先是什麼？

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

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

60、物件導向中super的作用？

1、super在物件導向繼承類中代指父類，書寫方法super(類名,self).屬性或者方法或super().屬性或者方法
2、super方法可以增加類之間呼叫的靈活性，當父類名發生變化時不必修改
3、super方法在類的多繼承時可以簡化程式碼，避免程式碼冗餘
4、super機制裡可以保證公共父類僅被執行一次，執行的順序遵循MRO，廣度優先查詢方法

61、是否使用過functools中的函式？其作用是什麼？

functools用於高階函式：指那些作用於函式或者返回其他函式的函式。通常情況下，只要是
可以被當做函式呼叫的物件就是這個模組的目標。

62、列舉物件導向中帶雙下劃線的特殊方法，如：new、initnew：構造方法，建立一個物件，例項化時第一個被執行，返回一個建立好的物件及init(self)的self，只有繼承了object的類才會有這個方法init：初始化方法，init在new的基礎上完成一些其它初始化的動作，init沒有返回值

63、如何判斷是函式還是方法？

函式和方法都封裝了一些獨立的功能，如果在類中定義的函式那就是方法(物件或者類名點方法名呼叫)，
否則就是函式(函式名()直接呼叫)

64、靜態方法和類方法區別？

靜態方法：是既不是用類中的屬性又不使用物件中的屬性，由類或者物件呼叫的方法，依賴python裝飾器@staticmethod來實現類方法：只使用類中的靜態變數，一般都是由類呼叫，依賴python裝飾器@classmethod來實現

65、列舉物件導向中的特殊成員以及應用場景？

call：物件的構造方法，物件加上()，可以觸發這個類的call方法。
len：內建函式的len函式是依賴類中的len方法
eq：判斷值是否相等的時候依賴eq方法
hash:判斷hash值是否相等的時候依賴hash方法(擴充：set的去重機制其實就是根據hash和eq方法實現的)
str：和str() print() %s 都是息息相關的，返回值一定是字串型別
repr：和 repr() %r都是息息相關的，在沒有str方法時，repr可以完全取代str。
del 析構方法，對應著一個物件的刪除之前執行的內容

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

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

定義：透過用字串資料型別的變數名來訪問這個變數的值，在python物件導向中的反射,透過字串的形式操作物件相關的屬性或方法.

應用場景：用於處理透過使用者輸入，檔案讀取，或者網路傳輸所得到的字串形式的指令來完成對應的操作

68、metaclass作用？以及應用場景？

metaclass，直譯為元類，簡單的解釋就是：當我們定義了類以後，就可以根據這個類建立出例項，
所以：先定義類，然後建立例項。但是如果我們想建立出類呢？那就必須根據metaclass建立出類，
所以：先定義metaclass，然後建立類。換句話說，你可以把類看成是metaclass建立出來的“例項”

69、用盡量多的方法實現單例模式。

1、基於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

2、基於模組匯入方式，現在一個py檔案中寫好一個類，例項化一個物件。以後用這個類直接匯入這個模組就是單例模式。

3、基於裝飾器方法實現

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@singletonclass Person:
    pass

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

裝飾器的寫法：

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

裝飾器的應用場景：

比如註冊登入、插入日誌，效能測試，事務處理，快取等等場景

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

異常處理的常規寫法：

try:
執行的主體函式
except Exception as e:
print(str(e))
主動丟擲異常：
raise TypeError('出現了不可思議的異常')#TypeError可以是任意的錯誤型別

72、什麼是物件導向的mro

MRO(Method Resolution Order 方法解析順序)是物件導向中用於查詢類的多繼承的繼承順序的方法，
它是基於演算法來實現的，不同的演算法實現的MRO的順序不同

73、isinstance作用以及應用場景？

isinstance作用是來判斷一個物件是否是一個已知的型別

74、寫程式碼並實現：

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

75、json序列化時，可以處理的資料型別有哪些？如何定製支援datetime型別？

1、可以處理的資料型別是 string、int、list、tuple、dict、bool、null
2、定製支援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 jsonimport 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))

76、json序列化時，預設遇到中文會轉換成unicode，如果想要保留中文怎麼辦？

在序列化是將json.dumps中的預設引數ensure_ascii改為False就可以保留中文了
json.dumps(obj,ensure_ascii=False)

77、什麼是斷言？應用場景？

assert 條件,'自定義錯誤提示(可有可無)' 例：assert 1 == 0,'這是一個低階的錯誤'合約式設計是斷言的經典應用，在一個正確的程式裡，所有的前置條件和後置條件都將得到處理。

78、使用程式碼實現檢視列舉目錄下的所有檔案。

方法一：遞迴處理

import osurl = 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 osurl = 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)

79、簡述 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)

81、程式碼實現隨機發紅包功能

import randomdef 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 randomdef 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])/100ret = red_packge(100,10)
print(ret)

82、請儘可能列舉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]

83、Python自省

自省就是物件導向的語言所寫的程式在執行時，就能知道物件的型別。也就是程式執行時能夠獲得物件的型別。比如type()，dir()，getattr()，hasattr()，isinstance()。

84、Python是如何進行記憶體管理的？

從三個方面來說,一物件的引用計數機制,二垃圾回收機制,三記憶體池機制

一、物件的引用計數機制

Python內部使用引用計數，來保持追蹤記憶體中的物件，所有物件都有引用計數。
引用計數增加的情況：
1，一個物件分配一個新名稱
2，將其放入一個容器中（如列表、元組或字典）
引用計數減少的情況：
1，使用del語句對物件別名顯示的銷燬
2，引用超出作用域或被重新賦值
sys.getrefcount( )函式可以獲得物件的當前引用計數
多數情況下，引用計數比你猜測得要大得多。對於不可變資料（如數字和字串），直譯器會在程式的不同部分共享記憶體，以便節約記憶體。

二、垃圾回收

1，當一個物件的引用計數歸零時，它將被垃圾收集機制處理掉。
2，當兩個物件a和b相互引用時，del語句可以減少a和b的引用計數，並銷燬用於引用底層物件的名稱。然而由於每個物件都包含一個對其他物件的應用，因此引用計數不會歸零，物件也不會銷燬。（從而導致記憶體洩露）。為解決這一問題，直譯器會定期執行一個迴圈檢測器，搜尋不可訪問物件的迴圈並刪除它們。

三、記憶體池機制

Python提供了對記憶體的垃圾收集機制，但是它將不用的記憶體放到記憶體池而不是返回給作業系統。
1，Pymalloc機制。為了加速Python的執行效率，Python引入了一個記憶體池機制，用於管理對小塊記憶體的申請和釋放。
2，Python中所有小於256個位元組的物件都使用pymalloc實現的分配器，而大的物件則使用系統的malloc。
3，對於Python物件，如整數，浮點數和List，都有其獨立的私有記憶體池，物件間不共享他們的記憶體池。也就是說如果你分配又釋放了大量的整數，用於快取這些整數的記憶體就不能再分配給浮點數。

85、介紹一下except的用法和作用？

try…except…except…[else…][finally…]
-- 執行try下的語句，如果引發異常，則執行過程會跳到except語句。對每個except分支順序嘗試執行，如果引發的異常與except中的異常組匹配，執行相應的語句。如果所有的except都不匹配，則異常會傳遞到下一個呼叫本程式碼的最高層try程式碼中。
-- try下的語句正常執行，則執行else塊程式碼。如果發生異常，就不會執行
-- 如果存在finally語句，最後總是會執行。

86、如何用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()一樣，不過它會返回一個二維陣列，包括替換後的新的字串和總共替換的數量

87、有沒有一個工具可以幫助查詢python的bug和進行靜態的程式碼分析？

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

很多時候跟著書和不繫統的影片網站學習，會發現沒有目標，學了很多卻不知道自己到底能夠做出什麼成績。要有一個清晰的職業學習規劃，學習過程中會遇到很多問題，你可以到我們的 python學習 -q-u-n- 【 784758214 】，基礎，進階。好友都會在裡面交流，分享一些學習的方法和需要注意的小細節，每天也會準時講一些專案實戰案例。

點選：