1、為什麼學習Python？
人生苦短....哈哈,自己想吧！！！
2、通過什麼途徑學習的Python？
官網、網上視頻、學習網站
有需要Python學習資料的小夥伴嗎?小編整理一套Python資料和PDF，感興趣者可以關注小編後私信學習資料（是關注後私信哦）反正閒著也是閒著呢，不如學點東西啦
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()不再存在。
更多不同：https://www.cnblogs.com/weikunzz/p/6857971.html
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,i*j) 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) - 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))
53、談談你對閉包的理解？
在一個外函數中定義了一個內函數，內函數裡運用了外函數的臨時變量，並且外函數的返回值是內函數的引用。這樣就構成了一個閉包。
一般情況下，在我們認知當中，如果一個函數結束，函數的內部所有東西都會釋放掉，還給內存，局部變量都會消失。
但是閉包是一種特殊情況，如果外函數在結束的時候發現有自己的臨時變量將來會在內部函數中用到，就把這個臨時變量綁定給了內部函數，然後自己再結束。
54、os和sys模塊的作用？
os模塊負責程序與操作系統的交互，提供了訪問操作系統底層的接口;
sys模塊負責程序與python解釋器的交互，提供了一系列的函數和變量，用於操控python的運行時環境。
55、如何生成一個隨機數？
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)
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 、 init
__new__：構造方法，創建一個對象，實例化時第一個被執行，返回一個創建好的對象及__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
@singleton
class Person:
pass
70、裝飾器的寫法以及應用場景。
裝飾器的寫法：
def wrapper(func):
def inner(*args,**kwargs):
'被裝飾之前的操作'
ret = func(*args,**kwargs)
'被裝飾之後的操作'
return ret
return 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 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))
76、json序列化時，默認遇到中文會轉換成unicode，如果想要保留中文怎麼辦？
在序列化是將json.dumps中的默認參數ensure_ascii改為False就可以保留中文了
json.dumps(obj,ensure_ascii=False)
77、什麼是斷言？應用場景？
assert 條件,'自定義錯誤提示(可有可無)' 例：assert 1 == 0,'這是一個低級的錯誤'
合約式設計是斷言的經典應用，在一個正確的程序裡，所有的前置條件和後置條件都將得到處理。
78、使用代碼實現查看列舉目錄下的所有文件。
方法一：遞歸處理
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)
79、簡述 yield和yield from關鍵字。
yield 是一個類似 return 的關鍵字，只是這個函數返回的是個生成器當你調用這個函數的時候，
函數內部的代碼並不立馬執行 ，這個函數只是返回一個生成器對象，當你使用for進行迭代的時候，
函數中的代碼才會執行
yield from 的主要功能是打開雙向通道，把最外層的調用方與最內層的子生成器連接起來，
這樣二者可以直接發送和產出值，還可以直接傳入異常，而不用在位於中間的協程中添加大量處理異常的樣板代碼。
有了這個結構，協程可以通過以前不可能的方式委託職責。
更多解析詳見：http://blog.gusibi.com/post/python-coroutine-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 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)
九九八十一難後繼續闖關東：
1、請儘可能列舉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]
有需要Python學習資料的小夥伴嗎?小編整理一套Python資料和PDF，感興趣者可以關注小編後私信學習資料（是關注後私信哦）反正閒著也是閒著呢，不如學點東西啦
相關推薦
